@storm-software/workspace-tools 1.295.69 → 1.295.71

package/dist/chunk-UKTILFKM.mjs

@@ -0,0 +1,32 @@
+import {
+  buildCargoCommand,
+  cargoCommand
+} from "./chunk-GKLFEOKK.mjs";
+import {
+  withRunExecutor
+} from "./chunk-SEZ726NO.mjs";
+
+// src/executors/cargo-clippy/executor.ts
+async function cargoClippyExecutor(options, context) {
+  const command = buildCargoCommand("clippy", options, context);
+  return await cargoCommand(context.root, ...command);
+}
+var executor_default = withRunExecutor(
+  "Cargo - Clippy",
+  cargoClippyExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.toolchain ??= "stable";
+        options.fix ??= false;
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  cargoClippyExecutor,
+  executor_default
+};

package/dist/chunk-UNUH7N7Y.mjs

@@ -0,0 +1,76 @@
+import {
+  withRunGenerator
+} from "./chunk-46GNS53C.mjs";
+import {
+  schemaRegistry,
+  workspaceConfigSchema
+} from "./chunk-K7B3YICS.mjs";
+import {
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "./chunk-T55IDP24.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-3J2CP54B.mjs";
+
+// src/generators/config-schema/generator.ts
+import { formatFiles, writeJson } from "@nx/devkit";
+import * as z from "zod";
+async function configSchemaGeneratorFn(tree, options, config) {
+  writeInfo(
+    "\u{1F4E6}  Running Storm Workspace Configuration JSON Schema generator",
+    config
+  );
+  writeTrace(
+    `Determining the Storm Workspace Configuration JSON Schema...`,
+    config
+  );
+  const jsonSchema = z.toJSONSchema(workspaceConfigSchema, {
+    target: "draft-7",
+    metadata: schemaRegistry
+  });
+  jsonSchema.$id ??= "https://public.storm-cdn.com/schemas/storm-workspace.schema.json";
+  jsonSchema.title ??= "Storm Workspace Configuration JSON Schema";
+  jsonSchema.description ??= "This JSON Schema defines the structure of the Storm Workspace configuration file (`storm-workspace.json`). It is used to validate the configuration file and ensure that it adheres to the expected format.";
+  writeTrace(jsonSchema, config);
+  if (!options.outputFile) {
+    throw new Error(
+      "The `outputFile` option is required. Please specify the output file path."
+    );
+  }
+  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
+  };
+}
+var generator_default = withRunGenerator(
+  "Configuration Schema Creator",
+  configSchemaGeneratorFn,
+  {
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputFile ??= "{workspaceRoot}/storm-workspace.schema.json";
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  configSchemaGeneratorFn,
+  generator_default
+};

package/dist/chunk-UTP3KI2H.js

@@ -0,0 +1,76 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _chunkRSYBXBX2js = require('./chunk-RSYBXBX2.js');
+
+
+
+var _chunkZJ75AYXEjs = require('./chunk-ZJ75AYXE.js');
+
+
+
+
+var _chunkAGR3NCGAjs = require('./chunk-AGR3NCGA.js');
+
+
+var _chunkLMYTVXGXjs = require('./chunk-LMYTVXGX.js');
+
+// src/generators/config-schema/generator.ts
+var _devkit = require('@nx/devkit');
+var _zod = require('zod'); var z = _interopRequireWildcard(_zod);
+async function configSchemaGeneratorFn(tree, options, config) {
+  _chunkAGR3NCGAjs.writeInfo.call(void 0, 
+    "\u{1F4E6}  Running Storm Workspace Configuration JSON Schema generator",
+    config
+  );
+  _chunkAGR3NCGAjs.writeTrace.call(void 0, 
+    `Determining the Storm Workspace Configuration JSON Schema...`,
+    config
+  );
+  const jsonSchema = z.toJSONSchema(_chunkZJ75AYXEjs.workspaceConfigSchema, {
+    target: "draft-7",
+    metadata: _chunkZJ75AYXEjs.schemaRegistry
+  });
+  jsonSchema.$id ??= "https://public.storm-cdn.com/schemas/storm-workspace.schema.json";
+  jsonSchema.title ??= "Storm Workspace Configuration JSON Schema";
+  jsonSchema.description ??= "This JSON Schema defines the structure of the Storm Workspace configuration file (`storm-workspace.json`). It is used to validate the configuration file and ensure that it adheres to the expected format.";
+  _chunkAGR3NCGAjs.writeTrace.call(void 0, jsonSchema, config);
+  if (!options.outputFile) {
+    throw new Error(
+      "The `outputFile` option is required. Please specify the output file path."
+    );
+  }
+  const outputPath = options.outputFile.replaceAll("{workspaceRoot}", "").replaceAll(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.workspaceRoot]), () => ( _chunkLMYTVXGXjs.findWorkspaceRoot.call(void 0, ))),
+    options.outputFile.startsWith("./") ? "" : "./"
+  );
+  _chunkAGR3NCGAjs.writeTrace.call(void 0, 
+    `\u{1F4DD}  Writing Storm Configuration JSON Schema to "${outputPath}"`,
+    config
+  );
+  _devkit.writeJson.call(void 0, tree, outputPath, jsonSchema, { spaces: 2 });
+  await _devkit.formatFiles.call(void 0, tree);
+  _chunkAGR3NCGAjs.writeSuccess.call(void 0, 
+    "\u{1F680}  Storm Configuration JSON Schema creation has completed successfully!",
+    config
+  );
+  return {
+    success: true
+  };
+}
+var generator_default = _chunkRSYBXBX2js.withRunGenerator.call(void 0, 
+  "Configuration Schema Creator",
+  configSchemaGeneratorFn,
+  {
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputFile ??= "{workspaceRoot}/storm-workspace.schema.json";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.configSchemaGeneratorFn = configSchemaGeneratorFn; exports.generator_default = generator_default;

package/dist/chunk-UV6QIFS3.js

@@ -0,0 +1,388 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _chunkBAPFD3TOjs = require('./chunk-BAPFD3TO.js');
+
+
+
+var _chunk32KQVUCFjs = require('./chunk-32KQVUCF.js');
+
+
+
+
+var _chunkTAP26ZJQjs = require('./chunk-TAP26ZJQ.js');
+
+// src/plugins/rust/cargo-toml.ts
+
+
+
+
+
+var _devkit = require('@nx/devkit');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _fs = require('fs');
+var _path = require('path');
+
+
+var _projectgraph = require('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 _devkit.createNodesFromFiles.call(void 0, 
+      (configFile, options2, context2) => {
+        try {
+          const profiles = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _ => _.profiles]), () => ( {}));
+          const includeApps = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _2 => _2.includeApps]), () => ( true));
+          const toolchain = _optionalChain([options2, 'optionalAccess', _3 => _3.toolchain]);
+          const skipDocs = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _4 => _4.skipDocs]), () => ( false));
+          const metadata = _chunk32KQVUCFjs.cargoMetadata.call(void 0, );
+          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 (!_chunk32KQVUCFjs.isExternal.call(void 0, cargoPackage, context2.workspaceRoot)) {
+              const root = _chunkBAPFD3TOjs.getRoot.call(void 0, _path.dirname.call(void 0, configFile), context2);
+              const project = {
+                root,
+                name: cargoPackage.name
+              };
+              if (_fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, root, "project.json"))) {
+                const projectJson = _devkit.readJsonFile.call(void 0, 
+                  _devkit.joinPathFragments.call(void 0, 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) {
+                _chunkTAP26ZJQjs.addProjectTag.call(void 0, 
+                  project,
+                  _chunkTAP26ZJQjs.ProjectTagConstants.Registry.TAG_ID,
+                  _chunkTAP26ZJQjs.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
+                };
+              }
+              _chunkTAP26ZJQjs.addProjectTag.call(void 0, 
+                project,
+                _chunkTAP26ZJQjs.ProjectTagConstants.Language.TAG_ID,
+                _chunkTAP26ZJQjs.ProjectTagConstants.Language.RUST,
+                { overwrite: true }
+              );
+              _chunkTAP26ZJQjs.setDefaultProjectTags.call(void 0, project, name);
+              projects[root] = _defu2.default.call(void 0, 
+                {
+                  targets,
+                  release: {
+                    version: {
+                      versionActions: "@storm-software/workspace-tools/release/rust-version-actions"
+                    }
+                  }
+                },
+                project
+              );
+            }
+            for (const dep of cargoPackage.dependencies) {
+              if (_chunk32KQVUCFjs.isExternal.call(void 0, dep, context2.workspaceRoot)) {
+                const externalDepName = `cargo:${dep.name}`;
+                if (!_optionalChain([externalNodes, 'optionalAccess', _5 => _5[externalDepName]])) {
+                  externalNodes[externalDepName] = {
+                    type: "cargo",
+                    name: externalDepName,
+                    data: {
+                      packageName: dep.name,
+                      version: _nullishCoalesce(_optionalChain([cargoPackageMap, 'access', _6 => _6.get, 'call', _7 => _7(dep.name), 'optionalAccess', _8 => _8.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 = _chunk32KQVUCFjs.cargoMetadata.call(void 0, );
+  if (!_optionalChain([metadata, 'optionalAccess', _9 => _9.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, _projectgraph.DependencyType.static)
+          );
+        } else {
+          const externalDepName = `cargo:${deps.name}`;
+          if (externalDepName in (_nullishCoalesce(context.externalNodes, () => ( {})))) {
+            dependencies.push(
+              createDependency(
+                context,
+                pkg,
+                externalDepName,
+                _projectgraph.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(/^\//, "")
+  };
+  _devkit.validateDependency.call(void 0, dependency, context);
+  return dependency;
+}
+
+
+
+
+
+
+
+exports.name = name; exports.description = description; exports.DefaultCargoPluginProfileMap = DefaultCargoPluginProfileMap; exports.createNodesV2 = createNodesV2; exports.createDependencies = createDependencies;