02f951aa7d
- Fixes: - `cli/runNopeBackend`: Fixing parameter `preventVarifiedNames` no works correctly. # 1.3.14 - Fixes: - `helpers/ui/helpers.nodejs`: Adding the option `upload-ui` - `helpers/ui/helpers.nodejs`: Adding the option `upload-ui` # 1.4.0 - Modified: - asyncified all ui-related services. - Adapted ui-defintion of functions: - `autoGenBySchema` Helper to enable auto generating a configuration - `requiresProviderForRendering` Flag to indicate, that rendering the service configuration requires a provider itself. This for instance is the case, if some needs to be called. - `types/ui/editor/IServiceEditPage.ts`: Asnycify the Calls - `types/ui/editor/render.callbacks.ts`: Asnycify the Calls # 1.4.1 - Modified: - loading all files related to `*.functions.js` - Adapted the following files to implement that behavior: - `getCentralDecoratedContainer` in `lib\decorators\container.ts` -> now provides services as Map - `exportFunctionAsNopeService` in `lib\decorators\functionDecorators.ts` to work with the map. - `loadFunctions` in `lib\loader\loadPackages.ts` to match the interface of `loadPackages` and add the functions to the package-loader. - added the function `addDecoratedElements` in the package-loader and the interface.
302 lines
7.5 KiB
TypeScript
302 lines
7.5 KiB
TypeScript
/**
|
|
* @author Martin Karkowski
|
|
* @email m.karkowski@zema.de
|
|
* @desc [description]
|
|
*/
|
|
|
|
import { readFile } from "fs/promises";
|
|
import { join, resolve } from "path";
|
|
import "reflect-metadata";
|
|
import { sleep } from "../helpers/async";
|
|
import { createFile, listFiles } from "../helpers/fileMethods";
|
|
import { determineDifference } from "../helpers/setMethods";
|
|
import {
|
|
getCentralDecoratedContainer,
|
|
parseWithFunctions,
|
|
stringifyWithFunctions,
|
|
} from "../index.browser";
|
|
import { getNopeLogger } from "../logger/getLogger";
|
|
import { IPackageDescription } from "../types/nope/nopePackage.interface";
|
|
import { INopePackageLoader } from "../types/nope/nopePackageLoader.interface";
|
|
|
|
const logger = getNopeLogger("helper-load-packages");
|
|
|
|
export interface IPackageConfig extends Partial<IPackageDescription<any>> {
|
|
// File Path of the element.
|
|
path: string;
|
|
}
|
|
|
|
export interface IConfigFile {
|
|
functions: {
|
|
path: string;
|
|
functions: [];
|
|
}[];
|
|
packages: IPackageConfig[];
|
|
}
|
|
|
|
/**
|
|
* List the available Packages
|
|
*
|
|
* @export
|
|
* @param {string} [dir='./modules']
|
|
* @return {*}
|
|
*/
|
|
export async function listPackages(dir = "./modules") {
|
|
// Define the Return Array.
|
|
const ret = new Array<{
|
|
package: IPackageDescription<any>;
|
|
path: string;
|
|
}>();
|
|
|
|
// Scan for the Package-Files
|
|
// And iterate over them.
|
|
for (const fileName of await listFiles(dir, ".package.js")) {
|
|
// Now Try to load a Package, to test whether is is an assembly.
|
|
try {
|
|
logger.info("found ", fileName);
|
|
|
|
ret.push({
|
|
package: (await import(resolve(fileName)))
|
|
.DESCRIPTION as IPackageDescription<any>,
|
|
path: fileName,
|
|
});
|
|
} catch (e) {
|
|
logger.error("Failed Loading the Package " + fileName);
|
|
logger.error(e);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
export async function listFunctions(dir = "./modules") {
|
|
// Define the Return Array.
|
|
const ret = new Array<{
|
|
content: any;
|
|
path: string;
|
|
}>();
|
|
|
|
// Scan for the Package-Files
|
|
// And iterate over them.
|
|
for (const fileName of await listFiles(dir, ".functions.js")) {
|
|
// Now Try to load a Package, to test whether is is an assembly.
|
|
try {
|
|
logger.info("found ", fileName);
|
|
|
|
ret.push({
|
|
content: (await import(resolve(fileName))).DESCRIPTION,
|
|
path: fileName,
|
|
});
|
|
} catch (e) {
|
|
logger.error("Failed Loading the functions in file: " + fileName);
|
|
logger.error(e);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Helper Function to write a default configuration.
|
|
*
|
|
* @export
|
|
* @param {string} [dir='./modules']
|
|
* @param {string} [filename=join(resolve(process.cwd()), 'config', 'assembly.json')]
|
|
*/
|
|
export async function writeDefaultConfig(
|
|
dir = "./modules",
|
|
filename: string = join(resolve(process.cwd()), "config", "assembly.json")
|
|
) {
|
|
// Determine all Packages
|
|
const packages: IPackageConfig[] = (await listPackages(dir)).map((item) => {
|
|
return {
|
|
nameOfPackage: item.package.nameOfPackage,
|
|
defaultInstances: item.package.defaultInstances,
|
|
autostart: item.package.autostart,
|
|
path: item.path,
|
|
};
|
|
});
|
|
|
|
const functions = (await listFunctions(dir)).map((item) => {
|
|
return {
|
|
path: item.path,
|
|
functions: Object.getOwnPropertyNames(item.content || {}),
|
|
};
|
|
});
|
|
|
|
await createFile(
|
|
filename,
|
|
stringifyWithFunctions(
|
|
{
|
|
functions,
|
|
packages,
|
|
},
|
|
4
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Function to load the Packages.
|
|
*
|
|
* @export
|
|
* @param {INopePackageLoader} loader
|
|
* @param {string} filename
|
|
*/
|
|
export async function loadPackages(
|
|
loader: INopePackageLoader,
|
|
filename: string = join(resolve(process.cwd()), "config", "settings.json"),
|
|
delay = 2
|
|
) {
|
|
let data: IConfigFile = {
|
|
functions: [],
|
|
packages: [],
|
|
};
|
|
|
|
try {
|
|
/** Load the File and Parse it. */
|
|
data = parseWithFunctions(await readFile(filename, { encoding: "utf8" }));
|
|
} catch (e) {
|
|
// Generate the Default File
|
|
await writeDefaultConfig(filename);
|
|
|
|
// Show an Hint
|
|
logger.warn(
|
|
"No configuration was present. Created a new config file in " + filename
|
|
);
|
|
|
|
// Readin the newly created Data.
|
|
data = JSON.parse(
|
|
await readFile(filename, {
|
|
encoding: "utf8",
|
|
})
|
|
);
|
|
}
|
|
|
|
// Define the Return Array.
|
|
const packages = new Array<IPackageDescription<any>>();
|
|
|
|
// Scan for the Package-Files
|
|
// And iterate over them.
|
|
for (const item of data.packages) {
|
|
// Now Try to load a Package, to test whether is is an assembly.
|
|
try {
|
|
const loadedPackage = (await import(resolve(item.path)))
|
|
.DESCRIPTION as IPackageDescription<any>;
|
|
loadedPackage.autostart = item.autostart;
|
|
loadedPackage.defaultInstances = item.defaultInstances;
|
|
packages.push(loadedPackage);
|
|
} catch (e) {
|
|
logger.error("Failed Loading the Package " + item.nameOfPackage);
|
|
logger.error(e);
|
|
}
|
|
}
|
|
|
|
await loader.dispatcher.ready.waitFor();
|
|
|
|
// Iterate over the Packages
|
|
for (const thePackageToLoad of packages) {
|
|
try {
|
|
await loader.addPackage(thePackageToLoad);
|
|
} catch (e) {
|
|
logger.error(
|
|
'Failed Add the Package "' +
|
|
thePackageToLoad.nameOfPackage +
|
|
'" to the PackageLoader',
|
|
e
|
|
);
|
|
}
|
|
}
|
|
|
|
if (delay > 0) {
|
|
logger.info(`Waiting ${delay} [s] before creating instances.`);
|
|
await sleep(delay * 1000);
|
|
}
|
|
|
|
// Generate the instances.
|
|
await loader.generateInstances();
|
|
}
|
|
|
|
/**
|
|
* Helper to read function provided in the defined configuration.
|
|
*
|
|
* @author M.Karkowski
|
|
* @export
|
|
* @param {string} [filename=join(resolve(process.cwd()), "config", "assembly.json")]
|
|
* @return {*}
|
|
*/
|
|
export async function loadFunctions(
|
|
loader: INopePackageLoader,
|
|
filename: string = join(resolve(process.cwd()), "config", "settings.json"),
|
|
delay = 2
|
|
) {
|
|
let data: IConfigFile = {
|
|
functions: [],
|
|
packages: [],
|
|
};
|
|
|
|
try {
|
|
/** Load the File and Parse it. */
|
|
data = JSON.parse(await readFile(filename, { encoding: "utf8" }));
|
|
} catch (e) {
|
|
// Generate the Default File
|
|
await writeDefaultConfig(filename);
|
|
|
|
// Show an Hint
|
|
logger.warn(
|
|
"No configuration was present. Created a new config file in " + filename
|
|
);
|
|
|
|
// Readin the newly created Data.
|
|
data = JSON.parse(
|
|
await readFile(filename, {
|
|
encoding: "utf8",
|
|
})
|
|
);
|
|
}
|
|
|
|
// Define the Return Array.
|
|
const successfull = new Array<any>();
|
|
|
|
// Get the container containing all registered Services and Classes.
|
|
const CONTAINER = getCentralDecoratedContainer();
|
|
|
|
// Scan for the Package-Files
|
|
// And iterate over them.
|
|
for (const item of data.functions) {
|
|
// Now Try to load a Package, to test whether is is an assembly.
|
|
try {
|
|
// Load the Function:
|
|
const before = new Set<string>(CONTAINER.services.keys());
|
|
await import(resolve(item.path));
|
|
const after = new Set<string>(CONTAINER.services.keys());
|
|
|
|
const diff = determineDifference(before, after);
|
|
if (diff.added.size > 0) {
|
|
logger.info(
|
|
"loaded services of file",
|
|
'"' + item.path + '"',
|
|
"found:" + JSON.stringify(Array.from(diff.added), undefined, 4)
|
|
);
|
|
}
|
|
|
|
// Mark the file as sucessfully loaded.
|
|
successfull.push(item.path);
|
|
} catch (e) {
|
|
logger.error("Failed Loading function-file at " + item.path);
|
|
logger.error(e);
|
|
}
|
|
}
|
|
|
|
await loader.addDecoratedElements({
|
|
consider: ["services"],
|
|
});
|
|
|
|
if (delay > 0) {
|
|
logger.info(`Waiting ${delay} [s] before creating instances.`);
|
|
await sleep(delay * 1000);
|
|
}
|
|
|
|
return successfull;
|
|
}
|