@vistta/cli 1.0.1 → 1.2.0

package/utils.js

@@ -1,9 +1,17 @@
 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 { inc, satisfies, valid } from "semver";
+import { platform } from "node:os";
+import { relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { inc, valid } from "semver";
+import { loadProjectConfig, mergeConfig } from "./config.js";
 
+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 +28,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 +37,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;
@@ -41,85 +49,70 @@ 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 = {},
-        compilerOptions: compiler = {},
-        bundlerOptions: bundler = {},
-      } = await importJSON(file);
-      if (cli.commands) {
-        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]]);
-      }
-      if (parent) return assign(await helper(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));
-  } catch (e) {
-    console.error(e.trace || e.message);
-    return options;
-  }
+  const { config } = loadProjectConfig();
+  return mergeConfig(options, {
+    cli: config.cli || {},
+    compiler: config.compilerOptions || {},
+    bundler: config.bundlerOptions || {},
+  });
 }
 
 export async function getOutdatedPackages(dirname) {
-  const packages = (await getProjectLock(dirname))?.packages || {};
-  const data = {};
-  const promises = [];
-  async function processPackage(filepath, workspace) {
-    if (!fs.existsSync(filepath)) {
-      if (workspace) return;
-      else throw new Error("No Package found");
-    }
-    const { dependencies, devDependencies, workspaces } = await importJSON(filepath);
-    await fetchPackageUpdates(filepath, dependencies);
-    await fetchPackageUpdates(filepath, devDependencies, true);
-    if (!(workspaces?.length > 0)) return;
-    const workspaceDirnames = await resolveWorkspacesDirnames(workspaces);
-    for (let i = 0, len = workspaceDirnames.length; i < len; i++)
-      await processPackage(fs.resolve(workspaceDirnames[i], "package.json"), true);
-  }
-  async function fetchPackageUpdates(path, deps = {}, dev) {
-    const keys = Object.keys(deps);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      const packageName = keys[i];
-      const { version, resolved, link } = packages["node_modules/" + packageName] || {};
-      if (link) continue;
-      if (!version) throw new Error(`Module ${packageName} not found `);
-      promises.push(
-        new Promise((resolve, reject) =>
-          fetch(resolved ? resolved.split("/-/")[0] + "/latest" : `https://registry.npmjs.org/${packageName}/latest`)
-            .then((response) => response.json())
-            .then(resolve)
-            .catch(reject),
-        ),
-      );
-      data[packageName] = {
-        package: path,
-        current: version,
-        wanted: deps[packageName],
-        dev,
-      };
-    }
-  }
+  const lock = await getProjectLock(dirname);
+  const packages = lock.packages || {};
+  if (!fs.existsSync(fs.resolve(dirname, "package.json"))) throw new Error("No Package found");
+  const output = await new Promise((resolve, reject) => {
+    const npmPath = process.env.npm_execpath;
+    const args = ["outdated", "--json", "--long", "--include=dev"];
+    const windowsShell = !npmPath && platform() === "win32";
+    const command = npmPath ? process.execPath : windowsShell ? process.env.ComSpec || "cmd.exe" : "npm";
+    const child = spawn(
+      command,
+      npmPath ? [npmPath, ...args] : windowsShell ? ["/d", "/s", "/c", "npm " + args.join(" ")] : args,
+      {
+        cwd: dirname,
+        windowsHide: true,
+      },
+    );
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (value) => {
+      stdout += value;
+    });
+    child.stderr.on("data", (value) => {
+      stderr += value;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      try {
+        const data = JSON.parse(stdout || "{}");
+        if ((code !== 0 && code !== 1) || data.error)
+          reject(new Error(data.error?.summary || stderr || `npm outdated exited with code ${code}`));
+        else resolve(data);
+      } catch (error) {
+        reject(new Error(stderr || error.message));
+      }
+    });
+  });
   const result = [];
-  await processPackage(fs.resolve(dirname, "package.json"));
-  const values = await Promise.all(promises);
-  for (let i = 0, len = values.length; i < len; i++) {
-    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 === module.latest) continue;
-    module.wanted = satisfies(module.latest, module.wanted) ? module.latest : module.current;
-    result.push(module);
+  for (const [name, entries] of Object.entries(output)) {
+    for (const entry of Array.isArray(entries) ? entries : [entries]) {
+      const location = entry.location
+        ? relative(lock.dirname, entry.location).replaceAll("\\", "/")
+        : "node_modules/" + name;
+      if (packages[location]?.link || packages["node_modules/" + name]?.link) continue;
+      if (entry.type !== "dependencies" && entry.type !== "devDependencies") continue;
+      const packagePath = fs.resolve(lock.dirname, entry.dependedByLocation || "", "package.json");
+      if (relative(lock.dirname, dirname) && relative(dirname, packagePath) !== "package.json") continue;
+      result.push({
+        name,
+        package: packagePath,
+        current: entry.current,
+        wanted: entry.wanted,
+        latest: entry.latest,
+        dev: entry.type === "devDependencies",
+      });
+    }
   }
   return result;
 }
@@ -140,9 +133,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,47 +152,69 @@ 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"));
+  if (fs.existsSync(path + "/package-lock.json"))
+    return { ...(await importJSON(fs.resolve(path, "package-lock.json"))), dirname: path };
   const newPath = fs.resolve(path, "..");
   if (newPath === path) throw new Error("No Package Lock found.");
   return await getProjectLock(newPath);
 }
 
-async function resolveWorkspacesDirnames(workspaces) {
-  const paths = [];
-  for (let i = 0, len = workspaces.length; i < len; i++) {
-    if (!workspaces[i].includes("*")) {
-      paths.push(workspaces[i]);
-      continue;
-    }
-    const entries = fs.glob(workspaces[i]);
-    let entry = (await entries.next())?.value;
-    while (entry) {
-      paths.push(entry);
-      entry = (await entries.next())?.value;
-    }
-  }
-  return paths;
-}
-
 function evaluate(value) {
   if (value == null || value === "true") return true;
   if (value === "false") return false;

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