@storm-software/workspace-tools 1.228.0 → 1.229.0

package/dist/chunk-DLQLZTCZ.mjs

@@ -0,0 +1,69 @@
+import {
+  joinPaths
+} from "./chunk-PVTEDLBL.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/pnpm-deps-update.ts
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import readYamlFile from "read-yaml-file";
+var pnpmCatalog;
+async function pnpmCatalogUpdate(packageRoot, workspaceRoot = process.cwd()) {
+  if (!pnpmCatalog) {
+    const pnpmWorkspacePath = joinPaths(workspaceRoot, "pnpm-workspace.yaml");
+    if (!existsSync(pnpmWorkspacePath)) {
+      console.warn(`No \`pnpm-workspace.yaml\` file found in workspace root (searching in: ${pnpmWorkspacePath}). Skipping pnpm catalog read for now.`);
+      return;
+    }
+    const pnpmWorkspaceYaml = await readYamlFile(pnpmWorkspacePath);
+    console.info(`pnpmWorkspaceYaml: ${JSON.stringify(pnpmWorkspaceYaml ?? {})}`);
+    if (pnpmWorkspaceYaml?.catalog) {
+      pnpmCatalog = pnpmWorkspaceYaml.catalog;
+    } else {
+      console.warn(`Found a \`pnpm-workspace.yaml\` file in the workspace root directory, but no pnpm catalog existed:
+File name: ${pnpmWorkspacePath}
+File contents: ${pnpmWorkspaceYaml ? JSON.stringify(pnpmWorkspaceYaml) : "EMPTY FILE"}`);
+    }
+  }
+  if (!pnpmCatalog) {
+    console.warn(`No pnpm catalog found. Attempting to read from workspace root's \`pnpm-workspace.yaml\` file.`);
+  }
+  const packageJsonPath = joinPaths(packageRoot, "package.json");
+  const packageJsonFile = await readFile(packageJsonPath, "utf8");
+  if (!packageJsonFile) {
+    throw new Error("No package.json file found in package root: " + packageRoot);
+  }
+  const packageJson = JSON.parse(packageJsonFile);
+  for (const dependencyType of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies"
+  ]) {
+    const dependencies = packageJson[dependencyType];
+    if (!dependencies) {
+      continue;
+    }
+    for (const dependencyName of Object.keys(dependencies)) {
+      if (dependencies[dependencyName] === "catalog:") {
+        if (!pnpmCatalog) {
+          throw new Error(`Dependency ${dependencyName} is marked as \`catalog:\`, but no catalog exists in the workspace root's \`pnpm-workspace.yaml\` file.`);
+        }
+        const catalogVersion = pnpmCatalog[dependencyName];
+        if (!catalogVersion) {
+          throw new Error("Missing pnpm catalog version for " + dependencyName);
+        }
+        dependencies[dependencyName] = catalogVersion;
+      } else if (dependencies[dependencyName].startsWith("catalog:")) {
+        throw new Error("multiple named catalogs not supported");
+      }
+    }
+  }
+  return writeFile(packageJsonPath, JSON.stringify(packageJson));
+}
+__name(pnpmCatalogUpdate, "pnpmCatalogUpdate");
+
+export {
+  pnpmCatalogUpdate
+};

package/dist/chunk-DMUTOQCB.mjs

@@ -0,0 +1,82 @@
+import {
+  correctPaths
+} from "./chunk-PVTEDLBL.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// ../config-tools/src/utilities/find-up.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames) {
+  const _startPath = startPath ?? process.cwd();
+  if (endFileNames.some((endFileName) => existsSync(join(_startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = join(_startPath, "..");
+    return findFolderUp(parent, endFileNames);
+  }
+  return void 0;
+}
+__name(findFolderUp, "findFolderUp");
+
+// ../config-tools/src/utilities/find-workspace-root.ts
+var rootFiles = [
+  "storm.json",
+  "storm.json",
+  "storm.yaml",
+  "storm.yml",
+  "storm.js",
+  "storm.ts",
+  ".storm.json",
+  ".storm.yaml",
+  ".storm.yml",
+  ".storm.js",
+  ".storm.ts",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "npm-workspace.json",
+  "yarn-workspace.json",
+  "pnpm-workspace.json",
+  "npm-workspace.yaml",
+  "yarn-workspace.yaml",
+  "pnpm-workspace.yaml",
+  "npm-workspace.yml",
+  "yarn-workspace.yml",
+  "pnpm-workspace.yml",
+  "npm-lock.json",
+  "yarn-lock.json",
+  "pnpm-lock.json",
+  "npm-lock.yaml",
+  "yarn-lock.yaml",
+  "pnpm-lock.yaml",
+  "npm-lock.yml",
+  "yarn-lock.yml",
+  "pnpm-lock.yml",
+  "bun.lockb"
+];
+function findWorkspaceRootSafe(pathInsideMonorepo) {
+  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+    return correctPaths(process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH);
+  }
+  return correctPaths(findFolderUp(pathInsideMonorepo ?? process.cwd(), rootFiles));
+}
+__name(findWorkspaceRootSafe, "findWorkspaceRootSafe");
+function findWorkspaceRoot(pathInsideMonorepo) {
+  const result = findWorkspaceRootSafe(pathInsideMonorepo);
+  if (!result) {
+    throw new Error(`Cannot find workspace root upwards from known path. Files search list includes: 
+${rootFiles.join("\n")}
+Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`);
+  }
+  return result;
+}
+__name(findWorkspaceRoot, "findWorkspaceRoot");
+
+export {
+  findWorkspaceRoot
+};

package/dist/chunk-EK75QNMS.mjs

@@ -0,0 +1,40 @@
+// src/utils/versions.ts
+var tsupVersion = "^7.2.0";
+var prettierPackageJsonVersion = "2.4.6";
+var prettierPrismaVersion = "5.0.0";
+var prettierVersion = "^3.0.3";
+var swcCliVersion = "~0.1.62";
+var swcCoreVersion = "~1.3.95";
+var swcHelpersVersion = "~0.5.3";
+var swcNodeVersion = "1.6.8";
+var tsLibVersion = "2.6.2";
+var typesNodeVersion = "20.9.0";
+var verdaccioVersion = "5.27.0";
+var typescriptVersion = "~5.2.2";
+var eslintVersion = "~8.53.0";
+var lintStagedVersion = "15.0.2";
+var semanticReleaseVersion = "22.0.7";
+var nxVersion = "^18.0.4";
+var nodeVersion = "20.11.0";
+var pnpmVersion = "8.10.2";
+
+export {
+  tsupVersion,
+  prettierPackageJsonVersion,
+  prettierPrismaVersion,
+  prettierVersion,
+  swcCliVersion,
+  swcCoreVersion,
+  swcHelpersVersion,
+  swcNodeVersion,
+  tsLibVersion,
+  typesNodeVersion,
+  verdaccioVersion,
+  typescriptVersion,
+  eslintVersion,
+  lintStagedVersion,
+  semanticReleaseVersion,
+  nxVersion,
+  nodeVersion,
+  pnpmVersion
+};

package/dist/chunk-ESRRKJO5.mjs

@@ -0,0 +1,51 @@
+import {
+  withRunGenerator
+} from "./chunk-B3KIYNGT.mjs";
+import {
+  StormConfigSchema,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "./chunk-WJ5TU6JU.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-DMUTOQCB.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/generators/config-schema/generator.ts
+import { formatFiles, writeJson } from "@nx/devkit";
+import { zodToJsonSchema } from "zod-to-json-schema";
+async function configSchemaGeneratorFn(tree, options, config) {
+  writeInfo("\u{1F4E6}  Running Storm Configuration JSON Schema generator", config);
+  writeTrace(`Determining the Storm Configuration JSON Schema...`, config);
+  const jsonSchema = zodToJsonSchema(StormConfigSchema, {
+    name: "StormWorkspaceConfiguration"
+  });
+  writeTrace(jsonSchema, config);
+  const outputPath = options.outputFile.replaceAll("{workspaceRoot}", "").replaceAll(config?.workspaceRoot ?? findWorkspaceRoot(), options.outputFile?.startsWith("./") ? "" : "./");
+  writeTrace(`\u{1F4DD}  Writing Storm Configuration JSON Schema to "${outputPath}"`, config);
+  writeJson(tree, outputPath, jsonSchema, {
+    spaces: 2
+  });
+  await formatFiles(tree);
+  writeSuccess("\u{1F680}  Storm Configuration JSON Schema creation has completed successfully!", config);
+  return {
+    success: true
+  };
+}
+__name(configSchemaGeneratorFn, "configSchemaGeneratorFn");
+var generator_default = withRunGenerator("Configuration Schema Creator", configSchemaGeneratorFn, {
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ __name((options) => {
+      options.outputFile ??= "{workspaceRoot}/storm-workspace.schema.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+export {
+  configSchemaGeneratorFn,
+  generator_default
+};

package/dist/chunk-F5WI7VDM.js

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+var _chunkULBTYC2Bjs = require('./chunk-ULBTYC2B.js');
+
+
+var _chunkMSENNRAYjs = require('./chunk-MSENNRAY.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/executors/cargo-doc/executor.ts
+var _deepclone = require('deep-clone'); var _deepclone2 = _interopRequireDefault(_deepclone);
+async function cargoDocExecutor(options, context) {
+  const opts = _deepclone2.default.call(void 0, options);
+  opts["no-deps"] = opts.noDeps;
+  delete opts.noDeps;
+  const command = _chunkULBTYC2Bjs.buildCargoCommand.call(void 0, "doc", options, context);
+  return await _chunkULBTYC2Bjs.cargoCommand.call(void 0, ...command);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, cargoDocExecutor, "cargoDocExecutor");
+var executor_default = _chunkMSENNRAYjs.withRunExecutor.call(void 0, "Cargo Doc", cargoDocExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
+      options.outputPath ??= "dist/docs/{projectRoot}";
+      options.toolchain ??= "stable";
+      options.release ??= options.profile ? false : true;
+      options.allFeatures ??= true;
+      options.lib ??= true;
+      options.bins ??= true;
+      options.examples ??= true;
+      options.noDeps ??= false;
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.cargoDocExecutor = cargoDocExecutor; exports.executor_default = executor_default;

package/dist/chunk-F7QTSVDJ.mjs

@@ -0,0 +1,130 @@
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/lock-file.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { output, readJsonFile, workspaceRoot } from "nx/src/devkit-exports";
+import { getNpmLockfileDependencies, getNpmLockfileNodes } from "nx/src/plugins/js/lock-file/npm-parser";
+import { getPnpmLockfileDependencies, getPnpmLockfileNodes } from "nx/src/plugins/js/lock-file/pnpm-parser";
+import { getYarnLockfileDependencies, getYarnLockfileNodes } from "nx/src/plugins/js/lock-file/yarn-parser";
+var YARN_LOCK_FILE = "yarn.lock";
+var NPM_LOCK_FILE = "package-lock.json";
+var PNPM_LOCK_FILE = "pnpm-lock.yaml";
+var LOCK_FILES = [
+  YARN_LOCK_FILE,
+  NPM_LOCK_FILE,
+  PNPM_LOCK_FILE
+];
+var YARN_LOCK_PATH = join(workspaceRoot, YARN_LOCK_FILE);
+var NPM_LOCK_PATH = join(workspaceRoot, NPM_LOCK_FILE);
+var PNPM_LOCK_PATH = join(workspaceRoot, PNPM_LOCK_FILE);
+function getLockFileNodes(packageManager, contents, lockFileHash, context) {
+  try {
+    if (packageManager === "yarn") {
+      const packageJson = readJsonFile(join(context.workspaceRoot, "package.json"));
+      return getYarnLockfileNodes(contents, lockFileHash, packageJson);
+    }
+    if (packageManager === "pnpm") {
+      return getPnpmLockfileNodes(contents, lockFileHash);
+    }
+    if (packageManager === "npm") {
+      return getNpmLockfileNodes(contents, lockFileHash);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+__name(getLockFileNodes, "getLockFileNodes");
+function getLockFileDependencies(packageManager, contents, lockFileHash, context) {
+  try {
+    if (packageManager === "yarn") {
+      return getYarnLockfileDependencies(contents, lockFileHash, context);
+    }
+    if (packageManager === "pnpm") {
+      return getPnpmLockfileDependencies(contents, lockFileHash, context);
+    }
+    if (packageManager === "npm") {
+      return getNpmLockfileDependencies(contents, lockFileHash, context);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+__name(getLockFileDependencies, "getLockFileDependencies");
+function lockFileExists(packageManager) {
+  if (packageManager === "yarn") {
+    return existsSync(YARN_LOCK_PATH);
+  }
+  if (packageManager === "pnpm") {
+    return existsSync(PNPM_LOCK_PATH);
+  }
+  if (packageManager === "npm") {
+    return existsSync(NPM_LOCK_PATH);
+  }
+  throw new Error(`Unknown package manager ${packageManager} or lock file missing`);
+}
+__name(lockFileExists, "lockFileExists");
+function getLockFileName(packageManager) {
+  if (packageManager === "yarn") {
+    return YARN_LOCK_FILE;
+  }
+  if (packageManager === "pnpm") {
+    return PNPM_LOCK_FILE;
+  }
+  if (packageManager === "npm") {
+    return NPM_LOCK_FILE;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+__name(getLockFileName, "getLockFileName");
+function errorBodyLines(originalError, additionalInfo = []) {
+  const result = [
+    "Please open an issue at `https://github.com/storm-software/storm-ops/issues/new?template=1-bug.yml` and provide a reproduction.",
+    ...additionalInfo
+  ];
+  if (originalError.message) {
+    result.push(`
+Original error: ${originalError.message}
+
+`);
+  }
+  if (originalError.stack) {
+    result.push(originalError.stack);
+  }
+  return result;
+}
+__name(errorBodyLines, "errorBodyLines");
+function isPostInstallProcess() {
+  return process.env.npm_command === "install" && process.env.npm_lifecycle_event === "postinstall";
+}
+__name(isPostInstallProcess, "isPostInstallProcess");
+
+export {
+  YARN_LOCK_FILE,
+  NPM_LOCK_FILE,
+  PNPM_LOCK_FILE,
+  LOCK_FILES,
+  YARN_LOCK_PATH,
+  NPM_LOCK_PATH,
+  PNPM_LOCK_PATH,
+  getLockFileNodes,
+  getLockFileDependencies,
+  lockFileExists,
+  getLockFileName
+};