@swizzyweb/swerve-manager 0.1.4 → 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

@@ -1,11 +1,12 @@
 // @ts-ignore
 import express from "@swizzyweb/express";
-import { getFullImportPath, getLoggerForService, } from "./utils/index.js";
+import { 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";
+import { getFullImportPath, resolvePackageEntry, } from "./utils/getFullImportPath.js";
 export var InstanceType;
 (function (InstanceType) {
     InstanceType["webservice"] = "webservice";
@@ -15,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;
@@ -50,18 +61,18 @@ export class SwerveManager {
                 }
                 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 serviceName = serviceEntry[0];
+                const packageName = service.packageName;
+                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,
@@ -118,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,
@@ -142,13 +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}`);
-            gLogger.debug(`Getting tool with path: ${importPathOrName}`);
-            const fullPath = await getFullImportPath(importPathOrName);
-            const tool = await import(fullPath); //require(fullPath); //require(packageName as string);
+            if (packageName) {
+                gLogger.debug(`Getting web service with name ${packageName}`);
+            }
+            else {
+                gLogger.debug(`Getting webservice with path: ${servicePath}`);
+            }
+            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);
@@ -161,6 +175,7 @@ export class SwerveManager {
                 port,
                 app,
                 packageName,
+                servicePath,
                 serviceArgs: { ...serviceArgs },
                 logger,
             });
@@ -184,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

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

package/dist/utils/getFullImportPath.js

@@ -0,0 +1,82 @@
+// 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;
+// @ts-ignore
+const isBun = typeof Bun !== "undefined";
+// @ts-ignore
+const isNode = !isDeno && !isBun;
+let join;
+let cwd;
+let fromFileUrl;
+// --- Runtime-specific shims ---
+if (isDeno) {
+    // @ts-ignore
+    // const path = await import("https://deno.land/std@0.203.0/path/mod.ts");
+    const path = await import("node:path");
+    join = path.join;
+    const url = await import("node:url");
+    // @ts-ignore
+    cwd = Deno.cwd;
+    fromFileUrl = url.fileURLToPath;
+    //  fromFileUrl = path.fromFileUrl;
+}
+else if (isNode) {
+    const path = await import("node:path");
+    const processMod = await import("node:process");
+    const url = await import("node:url");
+    join = path.join;
+    cwd = processMod.cwd;
+    fromFileUrl = url.fileURLToPath;
+}
+else if (isBun) {
+    const path = await import("path");
+    join = path.join;
+    cwd = () => process.cwd();
+    fromFileUrl = (u) => new URL(u).pathname; // Bun auto normalizes
+}
+// --- Universal function ---
+export async function getFullImportPath(importPathOrName) {
+    let importPath;
+    if (importPathOrName.startsWith(".")) {
+        importPath = join(cwd(), importPathOrName);
+    }
+    else {
+        importPath = importPathOrName;
+    }
+    if (importPathOrName === importPath) {
+        // Turn into a full absolute path
+        const fullUrl = new URL(importPath, import.meta.url).href;
+        return fromFileUrl(fullUrl);
+    }
+    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/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

package/dist/utils/installWebservice.d.ts

@@ -1,4 +1,3 @@
 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>;

package/dist/utils/installWebservice.js

@@ -45,7 +45,7 @@ Failed to install web service, is it installed with NPM? Check package exists in
         throw Error(exceptionMessage); //new Error(exceptionMessage);
     }
 }
-export async function getFullImportPath(importPathOrName) {
+async function getFullImportPath(importPathOrName) {
     const importPath = importPathOrName.startsWith(".")
         ? path.join(process.cwd(), importPathOrName)
         : importPathOrName;

package/package.json

@@ -1,37 +1,35 @@
 {
   "name": "@swizzyweb/swerve-manager",
-  "version": "0.1.4",
+  "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": "node --test ./test**/*.spec.ts",
+    "test": "npm run test:node && npm run test:bun && npm run test:deno",
+    "test:node": "node --test ./test**/*.spec.ts",
+    "test:deno": "deno test test/** --allow-env --allow-write --allow-read",
+    "test:bun": "bun test",
     "coverage": "jest --coverage"
   },
   "author": "Jason Gallagher",
   "license": "Apache-2.0",
   "devDependencies": {
     "@swizzyweb/express": "^4.19.2",
-    "@types/jest": "^29.5.14",
     "@types/node": "^22.7.7",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.3.2",
     "typescript": "^5.6.3"
   },
   "dependencies": {
     "@swizzyweb/swizzy-common": "^0.3.2",
     "@swizzyweb/swizzy-web-service": "^0.5.3",
     "bun": "^1.2.15",
-    "deno": "^2.3.6",
-    "ts-node": "^10.9.2"
+    "deno": "^2.3.6"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/swizzyweb/swerve.git"
+    "url": "git+https://github.com/swizzyweb/swerve-manager.git"
   },
   "keywords": [
     "swizzy",
@@ -43,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

@@ -1,7 +1,6 @@
 // @ts-ignore
 import express, { Application } from "@swizzyweb/express";
 import {
-  getFullImportPath,
   getLoggerForService,
   installWebService,
   SwerveArgs,
@@ -17,6 +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,
+  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> {
@@ -126,9 +141,9 @@ export class SwerveManager implements ISwerveManager {
         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 serviceName = serviceEntry[0];
+        const packageName = service.packageName;
+        gLogger.debug(`servicePath: ${service.servicePath}`);
         const serviceArgs: SwerveArgs = {
           ...service,
           ...service.serviceConfiguration,
@@ -136,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,
@@ -203,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,
@@ -232,7 +245,7 @@ export class SwerveManager implements ISwerveManager {
   async installWebService(props: {
     //
     serviceKey: string;
-    importPathOrName: string;
+    servicePath: string;
     app: Application;
     appDataRoot: string;
     packageName: string;
@@ -240,7 +253,6 @@ export class SwerveManager implements ISwerveManager {
     gLogger: ILogger<any>;
     serviceArgs: { [key: string]: any };
   }) {
-    //  const packageName = importPathOrName;
     const {
       app,
       appDataRoot,
@@ -248,7 +260,7 @@ export class SwerveManager implements ISwerveManager {
       port,
       gLogger,
       serviceArgs,
-      importPathOrName,
+      servicePath,
       serviceKey,
     } = props;
 
@@ -257,10 +269,14 @@ export class SwerveManager implements ISwerveManager {
         `Getting webservice package ${packageName} and will run on port ${port}`,
       );
 
-      gLogger.debug(`Getting tool with path: ${importPathOrName}`);
+      if (packageName) {
+        gLogger.debug(`Getting web service with name ${packageName}`);
+      } else {
+        gLogger.debug(`Getting webservice with path: ${servicePath}`);
+      }
 
-      const fullPath = 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...`);
@@ -281,6 +297,7 @@ export class SwerveManager implements ISwerveManager {
         port,
         app,
         packageName,
+        servicePath,
         serviceArgs: { ...serviceArgs },
         logger,
       });
@@ -309,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

@@ -0,0 +1,91 @@
+// 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;
+// @ts-ignore
+const isBun = typeof Bun !== "undefined";
+// @ts-ignore
+const isNode = !isDeno && !isBun;
+
+let join: (a: string, b: string) => string;
+let cwd: () => string;
+let fromFileUrl: (url: string) => string;
+
+// --- Runtime-specific shims ---
+if (isDeno) {
+  // @ts-ignore
+  // const path = await import("https://deno.land/std@0.203.0/path/mod.ts");
+
+  const path = await import("node:path");
+  join = path.join;
+  const url = await import("node:url");
+  // @ts-ignore
+  cwd = Deno.cwd;
+  fromFileUrl = url.fileURLToPath;
+  //  fromFileUrl = path.fromFileUrl;
+} else if (isNode) {
+  const path = await import("node:path");
+  const processMod = await import("node:process");
+  const url = await import("node:url");
+  join = path.join;
+  cwd = processMod.cwd;
+  fromFileUrl = url.fileURLToPath;
+} else if (isBun) {
+  const path = await import("path");
+  join = path.join;
+  cwd = () => process.cwd();
+  fromFileUrl = (u: string) => new URL(u).pathname; // Bun auto normalizes
+}
+
+// --- Universal function ---
+export async function getFullImportPath(
+  importPathOrName: string,
+): Promise<string> {
+  let importPath: string;
+
+  if (importPathOrName.startsWith(".")) {
+    importPath = join(cwd(), importPathOrName);
+  } else {
+    importPath = importPathOrName;
+  }
+
+  if (importPathOrName === importPath) {
+    // Turn into a full absolute path
+    const fullUrl = new URL(importPath, import.meta.url).href;
+    return fromFileUrl(fullUrl);
+  }
+
+  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/src/utils/index.ts

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

package/src/utils/installWebservice.ts

@@ -79,9 +79,7 @@ Failed to install web service, is it installed with NPM? Check package exists in
   }
 }
 
-export async function getFullImportPath(
-  importPathOrName: string,
-): Promise<string> {
+async function getFullImportPath(importPathOrName: string): Promise<string> {
   const importPath = importPathOrName.startsWith(".")
     ? path.join(process.cwd(), importPathOrName)
     : importPathOrName;

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);
 });

package/test/getFullImportPath.spec.ts

@@ -0,0 +1,16 @@
+import test from "node:test";
+import { getFullImportPath } from "../dist/utils/getFullImportPath.js";
+import assert from "node:assert";
+import path from "node:path";
+
+test("Should get full path with relative path", async () => {
+  const fullPath = await getFullImportPath("../");
+  assert(path.isAbsolute(fullPath));
+});
+
+test("Should get full path from packageName", async () => {
+  const fullPath = await getFullImportPath(
+    "@swizzyweb/swap-cache-db-web-service",
+  );
+  assert(path.isAbsolute(fullPath));
+});

package/jest.config.js

@@ -1,4 +0,0 @@
-module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-};