nope/lib/loader/loadPackages.ts

/**
 * @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 { parseWithFunctions, stringifyWithFunctions } from "../index.browser";
import { getNopeLogger } from "../logger/getLogger";
import { IInstanceCreationMsg } from "../types/nope/nopeCommunication.interface";
import { IPackageDescription } from "../types/nope/nopePackage.interface";
import { INopePackageLoader } from "../types/nope/nopePackageLoader.interface";

export interface IPackageConfig {
  nameOfPackage: string;
  defaultInstances: {
    options: Partial<IInstanceCreationMsg>;
    selector: string | symbol;
  }[];
  autostart: {
    [index: string]: {
      service: string;
      delay?: number;
      params: 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 {
      ret.push({
        package: (await import(resolve(fileName)))
          .DESCRIPTION as IPackageDescription<any>,
        path: fileName,
      });
    } catch (e) {
      getNopeLogger("helper-list-packages").error(
        "Failed Loading the Package " + fileName
      );
      getNopeLogger("helper-list-packages").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 {
      ret.push({
        content: (await import(resolve(fileName))).DESCRIPTION,
        path: fileName,
      });
    } catch (e) {
      getNopeLogger("helper-list-functions").error(
        "Failed Loading the functions in file: " + fileName
      );
      getNopeLogger("helper-list-functions").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
    getNopeLogger("helper-load-packages").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) {
      getNopeLogger("helper-load-packages").error(
        "Failed Loading the Package " + item.nameOfPackage
      );
      getNopeLogger("helper-load-packages").error(e);
    }
  }

  await loader.dispatcher.ready.waitFor((value) => value === true);

  // Iterate over the Packages
  for (const thePackageToLoad of packages) {
    try {
      await loader.addPackage(thePackageToLoad);
    } catch (e) {
      getNopeLogger("helper-load-packages").error(
        'Failed Add the Package "' +
          thePackageToLoad.nameOfPackage +
          '" to the PackageLoader',
        e
      );
    }
  }

  if (delay > 0) {
    getNopeLogger("helper-load-packages").info(
      `Waiting ${delay} [s] before creating instances.`
    );
    await sleep(delay * 1000);
  }

  // Generate the instances.
  await loader.generateInstances();
}

export async function loadFunctions(
  filename: string = join(resolve(process.cwd()), "config", "assembly.json")
) {
  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
    getNopeLogger("helper-load-packages").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 functionPackages = new Array<any>();

  // 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 {
      const loadedFunction = (await import(resolve(item.path)))
        .DESCRIPTION as IPackageDescription<any>;
      functionPackages.push(loadedFunction);
    } catch (e) {
      getNopeLogger("helper-load-packages").error(
        "Failed Loading function-file at " + item.path
      );
      getNopeLogger("helper-load-packages").error(e);
    }
  }

  return functionPackages;
}