@swizzyweb/swerve-manager 0.1.3

package/dist/swerve.js

@@ -0,0 +1,278 @@
+// @ts-ignore
+import express from "@swizzyweb/express";
+import { getFullImportPath, getLoggerForService, } from "./utils/index.js";
+import { SwizzyWinstonLogger, } from "@swizzyweb/swizzy-web-service";
+import os from "node:os";
+import process from "node:process";
+import path from "node:path";
+import { mkdirSync } from "node:fs";
+export var InstanceType;
+(function (InstanceType) {
+    InstanceType["webservice"] = "webservice";
+    InstanceType["stack"] = "stack";
+})(InstanceType || (InstanceType = {}));
+export class SwerveManager {
+    apps;
+    webServices;
+    configurations;
+    constructor(props) {
+        this.apps = props.apps ?? {};
+        this.webServices = props.webServices ?? [];
+    }
+    async run(request) {
+        const { args } = request;
+        const newWebServices = await this.runWithArgs({
+            args,
+        });
+        this.webServices.push(...newWebServices);
+        return { webServices: newWebServices };
+    }
+    async runWithArgs(request) {
+        const { args } = request;
+        const logLevel = process.env.LOG_LEVEL ?? args.logLevel ?? "info";
+        let gLogger = new SwizzyWinstonLogger({
+            port: 0,
+            logLevel,
+            appDataRoot: args.appDataRoot ?? ".",
+            appName: `swerve`,
+            hostName: os.hostname(),
+            ownerName: "swerve",
+            pid: process.pid,
+        });
+        try {
+            const webServices = [];
+            const newApps = {};
+            for (const serviceEntry of Object.entries(args.services)) {
+                const port = serviceEntry[1].port ?? args.port;
+                if (!this.apps[`${port}`]) {
+                    this.apps[`${port}`] = { app: await express(), services: {} };
+                    newApps[`${port}`] = this.apps[`${port}`];
+                }
+                const app = this.apps[`${port}`].app;
+                const service = serviceEntry[1];
+                const packageName = serviceEntry[0];
+                const importPathOrName = service.servicePath ?? service.packageName;
+                gLogger.debug(`importPathOrName ${importPathOrName}`);
+                const serviceArgs = {
+                    ...service,
+                    ...service.serviceConfiguration,
+                    ...args.serviceArgs,
+                };
+                const webservice = await this.installWebService({
+                    serviceKey: serviceEntry[0],
+                    packageName,
+                    importPathOrName,
+                    port,
+                    app,
+                    appDataRoot: args.appDataRoot,
+                    serviceArgs,
+                    gLogger,
+                });
+                this.apps[`${port}`].services[webservice.instanceId] = {
+                    webService: webservice,
+                    serviceArgs,
+                    runRequest: request,
+                };
+                webServices.push(webservice);
+            }
+            for (const newAppEntry of Object.entries(newApps)) {
+                const [port, appRecord] = newAppEntry;
+                const newApp = appRecord.app;
+                const server = await newApp.listen(port, () => {
+                    //          this.apps[port].services[newApp.instanceId] = {};
+                    gLogger.debug(`New app listening on port ${port}`);
+                });
+                this.apps[`${port}`].server = server;
+            }
+            for (const webService of webServices) {
+                gLogger.info(`${webService.name} running on port ${webService.port}`);
+            }
+            return webServices;
+        }
+        catch (e) {
+            gLogger.error(`Error occurred initializing service\n ${e.message}\n ${e.stack ?? {}}`);
+        }
+    }
+    async runWithApp(props) {
+        const { app, args } = props;
+        let gLogger = new SwizzyWinstonLogger({
+            port: 0,
+            logLevel: process.env.LOG_LEVEL ?? "info",
+            appDataRoot: args.appDataRoot,
+            appName: `swerve`,
+            hostName: os.hostname(),
+            pid: process.pid,
+        });
+        try {
+            gLogger = new SwizzyWinstonLogger({
+                logLevel: args.serviceArgs.logLevel ?? process.env.LOG_LEVEL ?? "info",
+                port: args.port,
+                logDir: args.appDataRoot,
+                appName: `swerve`,
+                hostName: os.hostname(),
+                pid: process.pid,
+            });
+            gLogger.debug(`Swerve Args: ${JSON.stringify(args)}`);
+            const PORT = args.port ?? 3005;
+            const webServices = [];
+            for (const serviceEntry of Object.entries(args.services)) {
+                const service = serviceEntry[1];
+                const packageName = service.packageName;
+                const importPathOrName = service.servicePath ?? service.serviceArgs.servicePath ?? packageName;
+                const webservice = await this.installWebService({
+                    serviceKey: serviceEntry[0],
+                    packageName,
+                    importPathOrName,
+                    port: PORT,
+                    app,
+                    appDataRoot: args.appDataRoot,
+                    serviceArgs: {
+                        ...service,
+                        ...service.serviceConfiguration,
+                        ...args.serviceArgs,
+                    },
+                    gLogger,
+                });
+                webServices.push(webservice);
+            }
+            return webServices;
+        }
+        catch (e) {
+            gLogger.error(`Error occurred initializing service\n ${e.message}\n ${e.stack ?? {}}`);
+        }
+    }
+    async installWebService(props) {
+        //  const packageName = importPathOrName;
+        const { app, appDataRoot, packageName, port, gLogger, serviceArgs, importPathOrName, serviceKey, } = props;
+        try {
+            gLogger.info(`Getting webservice package ${packageName} and will run on port ${port}`);
+            gLogger.debug(`Getting tool with path: ${importPathOrName}`);
+            const fullPath = 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(appDataRoot, "appdata", serviceKey);
+            mkdirSync(appDataPath, { recursive: true });
+            const logger = getLoggerForService(serviceArgs, serviceKey, port, gLogger);
+            gLogger.debug(`serviceArgs for ${packageName}: ${serviceArgs}`);
+            const service = await tool.getWebservice({
+                appDataPath,
+                ...serviceArgs,
+                port,
+                app,
+                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, error: ${e?.message} stack: ${e?.stack}`);
+            throw e; //new Error(exceptionMessage);
+        }
+    }
+    async stop(request) {
+        const { instanceDetails } = request;
+        const { instanceId, instanceType } = instanceDetails;
+        const instanceIds = [];
+        if (!instanceId) {
+            throw new Error(`Instance id required to stop web service`);
+        }
+        if (instanceType === InstanceType.webservice) {
+            //      console.log(`Matched instance type`);
+            instanceIds.push(`${instanceId}`);
+        }
+        else if (instanceType === InstanceType.stack) {
+            // TODO: implement
+            throw new Error(`Stack instance type is not yet supported`);
+        }
+        else {
+            //     this.logger.error(`Invalid instance details ${instanceDetails}`);
+            throw new Error(`Invalid instance details provided`);
+        }
+        //    console.log(`instanceIds: ${instanceIds}`);
+        const webServices = this.webServices.filter((service) => {
+            //      console.log(`instanceId ${service.instanceId}`);
+            return instanceIds.includes(`${service.instanceId}`);
+        });
+        if (!webServices || webServices.length < 1) {
+            //console.error(webServices); //this.webServices);
+            throw new Error(`WebService with instanceId ${instanceId} not found while attempting to stop`);
+        }
+        const ports = [];
+        for (const webService of webServices) {
+            const port = webService.port;
+            ports.push(port);
+            //console.log(webService);
+            await webService.uninstall({});
+            const indexes = this.webServices
+                .map((val, index, array) => {
+                //console.log(
+                //            `instanceInSwerve: ${val.instanceId} instanceInWebService ${webService.instanceId}`,
+                //          );
+                if (val.instanceId == webService.instanceId) {
+                    return index;
+                }
+                return undefined;
+            })
+                .filter((val) => val != undefined);
+            //.filter((val) => val);
+            if (indexes.length > 1) {
+                throw new Error(`Found multiple indexes for webservice instance ${webService.instanceId} ${indexes}`);
+            }
+            else if (indexes.length == 0) {
+                throw new Error(`No indexes for webservice instance ${webService.instanceId}`);
+            }
+            const index = indexes[0];
+            this.webServices.splice(index, 1);
+            if (!this.apps[`${port}`]?.services[webService.instanceId]) {
+                //console.log(`Apps does not contain service`);
+                // TODO: DO SOMETHING, log, throw maybe.
+            }
+            else {
+                delete this.apps[`${port}`].services[webService.instanceId];
+            }
+        }
+        //cleanup apps if no more services
+        for (const port of ports) {
+            const { services, server, app } = this.apps[`${port}`];
+            if (!services || Object.keys(services).length == 0) {
+                if (server) {
+                    server.close();
+                }
+                else {
+                    continue;
+                    // TODO: do something, log throw etc
+                }
+                delete this.apps[`${port}`];
+            }
+        }
+    }
+    async getRunningWebServices(props) {
+        const webservices = {};
+        for (const webservice of this.webServices) {
+            const instanceId = webservice.instanceId;
+            const { runRequest, serviceArgs } = this.apps[webservice.port].services[instanceId];
+            webservices[instanceId] = {
+                webService: webservice.toJson(),
+                serviceConfig: runRequest?.args,
+            };
+        }
+        return {
+            webServices: webservices,
+        };
+    }
+}

package/dist/utils/getArgs.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from "@swizzyweb/swizzy-common";
+import { IConfig, IService, KeyValue } from "../config/index.js";
+export declare function getServiceNameFromCurrentDirPackage(logger: ILogger<any>): string;
+export interface SwerveArgs extends IConfig {
+    services: KeyValue<IService>;
+    port: number;
+    appDataRoot?: string;
+    serviceArgs?: KeyValue<any>;
+    logLevel: string;
+    [key: string]: any;
+}
+export declare function getArgs(args: string[], logger: ILogger<any>): Promise<SwerveArgs>;

package/dist/utils/getArgs.js

@@ -0,0 +1,208 @@
+import path from "node:path";
+import process from "node:process";
+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) {
+    try {
+        return process.cwd();
+    }
+    catch (e) {
+        logger.debug(`Error getting package from current dir package.json ${e}`);
+        throw e;
+    }
+}
+function getAppDataRoot(appDataRootPath, logger) {
+    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, logger) {
+    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;
+    }
+}
+function getDefaultArgs() {
+    let currentServiceName = undefined;
+    return {
+        logLevel: "info",
+        services: {},
+        port: 3005,
+        serviceArgs: {},
+    };
+}
+const ARG_PREFIX = "--";
+const CONFIG_ARG_KEY = "config";
+function cliArgToPropertyName(rawArg) {
+    return rawArg.replace(ARG_PREFIX, "");
+}
+const configParser = new SwerveConfigParser();
+async function getConfigValuesFromPath(configPath, logger) {
+    try {
+        return await configParser.parse(configPath);
+    }
+    catch (e) {
+        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) {
+    return topLevelArgs.has(key);
+}
+function tryParseNumberArg(val) {
+    try {
+        return parseInt(val);
+    }
+    catch (e) {
+        return false;
+    }
+}
+function parseArgValue(val, logger) {
+    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, logger) {
+    let argKey = undefined;
+    let swerveArgs = getDefaultArgs();
+    let configFromFile;
+    const serviceCounts = new Map();
+    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());
+        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/dist/utils/getPackageJson.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 declare function getPackageJson(packageNameOrPath: string): {
+    packageJson: Record<string, any>;
+    servicePath: string;
+} | null;
+/**
+ * Get the nearest package.json of a given import name.
+ * @param packageName The name of the imported package (e.g. "lodash")
+ */
+export declare function getPackageJsonOrig(packageName: string): Record<string, any> | null;

package/dist/utils/getPackageJson.js

@@ -0,0 +1,78 @@
+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) {
+    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) {
+    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) {
+    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/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

package/dist/utils/installWebservice.d.ts

@@ -0,0 +1,4 @@
+import { ILogger } from "@swizzyweb/swizzy-common";
+export declare function installWebService(appName: string, importPathOrName: string, port: number, expressApp: any, serviceArgs: any, gLogger: ILogger<any>): Promise<any>;
+export declare function getFullImportPath(importPathOrName: string): Promise<string>;
+export declare function getLoggerForService(serviceArgs: any, appName: string, port: number, gLogger: ILogger<any>): ILogger<any>;