@storm-software/workspace-tools 1.270.2 → 1.271.1

package/src/base/typescript-library-generator.ts

@@ -1,415 +0,0 @@
-import {
-  type GeneratorCallback,
-  type ProjectConfiguration,
-  type Tree,
-  addDependenciesToPackageJson,
-  addProjectConfiguration,
-  ensurePackage,
-  formatFiles,
-  names,
-  offsetFromRoot,
-  readJson,
-  updateJson,
-  writeJson
-} from "@nx/devkit";
-import { determineProjectNameAndRootOptions } from "@nx/devkit/src/generators/project-name-and-root-utils";
-import {
-  addTsConfigPath,
-  getRelativePathToRootTsConfig,
-  tsConfigBaseOptions
-} from "@nx/js";
-import jsInitGenerator from "@nx/js/src/generators/init/init";
-import { InitSchema } from "@nx/js/src/generators/init/schema";
-import {
-  Bundler,
-  NormalizedLibraryGeneratorOptions
-} from "@nx/js/src/generators/library/schema";
-import setupVerdaccio from "@nx/js/src/generators/setup-verdaccio/generator";
-import { ProjectPackageManagerWorkspaceState } from "@nx/js/src/utils/package-manager-workspaces";
-import { StormWorkspaceConfig } from "@storm-software/config";
-import { joinPaths } from "@storm-software/config-tools/utilities/correct-paths";
-import type { PackageJson } from "nx/src/utils/package-json";
-import { UnbuildExecutorSchema } from "../executors/unbuild/schema.d";
-import { addProjectTag, ProjectTagConstants } from "../utils/project-tags";
-import { nxVersion } from "../utils/versions";
-import { TypeScriptLibraryGeneratorSchema } from "./typescript-library-generator.schema.d";
-
-export type TypeScriptLibraryGeneratorOptions =
-  TypeScriptLibraryGeneratorSchema & {
-    devDependencies?: Record<string, string>;
-    peerDependencies?: Record<string, string>;
-    peerDependenciesMeta?: Record<string, any>;
-    tsconfigOptions?: Record<string, any>;
-  };
-
-export type TypeScriptLibraryGeneratorNormalizedOptions =
-  TypeScriptLibraryGeneratorOptions &
-    NormalizedLibraryGeneratorOptions & {
-      rootProject: boolean;
-    };
-
-type TypeScriptLibraryProjectConfig = ProjectConfiguration & {
-  targets: {
-    build: { options: Partial<UnbuildExecutorSchema> };
-  } & Record<string, any>;
-};
-
-export async function typeScriptLibraryGeneratorFn(
-  tree: Tree,
-  options: TypeScriptLibraryGeneratorOptions,
-  config?: StormWorkspaceConfig
-) {
-  const normalized = await normalizeOptions(tree, { ...options });
-
-  const tasks: GeneratorCallback[] = [];
-  tasks.push(
-    await jsInitGenerator(tree, {
-      ...normalized,
-      tsConfigName: normalized.rootProject
-        ? "tsconfig.json"
-        : "tsconfig.base.json"
-    } as InitSchema)
-  );
-
-  tasks.push(
-    addDependenciesToPackageJson(
-      tree,
-      {},
-      {
-        "@storm-software/workspace-tools": "latest",
-        "@storm-software/testing-tools": "latest",
-        ...(options.devDependencies ?? {})
-      }
-    )
-  );
-
-  if (normalized.publishable) {
-    tasks.push(await setupVerdaccio(tree, { ...normalized, skipFormat: true }));
-  }
-
-  const projectConfig = {
-    root: normalized.directory,
-    projectType: "library",
-    sourceRoot: joinPaths(normalized.directory ?? "", "src"),
-    targets: {
-      build: {
-        executor: options.buildExecutor,
-        outputs: ["{options.outputPath}"],
-        options: {
-          entry: [joinPaths(normalized.projectRoot, "src", "index.ts")],
-          outputPath: getOutputPath(normalized),
-          tsconfig: joinPaths(normalized.projectRoot, "tsconfig.json"),
-          project: joinPaths(normalized.projectRoot, "package.json"),
-          defaultConfiguration: "production",
-          platform: "neutral",
-          assets: [
-            {
-              input: normalized.projectRoot,
-              glob: "*.md",
-              output: "/"
-            },
-            {
-              input: "",
-              glob: "LICENSE",
-              output: "/"
-            }
-          ]
-        },
-        configurations: {
-          production: {
-            debug: false,
-            verbose: false
-          },
-          development: {
-            debug: true,
-            verbose: true
-          }
-        }
-      }
-    }
-  } as TypeScriptLibraryProjectConfig;
-
-  if (options.platform) {
-    projectConfig.targets.build.options.platform =
-      options.platform === "worker" ? "node" : options.platform;
-  }
-
-  addProjectTag(
-    projectConfig,
-    ProjectTagConstants.Platform.TAG_ID,
-    options.platform === "node"
-      ? ProjectTagConstants.Platform.NODE
-      : options.platform === "worker"
-        ? ProjectTagConstants.Platform.WORKER
-        : options.platform === "browser"
-          ? ProjectTagConstants.Platform.BROWSER
-          : ProjectTagConstants.Platform.NEUTRAL,
-    { overwrite: false }
-  );
-
-  createProjectTsConfigJson(tree, normalized);
-  addProjectConfiguration(tree, normalized.name, projectConfig);
-
-  let repository = {
-    type: "github",
-    url:
-      config?.repository ||
-      `https://github.com/${config?.organization || "storm-software"}/${config?.namespace || config?.name || "repository"}.git`
-  };
-
-  let description =
-    options.description ||
-    "A package developed by Storm Software used to create modern, scalable web applications.";
-
-  if (tree.exists("package.json")) {
-    const packageJson = readJson<{
-      repository: any;
-      description: string;
-    }>(tree, "package.json");
-
-    if (packageJson?.repository) {
-      repository = packageJson.repository;
-    }
-    if (packageJson?.description) {
-      description = packageJson.description;
-    }
-  }
-
-  if (!normalized.importPath) {
-    normalized.importPath = normalized.name;
-  }
-
-  const packageJsonPath = joinPaths(normalized.projectRoot, "package.json");
-  if (tree.exists(packageJsonPath)) {
-    updateJson<PackageJson>(tree, packageJsonPath, (json: PackageJson) => {
-      if (!normalized.importPath) {
-        normalized.importPath = normalized.name;
-      }
-
-      json.name = normalized.importPath;
-      json.version = "0.0.1";
-
-      // If the package is publishable or root/standalone, we should remove the private field.
-      if (json.private && (normalized.publishable || normalized.rootProject)) {
-        json.private = undefined;
-      }
-
-      return {
-        ...json,
-        version: "0.0.1",
-        description,
-        repository: {
-          ...repository,
-          directory: normalized.projectRoot
-        },
-        type: "module",
-        dependencies: {
-          ...json.dependencies
-        },
-        publishConfig: {
-          access: "public"
-        }
-      } as unknown as PackageJson;
-    });
-  } else {
-    writeJson<PackageJson>(tree, packageJsonPath, {
-      name: normalized.importPath,
-      version: "0.0.1",
-      description,
-      repository: {
-        ...repository,
-        directory: normalized.projectRoot
-      },
-      private: !normalized.publishable || normalized.rootProject,
-      type: "module",
-      publishConfig: {
-        access: "public"
-      }
-    } as unknown as PackageJson);
-  }
-
-  if (tree.exists("package.json") && normalized.importPath) {
-    updateJson(tree, "package.json", json => ({
-      ...json,
-      pnpm: {
-        ...json?.pnpm,
-        overrides: {
-          ...json?.pnpm?.overrides,
-          [normalized.importPath ?? ""]: "workspace:*"
-        }
-      }
-    }));
-  }
-
-  addTsConfigPath(tree, normalized.importPath, [
-    joinPaths(
-      normalized.projectRoot,
-      "./src",
-      `index.${normalized.js ? "js" : "ts"}`
-    )
-  ]);
-  addTsConfigPath(tree, joinPaths(normalized.importPath, "/*"), [
-    joinPaths(normalized.projectRoot, "./src", "/*")
-  ]);
-
-  if (tree.exists("package.json")) {
-    const packageJson = readJson<{
-      repository: any;
-      description: string;
-    }>(tree, "package.json");
-
-    if (packageJson?.repository) {
-      repository = packageJson.repository;
-    }
-    if (packageJson?.description) {
-      description = packageJson.description;
-    }
-  }
-
-  const tsconfigPath = joinPaths(normalized.projectRoot, "tsconfig.json");
-  if (tree.exists(tsconfigPath)) {
-    updateJson(tree, tsconfigPath, (json: any) => {
-      json.composite ??= true;
-
-      return json;
-    });
-  } else {
-    writeJson(tree, tsconfigPath, {
-      extends: `${offsetFromRoot(normalized.projectRoot)}tsconfig.base.json`,
-      composite: true,
-      compilerOptions: {
-        outDir: `${offsetFromRoot(normalized.projectRoot)}dist/out-tsc`
-      },
-      files: [],
-      include: ["src/**/*.ts", "src/**/*.js"],
-      exclude: ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-    });
-  }
-
-  // const lintCallback = await addLint(tree, options);
-  // tasks.push(lintCallback);
-
-  await formatFiles(tree);
-
-  return null;
-}
-
-export function getOutputPath(
-  options: TypeScriptLibraryGeneratorNormalizedOptions
-) {
-  const parts = ["dist"];
-  if (options.projectRoot === ".") {
-    parts.push(options.name);
-  } else {
-    parts.push(options.projectRoot);
-  }
-  return joinPaths(...parts);
-}
-
-export function createProjectTsConfigJson(
-  tree: Tree,
-  options: TypeScriptLibraryGeneratorNormalizedOptions
-) {
-  const tsconfig = {
-    extends: options.rootProject
-      ? undefined
-      : getRelativePathToRootTsConfig(tree, options.projectRoot),
-    ...(options?.tsconfigOptions ?? {}),
-    compilerOptions: {
-      ...(options.rootProject ? tsConfigBaseOptions : {}),
-      outDir: joinPaths(offsetFromRoot(options.projectRoot), "dist/out-tsc"),
-      noEmit: true,
-      ...(options?.tsconfigOptions?.compilerOptions ?? {})
-    },
-    files: [...(options?.tsconfigOptions?.files ?? [])],
-    include: [
-      ...(options?.tsconfigOptions?.include ?? []),
-      "src/**/*.ts",
-      "src/**/*.js",
-      "bin/**/*"
-    ],
-    exclude: [
-      ...(options?.tsconfigOptions?.exclude ?? []),
-      "jest.config.ts",
-      "src/**/*.spec.ts",
-      "src/**/*.test.ts"
-    ]
-  };
-
-  writeJson(tree, joinPaths(options.projectRoot, "tsconfig.json"), tsconfig);
-}
-
-export type UnitTestRunner = "jest" | "vitest" | "none" | undefined;
-export type TestEnvironment = "jsdom" | "node" | undefined;
-
-export async function normalizeOptions(
-  tree: Tree,
-  options: TypeScriptLibraryGeneratorOptions,
-  config?: StormWorkspaceConfig
-): Promise<TypeScriptLibraryGeneratorNormalizedOptions> {
-  let importPath = options.importPath;
-  if (!importPath && config?.namespace) {
-    importPath = `@${config?.namespace}/${options.name}`;
-  }
-
-  if (options.publishable) {
-    if (!importPath) {
-      throw new Error(
-        `For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`
-      );
-    }
-  }
-
-  let bundler: Bundler = "tsc";
-  if (options.publishable === false && options.buildable === false) {
-    bundler = "none";
-  }
-
-  const { Linter } = ensurePackage("@nx/eslint", nxVersion);
-
-  const rootProject = false;
-  const {
-    projectName,
-    names: projectNames,
-    projectRoot,
-    importPath: normalizedImportPath
-  } = await determineProjectNameAndRootOptions(tree, {
-    name: options.name,
-    projectType: "library",
-    directory: options.directory,
-    importPath,
-    rootProject
-  });
-
-  const normalized = names(projectNames.projectFileName);
-  const fileName = normalized.fileName;
-
-  return {
-    js: false,
-    pascalCaseFiles: false,
-    skipFormat: false,
-    skipTsConfig: false,
-    includeBabelRc: false,
-    unitTestRunner: "jest" as UnitTestRunner,
-    linter: Linter.EsLint,
-    testEnvironment: "node" as TestEnvironment,
-    config: "project",
-    compiler: "tsc",
-    bundler,
-    skipTypeCheck: false,
-    minimal: false,
-    hasPlugin: false,
-    isUsingTsSolutionConfig: false,
-    projectPackageManagerWorkspaceState:
-      "included" as ProjectPackageManagerWorkspaceState,
-    ...options,
-    fileName,
-    name: projectName,
-    projectNames,
-    projectRoot,
-    parsedTags: options.tags ? options.tags.split(",").map(s => s.trim()) : [],
-    importPath: normalizedImportPath,
-    rootProject,
-    shouldUseSwcJest: false
-  } as TypeScriptLibraryGeneratorNormalizedOptions;
-}

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

@@ -1,106 +0,0 @@
-import { defineUntypedSchema } from "untyped";
-import baseGeneratorSchema from "./base-generator.untyped";
-
-export default defineUntypedSchema({
-  ...baseGeneratorSchema,
-  $schema: {
-    id: "TypeScriptLibraryGeneratorSchema",
-    title: "TypeScript Library Generator",
-    description:
-      "A type definition for the base TypeScript Library Generator schema",
-    required: ["directory", "name"],
-  },
-  name: {
-    $schema: {
-      title: "Name",
-      type: "string",
-      description: "The name of the library",
-    },
-  },
-  description: {
-    $schema: {
-      title: "Description",
-      type: "string",
-      description: "The description of the library",
-    },
-  },
-  buildExecutor: {
-    $schema: {
-      title: "Build Executor",
-      type: "string",
-      description: "The executor to use for building the library",
-    },
-    $default: "@storm-software/workspace-tools:unbuild",
-  },
-  platform: {
-    $schema: {
-      title: "Platform",
-      type: "string",
-      description: "The platform to target with the library",
-      enum: ["neutral", "node", "worker", "browser"],
-    },
-    $default: "neutral",
-  },
-  importPath: {
-    $schema: {
-      title: "Import Path",
-      type: "string",
-      description: "The import path for the library",
-    },
-  },
-  tags: {
-    $schema: {
-      title: "Tags",
-      type: "string",
-      description: "The tags for the library",
-    },
-  },
-  unitTestRunner: {
-    $schema: {
-      title: "Unit Test Runner",
-      type: "string",
-      enum: ["jest", "vitest", "none"],
-      description: "The unit test runner to use",
-    },
-  },
-  testEnvironment: {
-    $schema: {
-      title: "Test Environment",
-      type: "string",
-      enum: ["jsdom", "node"],
-      description: "The test environment to use",
-    },
-  },
-  pascalCaseFiles: {
-    $schema: {
-      title: "Pascal Case Files",
-      type: "boolean",
-      description: "Use PascalCase for file names",
-    },
-    $default: false,
-  },
-  strict: {
-    $schema: {
-      title: "Strict",
-      type: "boolean",
-      description: "Enable strict mode",
-    },
-    $default: true,
-  },
-  publishable: {
-    $schema: {
-      title: "Publishable",
-      type: "boolean",
-      description: "Make the library publishable",
-    },
-    $default: false,
-  },
-  buildable: {
-    $schema: {
-      title: "Buildable",
-      type: "boolean",
-      description: "Make the library buildable",
-    },
-    $default: true,
-  },
-});

package/src/executors/cargo-build/executor.spec.ts

@@ -1,18 +0,0 @@
-import { ExecutorContext } from "@nx/devkit";
-
-import executor from "./executor";
-import { CargoBuildExecutorSchema } from "./schema.d";
-
-const options: CargoBuildExecutorSchema = {};
-const context: ExecutorContext = {
-  root: "",
-  cwd: process.cwd(),
-  isVerbose: false,
-};
-
-describe("CargoBuild Executor", () => {
-  it("can run", async () => {
-    const output = await executor(options, context);
-    expect(output.success).toBe(true);
-  });
-});

package/src/executors/cargo-build/executor.ts

@@ -1,28 +0,0 @@
-import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
-import { withRunExecutor } from "../../base/base-executor";
-import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
-import { CargoBuildExecutorSchema } from "./schema.d";
-
-export async function cargoBuildExecutor(
-  options: CargoBuildExecutorSchema,
-  context: ExecutorContext,
-) {
-  const command = buildCargoCommand("build", options, context);
-  return await cargoCommand(...command);
-}
-
-export default withRunExecutor<CargoBuildExecutorSchema>(
-  "Cargo Build",
-  cargoBuildExecutor,
-  {
-    skipReadingConfig: false,
-    hooks: {
-      applyDefaultOptions: (options: CargoBuildExecutorSchema) => {
-        options.outputPath ??= "dist/target/{projectRoot}";
-        options.toolchain ??= "stable";
-
-        return options as CargoBuildExecutorSchema;
-      },
-    },
-  },
-) as PromiseExecutor<CargoBuildExecutorSchema>;

package/src/executors/cargo-build/untyped.ts

@@ -1,18 +0,0 @@
-import { defineUntypedSchema } from "untyped";
-import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
-
-export default defineUntypedSchema({
-  ...cargoBaseExecutorSchema,
-  $schema: {
-    id: "CargoBuildExecutorSchema",
-    title: "Cargo Build Executor",
-    description: "A type definition for a Cargo/rust build executor schema",
-  },
-  outputPath: {
-    $schema: {
-      title: "Output Path",
-      type: "string",
-      description: "The path to the output directory",
-    },
-  },
-});

package/src/executors/cargo-check/executor.spec.ts

@@ -1,18 +0,0 @@
-import { ExecutorContext } from "@nx/devkit";
-
-import executor from "./executor";
-import { CargoCheckExecutorSchema } from "./schema.d";
-
-const options: CargoCheckExecutorSchema = {};
-const context: ExecutorContext = {
-  root: "",
-  cwd: process.cwd(),
-  isVerbose: false,
-};
-
-describe("CargoCheck Executor", () => {
-  it("can run", async () => {
-    const output = await executor(options, context);
-    expect(output.success).toBe(true);
-  });
-});

package/src/executors/cargo-check/executor.ts

@@ -1,27 +0,0 @@
-import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
-import { withRunExecutor } from "../../base/base-executor";
-import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
-import { CargoCheckExecutorSchema } from "./schema.d";
-
-export async function cargoCheckExecutor(
-  options: CargoCheckExecutorSchema,
-  context: ExecutorContext,
-) {
-  const command = buildCargoCommand("check", options, context);
-  return await cargoCommand(...command);
-}
-
-export default withRunExecutor<CargoCheckExecutorSchema>(
-  "Cargo Check",
-  cargoCheckExecutor,
-  {
-    skipReadingConfig: false,
-    hooks: {
-      applyDefaultOptions: (options: CargoCheckExecutorSchema) => {
-        options.toolchain ??= "stable";
-
-        return options as CargoCheckExecutorSchema;
-      },
-    },
-  },
-) as PromiseExecutor<CargoCheckExecutorSchema>;

package/src/executors/cargo-check/untyped.ts

@@ -1,11 +0,0 @@
-import { defineUntypedSchema } from "untyped";
-import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
-
-export default defineUntypedSchema({
-  ...cargoBaseExecutorSchema,
-  $schema: {
-    id: "CargoCheckExecutorSchema",
-    title: "Cargo Check Executor",
-    description: "A type definition for a Cargo/rust check executor schema",
-  },
-});

package/src/executors/cargo-clippy/executor.spec.ts

@@ -1,18 +0,0 @@
-import { ExecutorContext } from "@nx/devkit";
-
-import executor from "./executor";
-import { CargoCheckExecutorSchema } from "./schema.d";
-
-const options: CargoCheckExecutorSchema = {};
-const context: ExecutorContext = {
-  root: "",
-  cwd: process.cwd(),
-  isVerbose: false,
-};
-
-describe("CargoCheck Executor", () => {
-  it("can run", async () => {
-    const output = await executor(options, context);
-    expect(output.success).toBe(true);
-  });
-});

package/src/executors/cargo-clippy/executor.ts

@@ -1,28 +0,0 @@
-import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
-import { withRunExecutor } from "../../base/base-executor";
-import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
-import { CargoClippyExecutorSchema } from "./schema.d";
-
-export async function cargoClippyExecutor(
-  options: CargoClippyExecutorSchema,
-  context: ExecutorContext,
-) {
-  const command = buildCargoCommand("clippy", options, context);
-  return await cargoCommand(...command);
-}
-
-export default withRunExecutor<CargoClippyExecutorSchema>(
-  "Cargo Clippy",
-  cargoClippyExecutor,
-  {
-    skipReadingConfig: false,
-    hooks: {
-      applyDefaultOptions: (options: CargoClippyExecutorSchema) => {
-        options.toolchain ??= "stable";
-        options.fix ??= false;
-
-        return options as CargoClippyExecutorSchema;
-      },
-    },
-  },
-) as PromiseExecutor<CargoClippyExecutorSchema>;