@swizzyweb/swerve-manager 0.1.3

package/src/utils/getArgs.ts

@@ -0,0 +1,256 @@
+// @ts-ignore
+import { ILogger } from "@swizzyweb/swizzy-common";
+import path from "node:path";
+import process from "node:process";
+import { IConfig, IService, KeyValue } from "../config/index.js";
+import { SwerveConfigParser } from "../config/config-parser.js";
+import { deepMerge } from "@swizzyweb/swizzy-common";
+import { getPackageJson } from "./getPackageJson.js";
+
+function getHelpText() {
+  return `Help --
+npm run server <serviceName> <port (optional)>
+		`;
+}
+
+export function getServiceNameFromCurrentDirPackage(logger: ILogger<any>) {
+  try {
+    return process.cwd();
+  } catch (e) {
+    logger.debug(`Error getting package from current dir package.json ${e}`);
+    throw e;
+  }
+}
+
+function getAppDataRoot(
+  appDataRootPath: string | undefined,
+  logger: ILogger<any>,
+) {
+  try {
+    let directory;
+    if (!appDataRootPath || appDataRootPath === ".") {
+      directory = getServiceNameFromCurrentDirPackage(logger);
+    } else {
+      directory = appDataRootPath;
+    }
+    return directory;
+  } catch (e) {
+    throw {
+      message: `Unable to get app data root ${appDataRootPath}`,
+      exception: e,
+    };
+  }
+}
+
+function getService(serviceName: string | undefined, logger: ILogger<any>) {
+  try {
+    let directory;
+    let packageJson;
+    if (!serviceName || serviceName === ".") {
+      directory = getServiceNameFromCurrentDirPackage(logger);
+      //      packageJson = getPackageJsonFromDirectory(directory);
+      const packageResult = getPackageJson(directory);
+      packageJson = packageResult.packageJson;
+      directory = packageResult.servicePath;
+    } else if (serviceName && serviceName.startsWith(".")) {
+      //      directory = serviceName;
+      //      const jsonPath = path.join(serviceName);
+      //      packageJson = getPackageJsonFromDirectory(path.resolve(jsonPath));
+      const packageResult = getPackageJson(serviceName);
+      packageJson = packageResult.packageJson;
+      directory = packageResult.servicePath;
+    } else {
+      return getPackageJson(serviceName);
+    }
+
+    const response = {
+      servicePath: directory,
+      packageJson,
+    };
+    logger.debug(`response ${response}`);
+    return response;
+  } catch (e) {
+    const ex = {
+      message: "Error getting service name",
+      serviceName,
+      error: e,
+    };
+    throw ex;
+  }
+}
+
+export interface SwerveArgs extends IConfig {
+  services: KeyValue<IService>;
+  port: number;
+  appDataRoot?: string;
+  serviceArgs?: KeyValue<any>;
+  logLevel: string;
+  [key: string]: any;
+}
+
+function getDefaultArgs(): SwerveArgs {
+  let currentServiceName = undefined;
+
+  return {
+    logLevel: "info",
+    services: {},
+    port: 3005,
+    serviceArgs: {},
+  };
+}
+const ARG_PREFIX = "--";
+const CONFIG_ARG_KEY = "config";
+
+function cliArgToPropertyName(rawArg: string): string {
+  return rawArg.replace(ARG_PREFIX, "");
+}
+
+const configParser = new SwerveConfigParser();
+
+async function getConfigValuesFromPath(
+  configPath: string,
+  logger: ILogger<any>,
+) {
+  try {
+    return await configParser.parse(configPath);
+  } catch (e: any) {
+    logger.error(`Error occurred parsing config values from path`);
+    throw {
+      message:
+        "Unexpected error occurred when attempting to read serviceConfiguration file",
+      configFilePath: configPath,
+      error: e,
+    };
+  }
+}
+const topLevelArgs = new Set();
+topLevelArgs.add("port");
+function isTopLevelArg(key: string) {
+  return topLevelArgs.has(key);
+}
+
+function tryParseNumberArg(val): number | boolean {
+  try {
+    return parseInt(val);
+  } catch (e) {
+    return false;
+  }
+}
+
+function parseArgValue(val: string, logger: ILogger<any>) {
+  try {
+    return JSON.parse(val);
+  } catch (e) {
+    logger.warn(
+      `Exception occurred while parsing arg value ${val}. This is sometimes expected. Error ${e}`,
+    );
+  }
+
+  return val;
+}
+
+const DEFAULT_PORT = 3005;
+export async function getArgs(
+  args: string[],
+  logger: ILogger<any>,
+): Promise<SwerveArgs> {
+  let argKey = undefined;
+  let swerveArgs = getDefaultArgs();
+  let configFromFile: IConfig;
+  const serviceCounts = new Map<string, number>();
+  for (let i = 2; i < args.length; i++) {
+    const nextVal = args[i];
+    if (argKey) {
+      if (argKey == CONFIG_ARG_KEY) {
+        if (configFromFile) {
+          throw new Error(
+            `Config file already specified, you can only specify one config file with the --config arg`,
+          );
+        }
+        configFromFile = await getConfigValuesFromPath(nextVal, logger);
+        argKey = undefined;
+        continue;
+      }
+      swerveArgs.serviceArgs[argKey] = parseArgValue(nextVal, logger);
+      argKey = undefined;
+      continue;
+    }
+    if (nextVal.startsWith(ARG_PREFIX)) {
+      argKey = cliArgToPropertyName(nextVal);
+      continue;
+    }
+
+    const serviceDetails = getService(nextVal, logger);
+    const serviceName = serviceDetails.packageJson.name;
+    const serviceIndex = serviceCounts.get(serviceName) ?? 0;
+    serviceCounts.set(serviceName, serviceIndex + 1);
+    swerveArgs.services[`${serviceDetails.packageJson.name}-${serviceIndex}`] =
+      {
+        serviceConfiguration: {},
+        ...serviceDetails,
+      };
+  }
+
+  swerveArgs.port =
+    configFromFile?.port ?? swerveArgs.serviceArgs?.port ?? DEFAULT_PORT;
+
+  logger.debug(`configFromFile ${configFromFile}`);
+  if (configFromFile?.services) {
+    logger.debug(`ConfigFromFile has service`);
+    for (const serviceEntry of Object.entries(configFromFile.services)) {
+      let { servicePath, packageName } = serviceEntry[1];
+      //        serviceEntry[1].servicePath ?? serviceEntry[1].packageName;
+      if (!servicePath) {
+        serviceEntry[1].servicePath = packageName!;
+        //        throw new Error(
+        //        `servicePath or packageName must be set in service configurations`,
+        //      );
+      } else {
+        const serviceData = getService(servicePath, logger);
+        serviceEntry[1].packageName = serviceData.packageJson?.name;
+        serviceEntry[1].servicePath = serviceData.servicePath;
+      }
+      //      logger.debug(`ServiceName: ${}`);
+      swerveArgs.services[serviceEntry[0]] = await deepMerge(
+        await deepMerge(
+          swerveArgs.serviceArgs ?? {},
+          serviceEntry.values() ?? {},
+        ),
+        configFromFile.services[serviceEntry[0]],
+      );
+    }
+    logger.debug(`packagedConfigFromFile into services`);
+  }
+  swerveArgs = deepMerge(swerveArgs, configFromFile ?? {});
+  logger.debug(`${JSON.stringify(swerveArgs)}`);
+
+  if (
+    swerveArgs.serviceArgs?.appDataRoot?.startsWith(".") ||
+    swerveArgs.serviceArgs?.appDataRoot == undefined
+  ) {
+    const appDataRootPath = path.join(
+      process.cwd(),
+      //      Object.values(swerveArgs.services)[0].servicePath,
+    );
+
+    swerveArgs.appDataRoot = appDataRootPath;
+    swerveArgs.serviceArgs.appDataRoot = appDataRootPath;
+  } else {
+    swerveArgs.appDataRoot = swerveArgs.serviceArgs.appDataRoot;
+  }
+
+  if (Object.keys(swerveArgs.services).length < 1) {
+    logger.info(`swerveArgs.services.length < 1`);
+    const { servicePath, packageJson } = getService(".", logger);
+    swerveArgs.services[packageJson.name] = {
+      servicePath,
+      packageJson,
+      appDataRoot: swerveArgs.appDataRoot,
+      ...swerveArgs.serviceArgs,
+    };
+  }
+  logger.debug(
+    `getArgs complete with parsed swerveArgs: ${JSON.stringify(swerveArgs)}`,
+  );
+  return swerveArgs;
+}

package/src/utils/getPackageJson.ts

@@ -0,0 +1,90 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/**
+ * Determines whether the input string is a relative or absolute path.
+ */
+function isPath(input: string): boolean {
+  return input.startsWith(".") || path.isAbsolute(input);
+}
+
+/**
+ * Resolves the package.json file for a given package name or path.
+ * @param packageNameOrPath Package name (e.g., 'lodash', '@nestjs/core') or path (e.g., './node_modules/lodash')
+ * @returns Parsed package.json content or null
+ */
+export function getPackageJson(
+  packageNameOrPath: string,
+): { packageJson: Record<string, any>; servicePath: string } | null {
+  try {
+    // Step 1: Resolve to an absolute path
+    //    const resolvedEntry = isPath(packageNameOrPath)
+    //    ? require.resolve(path.resolve(packageNameOrPath))
+    //      : //      : require.resolve(packageNameOrPath);
+    //        require.resolve(packageNameOrPath, { paths: [process.cwd()] });
+    const resolvedEntry = isPath(packageNameOrPath)
+      ? pathToFileURL(path.resolve(packageNameOrPath)).href
+      : import.meta.resolve(packageNameOrPath);
+
+    // Step 2: Traverse upward to find the nearest package.json
+    let dir = fileURLToPath(resolvedEntry); //path.dirname(resolvedEntry);
+    //    console.log(dir);
+    while (dir !== path.parse(dir).root) {
+      const pkgPath = path.join(dir, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const content = fs.readFileSync(pkgPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        if (!dir || dir === ".") {
+          dir = process.cwd();
+        } else if (dir.startsWith(".")) {
+          dir = path.join(process.cwd(), dir);
+        }
+        //      console.log(dir);
+        const entrypoint = path.join(dir, packageJson.main);
+        //    console.log(entrypoint);
+        //   console.error(`Entrypoint is ${entrypoint}`);
+        //        throw `Entrypoint is ${entrypoint}`;
+        return { packageJson, servicePath: entrypoint };
+      }
+      dir = path.dirname(dir);
+    }
+
+    throw new Error(`Could not parse package.json`);
+  } catch (err) {
+    throw new Error(
+      `Could not resolve package.json for "${packageNameOrPath}"`,
+    );
+  }
+}
+/**
+ * Get the nearest package.json of a given import name.
+ * @param packageName The name of the imported package (e.g. "lodash")
+ */
+export function getPackageJsonOrig(
+  packageName: string,
+): Record<string, any> | null {
+  try {
+    // Resolve the entry file of the package
+    const entryPath = import.meta.resolve(packageName); //require.resolve(packageName);
+
+    // Traverse up from the resolved file to find package.json
+    let dir = path.dirname(entryPath);
+
+    while (dir !== path.parse(dir).root) {
+      const pkgPath = path.join(dir, "package.json");
+
+      if (fs.existsSync(pkgPath)) {
+        const content = fs.readFileSync(pkgPath, "utf8");
+        return { packageJson: JSON.parse(content), servicePath: dir };
+      }
+
+      dir = path.dirname(dir);
+    }
+
+    return null;
+  } catch (error) {
+    //console.error(`Failed to resolve package "${packageName}":`, error);
+    return null;
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./getArgs.js";
+export * from "./installWebservice.js";

package/src/utils/installWebservice.ts

@@ -0,0 +1,131 @@
+// @ts-ignore
+import express, { Request, Response } from "@swizzyweb/express";
+import {
+  BrowserLogger,
+  getPackageJsonFromDirectory,
+  ILogger,
+} from "@swizzyweb/swizzy-common";
+import { SwizzyWinstonLogger } from "@swizzyweb/swizzy-web-service";
+import { readFileSync } from "fs";
+import path from "node:path";
+import os from "node:os";
+import process from "node:process";
+import { getServiceNameFromCurrentDirPackage } from "./getArgs.js";
+import { mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export async function installWebService(
+  appName: string,
+  importPathOrName: string,
+  port: number,
+  expressApp: any,
+  serviceArgs: any,
+  gLogger: ILogger<any>,
+) {
+  const packageName = importPathOrName;
+
+  try {
+    gLogger.info(
+      `Getting webservice package ${packageName} and will run on port ${port}`,
+    );
+
+    gLogger.debug(`Getting tool with path: ${importPathOrName}`);
+
+    const fullPath = importPathOrName; //await getFullImportPath(importPathOrName);
+    const tool = await import(fullPath); //require(fullPath); //require(packageName as string);
+
+    gLogger.debug(`Got service with require: ${JSON.stringify(tool)}`);
+    gLogger.debug(`Getting web service from tool...`);
+
+    const appDataPath = path.join(serviceArgs.appDataRoot, "appdata", appName);
+    mkdirSync(appDataPath, { recursive: true });
+
+    const logger = getLoggerForService(
+      serviceArgs,
+      serviceArgs.appName,
+      port,
+      gLogger,
+    );
+    gLogger.debug(`serviceArgs for ${packageName}: ${serviceArgs}`);
+    const service = await tool.getWebservice({
+      appDataPath,
+      ...serviceArgs,
+      port,
+      app: expressApp,
+      packageName,
+      serviceArgs: { ...serviceArgs },
+      logger,
+    });
+
+    logger.debug(`Got web service`);
+
+    gLogger.debug(`Installing web service...`);
+    await service.install({});
+
+    gLogger.debug(`Installed web service ${packageName}`);
+    return service;
+  } catch (e) {
+    const exceptionMessage = `exception: ${e}
+Failed to install web service, is it installed with NPM? Check package exists in node_modules
+    To add, run:
+			npm install ${packageName ?? "packageName"}
+		args:
+			packageName: ${packageName}
+			port: ${port}
+`;
+    //		${getHelpText}`;
+    gLogger.error(`Failed to install web service`);
+    throw Error(exceptionMessage); //new Error(exceptionMessage);
+  }
+}
+
+export async function getFullImportPath(
+  importPathOrName: string,
+): Promise<string> {
+  const importPath = importPathOrName.startsWith(".")
+    ? path.join(process.cwd(), importPathOrName)
+    : importPathOrName;
+  let fullPath;
+  if (importPathOrName === importPath) {
+    const fullUrl = import.meta.resolve(importPath, import.meta.url);
+    fullPath = fileURLToPath(fullUrl);
+    //    const pkg = await import(fullUrl, {
+    //      assert: { type: "json" },
+    //    });
+
+    //      await require.resolve(importPath, {
+    //      paths: [process.cwd()],
+    //    });
+  } else {
+    fullPath = importPath;
+  }
+
+  return fullPath;
+}
+
+export function getLoggerForService(
+  serviceArgs: any,
+  appName: string,
+  port: number,
+  gLogger: ILogger<any>,
+) {
+  const logLevel = serviceArgs.logLevel ?? gLogger.getLoggerProps().logLevel;
+  const logFileName = serviceArgs.logFileName ?? undefined;
+  const ownerName = appName;
+  const pid = process.pid;
+  const hostName = os.hostname();
+  const logDir = serviceArgs.logDir;
+  const appDataRoot = serviceArgs.appDataRoot;
+
+  return gLogger.clone({
+    port,
+    appName,
+    appDataRoot,
+    logDir,
+    hostName,
+    pid,
+    logLevel,
+    ownerName,
+    logFileName,
+  });
+}

package/test/config/config.spec.ts

@@ -0,0 +1,23 @@
+import { IConfig } from "../../dist/config/config.js";
+
+describe(`Config tests`, () => {
+  it("Should accept service configuration", () => {
+    const config: IConfig = {
+      port: 3005,
+      services: {
+        dynserve: {
+          packageName: "@swizzyweb/dyn-serve-web-service",
+
+          serviceConfiguration: {
+            myVar: "thisisit",
+            butThis: {
+              echo: ["isNumber", 1],
+            },
+          },
+        },
+      },
+    };
+
+    // Noop, fails if model changed
+  });
+});

package/test/config/serviceConfig.json

@@ -0,0 +1,19 @@
+{
+  "port": 3000,
+  "services": {
+    "my-first-web-service1": {
+      "someOtherArgFromConfig": "ThisIsTheArgValue",
+      "someNumberINeed": 100,
+      "shouldTimeout": true,
+      "nestedJson": {
+        "hello": "world",
+        "none": false
+      },
+      "packageName": "@swizzyweb/my-first-web-service",
+      "serviceConfiguration": {
+        "port": 3001,
+        "tableName": "someString"
+      }
+    }
+  }
+}