@storm-software/workspace-tools 1.270.2 → 1.271.1

package/src/base/base-executor.ts

@@ -1,200 +0,0 @@
-import type { ExecutorContext, PromiseExecutor } from "@nx/devkit";
-import type { StormWorkspaceConfig } from "@storm-software/config";
-import {
-  applyWorkspaceProjectTokens,
-  applyWorkspaceTokens,
-  findWorkspaceRoot,
-  formatLogMessage,
-  getConfig,
-  getStopwatch,
-  ProjectTokenizerOptions,
-  writeDebug,
-  writeError,
-  writeFatal,
-  writeInfo,
-  writeSuccess,
-  writeTrace
-} from "@storm-software/config-tools";
-import { defu } from "defu";
-import { BaseExecutorOptions, BaseExecutorResult } from "../types";
-import { BaseExecutorSchema } from "./base-executor.schema.d";
-
-export const withRunExecutor =
-  <TExecutorSchema extends BaseExecutorSchema = BaseExecutorSchema>(
-    name: string,
-    executorFn: (
-      options: TExecutorSchema,
-      context: ExecutorContext,
-      config: StormWorkspaceConfig
-    ) =>
-      | Promise<BaseExecutorResult | null | undefined>
-      | AsyncGenerator<any, BaseExecutorResult | null | undefined>
-      | BaseExecutorResult
-      | null
-      | undefined,
-    executorOptions: BaseExecutorOptions<TExecutorSchema> = {}
-  ): PromiseExecutor<TExecutorSchema> =>
-  async (
-    _options: TExecutorSchema,
-    context: ExecutorContext
-  ): Promise<{ success: boolean }> => {
-    const stopwatch = getStopwatch(name);
-    let options = _options;
-
-    let config = {} as StormWorkspaceConfig;
-    try {
-      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 ||
-        projectRoot ||
-        workspaceRoot;
-      const projectName = context.projectName;
-      config.workspaceRoot = workspaceRoot;
-
-      writeInfo(`⚡ Running the ${name} executor for ${projectName} `, config);
-
-      if (!executorOptions.skipReadingConfig) {
-        writeTrace(
-          `Loading the Storm Config from environment variables and storm.config.js file...
- - workspaceRoot: ${workspaceRoot}
- - projectRoot: ${projectRoot}
- - sourceRoot: ${sourceRoot}
- - projectName: ${projectName}\n`,
-          config
-        );
-
-        config = await getConfig(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 ⚙️
-${formatLogMessage(options)}
-`,
-        config
-      );
-
-      const tokenized = (await applyWorkspaceTokens<ProjectTokenizerOptions>(
-        options,
-        defu(
-          { workspaceRoot, projectRoot, sourceRoot, projectName, config },
-          config,
-          context.projectsConfigurations.projects[context.projectName]
-        ),
-        applyWorkspaceProjectTokens
-      )) as TExecutorSchema;
-
-      writeTrace(
-        `Executor schema tokenized options ⚙️
-${formatLogMessage(tokenized)}
-`,
-        config
-      );
-
-      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 as AsyncGenerator)?.next)) {
-        const asyncGen = ret as AsyncGenerator;
-        for await (const iter of asyncGen) {
-          void iter;
-        }
-      }
-
-      const result = await Promise.resolve(
-        ret as
-          | Promise<BaseExecutorResult | null | undefined>
-          | BaseExecutorResult
-          | null
-          | undefined
-      );
-      if (
-        result &&
-        (!result.success ||
-          (result.error &&
-            (result?.error as Error)?.message &&
-            typeof (result?.error as Error)?.message === "string" &&
-            (result?.error as Error)?.name &&
-            typeof (result?.error as Error)?.name === "string"))
-      ) {
-        writeTrace(
-          `Failure determined by the ${name} executor \n${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!\n`, 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 \n - Details: ${error.message}\n - Stacktrace: ${error.stack}`,
-        config
-      );
-
-      return {
-        success: false
-      };
-    } finally {
-      stopwatch();
-    }
-  };
-
-const _isFunction = (
-  value: unknown
-): value is ((params?: unknown) => unknown) & ((param?: any) => any) => {
-  try {
-    return (
-      value instanceof Function ||
-      typeof value === "function" ||
-      !!(value?.constructor && (value as any)?.call && (value as any)?.apply)
-    );
-    // biome-ignore lint/correctness/noUnusedVariables: <explanation>
-  } catch (e) {
-    return false;
-  }
-};

package/src/base/base-executor.untyped.ts

@@ -1,18 +0,0 @@
-import { defineUntypedSchema } from "untyped";
-
-export default defineUntypedSchema({
-  $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",
-    },
-    $default: "dist/{projectRoot}",
-  },
-});

package/src/base/base-generator.ts

@@ -1,130 +0,0 @@
-import type { GeneratorCallback, Tree } from "@nx/devkit";
-import type { StormWorkspaceConfig } from "@storm-software/config";
-import {
-  applyWorkspaceBaseTokens,
-  applyWorkspaceTokens,
-  findWorkspaceRoot,
-  getConfig,
-  getStopwatch,
-  writeDebug,
-  writeError,
-  writeFatal,
-  writeInfo,
-  writeSuccess,
-  writeTrace
-} from "@storm-software/config-tools";
-import type { BaseGeneratorOptions, BaseGeneratorResult } from "../types";
-import type { BaseGeneratorSchema } from "./base-generator.schema.d";
-
-export const withRunGenerator =
-  <TGeneratorSchema extends BaseGeneratorSchema = BaseGeneratorSchema>(
-    name: string,
-    generatorFn: (
-      tree: Tree,
-      options: TGeneratorSchema,
-      config?: StormWorkspaceConfig
-    ) =>
-      | Promise<BaseGeneratorResult | null | undefined>
-      | BaseGeneratorResult
-      | null
-      | undefined,
-    generatorOptions: BaseGeneratorOptions<TGeneratorSchema> = {
-      skipReadingConfig: false
-    }
-  ) =>
-  async (
-    tree: Tree,
-    _options: TGeneratorSchema
-  ): Promise<GeneratorCallback | BaseGeneratorResult> => {
-    const stopwatch = getStopwatch(name);
-    let options = _options;
-
-    let config: StormWorkspaceConfig | undefined;
-    try {
-      writeInfo(`⚡ Running the ${name} generator...\n\n`, config);
-
-      const workspaceRoot = findWorkspaceRoot();
-      if (!generatorOptions.skipReadingConfig) {
-        writeDebug(
-          `Loading the Storm Config from environment variables and storm.config.js file...
- - workspaceRoot: ${workspaceRoot}`,
-          config
-        );
-
-        config = await getConfig(workspaceRoot);
-      }
-
-      if (generatorOptions?.hooks?.applyDefaultOptions) {
-        writeDebug("Running the applyDefaultOptions hook...", config);
-        options = await Promise.resolve(
-          generatorOptions.hooks.applyDefaultOptions(options, config)
-        );
-        writeDebug("Completed the applyDefaultOptions hook", config);
-      }
-
-      writeTrace(
-        `Generator schema options ⚙️ \n${Object.keys(options ?? {})
-          .map(key => ` - ${key}=${JSON.stringify(options[key])}`)
-          .join("\n")}`,
-        config
-      );
-
-      const tokenized = (await applyWorkspaceTokens(
-        options as Record<string, any>,
-        { workspaceRoot: tree.root, config },
-        applyWorkspaceBaseTokens
-      )) as TGeneratorSchema;
-
-      if (generatorOptions?.hooks?.preProcess) {
-        writeDebug("Running the preProcess hook...", config);
-        await Promise.resolve(
-          generatorOptions.hooks.preProcess(tokenized, config)
-        );
-        writeDebug("Completed the preProcess hook", config);
-      }
-
-      // Run the generator function
-      const result = await Promise.resolve(
-        generatorFn(tree, tokenized, config)
-      );
-      if (result) {
-        if (
-          result.success === false ||
-          (result.error &&
-            (result?.error as Error)?.message &&
-            typeof (result?.error as Error)?.message === "string" &&
-            (result?.error as Error)?.name &&
-            typeof (result?.error as Error)?.name === "string")
-        ) {
-          throw new Error(`The ${name} generator failed to run`, {
-            cause: result?.error
-          });
-        } else if (result.success && result.data) {
-          return result as any;
-        }
-      }
-
-      if (generatorOptions?.hooks?.postProcess) {
-        writeDebug("Running the postProcess hook...", config);
-        await Promise.resolve(generatorOptions.hooks.postProcess(config));
-        writeDebug("Completed the postProcess hook", config);
-      }
-
-      return () => {
-        writeSuccess(`Completed running the ${name} generator!\n`, config);
-      };
-    } catch (error) {
-      return () => {
-        writeFatal(
-          "A fatal error occurred while running the generator - the process was forced to terminate",
-          config
-        );
-        writeError(
-          `An exception was thrown in the generator's process \n - Details: ${error.message}\n - Stacktrace: ${error.stack}`,
-          config
-        );
-      };
-    } finally {
-      stopwatch();
-    }
-  };

package/src/base/base-generator.untyped.ts

@@ -1,16 +0,0 @@
-import { defineUntypedSchema } from "untyped";
-
-export default defineUntypedSchema({
-  $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",
-    },
-  },
-});

package/src/base/cargo-base-executor.untyped.ts

@@ -1,73 +0,0 @@
-import { defineUntypedSchema } from "untyped";
-import baseExecutorSchema from "./base-executor.untyped";
-
-export default defineUntypedSchema({
-  ...baseExecutorSchema,
-  $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",
-    },
-  },
-});

package/src/base/index.ts

@@ -1,8 +0,0 @@
-export * from "./base-executor";
-export { default as baseExecutorSchema } from "./base-executor.untyped";
-export * from "./base-generator";
-export { default as baseGeneratorSchema } from "./base-generator.untyped";
-export { default as cargoBaseExecutorSchema } from "./cargo-base-executor.untyped";
-export { default as typescriptBuildExecutorSchema } from "./typescript-build-executor.untyped";
-export * from "./typescript-library-generator";
-export { default as typescriptLibraryGeneratorSchema } from "./typescript-library-generator.untyped";

package/src/base/typescript-build-executor.untyped.ts

@@ -1,153 +0,0 @@
-import { defineUntypedSchema } from "untyped";
-import baseExecutorSchema from "./base-executor.untyped";
-
-export default defineUntypedSchema({
-  ...baseExecutorSchema,
-  $schema: {
-    id: "TypeScriptBuildExecutorSchema",
-    title: "TypeScript Build Executor",
-    description:
-      "A type definition for the base TypeScript build executor schema",
-    required: ["entry", "tsconfig"],
-  },
-  entry: {
-    $schema: {
-      title: "Entry File(s)",
-      format: "path",
-      type: "array",
-      description: "The entry file or files to build",
-      items: { type: "string" },
-    },
-    $default: ["{sourceRoot}/index.ts"],
-  },
-  tsconfig: {
-    $schema: {
-      title: "TSConfig Path",
-      type: "string",
-      format: "path",
-      description: "The path to the tsconfig file",
-    },
-    $default: "{projectRoot}/tsconfig.json",
-  },
-  bundle: {
-    $schema: {
-      title: "Bundle",
-      type: "boolean",
-      description: "Bundle the output",
-    },
-  },
-  minify: {
-    $schema: {
-      title: "Minify",
-      type: "boolean",
-      description: "Minify the output",
-    },
-  },
-  debug: {
-    $schema: {
-      title: "Debug",
-      type: "boolean",
-      description: "Debug the output",
-    },
-  },
-  sourcemap: {
-    $schema: {
-      title: "Sourcemap",
-      type: "boolean",
-      description: "Generate a sourcemap",
-    },
-  },
-  silent: {
-    $schema: {
-      title: "Silent",
-      type: "boolean",
-      description:
-        "Should the build run silently - only report errors back to the user",
-    },
-    $default: false,
-  },
-  target: {
-    $schema: {
-      title: "Target",
-      type: "string",
-      description: "The target to build",
-      enum: [
-        "es3",
-        "es5",
-        "es6",
-        "es2015",
-        "es2016",
-        "es2017",
-        "es2018",
-        "es2019",
-        "es2020",
-        "es2021",
-        "es2022",
-        "es2023",
-        "es2024",
-        "esnext",
-        "node12",
-        "node14",
-        "node16",
-        "node18",
-        "node20",
-        "node22",
-        "browser",
-        "chrome58",
-        "chrome59",
-        "chrome60",
-      ],
-    },
-    $default: "esnext",
-    $resolve: (val: string = "esnext") => val.toLowerCase(),
-  },
-  format: {
-    $schema: {
-      title: "Format",
-      type: "array",
-      description: "The format to build",
-      items: {
-        type: "string",
-        enum: ["cjs", "esm", "iife"],
-      },
-    },
-    $resolve: (val: string[] = ["cjs", "esm"]) => ([] as string[]).concat(val),
-  },
-  platform: {
-    $schema: {
-      title: "Platform",
-      type: "string",
-      description: "The platform to build",
-      enum: ["neutral", "node", "browser"],
-    },
-    $default: "neutral",
-  },
-  external: {
-    $schema: {
-      title: "External",
-      type: "array",
-      description: "The external dependencies",
-    },
-    $resolve: (val: string[] = []) => ([] as string[]).concat(val),
-  },
-  define: {
-    $schema: {
-      title: "Define",
-      type: "object",
-      tsType: "Record<string, string>",
-      description: "The define values",
-    },
-    $resolve: (val: Record<string, string> = {}) => val,
-    $default: {},
-  },
-  env: {
-    $schema: {
-      title: "Environment Variables",
-      type: "object",
-      tsType: "Record<string, string>",
-      description: "The environment variable values",
-    },
-    $resolve: (val: Record<string, string> = {}) => val,
-    $default: {},
-  },
-});