@storm-software/workspace-tools 1.270.2 → 1.271.1

package/src/plugins/typescript/tsup.ts

@@ -1,198 +0,0 @@
-import {
-  createNodesFromFiles,
-  CreateNodesResultV2,
-  CreateNodesV2,
-  readJsonFile
-} from "@nx/devkit";
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { readNxJson } from "nx/src/config/nx-json.js";
-import type { ProjectConfiguration } from "nx/src/config/workspace-json-project-json";
-import { readTargetsFromPackageJson } from "nx/src/utils/package-json";
-import type { PackageJson } from "pkg-types";
-import { setDefaultProjectTags } from "../../utils/project-tags";
-
-export const name = "storm-software/typescript/tsup";
-
-export type TsupPluginOptions = object;
-
-export const createNodesV2: CreateNodesV2<TsupPluginOptions> = [
-  "**/tsup.config.ts",
-  async (configFiles, options, context): Promise<CreateNodesResultV2> => {
-    return await createNodesFromFiles(
-      (configFile, options, context) => {
-        try {
-          console.log(`Processing tsup.config.ts file: ${configFile}`);
-
-          const projectRoot = createProjectRoot(
-            configFile,
-            context.workspaceRoot
-          );
-          if (!projectRoot) {
-            console.error(
-              `tsup.config.ts file must be location in the project root directory: ${configFile}`
-            );
-            return {};
-          }
-
-          const packageJson = readJsonFile(join(projectRoot, "package.json"));
-          if (!packageJson) {
-            console.error(
-              `No package.json found in project root: ${projectRoot}`
-            );
-            return {};
-          }
-
-          if (
-            !packageJson.devDependencies?.tsup &&
-            !packageJson.dependencies?.tsup
-          ) {
-            console.warn(
-              `No "tsup" dependency or devDependency found in package.json: ${configFile}
-Please add it to your dependencies by running "pnpm add tsup -D --filter="${packageJson.name}"`
-            );
-          }
-
-          const project = createProjectFromPackageJsonNextToProjectJson(
-            join(projectRoot, "project.json"),
-            packageJson
-          );
-
-          const nxJson = readNxJson(context.workspaceRoot);
-          const targets: ProjectConfiguration["targets"] =
-            readTargetsFromPackageJson(packageJson, nxJson);
-
-          let relativeRoot = projectRoot
-            .replaceAll("\\", "/")
-            .replace(context.workspaceRoot.replaceAll("\\", "/"), "");
-          if (relativeRoot.startsWith("/")) {
-            relativeRoot = relativeRoot.slice(1);
-          }
-
-          let relativeConfig = configFile.replaceAll(relativeRoot, "");
-          while (relativeConfig.startsWith(".")) {
-            relativeConfig = relativeConfig.slice(1);
-          }
-          while (relativeConfig.startsWith("/")) {
-            relativeConfig = relativeConfig.slice(1);
-          }
-
-          targets["build-base"] ??= {
-            cache: true,
-            inputs: [
-              `{workspaceRoot}/${configFile}`,
-              "typescript",
-              "^production"
-            ],
-            outputs: ["{projectRoot}/dist"],
-            executor: "nx:run-commands",
-            dependsOn: ["build-untyped", "^build"],
-            options: {
-              command: `tsup --config="${relativeConfig}"`,
-              cwd: relativeRoot
-            }
-          };
-
-          targets.build ??= {
-            cache: true,
-            inputs: [
-              "{workspaceRoot}/LICENSE",
-              "{projectRoot}/dist",
-              "{projectRoot}/*.md",
-              "{projectRoot}/package.json"
-            ],
-            outputs: ["{workspaceRoot}/dist/{projectRoot}"],
-            executor: "nx:run-commands",
-            dependsOn: ["build-base", "build-untyped", "^build"],
-            options: {
-              commands: [
-                `pnpm copyfiles LICENSE dist/${relativeRoot}`,
-                `pnpm copyfiles --up=2 ./${relativeRoot}/*.md ./${relativeRoot}/package.json dist/${relativeRoot}`,
-                `pnpm copyfiles --up=3 "./${relativeRoot}/dist/**/*" dist/${relativeRoot}/dist`
-              ]
-            }
-          };
-
-          targets.clean = {
-            executor: "nx:run-commands",
-            inputs: [
-              `{workspaceRoot}/${configFile}`,
-              "typescript",
-              "^production"
-            ],
-            options: {
-              commands: [
-                `pnpm exec rimraf dist/${relativeRoot}`,
-                `pnpm exec rimraf ${relativeRoot}/dist`
-              ]
-            }
-          };
-
-          setDefaultProjectTags(project, name);
-
-          const result = project?.name
-            ? {
-                projects: {
-                  [project.name]: {
-                    ...project,
-                    root: relativeRoot,
-                    targets
-                  }
-                }
-              }
-            : {};
-          console.log(`Writing Results for ${project?.name ?? "missing name"}`);
-          console.log(result);
-
-          return result;
-        } catch (e) {
-          console.error(e);
-          return {};
-        }
-      },
-      configFiles,
-      options,
-      context
-    );
-  }
-];
-
-function createProjectFromPackageJsonNextToProjectJson(
-  projectJsonPath: string,
-  packageJson: PackageJson
-): ProjectConfiguration {
-  const { nx, name } = packageJson;
-  const root = dirname(projectJsonPath);
-  const projectJson = readJsonFile(projectJsonPath);
-
-  return {
-    targets: {},
-    tags: [],
-    name,
-    ...nx,
-    ...projectJson,
-    root
-  } as ProjectConfiguration;
-}
-
-function createProjectRoot(
-  configPath: string,
-  workspaceRoot: string
-): string | null {
-  try {
-    const root = dirname(configPath);
-    const projectRoot = join(workspaceRoot, root);
-
-    if (
-      !existsSync(join(projectRoot, "package.json")) &&
-      !existsSync(join(projectRoot, "project.json"))
-    ) {
-      return null;
-    }
-
-    return projectRoot;
-  } catch (e) {
-    console.error(e);
-    return null;
-  }
-}

package/src/types.ts

@@ -1,130 +0,0 @@
-import type { StormWorkspaceConfig } from "@storm-software/config";
-import type { Options } from "tsup";
-import { BaseExecutorSchema } from "./base/base-executor.schema.d";
-import { BaseGeneratorSchema } from "./base/base-generator.schema.d";
-
-export interface TsupContext {
-  projectRoot: string;
-  sourceRoot: string;
-  projectName: string;
-  main: string;
-}
-
-export type BuildOptions = Options;
-export type Entry = string | string[] | Record<string, string>;
-
-export interface WorkspaceToolHooks<TSchema = any> {
-  applyDefaultOptions?: (
-    options: Partial<TSchema>,
-    config?: StormWorkspaceConfig
-  ) => Promise<TSchema> | TSchema;
-  preProcess?: (
-    options: TSchema,
-    config?: StormWorkspaceConfig
-  ) => Promise<void> | void;
-  postProcess?: (config?: StormWorkspaceConfig) => Promise<void> | void;
-}
-
-export interface BaseWorkspaceToolOptions<TSchema = any> {
-  skipReadingConfig?: boolean;
-  hooks?: WorkspaceToolHooks<TSchema>;
-}
-
-export type BaseExecutorOptions<
-  TExecutorSchema extends BaseExecutorSchema = BaseExecutorSchema
-> = BaseWorkspaceToolOptions<TExecutorSchema>;
-
-export interface BaseExecutorResult {
-  error?: Error;
-  success?: boolean;
-}
-
-export type BaseGeneratorOptions<
-  TGeneratorSchema extends BaseGeneratorSchema = BaseGeneratorSchema
-> = BaseWorkspaceToolOptions<TGeneratorSchema>;
-
-export interface BaseGeneratorResult extends Record<string, any> {
-  error?: Error;
-  success?: boolean;
-  data?: any;
-}
-
-// export type TypeScriptLibraryGeneratorSchema = Omit<
-//   LibraryGeneratorSchema,
-//   | "js"
-//   | "pascalCaseFiles"
-//   | "skipFormat"
-//   | "skipTsConfig"
-//   | "skipPackageJson"
-//   | "includeBabelRc"
-//   | "unitTestRunner"
-//   | "platform"
-//   | "linter"
-//   | "testEnvironment"
-//   | "config"
-//   | "compiler"
-//   | "bundler"
-//   | "skipTypeCheck"
-//   | "minimal"
-// > & {
-//   name: string;
-//   description: string;
-//   buildExecutor: string;
-//   platform?: "neutral" | "node" | "browser" | "worker";
-//   devDependencies?: Record<string, string>;
-//   peerDependencies?: Record<string, string>;
-//   peerDependenciesMeta?: Record<string, any>;
-//   tsConfigOptions?: Record<string, any>;
-// };
-
-export type ProjectTagVariant =
-  | "language"
-  | "type"
-  | "dist-style"
-  | "provider"
-  | "platform"
-  | "registry"
-  | "plugin";
-export const ProjectTagVariant = {
-  LANGUAGE: "language" as ProjectTagVariant,
-  TYPE: "type" as ProjectTagVariant,
-  DIST_STYLE: "dist-style" as ProjectTagVariant,
-  PROVIDER: "provider" as ProjectTagVariant,
-  PLATFORM: "platform" as ProjectTagVariant,
-  REGISTRY: "registry" as ProjectTagVariant,
-  PLUGIN: "plugin" as ProjectTagVariant
-};
-
-export type ProjectTagLanguageValue = "typescript" | "rust";
-export const ProjectTagLanguageValue = {
-  TYPESCRIPT: "typescript" as ProjectTagLanguageValue,
-  RUST: "rust" as ProjectTagLanguageValue
-};
-
-export type ProjectTagTypeValue = "library" | "application";
-export const ProjectTagTypeValue = {
-  LIBRARY: "library" as ProjectTagTypeValue,
-  APPLICATION: "application" as ProjectTagTypeValue
-};
-
-export type ProjectTagDistStyleValue = "normal" | "clean";
-export const ProjectTagDistStyleValue = {
-  NORMAL: "normal" as ProjectTagDistStyleValue,
-  CLEAN: "clean" as ProjectTagDistStyleValue
-};
-
-export type ProjectTagPlatformValue = "node" | "browser" | "neutral" | "worker";
-export const ProjectTagPlatformValue = {
-  NODE: "node" as ProjectTagPlatformValue,
-  BROWSER: "browser" as ProjectTagPlatformValue,
-  NEUTRAL: "neutral" as ProjectTagPlatformValue,
-  WORKER: "worker" as ProjectTagPlatformValue
-};
-
-export type ProjectTagRegistryValue = "cargo" | "npm" | "container" | "cyclone";
-export const ProjectTagRegistryValue = {
-  CARGO: "cargo" as ProjectTagRegistryValue,
-  NPM: "npm" as ProjectTagRegistryValue,
-  CONTAINER: "container" as ProjectTagRegistryValue,
-  CYCLONE: "cyclone" as ProjectTagRegistryValue
-};

package/src/utils/apply-workspace-tokens.ts

@@ -1,73 +0,0 @@
-import type { ProjectConfiguration } from "@nx/devkit";
-import {
-  findWorkspaceRoot,
-  type BaseTokenizerOptions,
-} from "@storm-software/config-tools";
-
-export type ExecutorTokenizerOptions = BaseTokenizerOptions &
-  ProjectConfiguration & {
-    projectName: string;
-    projectRoot: string;
-    sourceRoot: string;
-  };
-
-export const applyWorkspaceExecutorTokens = async (
-  option: string,
-  tokenizerOptions: ExecutorTokenizerOptions,
-): Promise<string> => {
-  let result = option;
-  if (!result) {
-    return result;
-  }
-
-  let projectName!: string;
-  let projectRoot!: string;
-  let sourceRoot!: string;
-  if ((tokenizerOptions as ExecutorTokenizerOptions)?.projectName) {
-    const context = tokenizerOptions as ExecutorTokenizerOptions;
-    projectName = context.projectName;
-    projectRoot = context.root;
-    sourceRoot = context.sourceRoot;
-  } else {
-    const projectConfig = tokenizerOptions as ProjectConfiguration;
-    projectRoot = projectConfig.root;
-
-    if (projectConfig.name) {
-      projectName = projectConfig.name;
-    }
-    if (projectConfig.sourceRoot) {
-      sourceRoot = projectConfig.sourceRoot;
-    }
-  }
-
-  if (tokenizerOptions.config) {
-    const configKeys = Object.keys(tokenizerOptions.config);
-    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
-      for (const configKey of configKeys) {
-        if (result.includes(`{${configKey}}`)) {
-          result = result.replaceAll(
-            `{${configKey}}`,
-            tokenizerOptions.config[configKey],
-          );
-        }
-      }
-    }
-  }
-  if (result.includes("{projectName}")) {
-    result = result.replaceAll("{projectName}", projectName);
-  }
-  if (result.includes("{projectRoot}")) {
-    result = result.replaceAll("{projectRoot}", projectRoot);
-  }
-  if (result.includes("{sourceRoot}")) {
-    result = result.replaceAll("{sourceRoot}", sourceRoot);
-  }
-  if (result.includes("{workspaceRoot}")) {
-    result = result.replaceAll(
-      "{workspaceRoot}",
-      tokenizerOptions.workspaceRoot ?? findWorkspaceRoot(),
-    );
-  }
-
-  return result;
-};

package/src/utils/cargo.ts

@@ -1,219 +0,0 @@
-import { ExecutorContext, joinPathFragments, workspaceRoot } from "@nx/devkit";
-import {
-  type ChildProcess,
-  execSync,
-  spawn,
-  type StdioOptions,
-} from "node:child_process";
-import { relative } from "node:path";
-import { CargoBaseExecutorSchema } from "../base/cargo-base-executor.schema.d";
-import type { CargoMetadata, Dependency, Package } from "./toml";
-
-interface CargoRun {
-  success: boolean;
-  output: string;
-}
-
-interface RunCargoOptions {
-  stdio: StdioOptions;
-  env: NodeJS.ProcessEnv | undefined;
-}
-
-export const INVALID_CARGO_ARGS = [
-  "allFeatures",
-  "allTargets",
-  "main",
-  "outputPath",
-  "package",
-  "tsConfig",
-];
-
-export let childProcess: ChildProcess | null;
-
-export const buildCargoCommand = (
-  baseCommand: string,
-  options: CargoBaseExecutorSchema,
-  context: ExecutorContext,
-): string[] => {
-  const args = [] as string[];
-
-  if (options.toolchain && options.toolchain !== "stable") {
-    args.push(`+${options.toolchain}`);
-  }
-
-  args.push(baseCommand);
-
-  for (const [key, value] of Object.entries(options)) {
-    if (
-      key === "toolchain" ||
-      key === "release" ||
-      INVALID_CARGO_ARGS.includes(key)
-    ) {
-      continue;
-    }
-
-    if (typeof value === "boolean") {
-      // false flags should not be added to the cargo args
-      if (value) {
-        args.push(`--${key}`);
-      }
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        args.push(`--${key}`, item);
-      }
-    } else {
-      args.push(`--${key}`, String(value));
-    }
-  }
-
-  if (context.projectName) {
-    args.push("-p", context.projectName);
-  }
-
-  if (options.allFeatures && !args.includes("--all-features")) {
-    args.push("--all-features");
-  }
-
-  if (options.allTargets && !args.includes("--all-targets")) {
-    args.push("--all-targets");
-  }
-
-  if (options.release && !args.includes("--profile")) {
-    args.push("--release");
-  }
-
-  if (options.outputPath && !args.includes("--target-dir")) {
-    args.push("--target-dir", options.outputPath);
-  }
-
-  return args;
-};
-
-export async function cargoCommand(
-  ...args: string[]
-): Promise<{ success: boolean }> {
-  console.log(`> cargo ${args.join(" ")}`);
-  args.push("--color", "always");
-
-  return await Promise.resolve(runProcess("cargo", ...args));
-}
-
-export function cargoRunCommand(
-  ...args: string[]
-): Promise<{ success: boolean }> {
-  console.log(`> cargo ${args.join(" ")}`);
-  return new Promise((resolve, reject) => {
-    childProcess = spawn("cargo", [...args, "--color", "always"], {
-      cwd: process.cwd(),
-      windowsHide: true,
-      detached: true,
-      shell: false,
-      stdio: ["inherit", "inherit", "inherit"],
-    });
-
-    // Ensure the child process is killed when the parent exits
-    process.on("exit", () => childProcess?.kill());
-    process.on("SIGTERM", () => childProcess?.kill());
-    process.on("SIGINT", () => childProcess?.kill());
-
-    childProcess.on("error", (_err) => {
-      reject({ success: false });
-    });
-
-    childProcess.on("exit", (code) => {
-      childProcess = null;
-      if (code === 0) {
-        resolve({ success: true });
-      } else {
-        reject({ success: false });
-      }
-    });
-  });
-}
-
-export function cargoCommandSync(
-  args = "",
-  options?: Partial<RunCargoOptions>,
-): CargoRun {
-  const normalizedOptions: RunCargoOptions = {
-    stdio: options?.stdio ?? "inherit",
-    env: {
-      ...process.env,
-      ...options?.env,
-    },
-  };
-
-  try {
-    return {
-      output: execSync(`cargo ${args}`, {
-        encoding: "utf8",
-        windowsHide: true,
-        stdio: normalizedOptions.stdio,
-        env: normalizedOptions.env,
-        maxBuffer: 1024 * 1024 * 10,
-      }),
-      success: true,
-    };
-  } catch (e) {
-    return {
-      output: e as string,
-      success: false,
-    };
-  }
-}
-
-export function cargoMetadata(): CargoMetadata | null {
-  const output = cargoCommandSync("metadata --format-version=1", {
-    stdio: "pipe",
-  });
-
-  if (!output.success) {
-    console.error("Failed to get cargo metadata");
-    return null;
-  }
-
-  return JSON.parse(output.output) as CargoMetadata;
-}
-
-export function isExternal(
-  packageOrDep: Package | Dependency,
-  workspaceRoot: string,
-) {
-  const isRegistry = packageOrDep.source?.startsWith("registry+") ?? false;
-  const isGit = packageOrDep.source?.startsWith("git+") ?? false;
-  const isOutsideWorkspace =
-    "path" in packageOrDep &&
-    relative(workspaceRoot, packageOrDep.path).startsWith("..");
-
-  return isRegistry || isGit || isOutsideWorkspace;
-}
-
-export function runProcess(
-  processCmd: string,
-  ...args: string[]
-): { success: boolean } | PromiseLike<{ success: boolean }> {
-  const metadata = cargoMetadata();
-  const targetDir =
-    metadata?.target_directory ??
-    joinPathFragments(workspaceRoot, "dist", "cargo");
-
-  return new Promise((resolve) => {
-    if (process.env.VERCEL) {
-      // Vercel doesnt have support for cargo atm, so auto success builds
-      return resolve({ success: true });
-    }
-
-    execSync(`${processCmd} ${args.join(" ")}`, {
-      cwd: process.cwd(),
-      env: {
-        ...process.env,
-        RUSTC_WRAPPER: "",
-        CARGO_TARGET_DIR: targetDir,
-        CARGO_BUILD_TARGET_DIR: targetDir,
-      },
-      windowsHide: true,
-      stdio: ["inherit", "inherit", "inherit"],
-    });
-    resolve({ success: true });
-  });
-}

package/src/utils/create-cli-options.ts

@@ -1,23 +0,0 @@
-import { names } from "@nx/devkit";
-
-export function createCliOptions<
-  T extends Record<string, string | number | boolean | string[]>,
->(obj: T): string[] {
-  const args: string[] = [];
-
-  for (const key in obj) {
-    const value = obj[key];
-    if (value) {
-      const arg = names(key).fileName;
-      if (Array.isArray(value)) {
-        args.push(
-          `--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`,
-        );
-      } else {
-        args.push(`--${arg.toLowerCase()}=${value}`);
-      }
-    }
-  }
-
-  return args;
-}

package/src/utils/get-project-configurations.ts

@@ -1,27 +0,0 @@
-import type { ProjectConfiguration } from "@nx/devkit";
-import { findWorkspaceRoot } from "@storm-software/config-tools/utilities/find-workspace-root";
-import { retrieveProjectConfigurationsWithoutPluginInference } from "nx/src/project-graph/utils/retrieve-workspace-files";
-
-/**
- * Retrieve the project configurations from the workspace.
- *
- * @returns The project configurations.
- */
-export const getProjectConfigurations = async <
-  TConfig extends ProjectConfiguration = ProjectConfiguration,
->(): Promise<Record<string, TConfig>> => {
-  return retrieveProjectConfigurationsWithoutPluginInference(
-    findWorkspaceRoot(),
-  ) as Promise<Record<string, TConfig>>;
-};
-
-/**
- * Retrieve the project configurations from the workspace.
- *
- * @returns The project configurations.
- */
-export const getProjectConfiguration = <
-  TConfig extends ProjectConfiguration = ProjectConfiguration,
->(
-  projectName: string,
-): TConfig | undefined => getProjectConfigurations<TConfig>()?.[projectName];

package/src/utils/index.ts

@@ -1,12 +0,0 @@
-export * from "./apply-workspace-tokens";
-export * from "./cargo";
-export * from "./create-cli-options";
-export * from "./get-project-configurations";
-export * from "./lock-file";
-export * from "./package-helpers";
-export * from "./plugin-helpers";
-export * from "./pnpm-deps-update";
-export * from "./project-tags";
-export * from "./toml";
-export * from "./typia-transform";
-export * from "./versions";