@storm-software/cloudflare-tools 0.58.2 → 0.59.0

package/src/generators/worker/generator.ts

@@ -1,289 +0,0 @@
-import {
-  convertNxGenerator,
-  ensurePackage,
-  formatFiles,
-  generateFiles,
-  GeneratorCallback,
-  joinPathFragments,
-  names,
-  readProjectConfiguration,
-  runTasksInSerial,
-  Tree,
-  updateJson,
-  updateProjectConfiguration
-} from "@nx/devkit";
-import { determineProjectNameAndRootOptions } from "@nx/devkit/src/generators/project-name-and-root-utils";
-import { applicationGenerator as nodeApplicationGenerator } from "@nx/node";
-import { nxVersion } from "@nx/node/src/utils/versions";
-import { StormWorkspaceConfig } from "@storm-software/config";
-import {
-  getConfig,
-  getStopwatch,
-  writeDebug,
-  writeError,
-  writeFatal,
-  writeInfo,
-  writeTrace
-} from "@storm-software/config-tools";
-import { findWorkspaceRoot } from "@storm-software/config-tools/utilities/find-workspace-root";
-import { join } from "path";
-import initGenerator from "../init/generator";
-import { getAccountId } from "./libs/get-account-id";
-import { vitestImports } from "./libs/vitest-imports";
-import { vitestScript } from "./libs/vitest-script";
-import type { NormalizedSchema, WorkerGeneratorSchema } from "./schema";
-
-export async function applicationGenerator(
-  tree: Tree,
-  schema: WorkerGeneratorSchema
-) {
-  const stopwatch = getStopwatch("Storm Worker generator");
-
-  let config: StormWorkspaceConfig | undefined;
-  try {
-    writeInfo(`⚡ Running the Storm Worker generator...\n\n`, config);
-
-    const workspaceRoot = findWorkspaceRoot();
-
-    writeDebug(
-      `Loading the Storm Config from environment variables and storm.json file...
-- workspaceRoot: ${workspaceRoot}`,
-      config
-    );
-
-    config = await getConfig(workspaceRoot);
-    writeTrace(
-      `Loaded Storm config into env: \n${Object.keys(process.env)
-        .map(key => ` - ${key}=${JSON.stringify(process.env[key])}`)
-        .join("\n")}`,
-      config
-    );
-
-    const options = await normalizeOptions(tree, schema, config);
-    const tasks: GeneratorCallback[] = [];
-
-    // Set up the needed packages.
-    tasks.push(
-      await initGenerator(tree, {
-        ...options,
-        skipFormat: true
-      })
-    );
-
-    tasks.push(
-      await nodeApplicationGenerator(tree, {
-        ...options,
-        framework: "none",
-        skipFormat: true,
-        unitTestRunner:
-          options.unitTestRunner == "vitest" ? "none" : options.unitTestRunner,
-        e2eTestRunner: "none",
-        name: schema.name
-      })
-    );
-
-    if (options.unitTestRunner === "vitest") {
-      const { vitestGenerator, createOrEditViteConfig } = ensurePackage(
-        "@nx/vite",
-        nxVersion
-      );
-      const vitestTask = await vitestGenerator(tree, {
-        project: options.name,
-        uiFramework: "none",
-        coverageProvider: "v8",
-        skipFormat: true,
-        testEnvironment: "node"
-      });
-      tasks.push(vitestTask);
-      createOrEditViteConfig(
-        tree,
-        {
-          project: options.name,
-          includeLib: false,
-          includeVitest: true,
-          testEnvironment: "node"
-        },
-        true
-      );
-    }
-
-    addCloudflareFiles(tree, options);
-    updateTsAppConfig(tree, options);
-    addTargets(tree, options);
-
-    if (options.unitTestRunner === "none") {
-      removeTestFiles(tree, options);
-    }
-
-    if (!options.skipFormat) {
-      await formatFiles(tree);
-    }
-
-    if (options.template === "hono") {
-      tasks.push(() => {
-        const packageJsonPath = joinPathFragments(
-          options.directory ?? "",
-          "package.json"
-        );
-        if (tree.exists(packageJsonPath)) {
-          updateJson(tree, packageJsonPath, json => ({
-            ...json,
-            dependencies: {
-              hono: "4.4.0",
-              ...json?.dependencies
-            }
-          }));
-        }
-      });
-    }
-
-    return runTasksInSerial(...tasks);
-  } 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();
-  }
-}
-
-// Modify the default tsconfig.app.json generate by the node application generator to support workers.
-function updateTsAppConfig(tree: Tree, options: NormalizedSchema) {
-  updateJson(tree, join(options.appProjectRoot, "tsconfig.app.json"), json => {
-    json.compilerOptions = {
-      ...json.compilerOptions,
-      esModuleInterop: true,
-      target: "es2021",
-      lib: ["es2021"],
-      module: "es2022",
-      moduleResolution: "node",
-      resolveJsonModule: true,
-
-      allowJs: true,
-      checkJs: false,
-      noEmit: true,
-
-      isolatedModules: true,
-      allowSyntheticDefaultImports: true,
-      forceConsistentCasingInFileNames: true,
-
-      strict: true,
-      skipLibCheck: true
-    };
-    json.compilerOptions.types = [
-      ...json.compilerOptions.types,
-      "@cloudflare/workers-types"
-    ];
-    return json;
-  });
-}
-
-// Adds the needed files from the common folder and the selected template folder
-function addCloudflareFiles(tree: Tree, options: NormalizedSchema) {
-  // Delete main.ts. Workers convention is a file named `index.js` or `index.ts
-  tree.delete(join(options.appProjectRoot, "src/main.ts"));
-
-  // General configuration files for workers
-  generateFiles(
-    tree,
-    join(__dirname, "./files/common"),
-    options.appProjectRoot,
-    {
-      ...options,
-      tmpl: "",
-      name: options.name,
-      accountId: options.accountId ? getAccountId(options.accountId) : "",
-      vitestScript: options.unitTestRunner === "vitest" ? vitestScript : ""
-    }
-  );
-
-  // Generate template files with workers code
-  if (options.template && options.template !== "none") {
-    generateFiles(
-      tree,
-      join(__dirname, `./files/${options.template}`),
-      join(options.appProjectRoot, "src"),
-      {
-        ...options,
-        tmpl: "",
-        name: options.name,
-        accountId: options.accountId ? getAccountId(options.accountId) : "",
-        vitestScript: options.unitTestRunner === "vitest" ? vitestScript : "",
-        vitestImports: options.unitTestRunner === "vitest" ? vitestImports : ""
-      }
-    );
-  }
-}
-
-// Adds the targets to the project configuration
-function addTargets(tree: Tree, options: NormalizedSchema) {
-  try {
-    const projectConfiguration = readProjectConfiguration(tree, options.name);
-
-    projectConfiguration.targets = {
-      ...(projectConfiguration.targets ?? {}),
-      serve: {
-        executor: "@storm-software/cloudflare-tools:serve",
-        options: {
-          port: options.port
-        }
-      },
-      "nx-release-publish": {
-        executor: "@storm-software/cloudflare-tools:cloudflare-publish"
-      }
-    };
-
-    if (projectConfiguration.targets.build) {
-      delete projectConfiguration.targets.build;
-    }
-
-    updateProjectConfiguration(tree, options.name, projectConfiguration);
-  } catch (e) {
-    console.error(e);
-  }
-}
-
-function removeTestFiles(tree: Tree, options: NormalizedSchema) {
-  tree.delete(join(options.appProjectRoot, "src", "index.test.ts"));
-}
-
-// Transform the options to the normalized schema. Loads defaults options.
-async function normalizeOptions(
-  host: Tree,
-  options: WorkerGeneratorSchema,
-  config?: StormWorkspaceConfig
-): Promise<NormalizedSchema> {
-  const { projectName: appProjectName, projectRoot: appProjectRoot } =
-    await determineProjectNameAndRootOptions(host, {
-      name: options.name,
-      projectType: "application",
-      directory: options.directory,
-      rootProject: options.rootProject
-    });
-  options.rootProject = appProjectRoot === ".";
-
-  return {
-    addPlugin: process.env.NX_ADD_PLUGINS !== "false",
-    accountId: process.env.STORM_BOT_CLOUDFLARE_ACCOUNT,
-    ...options,
-    name: names(appProjectName).fileName,
-    frontendProject: options.frontendProject
-      ? names(options.frontendProject).fileName
-      : undefined,
-    appProjectRoot,
-    unitTestRunner: options.unitTestRunner ?? "vitest",
-    rootProject: options.rootProject ?? false,
-    template: options.template ?? "fetch-handler",
-    port: options.port ?? 3000
-  };
-}
-
-export default applicationGenerator;
-export const applicationSchematic = convertNxGenerator(applicationGenerator);

package/src/generators/worker/libs/get-account-id.ts

@@ -1,3 +0,0 @@
-export function getAccountId(accountId: string): string {
-  return `account_id = "${accountId}"`;
-}

package/src/generators/worker/libs/vitest-imports.ts

@@ -1 +0,0 @@
-export const vitestImports = `import { describe, expect, it, beforeAll, afterAll } from 'vitest';`;

package/src/generators/worker/libs/vitest-script.ts

@@ -1 +0,0 @@
-export const vitestScript = `"test": "vitest run"`;

package/src/plugins/index.ts

@@ -1,137 +0,0 @@
-import {
-  ProjectTagConstants,
-  addProjectTag,
-} from "@storm-software/workspace-tools/utils/project-tags";
-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 { readJsonFile } from "nx/src/utils/fileutils";
-import {
-  type PackageJson,
-  readTargetsFromPackageJson,
-} from "nx/src/utils/package-json";
-
-export const name = "storm-software/cloudflare";
-
-export const createNodes = [
-  "{**/wrangler.toml}",
-  (file, _, ctx) => {
-    const packageJson = createPackageJson(file, ctx.workspaceRoot);
-    if (!packageJson) {
-      return {};
-    }
-
-    const project = createProjectFromPackageJsonNextToProjectJson(
-      file,
-      packageJson,
-    );
-    const nxJson = readNxJson(ctx.workspaceRoot);
-
-    const targets: ProjectConfiguration["targets"] = readTargetsFromPackageJson(
-      packageJson,
-      nxJson,
-    );
-
-    // Apply nx-release-publish target for non-private projects
-
-    targets["serve"] = {
-      cache: false,
-      inputs: ["typescript", "^production"],
-      dependsOn: ["build"],
-      executor: "@storm-software/cloudflare-tools:serve",
-      options: {
-        port: 4500,
-      },
-    };
-
-    targets["clean-package"] = {
-      cache: true,
-      dependsOn: ["build"],
-      inputs: ["typescript", "^production"],
-      outputs: ["{workspaceRoot}/dist/{projectRoot}"],
-      executor: "@storm-software/workspace-tools:clean-package",
-      options: {
-        cleanReadMe: true,
-        cleanComments: true,
-      },
-    };
-
-    targets["nx-release-publish"] = {
-      cache: false,
-      inputs: ["typescript", "^production"],
-      dependsOn: ["clean-package", "^nx-release-publish"],
-      executor: "@storm-software/cloudflare-tools:cloudflare-publish",
-      options: {},
-    };
-
-    addProjectTag(
-      project,
-      ProjectTagConstants.ProjectType.TAG_ID,
-      project.projectType === "application"
-        ? ProjectTagConstants.ProjectType.APPLICATION
-        : ProjectTagConstants.ProjectType.LIBRARY,
-      { overwrite: true },
-    );
-    addProjectTag(
-      project,
-      ProjectTagConstants.DistStyle.TAG_ID,
-      ProjectTagConstants.DistStyle.CLEAN,
-      { overwrite: true },
-    );
-    addProjectTag(project, ProjectTagConstants.Provider.TAG_ID, "cloudflare", {
-      overwrite: true,
-    });
-
-    return project?.name
-      ? {
-          projects: {
-            [project.name]: {
-              ...project,
-              targets,
-              release: {
-                ...project?.release,
-                version: {
-                  ...project?.release?.version,
-                  generator: "@storm-software/workspace-tools:release-version",
-                },
-              },
-            },
-          },
-        }
-      : {};
-  },
-];
-
-function createProjectFromPackageJsonNextToProjectJson(
-  projectJsonPath: string,
-  packageJson: PackageJson,
-): ProjectConfiguration {
-  const { nx, name } = packageJson;
-  const root = dirname(projectJsonPath);
-
-  return {
-    ...nx,
-    name,
-    root,
-    targets: {},
-  } as ProjectConfiguration;
-}
-
-function createPackageJson(
-  projectJsonPath: string,
-  workspaceRoot: string,
-): PackageJson | null {
-  try {
-    const root = dirname(projectJsonPath);
-    const packageJsonPath = join(workspaceRoot, root, "package.json");
-    if (!existsSync(packageJsonPath)) {
-      return null;
-    }
-
-    return readJsonFile(packageJsonPath) as PackageJson;
-  } catch (e) {
-    console.log(e);
-    return null;
-  }
-}

package/src/utils/index.ts

@@ -1 +0,0 @@
-export * from "./r2-bucket-helpers";

package/src/utils/r2-bucket-helpers.ts

@@ -1,56 +0,0 @@
-import { S3 } from "@aws-sdk/client-s3";
-import {
-  ProjectGraph,
-  ProjectGraphDependency,
-  ProjectGraphProjectNode,
-} from "@nx/devkit";
-import { writeDebug, writeWarning } from "@storm-software/config-tools";
-import { createHash } from "node:crypto";
-
-export const r2UploadFile = async (
-  client: S3,
-  bucketName: string,
-  projectPath: string,
-  fileName: string,
-  version: string,
-  fileContent: string,
-  contentType = "text/plain",
-  isDryRun = false,
-) => {
-  const checksum = createHash("sha256").update(fileContent).digest("base64");
-  const fileKey = `${projectPath}/${fileName.startsWith("/") ? fileName.substring(1) : fileName}`;
-  writeDebug(`Uploading file: ${fileKey}`);
-
-  if (!isDryRun) {
-    await client.putObject({
-      Bucket: bucketName,
-      Key: fileKey,
-      Body: fileContent.replaceAll(' from "@cyclone-ui/', ' from "../'),
-      ContentType: contentType,
-      Metadata: {
-        version,
-        checksum,
-      },
-    });
-  } else {
-    writeWarning("[Dry run]: skipping upload to the Cyclone Registry.");
-  }
-};
-
-export const getInternalDependencies = (
-  projectName: string,
-  graph: ProjectGraph,
-): ProjectGraphProjectNode[] => {
-  const allDeps = graph.dependencies[projectName] ?? [];
-
-  return Array.from(
-    allDeps.reduce(
-      (acc: ProjectGraphProjectNode[], node: ProjectGraphDependency) => {
-        const found = graph.nodes[node.target];
-        if (found) acc.push(found);
-        return acc;
-      },
-      [],
-    ),
-  );
-};

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "rootDir": "../..",
-    "target": "ESNext",
-    "module": "ESNext",
-    "lib": ["ESNext"],
-    "skipLibCheck": true,
-    "skipDefaultLibCheck": true,
-    "moduleResolution": "Bundler",
-    "moduleDetection": "force",
-    "types": ["node"]
-  },
-  "include": [
-    "executors.ts",
-    "generators.ts",
-    "index.ts",
-    "src/**/*.ts",
-    "src/**/*.d.ts",
-    "src/**/*.json",
-    "tsup.config.ts"
-  ],
-  "exclude": [
-    "jest.config.ts",
-    "src/generators/**/files/**/*",
-    "src/**/untyped.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.ts"
-  ]
-}

package/tsup.config.ts

@@ -1,27 +0,0 @@
-import { defineConfig, Options } from "tsup";
-
-const config = defineConfig([
-  {
-    name: "cloudflare-tools",
-    target: "node22",
-    entryPoints: [
-      "./*.ts",
-      "./src/utils/*.ts",
-      "./src/executors/*/executor.ts",
-      "./src/generators/*/generator.ts",
-      "./src/generators/plugins/*.ts"
-    ],
-    outDir: "dist",
-    format: ["cjs", "esm"],
-    platform: "node",
-    splitting: true,
-    clean: true,
-    dts: true,
-    sourcemap: false,
-    shims: true,
-    tsconfig: "./tsconfig.json",
-    external: ["@storm-software/workspace-tools"]
-  }
-]) as Options;
-
-export default config;