@vistta/cli 1.0.1 → 1.1.0

package/tests/runtime.test.js

@@ -0,0 +1,76 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Runtime } from "../classes/runtime.js";
+
+suite("Runtime", () => {
+  test("resolve yields distinct URLs for plain vs bundler imports of the same file", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const file = import.meta.filename || new URL(import.meta.url).pathname.replace(/^\//, "");
+    const captured = [];
+    const next = (url) => {
+      captured.push(url);
+      return url;
+    };
+
+    await runtime.resolve(file, {}, next);
+    await runtime.resolve(file, { importAttributes: { type: "bundler" } }, next);
+    await runtime.resolve(file, { conditions: ["bundler"] }, next);
+
+    expect(captured[0]).not.toEqual(captured[1]);
+    expect(captured[0]).not.toEqual(captured[2]);
+    expect(captured[1]).toEqual(captured[2]);
+    expect(/\?__bundler__$/.test(captured[1])).toEqual(true);
+    expect(/\?__bundler__$/.test(captured[0])).toEqual(false);
+  });
+
+  test("resolve strips bundler suffix from parentURL when resolving relatives", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const here = new URL(".", import.meta.url).href;
+    const parentURL = here + "runtime.test.js?__bundler__";
+    let captured;
+    await runtime.resolve("./runtime.test.js", { parentURL, importAttributes: { type: "bundler" } }, (url) => {
+      captured = url;
+      return url;
+    });
+    expect(captured.includes("?__bundler__?")).toEqual(false);
+    expect(/\?__bundler__$/.test(captured)).toEqual(true);
+  });
+
+  test("resolve detects bundler mode from importAttributes.type even without conditions", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const file = import.meta.filename || new URL(import.meta.url).pathname.replace(/^\//, "");
+    const captured = [];
+    await runtime.resolve(file, { importAttributes: { type: "bundler" } }, (url) => {
+      captured.push(url);
+      return url;
+    });
+    expect(/\?__bundler__$/.test(captured[0])).toEqual(true);
+  });
+
+  test("resolve marks context.file for absolute bundler imports", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: [], options: {} });
+    const dir = mkdtempSync(join(tmpdir(), "vistta-runtime-"));
+    const file = join(dir, "page.jsx");
+    writeFileSync(file, "export default 1;");
+    const ctx = { importAttributes: { type: "bundler" } };
+    await runtime.resolve(file, ctx, (url) => url);
+    expect(ctx.file).toEqual(true);
+  });
+
+  test("resolve preserves non-bundler query string params", async () => {
+    const runtime = new Runtime({ loaders: [], resolvers: ["js"], options: {} });
+    const dir = mkdtempSync(join(tmpdir(), "vistta-runtime-"));
+    const file = join(dir, "data.js");
+    writeFileSync(file, "export default 1;");
+    const here = new URL(import.meta.url);
+    const hereURL = new URL(".", here).href;
+    const captured = [];
+    await runtime.resolve("./data.js?type=json", { parentURL: hereURL }, (url) => {
+      captured.push(url);
+      return url;
+    });
+    expect(captured[0].includes("type=json")).toEqual(true);
+    expect(/\?__bundler__$/.test(captured[0])).toEqual(false);
+  });
+});

package/tests/test-runner.test.js

@@ -0,0 +1,83 @@
+import { TestRunner } from "../classes/test-runner.js";
+
+suite("TestRunner", () => {
+  test("suite().test() registers a passing test", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test("t", () => 1);
+    });
+    const results = await runner.run();
+    expect(results[0].name).toEqual("s");
+    expect(results[0].tests[0].name).toEqual("t");
+    expect(results[0].tests[0].status).toEqual("pass");
+    expect(results[0].tests[0].result).toEqual(1);
+  });
+
+  test("failing test reports status=fail with the error", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test("boom", () => {
+        throw new Error("kaboom");
+      });
+    });
+    const results = await runner.run();
+    expect(results[0].tests[0].status).toEqual("fail");
+    expect(results[0].tests[0].error.message).toEqual("kaboom");
+  });
+
+  test("async tests are awaited before status is set", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test("async", async () => {
+        await new Promise((r) => setTimeout(r, 10));
+        return "done";
+      });
+    });
+    const results = await runner.run();
+    expect(results[0].tests[0].status).toEqual("pass");
+    expect(results[0].tests[0].result).toEqual("done");
+  });
+
+  test("test.skip is recorded as 'skip'", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      runner.test.skip("skipped", () => {});
+    });
+    const results = await runner.run();
+    expect(results[0].tests[0].status).toEqual("skip");
+  });
+
+  test("only: option restricts execution to marked tests", async () => {
+    const runner = new TestRunner({ only: true });
+    runner.suite("s", () => {
+      runner.test("not run", () => "x");
+      runner.test.only("run", () => "y");
+    });
+    const results = await runner.run();
+    const names = results[0].tests.map((t) => t.name);
+    expect(names.length).toEqual(1);
+    expect(names[0]).toEqual("run");
+  });
+
+  test("filter option restricts by test name (case-insensitive)", async () => {
+    const runner = new TestRunner({ filter: "MATCH" });
+    runner.suite("s", () => {
+      runner.test("will match", () => {});
+      runner.test("will skip", () => {});
+    });
+    const results = await runner.run();
+    const names = results[0].tests.map((t) => t.name);
+    expect(names.length).toEqual(1);
+    expect(names[0]).toEqual("will match");
+  });
+
+  test("suite errors are swallowed and surfaced via empty tests", async () => {
+    const runner = new TestRunner();
+    runner.suite("s", () => {
+      throw new Error("setup failed");
+    });
+    const results = await runner.run();
+    expect(results.length).toEqual(1);
+    expect(results[0].tests.length).toEqual(0);
+  });
+});

package/tsconfig.json

@@ -3,6 +3,7 @@
     "strict": false,
     "noEmit": true,
     "allowJs": true,
+    "checkJs": true,
     "resolveJsonModule": true,
     "module": "esnext",
     "target": "ESNext",
@@ -10,9 +11,7 @@
     "moduleResolution": "bundler",
     "skipLibCheck": true,
     "jsx": "react",
-    "typeRoots": ["./global.d.ts"],
-    "paths": {
-      "@/*": ["./*"]
-    }
-  }
+    "paths": {}
+  },
+  "include": ["./**/*.js", "./global.d.ts"]
 }

package/utils.js

@@ -1,9 +1,16 @@
 import fs from "@vistta/fs";
 import { assign, async, extract, remove } from "@vistta/utils";
 import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
+import { platform } from "node:os";
+import { isAbsolute } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { inc, satisfies, valid } from "semver";
 
+export const CWD = process.cwd();
+export const FALLBACK = "*";
+export const BUNDLER_SUFFIX = "?__bundler__";
+export const BUNDLER_SUFFIX_RE = /\?__bundler__$/;
+export const WITH_TYPE_RE = /[?&]__with_type=([^&#]*)/;
 export const ENABLED_NODE_OPTIONS = {
   "-w": "NODE_WATCH",
   "--watch": "NODE_WATCH",
@@ -20,7 +27,7 @@ export const ENABLED_NODE_OPTIONS = {
 
 export async function importJSON(filepath) {
   try {
-    return JSON.parse(await fs.readFile(filepath));
+    return JSON.parse(String(await fs.readFile(filepath)));
   } catch {
     return {};
   }
@@ -29,7 +36,7 @@ export async function importJSON(filepath) {
 export async function importEnv(filepath) {
   try {
     const env = {};
-    const entries = (await fs.readFile(filepath, "utf8")).split("\n");
+    const entries = String(await fs.readFile(filepath, "utf8")).split("\n");
     for (let i = 0, len = entries.length; i < len; i++) {
       const [key, value] = entries[i].split("=");
       env[key] = value;
@@ -43,7 +50,6 @@ export async function importEnv(filepath) {
 export async function importConfig(options = {}) {
   try {
     const helper = async (file) => {
-      file = fileURLToPath(import.meta.resolve(file));
       const {
         extends: parent,
         cliOptions: cli = {},
@@ -54,15 +60,15 @@ export async function importConfig(options = {}) {
         const commands = Object.keys(cli.commands);
         const dirname = fs.dirname(file);
         for (let i = 0, len = commands.length; i < len; i++)
-          cli.commands[commands[i]] = fs.resolve(dirname, cli.commands[commands[i]]);
+          cli.commands[commands[i]] = resolve(dirname, cli.commands[commands[i]]);
       }
-      if (parent) return assign(await helper(parent), { cli, compiler, bundler });
+      if (parent) return assign(await helper(ensurePath(parent)), { cli, compiler, bundler });
       return { cli, compiler, bundler };
     };
     let file = fs.resolve(process.cwd(), "tsconfig.json");
     if (!fs.existsSync(file)) file = fs.resolve(process.cwd(), "jsconfig.json");
     if (!fs.existsSync(file)) return options;
-    return assign(options, await helper(file));
+    return assign(options, await helper(ensurePath(file)));
   } catch (e) {
     console.error(e.trace || e.message);
     return options;
@@ -92,7 +98,14 @@ export async function getOutdatedPackages(dirname) {
       const packageName = keys[i];
       const { version, resolved, link } = packages["node_modules/" + packageName] || {};
       if (link) continue;
-      if (!version) throw new Error(`Module ${packageName} not found `);
+      if (!version) {
+        data[packageName] = {
+          package: path,
+          dev,
+        };
+        promises.push({ name: packageName });
+        continue;
+      }
       promises.push(
         new Promise((resolve, reject) =>
           fetch(resolved ? resolved.split("/-/")[0] + "/latest" : `https://registry.npmjs.org/${packageName}/latest`)
@@ -116,7 +129,11 @@ export async function getOutdatedPackages(dirname) {
     const module = data[values[i]?.name];
     module.name = values[i]?.name;
     module.latest = values[i]?.version;
-    if (!module || !module?.latest || !module?.current || !module?.wanted) throw new Error(`Internal Error`);
+    if (!module.current) {
+      result.push(module);
+      continue;
+    }
+    if (!module || !module?.latest || !module?.wanted) throw new Error(`Internal Error`);
     if (module.current === module.latest) continue;
     module.wanted = satisfies(module.latest, module.wanted) ? module.latest : module.current;
     result.push(module);
@@ -140,9 +157,8 @@ export function saveCrashReport() {
   if (!fs.existsSync(crashFolder)) fs.mkdir(crashFolder);
   const logs = console.logs;
   let output = "";
-  for (let i = 0, len = logs.length; i < len; i++) {
-    output += logs[i].time.toISOString() + " - " + logs[i].toString().replace(/\n/gm, " ") + "\n";
-  }
+  for (let i = 0, len = logs.length; i < len; i++)
+    output += logs[i].time.toLocalISOString() + ": " + logs[i].toString({ time: false });
   fs.writeFileSync(fs.resolve(crashFolder, Date.now() + ".log"), output);
 }
 
@@ -160,22 +176,60 @@ export function run(script, ...args) {
   });
 }
 
-/**
- * Function to parse command line arguments.
- * @param {string[]} args
- * @returns
- */
 export function parseArgs(args) {
-  const result = [[], {}];
+  const result = /** @type {[string[], Record<string, any>]} */ ([[], {}]);
   for (let i = 0, len = args.length; i < len; i++) {
-    const [option, value] = args[i].toLowerCase().split("=");
+    const lower = args[i].toLowerCase();
+    const eq = lower.indexOf("=");
+    const option = eq === -1 ? lower : lower.slice(0, eq);
+    const value = eq === -1 ? undefined : args[i].slice(eq + 1);
     if (option.startsWith("--")) result[1][option.slice(2)] = evaluate(value);
     else result[0].push(args[i]);
   }
   return result;
 }
 
-export { assign, async, extract, fs, remove };
+export function resolve(...values) {
+  if (platform() === "win32") return pathToFileURL(fs.resolve(...values)).toString();
+  return fs.resolve(...values);
+}
+
+/**
+ * Append the bundler marker to a URL/path so it occupies a distinct slot in
+ * Node's ESM module cache from the same file imported without the marker.
+ * @param {string} url
+ * @returns {string}
+ */
+export function markBundler(url) {
+  return BUNDLER_SUFFIX_RE.test(url) ? url : url + BUNDLER_SUFFIX;
+}
+
+/**
+ * Remove the bundler marker from a URL/path if present.
+ * @param {string | undefined | null} url
+ * @returns {string}
+ */
+export function stripBundler(url) {
+  return url ? url.replace(BUNDLER_SUFFIX_RE, "") : "";
+}
+
+/**
+ * Build a stable, sorted query string encoding the import attributes so that
+ * two imports of the same file with different `with: { ... }` attributes land
+ * in distinct ESM module cache slots. Mirrors the bundler marker pattern.
+ * @param {Record<string, any> | undefined | null} attrs
+ * @returns {string}
+ */
+export function markAttributes(attrs) {
+  if (!attrs) return "";
+  const keys = Object.keys(attrs)
+    .filter((k) => attrs[k] != null)
+    .sort();
+  if (keys.length === 0) return "";
+  return keys.map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(String(attrs[k]))}`).join("&");
+}
+
+export { assign, async, extract, remove };
 
 async function getProjectLock(path) {
   if (fs.existsSync(path + "/package-lock.json")) return await importJSON(fs.resolve(path, "package-lock.json"));
@@ -206,3 +260,14 @@ function evaluate(value) {
   if (value === "false") return false;
   return value;
 }
+
+function ensurePath(value) {
+  try {
+    if (isAbsolute(value)) return value;
+    value = import.meta.resolve(value);
+    if (isAbsolute(value)) return value;
+    return fileURLToPath(value);
+  } catch {
+    return value;
+  }
+}

package/.gitea/workflows/prerelease.yml

@@ -1,62 +0,0 @@
-name: Development Workflow
-on:
-  push:
-    branches:
-      - development
-env:
-  module: cli
-jobs:
-  Validation:
-    runs-on: ubuntu-latest
-    container:
-      image: node:latest
-    steps:
-      - name: Checkout
-        uses: tiagomta/checkout@v1
-        with:
-          repository: vistta/workspace
-          ref: main
-          token: ${{ secrets.TOKEN }}
-          fetch-depth: 0
-          submodules: true
-      - name: Close Issues
-        uses: tiagomta/gitea@v1
-        with:
-          token: ${{ secrets.TOKEN }}
-          working-directory: ./packages/${{ env.module }}
-          command: issues close --fromCommit
-      - name: Setup Node
-        run: npm ci
-      - name: Module Validation
-        working-directory: ./packages/${{ env.module }}
-        run: npx vistta project outdated
-        continue-on-error: true
-      - name: Eslint Validation
-        working-directory: ./packages/${{ env.module }}
-        run: npx eslint .
-        continue-on-error: true
-      - name: Typescript Validation
-        working-directory: ./packages/${{ env.module }}
-        run: npx tsc
-        continue-on-error: true
-      - name: Unit Tests
-        working-directory: ./packages/${{ env.module }}
-        run: npx vistta test
-
-  PreRelease:
-    needs: Validation
-    runs-on: ubuntu-latest
-    container:
-      image: node:latest
-    steps:
-      - name: Checkout
-        uses: tiagomta/checkout@v1
-      - name: PreRelease
-        uses: tiagomta/npm@v1
-        with:
-          command: version prerelease SNAPSHOT-${{ gitea.run_id }} --email devops@vistta.org
-      - name: Publish PreRelease (Gitea)
-        uses: tiagomta/npm@v1
-        with:
-          command: publish --scope vistta --registry https://git.vistta.org/api/packages/vistta/npm/ --tag snapshot
-          token: ${{ secrets.TOKEN }}

package/.gitea/workflows/release.yml

@@ -1,124 +0,0 @@
-name: Release Workflow
-on:
-  workflow_dispatch:
-    inputs:
-      type:
-        description: "Release Type"
-        required: true
-        type: choice
-        options:
-          - Patch
-          - Minor
-          - Major
-      npm_publish:
-        description: "Publish to NPM Registry"
-        required: false
-        default: true
-        type: boolean
-      gitea_publish:
-        description: "Publish to Gitea Registry"
-        required: false
-        default: true
-        type: boolean
-
-env:
-  module: cli
-  ref: refs/heads/development
-jobs:
-  Validation:
-    runs-on: ubuntu-latest
-    container:
-      image: node:latest
-    steps:
-      - name: Checkout
-        uses: tiagomta/checkout@v1
-        with:
-          repository: vistta/workspace
-          ref: main
-          token: ${{ secrets.TOKEN }}
-          fetch-depth: 0
-          submodules: true
-      - name: Setup Node
-        run: npm ci
-      - name: Module Validation
-        working-directory: ./packages/${{ env.module }}
-        run: npx vistta project outdated
-      - name: Eslint Validation
-        working-directory: ./packages/${{ env.module }}
-        run: npx eslint .
-      - name: Typescript Validation
-        working-directory: ./packages/${{ env.module }}
-        run: npx tsc
-      - name: Unit Tests
-        working-directory: ./packages/${{ env.module }}
-        run: npx vistta test
-
-  Release:
-    needs: Validation
-    runs-on: ubuntu-latest
-    container:
-      image: node:latest
-    if: github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/development'
-    steps:
-      - name: Checkout
-        uses: tiagomta/checkout@v1
-        with:
-          ref: ${{ env.ref }}
-          token: ${{ secrets.TOKEN }}
-      - name: NPM Release
-        uses: tiagomta/nodejs-run@v1
-        id: npm
-        with:
-          target: inline
-          run: |
-            await git.config("user.email", "devops@vistta.org");
-            const version = await npm.version("${{ inputs.type }}".toLowerCase());
-            // Release Gitea
-            if (`${{ inputs.gitea_publish }}`.toLowerCase() === "true") {
-              await npm.config("set", "@vistta:registry", "https://git.vistta.org/api/packages/vistta/npm/");
-              await npm.config("set", "--", "//git.vistta.org/api/packages/vistta/npm/:_authToken", "${{ secrets.TOKEN }}");
-              await npm.publish();
-            }
-            // Release NPM
-            if (`${{ inputs.npm_publish }}`.toLowerCase() === "true") {
-              await npm.config("set", "@vistta:registry", "https://registry.npmjs.org/");
-              await npm.config("set", "--", "//registry.npmjs.org/:_authToken", "${{ secrets.NPM_TOKEN }}");
-              await npm.publish("--access", "public");
-            }
-            // Update Branches
-            await git.push("origin", "${{ env.ref }}", "--tags");
-            await git.fetch("origin", "master");
-            await git.checkout("master");
-            await git.reset("--hard", "${{ env.ref }}");
-            await git.push("origin", "master", "--force");
-            result = version;
-      - name: Gitea Release
-        uses: tiagomta/nodejs-run@v1
-        with:
-          target: inline
-          run: |
-            const version = (`${{ steps.npm.outputs.result }}`).trim();
-            const milestone = await gitea.milestones.create("${{ inputs.type }} (" + version + ")");
-            const issues = await gitea.issues.list({ state: "closed" });
-            const types = {};
-            for (let issue of issues) {
-              const type =
-                issue.labels.find((l) => l.name.startsWith("Project/"))?.name.slice(8) +
-                "s";
-              if (type && issue.milestone == milestone.id) {
-                if (!types[type]) types[type] = `## ${type}\n`;
-                types[type] += `- ${issue.title} (#${issue.number})\n`;
-              } else if (issue.milestone == null) {
-                await gitea.issues.update(issue.number, { milestone: milestone.id });
-                if (type) {
-                  if (!types[type]) types[type] = `## ${type}\n`;
-                  types[type] += `- ${issue.title} (#${issue.number})\n`;
-                }
-              }
-            }
-            await gitea.releases.create({
-              tag_name: version,
-              name: "${{ inputs.type }} (" + version + ")",
-              body: Object.values(types).join("\n")
-            });
-            await gitea.milestones.close(milestone.id);