@storm-software/workspace-tools 1.269.0 → 1.270.0

package/src/plugins/typescript/tsup.ts

@@ -0,0 +1,198 @@
+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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,12 @@
+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";