@storm-software/workspace-tools 1.295.70 → 1.295.73

package/dist/chunk-5JYAH2VL.mjs

@@ -0,0 +1,388 @@
+import {
+  getRoot
+} from "./chunk-K4QMCCQB.mjs";
+import {
+  cargoMetadata,
+  isExternal
+} from "./chunk-GKLFEOKK.mjs";
+import {
+  ProjectTagConstants,
+  addProjectTag,
+  setDefaultProjectTags
+} from "./chunk-2GQSCZ3J.mjs";
+
+// src/plugins/rust/cargo-toml.ts
+import {
+  createNodesFromFiles,
+  joinPathFragments,
+  readJsonFile,
+  validateDependency
+} from "@nx/devkit";
+import defu from "defu";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import {
+  DependencyType
+} from "nx/src/config/project-graph";
+var name = "storm-software/rust";
+var description = "Plugin for parsing Cargo.toml files";
+var DefaultCargoPluginProfileMap = {
+  development: "dev",
+  production: "prod"
+};
+var createNodesV2 = [
+  "*/**/Cargo.toml",
+  async (configFiles, options, context) => {
+    return await createNodesFromFiles(
+      (configFile, options2, context2) => {
+        try {
+          const profiles = options2?.profiles ?? {};
+          const includeApps = options2?.includeApps ?? true;
+          const toolchain = options2?.toolchain;
+          const skipDocs = options2?.skipDocs ?? false;
+          const metadata = cargoMetadata();
+          if (!metadata) {
+            return {};
+          }
+          const { packages: cargoPackages } = metadata;
+          const externalNodes = {};
+          const projects = {};
+          const profs = {
+            ...DefaultCargoPluginProfileMap,
+            ...profiles
+          };
+          const configurations = Object.keys(profs).reduce((ret, key) => {
+            ret[key] = {
+              profile: profs[key]
+            };
+            return ret;
+          }, {});
+          const cargoPackageMap = cargoPackages.reduce((acc, p) => {
+            if (!acc.has(p.name)) {
+              acc.set(p.name, p);
+            }
+            return acc;
+          }, /* @__PURE__ */ new Map());
+          for (const cargoPackage of cargoPackages) {
+            if (!isExternal(cargoPackage, context2.workspaceRoot)) {
+              const root = getRoot(dirname(configFile), context2);
+              const project = {
+                root,
+                name: cargoPackage.name
+              };
+              if (existsSync(joinPathFragments(root, "project.json"))) {
+                const projectJson = readJsonFile(
+                  joinPathFragments(root, "project.json")
+                );
+                if (projectJson) {
+                  Object.keys(projectJson).forEach((key) => {
+                    if (!project[key]) {
+                      project[key] = projectJson[key];
+                    }
+                  });
+                }
+              }
+              if (includeApps === false && project.projectType === "application") {
+                continue;
+              }
+              const targets = {
+                "lint-markdown": {
+                  cache: true,
+                  outputs: ["{projectRoot}/**/*.md", "{projectRoot}/**/*.mdx"],
+                  inputs: [
+                    "linting",
+                    "{projectRoot}/**/*.md",
+                    "{projectRoot}/**/*.mdx"
+                  ],
+                  dependsOn: ["^lint-markdown"],
+                  executor: "nx:run-commands",
+                  options: {
+                    command: 'pnpm exec markdownlint-cli2 "{projectRoot}/*.{md,mdx}" "{projectRoot}/**/*.{md,mdx}" --config "node_modules/@storm-software/markdownlint/config/recommended.markdownlint-cli2.jsonc" --fix'
+                  }
+                },
+                "lint-ls": {
+                  cache: true,
+                  inputs: ["linting", "rust", "^production"],
+                  dependsOn: ["^lint-ls"],
+                  options: {
+                    command: 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/.ls-lint.yml" ',
+                    color: true
+                  }
+                },
+                lint: {
+                  cache: true,
+                  inputs: ["linting", "rust", "^production"],
+                  dependsOn: ["lint-ls", "lint-markdown", "^lint"],
+                  executor: "@storm-software/workspace-tools:cargo-clippy",
+                  options: {
+                    toolchain,
+                    fix: false
+                  },
+                  defaultConfiguration: "development",
+                  configurations
+                },
+                check: {
+                  cache: true,
+                  inputs: ["linting", "rust", "^production"],
+                  dependsOn: ["lint", "^check"],
+                  executor: "@storm-software/workspace-tools:cargo-check",
+                  options: {
+                    toolchain
+                  },
+                  defaultConfiguration: "development",
+                  configurations
+                },
+                "format-readme": {
+                  cache: true,
+                  inputs: [
+                    "linting",
+                    "documentation",
+                    "{projectRoot}/{README.md,package.json,Cargo.toml,executors.json,generators.json}"
+                  ],
+                  outputs: ["{projectRoot}/README.md"],
+                  dependsOn: ["^format-readme"],
+                  executor: "nx:run-commands",
+                  options: {
+                    command: 'pnpm exec storm-git readme --templates="tools/readme-templates" --project="{projectName}"'
+                  }
+                },
+                "format-toml": {
+                  cache: true,
+                  inputs: ["linting", "{projectRoot}/**/*.toml"],
+                  outputs: ["{projectRoot}/**/*.toml"],
+                  dependsOn: ["^format-toml"],
+                  executor: "nx:run-commands",
+                  options: {
+                    command: 'pnpm exec taplo format --config="node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="node_modules/.cache/taplo/{projectRoot}" --colors="always" "{projectRoot}/*.toml" "{projectRoot}/**/*.toml" '
+                  }
+                },
+                "format-clippy": {
+                  cache: true,
+                  inputs: ["linting", "rust", "^production"],
+                  dependsOn: ["^format-clippy"],
+                  executor: "@storm-software/workspace-tools:cargo-clippy",
+                  options: {
+                    toolchain,
+                    fix: true
+                  },
+                  defaultConfiguration: "development",
+                  configurations
+                },
+                format: {
+                  cache: true,
+                  inputs: ["linting", "documentation", "rust", "^production"],
+                  dependsOn: [
+                    "format-readme",
+                    "format-clippy",
+                    "format-toml",
+                    "^format"
+                  ],
+                  executor: "@storm-software/workspace-tools:cargo-format",
+                  options: {
+                    toolchain,
+                    fix: true
+                  },
+                  defaultConfiguration: "development",
+                  configurations
+                },
+                clean: {
+                  cache: true,
+                  inputs: ["rust", "^production"],
+                  outputs: [`{workspaceRoot}/dist/{projectRoot}/target`],
+                  executor: "nx:run-commands",
+                  options: {
+                    command: `pnpm exec rimraf dist/{projectRoot}/target`,
+                    color: true,
+                    cwd: "{workspaceRoot}"
+                  }
+                },
+                build: {
+                  cache: true,
+                  inputs: ["rust", "^production"],
+                  dependsOn: ["build-base", "^build"],
+                  executor: "@storm-software/workspace-tools:cargo-build",
+                  outputs: [`{workspaceRoot}/dist/{projectRoot}/target`],
+                  options: {
+                    toolchain
+                  },
+                  defaultConfiguration: "development",
+                  configurations
+                },
+                rebuild: {
+                  cache: false,
+                  inputs: ["rust", "^production"],
+                  dependsOn: ["clean", "build-base", "^build"],
+                  executor: "@storm-software/workspace-tools:cargo-build",
+                  outputs: [`{workspaceRoot}/dist/{projectRoot}/target`],
+                  options: {
+                    toolchain
+                  },
+                  defaultConfiguration: "development",
+                  configurations
+                },
+                test: {
+                  cache: true,
+                  inputs: ["testing", "rust", "^production"],
+                  dependsOn: ["build", "^test"],
+                  executor: "@monodon/rust:test",
+                  outputs: ["{options.target-dir}"],
+                  options: {
+                    "target-dir": `{workspaceRoot}/dist/{projectRoot}/target`
+                  },
+                  defaultConfiguration: "development",
+                  configurations
+                }
+              };
+              if (skipDocs != true) {
+                targets.docs = {
+                  cache: true,
+                  inputs: ["linting", "documentation", "^production"],
+                  dependsOn: ["format-readme", "lint-docs", "^docs"],
+                  outputs: [`{workspaceRoot}/dist/{projectRoot}/docs`],
+                  executor: "@storm-software/workspace-tools:cargo-doc",
+                  options: {
+                    toolchain
+                  },
+                  defaultConfiguration: "production",
+                  configurations
+                };
+              }
+              if (cargoPackage.publish === null || cargoPackage.publish === void 0 || cargoPackage.publish === true || Array.isArray(cargoPackage.publish) && cargoPackage.publish.length > 0) {
+                addProjectTag(
+                  project,
+                  ProjectTagConstants.Registry.TAG_ID,
+                  ProjectTagConstants.Registry.CARGO,
+                  { overwrite: true }
+                );
+                targets["nx-release-publish"] = {
+                  cache: true,
+                  inputs: [
+                    "linting",
+                    "testing",
+                    "documentation",
+                    "rust",
+                    "^production"
+                  ],
+                  dependsOn: ["build", "^nx-release-publish"],
+                  executor: "@storm-software/workspace-tools:cargo-publish",
+                  options: {
+                    packageRoot: root
+                  },
+                  defaultConfiguration: "production",
+                  configurations
+                };
+              }
+              addProjectTag(
+                project,
+                ProjectTagConstants.Language.TAG_ID,
+                ProjectTagConstants.Language.RUST,
+                { overwrite: true }
+              );
+              setDefaultProjectTags(project, name);
+              projects[root] = defu(
+                {
+                  targets,
+                  release: {
+                    version: {
+                      versionActions: "@storm-software/workspace-tools/release/rust-version-actions"
+                    }
+                  }
+                },
+                project
+              );
+            }
+            for (const dep of cargoPackage.dependencies) {
+              if (isExternal(dep, context2.workspaceRoot)) {
+                const externalDepName = `cargo:${dep.name}`;
+                if (!externalNodes?.[externalDepName]) {
+                  externalNodes[externalDepName] = {
+                    type: "cargo",
+                    name: externalDepName,
+                    data: {
+                      packageName: dep.name,
+                      version: cargoPackageMap.get(dep.name)?.version ?? "0.0.0"
+                    }
+                  };
+                }
+              }
+            }
+          }
+          return {
+            projects,
+            externalNodes
+          };
+        } catch (e) {
+          console.error("An error occurred in the Storm Rust Nx plugin.");
+          console.error(e);
+          throw new Error("An error occurred in the Storm Rust Nx plugin.", {
+            cause: e
+          });
+        }
+      },
+      configFiles,
+      options,
+      context
+    );
+  }
+];
+var createDependencies = (options, context) => {
+  console.debug(
+    `[storm-software/rust]: Creating dependencies using cargo metadata.`
+  );
+  const metadata = cargoMetadata();
+  if (!metadata?.packages) {
+    console.debug(
+      `[storm-software/rust]: Unable to find cargo metadata. Skipping dependency creation.`
+    );
+    return [];
+  }
+  const dependencies = [];
+  for (const pkg of metadata.packages) {
+    if (context.projects[pkg.name]) {
+      for (const deps of pkg.dependencies) {
+        if (!metadata.packages.find((p) => p.name === deps.name)) {
+          console.debug(
+            `[storm-software/rust]: Dependency ${deps.name} not found in the cargo metadata.`
+          );
+          continue;
+        }
+        if (context.projects[deps.name]) {
+          dependencies.push(
+            createDependency(context, pkg, deps.name, DependencyType.static)
+          );
+        } else {
+          const externalDepName = `cargo:${deps.name}`;
+          if (externalDepName in (context.externalNodes ?? {})) {
+            dependencies.push(
+              createDependency(
+                context,
+                pkg,
+                externalDepName,
+                DependencyType.static
+              )
+            );
+          }
+        }
+      }
+    }
+  }
+  return dependencies;
+};
+function createDependency(context, pkg, depName, type) {
+  const dependency = {
+    type,
+    source: pkg.name,
+    target: depName,
+    sourceFile: pkg.manifest_path.replace(/\\/g, "/").replace(context.workspaceRoot.replace(/\\/g, "/"), "").replace(/^\//, "")
+  };
+  validateDependency(dependency, context);
+  return dependency;
+}
+
+export {
+  name,
+  description,
+  DefaultCargoPluginProfileMap,
+  createNodesV2,
+  createDependencies
+};

package/dist/chunk-5OS7GV5T.mjs

@@ -0,0 +1,51 @@
+// ../package-constants/src/types.ts
+var ProjectTagVariant = {
+  LANGUAGE: "language",
+  TYPE: "type",
+  DIST_STYLE: "dist-style",
+  PROVIDER: "provider",
+  PLATFORM: "platform",
+  REGISTRY: "registry",
+  PLUGIN: "plugin"
+};
+var ProjectTagLanguageValue = {
+  TYPESCRIPT: "typescript",
+  RUST: "rust"
+};
+var ProjectTagTypeValue = {
+  LIBRARY: "library",
+  APPLICATION: "application"
+};
+var ProjectTagDistStyleValue = {
+  NORMAL: "normal",
+  CLEAN: "clean"
+};
+var ProjectTagPlatformValue = {
+  NODE: "node",
+  BROWSER: "browser",
+  NEUTRAL: "neutral",
+  WORKER: "worker"
+};
+var ProjectTagRegistryValue = {
+  CARGO: "cargo",
+  NPM: "npm",
+  CONTAINER: "container",
+  CYCLONE: "cyclone"
+};
+
+// src/types.ts
+var TypescriptProjectLinkingType = /* @__PURE__ */ ((TypescriptProjectLinkingType2) => {
+  TypescriptProjectLinkingType2["ALIAS"] = "alias";
+  TypescriptProjectLinkingType2["REFERENCE"] = "reference";
+  return TypescriptProjectLinkingType2;
+})(TypescriptProjectLinkingType || {});
+
+export {
+  ProjectTagVariant,
+  ProjectTagLanguageValue,
+  ProjectTagTypeValue,
+  ProjectTagDistStyleValue,
+  ProjectTagPlatformValue,
+  ProjectTagRegistryValue,
+  TypescriptProjectLinkingType
+};

package/dist/chunk-6EMYX25V.js

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/utils/typia-transform.ts
+var _transform = require('typia/lib/transform'); var _transform2 = _interopRequireDefault(_transform);
+var getTypiaTransform = (program, diagnostics) => _transform2.default.call(void 0, program, {}, { addDiagnostic: (input) => diagnostics.push(input) });
+
+
+
+exports.getTypiaTransform = getTypiaTransform;

package/dist/chunk-77B77QNY.mjs

@@ -0,0 +1,148 @@
+// src/utils/lock-file.ts
+import {
+  output,
+  readJsonFile,
+  workspaceRoot
+} from "@nx/devkit";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+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}`);
+}
+function getLockFileDependencies(packageManager, contents, lockFileHash, context, keyMap) {
+  try {
+    if (packageManager === "yarn") {
+      return getYarnLockfileDependencies(
+        contents,
+        lockFileHash,
+        context,
+        keyMap
+      );
+    }
+    if (packageManager === "pnpm") {
+      return getPnpmLockfileDependencies(
+        contents,
+        lockFileHash,
+        context,
+        keyMap
+      );
+    }
+    if (packageManager === "npm") {
+      return getNpmLockfileDependencies(
+        contents,
+        lockFileHash,
+        context,
+        keyMap
+      );
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+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`
+  );
+}
+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}`);
+}
+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;
+}
+function isPostInstallProcess() {
+  return process.env.npm_command === "install" && process.env.npm_lifecycle_event === "postinstall";
+}
+
+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
+};

package/dist/chunk-7CJRMBX3.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/base/base-generator.untyped.ts
+var _untyped = require('untyped');
+var base_generator_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  $schema: {
+    id: "BaseGeneratorSchema",
+    title: "Base Generator",
+    description: "A type definition for the base Generator schema"
+  },
+  directory: {
+    $schema: {
+      title: "Directory",
+      type: "string",
+      description: "The directory to create the library in"
+    }
+  }
+});
+
+
+
+exports.base_generator_untyped_default = base_generator_untyped_default;

package/dist/chunk-7JRL2LE3.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/base/base-executor.untyped.ts
+var _untyped = require('untyped');
+var base_executor_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  $schema: {
+    id: "baseExecutor",
+    title: "Base Executor",
+    description: "A base type definition for an executor schema"
+  },
+  outputPath: {
+    $schema: {
+      title: "Output Path",
+      type: "string",
+      format: "path",
+      description: "The output path for the build"
+    }
+  }
+});
+
+
+
+exports.base_executor_untyped_default = base_executor_untyped_default;

package/dist/chunk-7RI43PE4.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk32KQVUCFjs = require('./chunk-32KQVUCF.js');
+
+
+var _chunkGSGT2T27js = require('./chunk-GSGT2T27.js');
+
+// src/executors/cargo-format/executor.ts
+async function cargoFormatExecutor(options, context) {
+  const command = _chunk32KQVUCFjs.buildCargoCommand.call(void 0, "fmt", options, context);
+  return await _chunk32KQVUCFjs.cargoCommand.call(void 0, context.root, ...command);
+}
+var executor_default = _chunkGSGT2T27js.withRunExecutor.call(void 0, 
+  "Cargo - Format",
+  cargoFormatExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputPath ??= "dist/{projectRoot}/target";
+        options.toolchain ??= "stable";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.cargoFormatExecutor = cargoFormatExecutor; exports.executor_default = executor_default;