@storm-software/workspace-tools 1.228.0 → 1.229.0

package/dist/chunk-6267MSX4.mjs

@@ -0,0 +1,118 @@
+import {
+  applyWorkspaceExecutorTokens
+} from "./chunk-FFBZYD6R.mjs";
+import {
+  applyWorkspaceTokens
+} from "./chunk-NDDXQD7R.mjs";
+import {
+  formatLogMessage,
+  getStopwatch,
+  loadStormConfig,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "./chunk-WJ5TU6JU.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-DMUTOQCB.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/base/base-executor.ts
+var withRunExecutor = /* @__PURE__ */ __name((name, executorFn, executorOptions = {}) => async (_options, context) => {
+  const stopwatch = getStopwatch(name);
+  let options = _options;
+  let config = {};
+  try {
+    writeInfo(`\u26A1 Running the ${name} executor...
+`, 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.");
+    }
+    const workspaceRoot = findWorkspaceRoot();
+    const projectRoot = context.projectsConfigurations.projects[context.projectName]?.root ?? workspaceRoot;
+    const sourceRoot = context.projectsConfigurations.projects[context.projectName]?.sourceRoot ?? workspaceRoot;
+    const projectName = context.projectsConfigurations.projects[context.projectName]?.name ?? context.projectName;
+    config.workspaceRoot = workspaceRoot;
+    if (!executorOptions.skipReadingConfig) {
+      writeTrace(`Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}
+ - projectRoot: ${projectRoot}
+ - sourceRoot: ${sourceRoot}
+ - projectName: ${projectName}
+`, config);
+      config = await loadStormConfig(workspaceRoot);
+    }
+    if (executorOptions?.hooks?.applyDefaultOptions) {
+      writeDebug("Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(executorOptions.hooks.applyDefaultOptions(options, config));
+      writeDebug("Completed the applyDefaultOptions hook", config);
+    }
+    writeTrace(`Executor schema options \u2699\uFE0F 
+${Object.keys(options).map((key) => ` - ${key}=${_isFunction(options[key]) ? "<function>" : JSON.stringify(options[key])}`).join("\n")}`, config);
+    const tokenized = await applyWorkspaceTokens(options, {
+      config,
+      workspaceRoot,
+      projectRoot,
+      sourceRoot,
+      projectName,
+      ...context.projectsConfigurations.projects[context.projectName],
+      ...executorOptions
+    }, applyWorkspaceExecutorTokens);
+    if (executorOptions?.hooks?.preProcess) {
+      writeDebug("Running the preProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.preProcess(tokenized, config));
+      writeDebug("Completed the preProcess hook", config);
+    }
+    const ret = executorFn(tokenized, context, config);
+    if (_isFunction(ret?.next)) {
+      const asyncGen = ret;
+      for await (const iter of asyncGen) {
+      }
+    }
+    const result = await Promise.resolve(ret);
+    if (result && (!result.success || result.error && result?.error?.message && typeof result?.error?.message === "string" && result?.error?.name && typeof result?.error?.name === "string")) {
+      writeTrace(`Failure determined by the ${name} executor 
+${formatLogMessage(result)}`, config);
+      console.error(result);
+      throw new Error(`The ${name} executor failed to run`, {
+        cause: result?.error
+      });
+    }
+    if (executorOptions?.hooks?.postProcess) {
+      writeDebug("Running the postProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.postProcess(config));
+      writeDebug("Completed the postProcess hook", config);
+    }
+    writeSuccess(`Completed running the ${name} task executor!
+`, config);
+    return {
+      success: true
+    };
+  } catch (error) {
+    writeFatal("A fatal error occurred while running the executor - the process was forced to terminate", config);
+    writeError(`An exception was thrown in the executor's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    return {
+      success: false
+    };
+  } finally {
+    stopwatch();
+  }
+}, "withRunExecutor");
+var _isFunction = /* @__PURE__ */ __name((value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(value?.constructor && value?.call && value?.apply);
+  } catch (e) {
+    return false;
+  }
+}, "_isFunction");
+
+export {
+  withRunExecutor
+};

package/dist/chunk-66TYTM73.mjs

@@ -0,0 +1,102 @@
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/project-tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  DistStyle: {
+    TAG_ID: "dist-style",
+    NORMAL: "normal",
+    CLEAN: "clean"
+  },
+  Provider: {
+    TAG_ID: "provider"
+  },
+  Platform: {
+    TAG_ID: "platform",
+    NODE: "node",
+    BROWSER: "browser",
+    NEUTRAL: "neutral",
+    WORKER: "worker"
+  },
+  Registry: {
+    TAG_ID: "registry",
+    CARGO: "cargo",
+    NPM: "npm",
+    CONTAINER: "container",
+    CYCLONE: "cyclone"
+  },
+  Plugin: {
+    TAG_ID: "plugin"
+  }
+};
+var formatProjectTag = /* @__PURE__ */ __name((variant, value) => {
+  return `${variant}:${value}`;
+}, "formatProjectTag");
+var hasProjectTag = /* @__PURE__ */ __name((project, variant) => {
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some((tag) => tag.startsWith(prefix) && tag.length > prefix.length);
+}, "hasProjectTag");
+var getProjectTag = /* @__PURE__ */ __name((project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return tag?.replace(prefix, "");
+}, "getProjectTag");
+var isEqualProjectTag = /* @__PURE__ */ __name((project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
+}, "isEqualProjectTag");
+var addProjectTag = /* @__PURE__ */ __name((project, variant, value, options = {
+  overwrite: false
+}) => {
+  project.tags = project.tags ?? [];
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter((tag) => !tag.startsWith(formatProjectTag(variant, "")));
+    project.tags.push(formatProjectTag(variant, value));
+  }
+}, "addProjectTag");
+var addPluginProjectTag = /* @__PURE__ */ __name((project, plugin) => {
+  project.tags = project.tags ?? [];
+  project.tags.push(formatProjectTag(ProjectTagConstants.Plugin.TAG_ID, plugin));
+}, "addPluginProjectTag");
+var setDefaultProjectTags = /* @__PURE__ */ __name((project, plugin) => {
+  project.tags = project.tags ?? [];
+  addProjectTag(project, ProjectTagConstants.ProjectType.TAG_ID, project.projectType === "application" ? ProjectTagConstants.ProjectType.APPLICATION : ProjectTagConstants.ProjectType.LIBRARY, {
+    overwrite: true
+  });
+  addProjectTag(project, ProjectTagConstants.DistStyle.TAG_ID, project.targets && Object.keys(project.targets).includes("clean-package") ? ProjectTagConstants.DistStyle.CLEAN : ProjectTagConstants.DistStyle.NORMAL, {
+    overwrite: true
+  });
+  addProjectTag(project, ProjectTagConstants.Platform.TAG_ID, project.targets?.build?.options.platform === "node" ? ProjectTagConstants.Platform.NODE : project.targets?.build?.options.platform === "worker" ? ProjectTagConstants.Platform.WORKER : project.targets?.build?.options.platform === "browser" ? ProjectTagConstants.Platform.BROWSER : ProjectTagConstants.Platform.NEUTRAL, {
+    overwrite: false
+  });
+  if (plugin) {
+    addPluginProjectTag(project, plugin);
+  }
+}, "setDefaultProjectTags");
+
+export {
+  ProjectTagConstants,
+  formatProjectTag,
+  hasProjectTag,
+  getProjectTag,
+  isEqualProjectTag,
+  addProjectTag,
+  addPluginProjectTag,
+  setDefaultProjectTags
+};

package/dist/chunk-6B6IVIMQ.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkULBTYC2Bjs = require('./chunk-ULBTYC2B.js');
+
+
+var _chunkMSENNRAYjs = require('./chunk-MSENNRAY.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/executors/cargo-check/executor.ts
+async function cargoCheckExecutor(options, context) {
+  const command = _chunkULBTYC2Bjs.buildCargoCommand.call(void 0, "check", options, context);
+  return await _chunkULBTYC2Bjs.cargoCommand.call(void 0, ...command);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, cargoCheckExecutor, "cargoCheckExecutor");
+var executor_default = _chunkMSENNRAYjs.withRunExecutor.call(void 0, "Cargo Check", cargoCheckExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
+      options.toolchain ??= "stable";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.cargoCheckExecutor = cargoCheckExecutor; exports.executor_default = executor_default;

package/dist/chunk-6QO3KMZA.js

@@ -0,0 +1,93 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkI734UVDTjs = require('./chunk-I734UVDT.js');
+
+// src/base/cargo-base-executor.untyped.ts
+var _untyped = require('untyped');
+var cargo_base_executor_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  ..._chunkI734UVDTjs.base_executor_untyped_default,
+  $schema: {
+    id: "cargoBaseExecutor",
+    title: "Cargo Base Executor",
+    description: "A base type definition for a Cargo/rust related executor schema"
+  },
+  package: {
+    $schema: {
+      title: "Cargo.toml Path",
+      type: "string",
+      format: "path",
+      description: "The path to the Cargo.toml file"
+    },
+    $default: "{projectRoot}/Cargo.toml"
+  },
+  toolchain: {
+    $schema: {
+      title: "Toolchain",
+      description: "The type of toolchain to use for the build",
+      enum: [
+        "stable",
+        "beta",
+        "nightly"
+      ],
+      default: "stable"
+    },
+    $default: "stable"
+  },
+  target: {
+    $schema: {
+      title: "Target",
+      type: "string",
+      description: "The target to build"
+    }
+  },
+  allTargets: {
+    $schema: {
+      title: "All Targets",
+      type: "boolean",
+      description: "Build all targets"
+    }
+  },
+  profile: {
+    $schema: {
+      title: "Profile",
+      type: "string",
+      description: "The profile to build"
+    }
+  },
+  release: {
+    $schema: {
+      title: "Release",
+      type: "boolean",
+      description: "Build in release mode"
+    }
+  },
+  features: {
+    $schema: {
+      title: "Features",
+      type: "string",
+      description: "The features to build",
+      oneOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      ]
+    }
+  },
+  allFeatures: {
+    $schema: {
+      title: "All Features",
+      type: "boolean",
+      description: "Build all features"
+    }
+  }
+});
+
+
+
+exports.cargo_base_executor_untyped_default = cargo_base_executor_untyped_default;

package/dist/chunk-6TSAUSG4.mjs

@@ -0,0 +1,18 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-DMUTOQCB.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/get-project-configurations.ts
+import { retrieveProjectConfigurationsWithoutPluginInference } from "nx/src/project-graph/utils/retrieve-workspace-files";
+var getProjectConfigurations = /* @__PURE__ */ __name(async () => {
+  return retrieveProjectConfigurationsWithoutPluginInference(findWorkspaceRoot());
+}, "getProjectConfigurations");
+var getProjectConfiguration = /* @__PURE__ */ __name((projectName) => getProjectConfigurations()?.[projectName], "getProjectConfiguration");
+
+export {
+  getProjectConfigurations,
+  getProjectConfiguration
+};

package/dist/chunk-6ZQ3QYXH.mjs

@@ -0,0 +1,93 @@
+import {
+  parseCargoToml
+} from "./chunk-VYH45FO6.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/executors/cargo-publish/executor.ts
+import { joinPathFragments } from "@nx/devkit";
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import https from "node:https";
+var LARGE_BUFFER = 1024 * 1e6;
+async function runExecutor(options, context) {
+  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+  if (!context.projectName) {
+    throw new Error("The executor requires a projectName.");
+  }
+  console.info(`\u{1F680}  Running Storm Cargo Publish executor on the ${context.projectName} crate`);
+  if (!context.projectName || !context.projectsConfigurations?.projects || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
+    throw new Error("The executor requires projectsConfigurations.");
+  }
+  const registry = options.registry ? options.registry : process.env.STORM_REGISTRY_CARGO ? process.env.STORM_REGISTRY_CARGO : "https://crates.io";
+  const root = context.projectsConfigurations.projects[context.projectName]?.root;
+  const packageRoot = joinPathFragments(context.root, options.packageRoot ? options.packageRoot : root);
+  const cargoToml = parseCargoToml(readFileSync(joinPathFragments(packageRoot, "Cargo.toml"), "utf-8"));
+  try {
+    const result = await getRegistryVersion(cargoToml.package.name, cargoToml.package.version, registry);
+    if (result) {
+      console.warn(`Skipped package "${cargoToml.package.name}" from project "${context.projectName}" because v${cargoToml.package.version} already exists in ${registry} with tag "latest"`);
+      return {
+        success: true
+      };
+    }
+  } catch (_) {
+  }
+  const cargoPublishCommandSegments = [
+    `cargo publish --allow-dirty -p ${cargoToml.package.name}`
+  ];
+  if (isDryRun) {
+    cargoPublishCommandSegments.push("--dry-run");
+  }
+  try {
+    const cargoPublishCommand = cargoPublishCommandSegments.join(" ");
+    console.log("");
+    console.log(`Running "${cargoPublishCommand}"...`);
+    console.log("");
+    execSync(cargoPublishCommand, {
+      maxBuffer: LARGE_BUFFER,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "true"
+      },
+      cwd: packageRoot,
+      stdio: [
+        "ignore",
+        "pipe",
+        "pipe"
+      ]
+    });
+    console.log("");
+    if (isDryRun) {
+      console.log(`Would publish to ${registry}, but [dry-run] was set`);
+    } else {
+      console.log(`Published to ${registry}`);
+    }
+    return {
+      success: true
+    };
+  } catch (error) {
+    console.error(`Failed to publish to ${registry}`);
+    console.error(error);
+    console.log("");
+    return {
+      success: false
+    };
+  }
+}
+__name(runExecutor, "runExecutor");
+var getRegistryVersion = /* @__PURE__ */ __name((name, version, registry) => {
+  return new Promise((resolve) => https.get(`${registry}/api/v1/crates/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, (res) => {
+    res.on("data", (d) => {
+      resolve(d);
+    });
+  }).on("error", (e) => {
+    throw e;
+  }));
+}, "getRegistryVersion");
+
+export {
+  runExecutor,
+  getRegistryVersion
+};

package/dist/chunk-7AXFMX2T.js

@@ -0,0 +1,37 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk7YRW5HNXjs = require('./chunk-7YRW5HNX.js');
+
+
+var _chunkZMFVKBRMjs = require('./chunk-ZMFVKBRM.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/utils/package-helpers.ts
+var _devkit = require('@nx/devkit');
+var _fs = require('fs');
+var PackageManagerTypes = {
+  PackageJson: "package.json",
+  CargoToml: "Cargo.toml"
+};
+var getPackageInfo = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (project) => {
+  if (_chunk7YRW5HNXjs.isEqualProjectTag.call(void 0, project, _chunk7YRW5HNXjs.ProjectTagConstants.Language.TAG_ID, _chunk7YRW5HNXjs.ProjectTagConstants.Language.RUST) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: _chunkZMFVKBRMjs.parseCargoToml.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))
+    };
+  } else if (_chunk7YRW5HNXjs.isEqualProjectTag.call(void 0, project, _chunk7YRW5HNXjs.ProjectTagConstants.Language.TAG_ID, _chunk7YRW5HNXjs.ProjectTagConstants.Language.TYPESCRIPT) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: _devkit.readJsonFile.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "package.json"))
+    };
+  }
+  return null;
+}, "getPackageInfo");
+
+
+
+
+exports.PackageManagerTypes = PackageManagerTypes; exports.getPackageInfo = getPackageInfo;

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;