@storm-software/workspace-tools 1.295.86 → 1.296.1

package/dist/chunk-DEP6TIXL.js

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkCBVZ57E6js = require('./chunk-CBVZ57E6.js');
+
+
+var _chunkGZA2CV3Cjs = require('./chunk-GZA2CV3C.js');
+
+// src/executors/typia/executor.ts
+var _fsextra = require('fs-extra');
+var _TypiaProgrammerjs = require('typia/lib/programmers/TypiaProgrammer.js');
+async function typiaExecutorFn(options, _, config) {
+  if (options.clean !== false) {
+    _chunkGZA2CV3Cjs.writeInfo.call(void 0, `\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
+    _fsextra.removeSync.call(void 0, options.outputPath);
+  }
+  await Promise.all(
+    options.entry.map((entry) => {
+      _chunkGZA2CV3Cjs.writeInfo.call(void 0, `\u{1F680} Running Typia on entry: ${entry}`, config);
+      return _TypiaProgrammerjs.TypiaProgrammer.build({
+        input: entry,
+        output: options.outputPath,
+        project: options.tsconfig
+      });
+    })
+  );
+  return {
+    success: true
+  };
+}
+var executor_default = _chunkCBVZ57E6js.withRunExecutor.call(void 0, 
+  "Typia runtime validation generator",
+  typiaExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.entry ??= ["{sourceRoot}/index.ts"];
+        options.outputPath ??= "{sourceRoot}/__generated__/typia";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        options.clean ??= true;
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.typiaExecutorFn = typiaExecutorFn; exports.executor_default = executor_default;

package/dist/chunk-DIUWF7BW.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkLMYTVXGXjs = require('./chunk-LMYTVXGX.js');
+
+// src/utils/get-project-configurations.ts
+var _retrieveworkspacefiles = require('nx/src/project-graph/utils/retrieve-workspace-files');
+var getProjectConfigurations = async () => {
+  return _retrieveworkspacefiles.retrieveProjectConfigurationsWithoutPluginInference.call(void 0, 
+    _chunkLMYTVXGXjs.findWorkspaceRoot.call(void 0, )
+  );
+};
+var getProjectConfiguration = (projectName) => _optionalChain([getProjectConfigurations, 'call', _ => _(), 'optionalAccess', _2 => _2[projectName]]);
+
+
+
+
+exports.getProjectConfigurations = getProjectConfigurations; exports.getProjectConfiguration = getProjectConfiguration;

package/dist/chunk-DJZX3XBE.mjs

@@ -0,0 +1,105 @@
+import {
+  withRunExecutor
+} from "./chunk-35ERFW7I.mjs";
+import {
+  writeInfo
+} from "./chunk-4AR5RJMF.mjs";
+import {
+  joinPaths
+} from "./chunk-TBW5MCN6.mjs";
+
+// src/executors/unbuild/executor.ts
+import { defu } from "defu";
+import { createJiti } from "jiti";
+async function unbuildExecutorFn(options, context, config) {
+  writeInfo("\u{1F4E6}  Running Storm Unbuild executor on the workspace", config);
+  if (!context.projectsConfigurations?.projects || !context.projectName || !context.projectsConfigurations.projects[context.projectName]) {
+    throw new Error(
+      "The Build process failed because the context is not valid. Please run this command from a workspace root directory."
+    );
+  }
+  if (!context.projectsConfigurations.projects[context.projectName].root) {
+    throw new Error(
+      "The Build process failed because the project root is not valid. Please run this command from a workspace root directory."
+    );
+  }
+  if (!context.projectsConfigurations.projects[context.projectName].sourceRoot) {
+    throw new Error(
+      "The Build process failed because the project's source root is not valid. Please run this command from a workspace root directory."
+    );
+  }
+  const jiti = createJiti(config.workspaceRoot, {
+    fsCache: config.skipCache ? false : joinPaths(
+      config.workspaceRoot,
+      config.directories.cache || "node_modules/.cache/storm",
+      "jiti"
+    ),
+    interopDefault: true
+  });
+  const stormUnbuild = await jiti.import(
+    jiti.esmResolve("@storm-software/unbuild/build")
+  );
+  await stormUnbuild.build(
+    defu(
+      {
+        ...options,
+        projectRoot: context.projectsConfigurations.projects[context.projectName].root,
+        projectName: context.projectName,
+        sourceRoot: context.projectsConfigurations.projects[context.projectName].sourceRoot,
+        platform: options.platform
+      },
+      {
+        stubOptions: {
+          jiti: {
+            fsCache: config.skipCache ? false : joinPaths(
+              config.workspaceRoot,
+              config.directories.cache || "node_modules/.cache/storm",
+              "jiti"
+            )
+          }
+        },
+        rollup: {
+          emitCJS: true,
+          watch: false,
+          dts: {
+            respectExternal: true
+          },
+          esbuild: {
+            target: options.target,
+            format: "esm",
+            platform: options.platform,
+            minify: options.minify ?? !options.debug,
+            sourcemap: options.sourcemap ?? options.debug,
+            treeShaking: options.treeShaking
+          }
+        }
+      }
+    )
+  );
+  return {
+    success: true
+  };
+}
+var executor_default = withRunExecutor(
+  "TypeScript Unbuild build",
+  unbuildExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: async (options, config) => {
+        options.debug ??= false;
+        options.treeShaking ??= true;
+        options.buildOnly ??= false;
+        options.platform ??= "neutral";
+        options.entry ??= ["{sourceRoot}"];
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  unbuildExecutorFn,
+  executor_default
+};

package/dist/chunk-DO2X7OZO.js

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-EGI64HQ2.mjs

@@ -0,0 +1,22 @@
+// src/utils/registry-helpers.ts
+import https from "node:https";
+var getCrateRegistryVersion = (name, tag = "latest", registry = "https://crates.io") => {
+  return new Promise(
+    (resolve) => https.get(
+      `${registry}/api/v1/crates/${encodeURIComponent(name)}/${encodeURIComponent(
+        tag
+      )}`,
+      (res) => {
+        res.on("data", (d) => {
+          resolve(d);
+        });
+      }
+    ).on("error", (e) => {
+      throw e;
+    })
+  );
+};
+
+export {
+  getCrateRegistryVersion
+};

package/dist/chunk-EMX7LTEI.mjs

@@ -0,0 +1,50 @@
+import {
+  withRunExecutor
+} from "./chunk-35ERFW7I.mjs";
+import {
+  writeInfo
+} from "./chunk-4AR5RJMF.mjs";
+
+// src/executors/typia/executor.ts
+import { removeSync } from "fs-extra";
+import { TypiaProgrammer } from "typia/lib/programmers/TypiaProgrammer.js";
+async function typiaExecutorFn(options, _, config) {
+  if (options.clean !== false) {
+    writeInfo(`\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
+    removeSync(options.outputPath);
+  }
+  await Promise.all(
+    options.entry.map((entry) => {
+      writeInfo(`\u{1F680} Running Typia on entry: ${entry}`, config);
+      return TypiaProgrammer.build({
+        input: entry,
+        output: options.outputPath,
+        project: options.tsconfig
+      });
+    })
+  );
+  return {
+    success: true
+  };
+}
+var executor_default = withRunExecutor(
+  "Typia runtime validation generator",
+  typiaExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.entry ??= ["{sourceRoot}/index.ts"];
+        options.outputPath ??= "{sourceRoot}/__generated__/typia";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        options.clean ??= true;
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  typiaExecutorFn,
+  executor_default
+};

package/dist/chunk-EQMVQ3I7.mjs

@@ -0,0 +1,213 @@
+import {
+  getCrateRegistryVersion
+} from "./chunk-EGI64HQ2.mjs";
+import {
+  parseCargoToml,
+  parseCargoTomlWithTree,
+  stringifyCargoToml
+} from "./chunk-X2UWPTFU.mjs";
+import {
+  getWorkspaceConfig
+} from "./chunk-35G4LHK2.mjs";
+
+// src/release/rust-version-actions.ts
+import {
+  joinPathFragments
+} from "@nx/devkit";
+import { VersionActions } from "nx/release";
+var StormRustVersionActions = class extends VersionActions {
+  validManifestFilenames = ["Cargo.toml"];
+  /**
+   * The Storm workspace configuration object, which is loaded from the `storm-workspace.json` file.
+   *
+   * @remarks
+   * This member variable is populated during the {@link init} method.
+   */
+  workspaceConfig = null;
+  constructor(releaseGroup, projectGraphNode, finalConfigForProject) {
+    super(releaseGroup, projectGraphNode, finalConfigForProject);
+  }
+  /**
+   * Asynchronous initialization of the version actions and resolution of manifest paths.
+   *
+   * @remarks
+   * This does NOT validate that manifest files exist - that happens later in validate().
+   *
+   * @params tree - The file system tree to read from.
+   */
+  async init(tree) {
+    this.workspaceConfig = await getWorkspaceConfig();
+    return super.init(tree);
+  }
+  async readCurrentVersionFromSourceManifest(tree) {
+    const sourceCargoTomlPath = joinPathFragments(
+      this.projectGraphNode.data.root,
+      "Cargo.toml"
+    );
+    try {
+      const cargoToml = parseCargoTomlWithTree(
+        tree,
+        this.projectGraphNode.data.root,
+        this.projectGraphNode.name
+      );
+      return {
+        manifestPath: sourceCargoTomlPath,
+        currentVersion: cargoToml.package.version
+      };
+    } catch {
+      throw new Error(
+        `Unable to determine the current version for project "${this.projectGraphNode.name}" from ${sourceCargoTomlPath}, please ensure that the "version" field is set within the Cargo.toml file`
+      );
+    }
+  }
+  async readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+    const cargoToml = parseCargoTomlWithTree(
+      tree,
+      this.projectGraphNode.data.root,
+      this.projectGraphNode.name
+    );
+    const crateName = cargoToml.package.name;
+    const metadata = currentVersionResolverMetadata;
+    const registryArg = typeof metadata?.registry === "string" ? metadata.registry : this.workspaceConfig?.registry?.cargo || "https://crates.io";
+    const tagArg = typeof metadata?.tag === "string" ? metadata.tag : "latest";
+    let currentVersion = null;
+    try {
+      currentVersion = await getCrateRegistryVersion(
+        crateName,
+        tagArg,
+        registryArg
+      );
+    } catch {
+    }
+    return {
+      currentVersion: currentVersion || "0.0.0",
+      // Make troubleshooting easier by including the registry and tag data in the log text
+      logText: `"cargoRegistry=${registryArg}" tag=${tagArg}`
+    };
+  }
+  async readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+    const cargoToml = parseCargoTomlWithTree(
+      tree,
+      this.projectGraphNode.data.root,
+      this.projectGraphNode.name
+    );
+    if (!projectGraph.nodes[dependencyProjectName]?.data?.root) {
+      return {
+        currentVersion: null,
+        dependencyCollection: null
+      };
+    }
+    const dependencyCargoToml = parseCargoTomlWithTree(
+      tree,
+      projectGraph.nodes[dependencyProjectName]?.data.root,
+      dependencyProjectName
+    );
+    if (!dependencyCargoToml?.package?.name) {
+      return {
+        currentVersion: null,
+        dependencyCollection: null
+      };
+    }
+    let currentVersion = null;
+    let dependencyCollection = null;
+    for (const depType of ["dependencies", "dev-dependencies"]) {
+      if (cargoToml[depType] && cargoToml[depType][dependencyCargoToml.package.name]) {
+        currentVersion = typeof cargoToml[depType][dependencyCargoToml.package.name] === "string" ? cargoToml[depType][dependencyCargoToml.package.name] : cargoToml[depType][dependencyCargoToml.package.name].version;
+        dependencyCollection = depType;
+        break;
+      }
+    }
+    return {
+      currentVersion,
+      dependencyCollection
+    };
+  }
+  async updateProjectVersion(tree, newVersion) {
+    const logMessages = [];
+    for (const manifestToUpdate of this.manifestsToUpdate) {
+      const cargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+      if (!cargoTomlString) {
+        throw new Error(
+          `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+        );
+      }
+      const cargoToml = parseCargoToml(cargoTomlString);
+      cargoToml.package.version = newVersion;
+      tree.write(manifestToUpdate.manifestPath, stringifyCargoToml(cargoToml));
+      logMessages.push(
+        `\u270D\uFE0F  New version ${newVersion} written to manifest: ${manifestToUpdate.manifestPath}`
+      );
+    }
+    return logMessages;
+  }
+  /**
+   * Updates the dependencies of the project in the specified Cargo.toml files.
+   *
+   * @param tree - The file system tree to read from and write to.
+   * @param projectGraph - The project graph to use for resolving dependencies.
+   * @param dependenciesToUpdate - A mapping of dependency names to their new versions.
+   * @returns An array of log messages indicating the results of the updates.
+   */
+  async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate = {}) {
+    const numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
+    if (numDependenciesToUpdate === 0) {
+      return [];
+    }
+    const logMessages = [];
+    for (const manifestToUpdate of this.manifestsToUpdate) {
+      const cargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+      if (!cargoTomlString) {
+        throw new Error(
+          `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+        );
+      }
+      const cargoToml = parseCargoToml(cargoTomlString);
+      for (const depType of ["dependencies", "dev-dependencies"]) {
+        if (cargoToml[depType]) {
+          for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
+            try {
+              const projectRoot = projectGraph.nodes[dep]?.data.root;
+              if (!projectRoot) {
+                throw new Error(
+                  `Unable to determine the project root for "${dep}" from the project graph metadata, please ensure that the "@storm-software/workspace-tools" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/storm-software/storm-ops/issues`
+                );
+              }
+              const dependencyCargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+              if (!dependencyCargoTomlString) {
+                throw new Error(
+                  `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+                );
+              }
+              const dependencyCargoToml = parseCargoToml(
+                dependencyCargoTomlString
+              );
+              const dependencyCrateName = cargoToml[depType][dependencyCargoToml.package.name] ? dependencyCargoToml.package.name : dep;
+              if (typeof cargoToml[depType][dependencyCrateName] === "string") {
+                cargoToml[depType][dependencyCrateName] = version;
+              } else {
+                cargoToml[depType][dependencyCrateName].version = version;
+              }
+              tree.write(
+                manifestToUpdate.manifestPath,
+                stringifyCargoToml(cargoToml)
+              );
+            } catch (error) {
+              throw new Error(
+                `Unable to update ${depType === "dev-dependencies" ? "dev-dependency" : "dependency"} "${dep}" in manifest at path: ${manifestToUpdate.manifestPath}.`,
+                { cause: error }
+              );
+            }
+          }
+        }
+      }
+      logMessages.push(
+        `\u270D\uFE0F  Updated ${numDependenciesToUpdate} ${numDependenciesToUpdate === 1 ? "dependency" : "dependencies"} in manifest: ${manifestToUpdate.manifestPath}`
+      );
+    }
+    return logMessages;
+  }
+};
+
+export {
+  StormRustVersionActions
+};

package/dist/chunk-ETSIRKO5.js

@@ -0,0 +1,79 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunk57OGFZNBjs = require('./chunk-57OGFZNB.js');
+
+
+var _chunkSZWM7COVjs = require('./chunk-SZWM7COV.js');
+
+
+var _chunkLULOWPU2js = require('./chunk-LULOWPU2.js');
+
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
+
+// src/generators/node-library/generator.ts
+
+
+
+
+
+var _devkit = require('@nx/devkit');
+async function nodeLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+    __dirname,
+    "src",
+    "generators",
+    "node-library",
+    "files"
+  );
+  const tsLibraryGeneratorOptions = {
+    platform: "node",
+    devDependencies: {
+      "@types/node": _chunkSZWM7COVjs.typesNodeVersion
+    },
+    buildExecutor: "@storm-software/workspace-tools:unbuild",
+    ...schema,
+    directory: schema.directory,
+    description: schema.description
+  };
+  const options = await _chunk57OGFZNBjs.normalizeOptions.call(void 0, tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = _devkit.names.call(void 0, options.name);
+  _devkit.generateFiles.call(void 0, tree, filesDir, options.projectRoot, {
+    ...schema,
+    dot: ".",
+    className,
+    name,
+    namespace: _nullishCoalesce(process.env.STORM_NAMESPACE, () => ( "storm-software")),
+    description: _nullishCoalesce(schema.description, () => ( "")),
+    propertyName,
+    js: !!options.js,
+    cliCommand: "nx",
+    strict: void 0,
+    tmpl: "",
+    offsetFromRoot: _devkit.offsetFromRoot.call(void 0, options.projectRoot),
+    buildable: options.bundler && options.bundler !== "none",
+    hasUnitTestRunner: options.unitTestRunner !== "none"
+  });
+  await _chunk57OGFZNBjs.typeScriptLibraryGeneratorFn.call(void 0, tree, tsLibraryGeneratorOptions, config);
+  await _devkit.formatFiles.call(void 0, tree);
+  return null;
+}
+var generator_default = _chunkLULOWPU2js.withRunGenerator.call(void 0, 
+  "TypeScript Library Creator (NodeJs Platform)",
+  nodeLibraryGeneratorFn,
+  {
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.description ??= "A library used by Storm Software to support NodeJs applications";
+        options.platform ??= "node";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.nodeLibraryGeneratorFn = nodeLibraryGeneratorFn; exports.generator_default = generator_default;

package/dist/chunk-EYO6EPEG.mjs

@@ -0,0 +1,93 @@
+import {
+  parseCargoToml
+} from "./chunk-X2UWPTFU.mjs";
+import {
+  ProjectTagConstants,
+  isEqualProjectTag
+} from "./chunk-2GQSCZ3J.mjs";
+import {
+  joinPaths
+} from "./chunk-TBW5MCN6.mjs";
+
+// src/utils/package-helpers.ts
+import {
+  joinPathFragments,
+  readJsonFile
+} from "@nx/devkit";
+import { execFileSync } from "child_process";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "path";
+import { format } from "prettier";
+var PackageManagerTypes = {
+  PackageJson: "package.json",
+  CargoToml: "Cargo.toml"
+};
+var getPackageInfo = (project) => {
+  if (isEqualProjectTag(
+    project,
+    ProjectTagConstants.Language.TAG_ID,
+    ProjectTagConstants.Language.RUST
+  ) && existsSync(joinPathFragments(project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: parseCargoToml(joinPathFragments(project.root, "Cargo.toml"))
+    };
+  } else if (isEqualProjectTag(
+    project,
+    ProjectTagConstants.Language.TAG_ID,
+    ProjectTagConstants.Language.TYPESCRIPT
+  ) && existsSync(joinPathFragments(project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: readJsonFile(
+        joinPathFragments(project.root, "package.json")
+      )
+    };
+  }
+  return null;
+};
+async function addPackageJsonGitHead(packageRoot) {
+  const packageJsonPath = joinPaths(packageRoot, "package.json");
+  if (!packageJsonPath) {
+    throw new Error(
+      "No file path provided. Please provide a valid path to the package.json file."
+    );
+  }
+  const packageJsonValue = JSON.parse(await readFile(packageJsonPath, "utf8"));
+  if (!packageJsonValue || typeof packageJsonValue !== "object") {
+    throw new Error(
+      `Invalid package.json file at ${packageJsonPath}. Please ensure it is a valid JSON file.`
+    );
+  }
+  const gitHead = execFileSync("git", ["rev-parse", "HEAD"], {
+    cwd: dirname(resolve(packageJsonPath)),
+    encoding: "utf8"
+  }).trim();
+  packageJsonValue.gitHead = gitHead;
+  return writeFile(
+    packageJsonPath,
+    await format(JSON.stringify(packageJsonValue), {
+      parser: "json",
+      proseWrap: "preserve",
+      trailingComma: "none",
+      tabWidth: 2,
+      semi: true,
+      singleQuote: false,
+      quoteProps: "as-needed",
+      insertPragma: false,
+      bracketSameLine: true,
+      printWidth: 80,
+      bracketSpacing: true,
+      arrowParens: "avoid",
+      endOfLine: "lf",
+      plugins: ["prettier-plugin-packagejson"]
+    })
+  );
+}
+
+export {
+  PackageManagerTypes,
+  getPackageInfo,
+  addPackageJsonGitHead
+};