@storm-software/workspace-tools 1.269.0 → 1.270.0

package/src/executors/clean-package/executor.ts

@@ -0,0 +1,214 @@
+import type { ExecutorContext } from "@nx/devkit";
+import { joinPathFragments } from "@nx/devkit";
+import type { StormWorkspaceConfig } from "@storm-software/config";
+import { writeInfo } from "@storm-software/config-tools/logger/console";
+import { joinPaths } from "@storm-software/config-tools/utilities/correct-paths";
+import {
+  copy,
+  mkdir,
+  pathExists,
+  readFile,
+  readJson,
+  remove,
+  writeFile,
+  writeJson
+} from "fs-extra";
+import { Glob } from "glob";
+import { withRunExecutor } from "../../base/base-executor";
+import { IGNORE_FIELDS, NPM_SCRIPTS, PUBLISH_CONFIG_FIELDS } from "./constants";
+import { CleanPackageExecutorSchema } from "./schema.d";
+import { PackageJson } from "./types";
+import { createFilesFilter, filterObjectByKey, isObject } from "./utils";
+
+export async function cleanPackageExecutorFn(
+  options: CleanPackageExecutorSchema,
+  context: ExecutorContext,
+  config: StormWorkspaceConfig
+) {
+  const tempDirectoryName = joinPathFragments(
+    config.workspaceRoot,
+    "tmp",
+    context.root
+  );
+
+  const exists = await pathExists(tempDirectoryName);
+  if (exists) {
+    writeInfo(
+      `🧹 Cleaning temporary directory path: ${tempDirectoryName}`,
+      config
+    );
+    await remove(tempDirectoryName);
+  }
+
+  await mkdir(tempDirectoryName);
+  writeInfo(`Created temporary directory: ${tempDirectoryName}`, config);
+
+  const packageJson = await readJson<PackageJson>(options.packageJsonPath);
+
+  await copy(options.outputPath, tempDirectoryName, {
+    filter: createFilesFilter(options.ignoredFiles, options.outputPath!)
+  });
+
+  if (options.cleanReadMe) {
+    await cleanReadMe(
+      tempDirectoryName,
+      packageJson.repository,
+      packageJson.homepage
+    );
+  }
+
+  if (options.cleanComments) {
+    await cleanComments(tempDirectoryName);
+  }
+
+  const tempPackageJson = clearPackageJSON(packageJson, options.fields);
+  writeJson(
+    joinPathFragments(tempDirectoryName, "package.json"),
+    tempPackageJson
+  );
+
+  await copy(tempDirectoryName, options.outputPath, {
+    override: true,
+    preserveTimestamps: true
+  });
+
+  await remove(tempDirectoryName);
+
+  return {
+    success: true
+  };
+}
+
+function getReadmeUrlFromRepository(repository: PackageJson["repository"]) {
+  const repoUrl = typeof repository === "object" ? repository.url : repository;
+  if (repoUrl) {
+    const name = repoUrl.match(/[^/:]+\/[^/:]+$/)?.[0]?.replace(/\.git$/, "");
+    return `https://github.com/${name}#README.md`;
+  }
+
+  return null;
+}
+
+async function cleanReadMe(
+  directoryName: string,
+  repository: PackageJson["repository"],
+  homepage: PackageJson["homepage"]
+) {
+  const readmePath = joinPathFragments(directoryName, "README.md");
+  const readme = await readFile(readmePath);
+  const readmeUrl = getReadmeUrlFromRepository(repository);
+  if (homepage || readmeUrl) {
+    const cleaned =
+      readme.toString().split(/\n##\s*\w/m)[0] +
+      "\n## Documentation\n" +
+      `Read full docs **[here](${homepage || readmeUrl})**.\n`;
+
+    await writeFile(readmePath, cleaned);
+  }
+}
+
+async function cleanComments(directoryName: string) {
+  const glob = new Glob(["**/*.js"], { cwd: directoryName });
+
+  const files = await glob.walk();
+  await Promise.all(
+    files.map(async i => {
+      const file = joinPathFragments(directoryName, i);
+      const content = await readFile(file);
+      const cleaned = content
+        .toString()
+        .replace(/\s*\/\/.*\n/gm, "\n")
+        .replace(/\s*\/\*[^/]+\*\/\n?/gm, "\n")
+        .replace(/\n+/gm, "\n")
+        .replace(/^\n+/gm, "");
+
+      await writeFile(file, cleaned);
+    })
+  );
+}
+
+function clearPackageJSON(packageJson, inputIgnoreFields) {
+  const ignoreFields = inputIgnoreFields
+    ? IGNORE_FIELDS.concat(inputIgnoreFields)
+    : IGNORE_FIELDS;
+
+  if (!packageJson.publishConfig) {
+    return packageJson;
+  }
+
+  const publishConfig = {
+    ...packageJson.publishConfig
+  };
+
+  PUBLISH_CONFIG_FIELDS.forEach(field => {
+    if (publishConfig[field]) {
+      packageJson[field] = publishConfig[field];
+      delete publishConfig[field];
+    }
+  });
+
+  if (!Object.keys(publishConfig).length) {
+    // delete property by destructuring
+    // eslint-disable-next-line no-unused-vars
+    const { publishConfig: _, ...pkg } = packageJson;
+
+    return pkg;
+  }
+
+  const cleanPackageJSON = filterObjectByKey(
+    {
+      ...packageJson,
+      publishConfig
+    },
+    key => !!(key && !ignoreFields.includes(key) && key !== "scripts")
+  ) as PackageJson;
+
+  if (packageJson.scripts && !ignoreFields.includes("scripts")) {
+    cleanPackageJSON.scripts = filterObjectByKey(
+      packageJson.scripts,
+      script => !!(script && NPM_SCRIPTS.includes(script))
+    );
+
+    if (
+      cleanPackageJSON.scripts.publish &&
+      /^clean-publish( |$)/.test(cleanPackageJSON.scripts.publish)
+    ) {
+      // "custom" publish script is actually calling clean-publish
+      delete cleanPackageJSON.scripts.publish;
+    }
+  }
+
+  for (const i in cleanPackageJSON) {
+    if (
+      isObject(cleanPackageJSON[i]) &&
+      Object.keys(cleanPackageJSON[i]).length === 0
+    ) {
+      delete cleanPackageJSON[i];
+    }
+  }
+  return cleanPackageJSON;
+}
+
+export default withRunExecutor<CleanPackageExecutorSchema>(
+  "Storm Clean-Package executor",
+  cleanPackageExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (
+        options: CleanPackageExecutorSchema
+      ): CleanPackageExecutorSchema => {
+        options.outputPath ??= "dist/{projectRoot}";
+        options.packageJsonPath ??= joinPaths(
+          options.outputPath,
+          "package.json"
+        );
+
+        options.cleanReadMe ??= true;
+        options.cleanComments ??= true;
+
+        return options;
+      }
+    }
+  }
+);

package/src/executors/clean-package/types.ts

@@ -0,0 +1,6 @@
+import type { PackageJson as NxPackageJson } from "nx/src/utils/package-json.js";
+
+export interface PackageJson extends NxPackageJson {
+  repository?: string | { type?: string; url: string };
+  homepage?: string;
+}

package/src/executors/clean-package/untyped.ts

@@ -0,0 +1,60 @@
+import { defineUntypedSchema } from "untyped";
+import baseExecutorSchema from "../../base/base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...baseExecutorSchema,
+  $schema: {
+    id: "CleanPackageExecutorSchema",
+    title: "Clean Package Executor",
+    description:
+      "The clean package executor is responsible for removing unnecessary files and fields from a distributable package to make it as light as possible (for scenarios like edge computing, limited memory environments, etc.)",
+  },
+  outputPath: {
+    $schema: {
+      title: "Output Path",
+      type: "string",
+      description: "The path to the output",
+    },
+    $default: "dist/{projectRoot}",
+  },
+  packageJsonPath: {
+    $schema: {
+      title: "Package JSON Path",
+      type: "string",
+      format: "path",
+      description: "The path to the package.json that will be modified",
+    },
+    $default: "{outputPath}/package.json",
+  },
+  ignoredFiles: {
+    $schema: {
+      title: "Ignored Files",
+      type: "string",
+      description: "The files to ignore",
+    },
+  },
+  fields: {
+    $schema: {
+      title: "Fields",
+      type: "string",
+      description: "The fields to include",
+    },
+    $resolve: (val: string[] = []) => ([] as string[]).concat(val),
+  },
+  cleanReadMe: {
+    $schema: {
+      title: "Clean Read Me",
+      type: "boolean",
+      description: "Clean the read me",
+    },
+    $default: true,
+  },
+  cleanComments: {
+    $schema: {
+      title: "Clean Comments",
+      type: "boolean",
+      description: "Clean the comments",
+    },
+    $default: true,
+  },
+});

package/src/executors/clean-package/utils.ts

@@ -0,0 +1,85 @@
+import { Glob, hasMagic } from "glob";
+import micromatch from "micromatch";
+import { basename } from "node:path";
+import { IGNORE_FILES } from "./constants";
+
+export function isObject(object) {
+  return Boolean(object) && typeof object === "object";
+}
+
+export function filterObjectByKey(
+  object: Record<string, any>,
+  filterByKey = (key?: string) => true,
+  deep = false,
+) {
+  const result = {};
+  let changed = false;
+
+  for (const key in object) {
+    if (filterByKey(key)) {
+      if (deep && isObject(object[key])) {
+        result[key] = filterObjectByKey(object[key], filterByKey, deep);
+
+        if (result[key] !== object[key]) {
+          changed = true;
+        }
+      } else {
+        result[key] = object[key];
+      }
+    } else {
+      changed = true;
+    }
+  }
+
+  return changed ? result : object;
+}
+
+export function createIgnoreMatcher(ignorePattern: string | RegExp = "**/*") {
+  if (ignorePattern instanceof RegExp) {
+    return (filename) => !ignorePattern.test(filename);
+  }
+
+  if (hasMagic(ignorePattern, { magicalBraces: true })) {
+    const isMatch = micromatch.matcher(ignorePattern);
+
+    return (_filename, path) => !isMatch(path);
+  }
+
+  return (filename) => filename !== ignorePattern;
+}
+
+export async function createFilesFilter(ignoreFiles = "", cwd: string) {
+  let ignoreFilesList = [] as string[];
+
+  if (ignoreFiles) {
+    const glob = new Glob(ignoreFiles, { cwd });
+    ignoreFilesList = await glob.walk();
+  }
+
+  const ignorePatterns =
+    ignoreFilesList.length > 0
+      ? IGNORE_FILES.concat(...ignoreFilesList).filter(Boolean)
+      : IGNORE_FILES;
+  const filter = ignorePatterns.reduce(
+    (
+      next: null | ((filename: string, path: string) => void),
+      ignorePattern,
+    ) => {
+      const ignoreMatcher = createIgnoreMatcher(ignorePattern);
+
+      if (!next) {
+        return ignoreMatcher;
+      }
+
+      return (filename: string, path: string) =>
+        ignoreMatcher(filename, path) && next && next(filename, path);
+    },
+    null,
+  );
+
+  return (path) => {
+    const filename = basename(path);
+
+    return filter?.(filename, path);
+  };
+}

package/src/executors/esbuild/executor.spec.ts

@@ -0,0 +1,11 @@
+import executor from "./executor";
+import { RolldownExecutorSchema } from "./schema.d";
+
+const options: RolldownExecutorSchema = {};
+
+describe("Rolldown Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/esbuild/executor.ts

@@ -0,0 +1,67 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormWorkspaceConfig } from "@storm-software/config";
+import { writeInfo } from "@storm-software/config-tools/logger/console";
+import { build, ESBuildOptions } from "@storm-software/esbuild";
+import { withRunExecutor } from "../../base/base-executor";
+import type { ESBuildExecutorSchema } from "./schema.d";
+
+export async function esbuildExecutorFn(
+  options: ESBuildExecutorSchema,
+  context: ExecutorContext,
+  config?: StormWorkspaceConfig
+) {
+  writeInfo("📦  Running Storm ESBuild executor on the workspace", config);
+
+  // #region Prepare build context variables
+
+  if (
+    !context.projectsConfigurations?.projects ||
+    !context.projectName ||
+    !context.projectsConfigurations.projects[context.projectName] ||
+    !context.projectsConfigurations.projects[context.projectName]?.root
+  ) {
+    throw new Error(
+      "The Build process failed because the context is not valid. Please run this command from a workspace."
+    );
+  }
+
+  // #endregion Prepare build context variables
+
+  await build({
+    ...options,
+    projectRoot:
+      context.projectsConfigurations.projects?.[context.projectName]!.root,
+    name: context.projectName,
+    sourceRoot:
+      context.projectsConfigurations.projects?.[context.projectName]
+        ?.sourceRoot,
+    format: options.format as ESBuildOptions["format"],
+    platform: options.format as ESBuildOptions["platform"]
+  });
+
+  // #endregion Run the build process
+
+  return {
+    success: true
+  };
+}
+
+export default withRunExecutor<ESBuildExecutorSchema>(
+  "Storm ESBuild build",
+  esbuildExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: async (
+        options: ESBuildExecutorSchema,
+        config?: StormWorkspaceConfig | undefined
+      ) => {
+        options.entry ??= ["src/index.ts"];
+        options.outputPath ??= "dist/{projectRoot}";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+
+        return options;
+      }
+    }
+  }
+);

package/src/executors/esbuild/untyped.ts

@@ -0,0 +1,20 @@
+import { defineUntypedSchema } from "untyped";
+import typescriptBuildExecutorSchema from "../../base/typescript-build-executor.untyped";
+
+export default defineUntypedSchema({
+  ...typescriptBuildExecutorSchema,
+  $schema: {
+    id: "ESBuildExecutorSchema",
+    title: "ESBuild Executor",
+    description: "A type definition for an ESBuild executor schema",
+  },
+  format: {
+    $schema: {
+      title: "Format",
+      type: "string",
+      description: "The format to build",
+      enum: ["cjs", "esm", "iife"],
+    },
+    $default: "esm",
+  },
+});

package/src/executors/npm-publish/executor.spec.ts

@@ -0,0 +1,11 @@
+// import type { NpmPublishExecutorSchema } from "./schema.d";
+// import executor from "./executor";
+
+// const options: NpmPublishExecutorSchema = {};
+
+// describe("NpmPublish Executor", () => {
+//   it("can run", async () => {
+//     const output = await executor(options);
+//     expect(output.success).toBe(true);
+//   });
+// });