@swizzyweb/swerve-manager 0.1.5 → 0.1.7

package/README.md

@@ -3,6 +3,10 @@
 swizzy-swerve is a bootstrapper for swizzy web services. This package will bootstrap and run
 independent swizzy web services.
 
+## Docs
+
+https://swizzyweb.github.io/swerve-manager/
+
 ### Supported commands
 
 swerve: synonym for swerven
@@ -201,7 +205,7 @@ appDataPath: "/appDataRoot/appdata/serviceName/"
     },
     "friendlyImportServiceName": {
       "port": 3002,
-      "servicePath": "@swizzyweb/dyn-serve-web-service" // running installed web service package
+      "packageName": "@swizzyweb/dyn-serve-web-service" // running installed web service package
     },
     "friendlyNeighborServiceName": {
       "port": 3002,
@@ -217,3 +221,9 @@ appDataPath: "/appDataRoot/appdata/serviceName/"
 ```
 swerve --config my-web-service-config.json
 ```
+
+# Generate Docs
+
+```
+npx typedoc
+```

package/dist/swerve.d.ts

@@ -50,6 +50,8 @@ export type Apps = {
 export interface SwerveManagerProps {
     apps?: Apps;
     webServices?: WebService<any>[];
+    nodeModulesPath?: string;
+    logger?: ILogger<any> | undefined;
 }
 export interface WebServiceConfiguration {
 }
@@ -60,13 +62,15 @@ export declare class SwerveManager implements ISwerveManager {
     apps: Apps;
     webServices: WebService<any>[];
     configurations: WebServiceConfigurations;
+    nodeModulesPath: string;
+    logger: ILogger<any>;
     constructor(props: SwerveManagerProps);
     run(request: RunRequest): Promise<RunResponse>;
     runWithArgs(request: RunRequest): Promise<WebService<any>[]>;
     private runWithApp;
     installWebService(props: {
         serviceKey: string;
-        importPathOrName: string;
+        servicePath: string;
         app: Application;
         appDataRoot: string;
         packageName: string;
@@ -76,6 +80,7 @@ export declare class SwerveManager implements ISwerveManager {
             [key: string]: any;
         };
     }): Promise<any>;
+    getImportName(packageName: string, servicePath: string): Promise<string>;
     stop(request: StopRequest): Promise<void>;
     getRunningWebServices(props: GetRunningWebServiceRequest): Promise<GetRunningWebServiceResponse>;
 }

package/dist/swerve.js

@@ -6,7 +6,7 @@ import os from "node:os";
 import process from "node:process";
 import path from "node:path";
 import { mkdirSync } from "node:fs";
-import { getFullImportPath } from "./utils/getFullImportPath.js";
+import { getFullImportPath, resolvePackageEntry, } from "./utils/getFullImportPath.js";
 export var InstanceType;
 (function (InstanceType) {
     InstanceType["webservice"] = "webservice";
@@ -16,9 +16,19 @@ export class SwerveManager {
     apps;
     webServices;
     configurations;
+    nodeModulesPath;
+    logger;
     constructor(props) {
         this.apps = props.apps ?? {};
         this.webServices = props.webServices ?? [];
+        this.nodeModulesPath = props.nodeModulesPath;
+        this.logger =
+            props.logger ??
+                new SwizzyWinstonLogger({
+                    appName: "swerve-manager",
+                    port: -1,
+                    hostName: os.hostname(),
+                });
     }
     async run(request) {
         const { args } = request;
@@ -53,17 +63,16 @@ export class SwerveManager {
                 const service = serviceEntry[1];
                 const serviceName = serviceEntry[0];
                 const packageName = service.packageName;
-                const importPathOrName = service.servicePath ?? service.packageName;
-                gLogger.debug(`importPathOrName ${importPathOrName}`);
+                gLogger.debug(`servicePath: ${service.servicePath}`);
                 const serviceArgs = {
                     ...service,
                     ...service.serviceConfiguration,
                     ...args.serviceArgs,
                 };
                 const webservice = await this.installWebService({
-                    serviceKey: serviceEntry[0],
+                    serviceKey: serviceName,
                     packageName,
-                    importPathOrName,
+                    servicePath: service.servicePath,
                     port,
                     app,
                     appDataRoot: args.appDataRoot,
@@ -120,11 +129,10 @@ export class SwerveManager {
             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,
+                    servicePath: service.servicePath,
                     port: PORT,
                     app,
                     appDataRoot: args.appDataRoot,
@@ -144,18 +152,17 @@ export class SwerveManager {
         }
     }
     async installWebService(props) {
-        //  const packageName = importPathOrName;
-        const { app, appDataRoot, packageName, port, gLogger, serviceArgs, importPathOrName, serviceKey, } = props;
+        const { app, appDataRoot, packageName, port, gLogger, serviceArgs, servicePath, serviceKey, } = props;
         try {
             gLogger.info(`Getting webservice package ${packageName} and will run on port ${port}`);
             if (packageName) {
                 gLogger.debug(`Getting web service with name ${packageName}`);
             }
             else {
-                gLogger.debug(`Getting webservice with path: ${importPathOrName}`);
+                gLogger.debug(`Getting webservice with path: ${servicePath}`);
             }
-            const fullPath = packageName ?? (await getFullImportPath(importPathOrName));
-            const tool = await import(fullPath); //require(fullPath); //require(packageName as string);
+            const fullPath = await this.getImportName(packageName, servicePath);
+            const tool = await import(fullPath);
             gLogger.debug(`Got service with require: ${JSON.stringify(tool)}`);
             gLogger.debug(`Getting web service from tool...`);
             const appDataPath = path.join(appDataRoot, "appdata", serviceKey);
@@ -168,6 +175,7 @@ export class SwerveManager {
                 port,
                 app,
                 packageName,
+                servicePath,
                 serviceArgs: { ...serviceArgs },
                 logger,
             });
@@ -191,6 +199,22 @@ Failed to install web service, is it installed with NPM? Check package exists in
             throw e; //new Error(exceptionMessage);
         }
     }
+    async getImportName(packageName, servicePath) {
+        const nodeModulesPath = this.nodeModulesPath;
+        this.logger.debug(`getImportPathName: modulesPath: ${nodeModulesPath}`);
+        if (servicePath) {
+            return await getFullImportPath(servicePath);
+        }
+        else {
+            if (nodeModulesPath) {
+                this.logger.debug(`Getting path with nodeModulesPath and packageName ${nodeModulesPath} ${packageName}`);
+                return await resolvePackageEntry(path.join(nodeModulesPath, packageName));
+            }
+            else {
+                return packageName;
+            }
+        }
+    }
     async stop(request) {
         const { instanceDetails } = request;
         const { instanceId, instanceType } = instanceDetails;

package/dist/utils/getFullImportPath.d.ts

@@ -1 +1,2 @@
 export declare function getFullImportPath(importPathOrName: string): Promise<string>;
+export declare function resolvePackageEntry(pkgDir: string): Promise<string>;

package/dist/utils/getFullImportPath.js

@@ -1,4 +1,6 @@
 // cross-runtime getFullImportPath.ts
+import { promises as fs } from "node:fs";
+import { pathToFileURL } from "node:url";
 // Runtime detection
 // @ts-ignore
 const isDeno = typeof Deno !== "undefined" && "cwd" in Deno;
@@ -51,3 +53,30 @@ export async function getFullImportPath(importPathOrName) {
     }
     return importPath;
 }
+export async function resolvePackageEntry(pkgDir) {
+    const pkgJsonPath = join(pkgDir, "package.json");
+    let entry;
+    try {
+        const pkgJsonRaw = await fs.readFile(pkgJsonPath, "utf-8");
+        const pkgJson = JSON.parse(pkgJsonRaw);
+        if (pkgJson.exports && typeof pkgJson.exports === "string") {
+            // Simple "exports": "./esm/index.js"
+            entry = pkgJson.exports;
+        }
+        else if (pkgJson.module) {
+            entry = pkgJson.module;
+        }
+        else if (pkgJson.main) {
+            entry = pkgJson.main;
+        }
+    }
+    catch {
+        // no package.json, fallback below
+    }
+    if (!entry) {
+        // fallback to index.js
+        entry = "index.js";
+    }
+    const absPath = join(pkgDir, entry);
+    return pathToFileURL(absPath).href; // usable in await import()
+}

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@swizzyweb/swerve-manager",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "swizzy-swerve is a bootstrapper for swizzy web services. This package will bootstrap and run independent swizzy web services.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "tsc",
-    "server:ts": "ts-node ./src/bootstrap.ts",
     "server": "node dist/bootstrap.js",
     "test": "npm run test:node && npm run test:bun && npm run test:deno",
     "test:node": "node --test ./test**/*.spec.ts",
@@ -30,7 +29,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/swizzyweb/swerve.git"
+    "url": "git+https://github.com/swizzyweb/swerve-manager.git"
   },
   "keywords": [
     "swizzy",
@@ -42,7 +41,7 @@
     "runner"
   ],
   "bugs": {
-    "url": "https://github.com/swizzyweb/swerve/issues"
+    "url": "https://github.com/swizzyweb/swerve-manager/issues"
   },
-  "homepage": "https://github.com/swizzyweb/swerve#readme"
+  "homepage": "https://github.com/swizzyweb/swerve-manager#readme"
 }

package/src/swerve.ts

@@ -16,7 +16,10 @@ import process from "node:process";
 import { ILogger } from "@swizzyweb/swizzy-common";
 import path from "node:path";
 import { mkdirSync } from "node:fs";
-import { getFullImportPath } from "./utils/getFullImportPath.js";
+import {
+  getFullImportPath,
+  resolvePackageEntry,
+} from "./utils/getFullImportPath.js";
 
 export interface ISwerveManager {
   run(request: RunRequest): Promise<RunResponse>;
@@ -74,6 +77,8 @@ export type Apps = {
 export interface SwerveManagerProps {
   apps?: Apps;
   webServices?: WebService<any>[];
+  nodeModulesPath?: string;
+  logger?: ILogger<any> | undefined;
 }
 
 export interface WebServiceConfiguration {}
@@ -86,9 +91,19 @@ export class SwerveManager implements ISwerveManager {
   apps: Apps;
   webServices: WebService<any>[];
   configurations: WebServiceConfigurations;
+  nodeModulesPath: string;
+  logger: ILogger<any>;
   constructor(props: SwerveManagerProps) {
     this.apps = props.apps ?? {};
     this.webServices = props.webServices ?? [];
+    this.nodeModulesPath = props.nodeModulesPath;
+    this.logger =
+      props.logger ??
+      new SwizzyWinstonLogger({
+        appName: "swerve-manager",
+        port: -1,
+        hostName: os.hostname(),
+      });
   }
 
   async run(request: RunRequest): Promise<RunResponse> {
@@ -128,8 +143,7 @@ export class SwerveManager implements ISwerveManager {
         const service = serviceEntry[1];
         const serviceName = serviceEntry[0];
         const packageName = service.packageName;
-        const importPathOrName = service.servicePath ?? service.packageName;
-        gLogger.debug(`importPathOrName ${importPathOrName}`);
+        gLogger.debug(`servicePath: ${service.servicePath}`);
         const serviceArgs: SwerveArgs = {
           ...service,
           ...service.serviceConfiguration,
@@ -137,9 +151,9 @@ export class SwerveManager implements ISwerveManager {
         };
 
         const webservice = await this.installWebService({
-          serviceKey: serviceEntry[0],
+          serviceKey: serviceName,
           packageName,
-          importPathOrName,
+          servicePath: service.servicePath,
           port,
           app,
           appDataRoot: args.appDataRoot,
@@ -204,12 +218,10 @@ export class SwerveManager implements ISwerveManager {
       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,
+          servicePath: service.servicePath,
           port: PORT,
           app,
           appDataRoot: args.appDataRoot,
@@ -233,7 +245,7 @@ export class SwerveManager implements ISwerveManager {
   async installWebService(props: {
     //
     serviceKey: string;
-    importPathOrName: string;
+    servicePath: string;
     app: Application;
     appDataRoot: string;
     packageName: string;
@@ -241,7 +253,6 @@ export class SwerveManager implements ISwerveManager {
     gLogger: ILogger<any>;
     serviceArgs: { [key: string]: any };
   }) {
-    //  const packageName = importPathOrName;
     const {
       app,
       appDataRoot,
@@ -249,7 +260,7 @@ export class SwerveManager implements ISwerveManager {
       port,
       gLogger,
       serviceArgs,
-      importPathOrName,
+      servicePath,
       serviceKey,
     } = props;
 
@@ -261,11 +272,11 @@ export class SwerveManager implements ISwerveManager {
       if (packageName) {
         gLogger.debug(`Getting web service with name ${packageName}`);
       } else {
-        gLogger.debug(`Getting webservice with path: ${importPathOrName}`);
+        gLogger.debug(`Getting webservice with path: ${servicePath}`);
       }
-      const fullPath =
-        packageName ?? (await getFullImportPath(importPathOrName));
-      const tool = await import(fullPath); //require(fullPath); //require(packageName as string);
+
+      const fullPath = await this.getImportName(packageName, servicePath);
+      const tool = await import(fullPath);
 
       gLogger.debug(`Got service with require: ${JSON.stringify(tool)}`);
       gLogger.debug(`Getting web service from tool...`);
@@ -286,6 +297,7 @@ export class SwerveManager implements ISwerveManager {
         port,
         app,
         packageName,
+        servicePath,
         serviceArgs: { ...serviceArgs },
         logger,
       });
@@ -314,6 +326,25 @@ Failed to install web service, is it installed with NPM? Check package exists in
     }
   }
 
+  async getImportName(packageName: string, servicePath: string) {
+    const nodeModulesPath = this.nodeModulesPath;
+    this.logger.debug(`getImportPathName: modulesPath: ${nodeModulesPath}`);
+    if (servicePath) {
+      return await getFullImportPath(servicePath);
+    } else {
+      if (nodeModulesPath) {
+        this.logger.debug(
+          `Getting path with nodeModulesPath and packageName ${nodeModulesPath} ${packageName}`,
+        );
+        return await resolvePackageEntry(
+          path.join(nodeModulesPath, packageName),
+        );
+      } else {
+        return packageName;
+      }
+    }
+  }
+
   async stop(request: StopRequest) {
     const { instanceDetails } = request;
     const { instanceId, instanceType } = instanceDetails;

package/src/utils/getFullImportPath.ts

@@ -1,4 +1,6 @@
 // cross-runtime getFullImportPath.ts
+import { promises as fs } from "node:fs";
+import { pathToFileURL } from "node:url";
 
 // Runtime detection
 // @ts-ignore
@@ -58,3 +60,32 @@ export async function getFullImportPath(
 
   return importPath;
 }
+
+export async function resolvePackageEntry(pkgDir: string): Promise<string> {
+  const pkgJsonPath = join(pkgDir, "package.json");
+  let entry: string | undefined;
+
+  try {
+    const pkgJsonRaw = await fs.readFile(pkgJsonPath, "utf-8");
+    const pkgJson = JSON.parse(pkgJsonRaw);
+
+    if (pkgJson.exports && typeof pkgJson.exports === "string") {
+      // Simple "exports": "./esm/index.js"
+      entry = pkgJson.exports;
+    } else if (pkgJson.module) {
+      entry = pkgJson.module;
+    } else if (pkgJson.main) {
+      entry = pkgJson.main;
+    }
+  } catch {
+    // no package.json, fallback below
+  }
+
+  if (!entry) {
+    // fallback to index.js
+    entry = "index.js";
+  }
+
+  const absPath = join(pkgDir, entry);
+  return pathToFileURL(absPath).href; // usable in await import()
+}

package/test/getArgs.spec.ts

@@ -15,67 +15,95 @@ const logger = new SwizzyWinstonLogger({
   pid: process.pid,
 });
 
-test("getArgs", () => {
-  test.it("Sets port and custom arg", async () => {
-    const args = [
-      "/path/to/package/",
-      "run.js",
-      "--port",
-      "80",
-      //"--appDataRoot",
-      //      ".",
-      "--someCustomArg",
-      "JasonIsTheBest",
-    ];
-    let result = await getArgs(args, logger);
-    assert.equal(result.port, 80);
-    assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
-  });
+test.it("Sets port and custom arg", async () => {
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    "--port",
+    "80",
+    //"--appDataRoot",
+    //      ".",
+    "--someCustomArg",
+    "JasonIsTheBest",
+  ];
+  let result: any = await getArgs(args, logger);
+  assert.equal(result.port, 80);
+  assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
+});
 
-  test.it("sets appDataRoot", async () => {
-    const args = [
-      "/path/to/package/",
-      "run.js",
-      "--port",
-      "80",
-      "--appDataRoot",
-      ".",
-      "--someCustomArg",
-      "JasonIsTheBest",
-    ];
-    let result = await getArgs(args, logger);
-    assert.equal(result.port, 80);
-    assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
-  });
+test.it("sets appDataRoot", async () => {
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    "--port",
+    "80",
+    "--appDataRoot",
+    ".",
+    "--someCustomArg",
+    "JasonIsTheBest",
+  ];
+  let result: any = await getArgs(args, logger);
+  assert.equal(result.port, 80);
+  assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
+});
 
-  test.it("Throws on invalid config file path", async () => {
-    const configPath = "/some/invalid/path";
-    const args = [
-      "/path/to/package/",
-      "run.js",
-      "--port",
-      "80",
-      "--appDataRoot",
-      ".",
-      "--someCustomArg",
-      "JasonIsTheBest",
-      "--config",
-      configPath,
-    ];
-    try {
-      let result = await getArgs(args, logger);
-    } catch (e) {
-      assert.deepEqual(
-        { message: e.message, configFilePath: configPath },
-        {
-          message:
-            "Unexpected error occurred when attempting to read serviceConfiguration file",
-          configFilePath: configPath,
-        },
-      );
-    }
+test.it("Throws on invalid config file path", async () => {
+  const configPath = "/some/invalid/path";
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    "--port",
+    "80",
+    "--appDataRoot",
+    ".",
+    "--someCustomArg",
+    "JasonIsTheBest",
+    "--config",
+    configPath,
+  ];
+  try {
+    let result: any = await getArgs(args, logger);
+  } catch (e: any) {
+    assert.deepEqual(
+      { message: e?.message, configFilePath: configPath },
+      {
+        message:
+          "Unexpected error occurred when attempting to read serviceConfiguration file",
+        configFilePath: configPath,
+      },
+    );
+  }
+});
+test.it("Should read config values from config", async () => {
+  const configPath = path.join(__dirname, "./config/serviceConfig.json");
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    "--port",
+    "80",
+    "--appDataRoot",
+    ".",
+    "--someCustomArg",
+    "JasonIsTheBest",
+    "--config",
+    configPath,
+  ];
+  let result: any = await getArgs(args, logger);
+  assert.equal(result.port, 3000);
+  const service = result.services["my-first-web-service1"];
+  assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
+
+  assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
+  assert.equal(service.shouldTimeout, true);
+  assert.deepEqual(service.nestedJson, {
+    hello: "world",
+    none: false,
   });
-  test.it("Should read config values from config", async () => {
+});
+
+test.it(
+  "Should override parameters in order of args, config file last",
+  async () => {
     const configPath = path.join(__dirname, "./config/serviceConfig.json");
     const args = [
       "/path/to/package/",
@@ -86,246 +114,216 @@ test("getArgs", () => {
       ".",
       "--someCustomArg",
       "JasonIsTheBest",
+      "--someNumberINeed",
+      "1000",
       "--config",
       configPath,
     ];
-    let result = await getArgs(args, logger);
-    assert.equal(result.port, 3000);
+    let result: any = await getArgs(args, logger);
+
     const service = result.services["my-first-web-service1"];
+    assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
+
+    assert.equal(result.port, 3000);
     assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
 
-    assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
+    assert.equal(result.serviceArgs?.someNumberINeed, 1000);
     assert.equal(service.shouldTimeout, true);
     assert.deepEqual(service.nestedJson, {
       hello: "world",
       none: false,
     });
-  });
-
-  test.it(
-    "Should override parameters in order of args, config file last",
-    async () => {
-      const configPath = path.join(__dirname, "./config/serviceConfig.json");
-      const args = [
-        "/path/to/package/",
-        "run.js",
-        "--port",
-        "80",
-        "--appDataRoot",
-        ".",
-        "--someCustomArg",
-        "JasonIsTheBest",
-        "--someNumberINeed",
-        "1000",
-        "--config",
-        configPath,
-      ];
-      let result = await getArgs(args, logger);
-
-      const service = result.services["my-first-web-service1"];
-      assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
-
-      assert.equal(result.port, 3000);
-      assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
+  },
+);
 
-      assert.equal(result.serviceArgs?.someNumberINeed, 1000);
-      assert.equal(service.shouldTimeout, true);
-      assert.deepEqual(service.nestedJson, {
-        hello: "world",
-        none: false,
-      });
-    },
-  );
-
-  test.it(
-    "Should override parameters in order of args, config file first",
-    async () => {
-      const configPath = path.join(__dirname, "./config/serviceConfig.json");
-      const args = [
-        "/path/to/package/",
-        "run.js",
-        "--port",
-        "80",
-        "--appDataRoot",
-        ".",
-        "--someCustomArg",
-        "JasonIsTheBest",
-        "--config",
-        configPath,
-        "--someNumberINeed",
-        "1000",
-      ];
-      let result = await getArgs(args, logger);
-      const service = result.services["my-first-web-service1"];
-      assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
-      assert.equal(result.port, 3000);
-      assert.equal(result.appDataRoot, path.join(__dirname, ".."));
-      assert.equal(result.appDataRoot, path.join(__dirname, ".."));
-      assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
-
-      assert.equal(result.serviceArgs?.someNumberINeed, 1000);
-      assert.equal(service.shouldTimeout, true);
-      assert.deepEqual(service.nestedJson, {
-        hello: "world",
-        none: false,
-      });
-    },
-  );
-
-  test.it("Should getService from args", async () => {
+test.it(
+  "Should override parameters in order of args, config file first",
+  async () => {
+    const configPath = path.join(__dirname, "./config/serviceConfig.json");
     const args = [
       "/path/to/package/",
       "run.js",
-      path.join(__dirname, "../package.json"),
       "--port",
       "80",
       "--appDataRoot",
       ".",
       "--someCustomArg",
       "JasonIsTheBest",
+      "--config",
+      configPath,
+      "--someNumberINeed",
+      "1000",
     ];
-    let result = await getArgs(args, logger);
-    assert.equal(result.port, 80);
-
+    let result: any = await getArgs(args, logger);
     const service = result.services["my-first-web-service1"];
-    //    expect(result.serviceArgs.appDataRoot, ".");
+    assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
+    assert.equal(result.port, 3000);
+    assert.equal(result.appDataRoot, path.join(__dirname, ".."));
+    assert.equal(result.appDataRoot, path.join(__dirname, ".."));
     assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
-  });
 
-  test.it(
-    "Should set appDataRoot to current package root by default",
-    async () => {
-      const configPath = path.join(__dirname, "./config/serviceConfig.json");
-      const args = [
-        "/path/to/package/",
-        "run.js",
-        "--port",
-        "80",
-        "--someCustomArg",
-        "JasonIsTheBest",
-        "--config",
-        configPath,
-        "--someNumberINeed",
-        "1000",
-      ];
-      let result = await getArgs(args, logger);
+    assert.equal(result.serviceArgs?.someNumberINeed, 1000);
+    assert.equal(service.shouldTimeout, true);
+    assert.deepEqual(service.nestedJson, {
+      hello: "world",
+      none: false,
+    });
+  },
+);
 
-      const service = result.services["my-first-web-service1"];
-      assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
-      assert.equal(result.port, 3000);
-      assert.equal(result.appDataRoot, path.join(__dirname, ".."));
-      assert.equal(result.serviceArgs?.someCustomArg!, "JasonIsTheBest");
+test.it("Should getService from args", async () => {
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    path.join(__dirname, "../package.json"),
+    "--port",
+    "80",
+    "--appDataRoot",
+    ".",
+    "--someCustomArg",
+    "JasonIsTheBest",
+  ];
+  let result: any = await getArgs(args, logger);
+  assert.equal(result.port, 80);
 
-      assert.equal(result.serviceArgs?.someNumberINeed!, 1000);
-      assert.equal(service.shouldTimeout, true);
-      assert.deepEqual(service.nestedJson, {
-        hello: "world",
-        none: false,
-      });
-    },
-  );
-  test.it("Should create multiple services", async () => {
+  const service = result.services["my-first-web-service1"];
+  //    expect(result.serviceArgs.appDataRoot, ".");
+  assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
+});
+
+test.it(
+  "Should set appDataRoot to current package root by default",
+  async () => {
     const configPath = path.join(__dirname, "./config/serviceConfig.json");
     const args = [
       "/path/to/package/",
       "run.js",
-      ".",
       "--port",
       "80",
       "--someCustomArg",
       "JasonIsTheBest",
-      //      "--config",
-      //      configPath,
+      "--config",
+      configPath,
       "--someNumberINeed",
       "1000",
-      ".",
-      "--port",
-      "91",
     ];
-    let result = await getArgs(args, logger);
+    let result: any = await getArgs(args, logger);
 
     const service = result.services["my-first-web-service1"];
-    assert.equal(result.port, 91);
+    assert.equal(service.someOtherArgFromConfig, "ThisIsTheArgValue");
+    assert.equal(result.port, 3000);
     assert.equal(result.appDataRoot, path.join(__dirname, ".."));
-    //   expect(service.someCustomArg, "JasonIsTheBest");
+    assert.equal(result.serviceArgs?.someCustomArg!, "JasonIsTheBest");
 
-    //    expect(service.someNumberINeed, 1000);
-    //    expect(service.shouldTimeout, true);
-    //    expect(service.nestedJson, {
-    //      hello: "world",
-    //      none: false,
-    //    });
-    //    expect(result.services.length, 2);
-  });
-  test.it("Should create absolute path appdata directory", async () => {
-    const configPath = path.join(__dirname, "./config/serviceConfig.json");
-    const appDataRoot = "/tmp/swizzy-dyn-serve-web-service";
-    const args = [
-      "/path/to/package/",
-      "run.js",
-      ".",
-      "--port",
-      "80",
-      "--someCustomArg",
-      "JasonIsTheBest",
-      //"--config",
-      //configPath,
-      "--someNumberINeed",
-      "1000",
-      ".",
-      "--port",
-      "91",
-      "--appDataRoot",
-      appDataRoot,
-    ];
-    let result = await getArgs(args, logger);
-    assert.equal(result.appDataRoot, appDataRoot);
-  });
+    assert.equal(result.serviceArgs?.someNumberINeed!, 1000);
+    assert.equal(service.shouldTimeout, true);
+    assert.deepEqual(service.nestedJson, {
+      hello: "world",
+      none: false,
+    });
+  },
+);
+test.it("Should create multiple services", async () => {
+  const configPath = path.join(__dirname, "./config/serviceConfig.json");
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    ".",
+    "--port",
+    "80",
+    "--someCustomArg",
+    "JasonIsTheBest",
+    //      "--config",
+    //      configPath,
+    "--someNumberINeed",
+    "1000",
+    ".",
+    "--port",
+    "91",
+  ];
+  let result: any = await getArgs(args, logger);
 
-  test.it("Should resolve package.json from package name", async () => {
-    const config = await getArgs(["@swizzyweb/swerve-manager"], logger);
-    assert(config.services["@swizzyweb/swerve-manager"].packageJson);
-    assert.equal(
-      config.services["@swizzyweb/swerve-manager"].packageJson.name,
-      "@swizzyweb/swerve-manager",
-    );
-  });
+  const service = result.services["my-first-web-service1"];
+  assert.equal(result.port, 91);
+  assert.equal(result.appDataRoot, path.join(__dirname, ".."));
+  //   expect(service.someCustomArg, "JasonIsTheBest");
 
-  test.it("Should resolve package.json from absolute path", async () => {
-    const config = await getArgs([path.join(__dirname, "..")], logger);
-    assert(config.services["@swizzyweb/swerve-manager"].packageJson);
-    assert.equal(
-      config.services["@swizzyweb/swerve-manager"].packageJson.name,
-      "@swizzyweb/swerve-manager",
-    );
-  });
-  test.it("Should not throw with no args", async () => {
-    const config = await getArgs([], logger);
-    assert(config.services["@swizzyweb/swerve-manager"].packageJson);
-    assert.equal(
-      config.services["@swizzyweb/swerve-manager"].packageJson.name,
-      "@swizzyweb/swerve-manager",
-    );
-  });
-  test.it("Should work with no port", async () => {
-    const configPath = path.join(__dirname, "./config/serviceConfig.json");
-    const args = [
-      "/path/to/package/",
-      "run.js",
-      "--appDataRoot",
-      ".",
-      "--someCustomArg",
-      "JasonIsTheBest",
-      "--someNumberINeed",
-      "1000",
-    ];
-    let result = await getArgs(args, logger);
-    const service = result.services["my-first-web-service1"];
-    assert.equal(result.port, 3005);
-    assert.equal(result.appDataRoot, path.join(__dirname, ".."));
-    assert.equal(result.appDataRoot, path.join(__dirname, ".."));
-    assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
+  //    expect(service.someNumberINeed, 1000);
+  //    expect(service.shouldTimeout, true);
+  //    expect(service.nestedJson, {
+  //      hello: "world",
+  //      none: false,
+  //    });
+  //    expect(result.services.length, 2);
+});
+test.it("Should create absolute path appdata directory", async () => {
+  const configPath = path.join(__dirname, "./config/serviceConfig.json");
+  const appDataRoot = "/tmp/swizzy-dyn-serve-web-service";
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    ".",
+    "--port",
+    "80",
+    "--someCustomArg",
+    "JasonIsTheBest",
+    //"--config",
+    //configPath,
+    "--someNumberINeed",
+    "1000",
+    ".",
+    "--port",
+    "91",
+    "--appDataRoot",
+    appDataRoot,
+  ];
+  let result: any = await getArgs(args, logger);
+  assert.equal(result.appDataRoot, appDataRoot);
+});
 
-    assert.equal(result.serviceArgs?.someNumberINeed, 1000);
-  });
+test.it("Should resolve package.json from package name", async () => {
+  const config: any = await getArgs(["@swizzyweb/swerve-manager"], logger);
+  assert(config.services["@swizzyweb/swerve-manager"].packageJson);
+  assert.equal(
+    config.services["@swizzyweb/swerve-manager"].packageJson.name,
+    "@swizzyweb/swerve-manager",
+  );
+});
+
+test.it("Should resolve package.json from absolute path", async () => {
+  const config: any = await getArgs([path.join(__dirname, "..")], logger);
+  assert(config.services["@swizzyweb/swerve-manager"].packageJson);
+  assert.equal(
+    config.services["@swizzyweb/swerve-manager"].packageJson.name,
+    "@swizzyweb/swerve-manager",
+  );
+});
+test.it("Should not throw with no args", async () => {
+  const config: any = await getArgs([], logger);
+  assert(config.services["@swizzyweb/swerve-manager"].packageJson);
+  assert.equal(
+    config.services["@swizzyweb/swerve-manager"].packageJson.name,
+    "@swizzyweb/swerve-manager",
+  );
+});
+test.it("Should work with no port", async () => {
+  const configPath = path.join(__dirname, "./config/serviceConfig.json");
+  const args = [
+    "/path/to/package/",
+    "run.js",
+    "--appDataRoot",
+    ".",
+    "--someCustomArg",
+    "JasonIsTheBest",
+    "--someNumberINeed",
+    "1000",
+  ];
+  let result: any = await getArgs(args, logger);
+  const service = result.services["my-first-web-service1"];
+  assert.equal(result.port, 3005);
+  assert.equal(result.appDataRoot, path.join(__dirname, ".."));
+  assert.equal(result.appDataRoot, path.join(__dirname, ".."));
+  assert.equal(result.serviceArgs?.someCustomArg, "JasonIsTheBest");
+
+  assert.equal(result.serviceArgs?.someNumberINeed, 1000);
 });