@storm-software/cloudflare-tools 0.48.0 → 0.49.0

package/dist/chunk-VPT6GF3S.mjs

@@ -0,0 +1,153 @@
+import {
+  getInternalDependencies,
+  r2UploadFile
+} from "./chunk-VYOULWAK.mjs";
+import {
+  createCliOptions,
+  getPackageInfo
+} from "./chunk-XU6MTFCV.mjs";
+import {
+  loadStormConfig
+} from "./chunk-OARYMVO7.mjs";
+import {
+  findWorkspaceRoot,
+  writeDebug,
+  writeInfo,
+  writeSuccess,
+  writeWarning
+} from "./chunk-NSLK6ZDO.mjs";
+import {
+  __name
+} from "./chunk-A7FFSBE6.mjs";
+
+// src/executors/r2-upload-publish/executor.ts
+import { S3 } from "@aws-sdk/client-s3";
+import { joinPathFragments, readCachedProjectGraph } from "@nx/devkit";
+import { glob } from "glob";
+import { execSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+async function runExecutor(options, context) {
+  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+  if (!context.projectName) {
+    throw new Error("The executor requires a projectName.");
+  }
+  console.info(`\u{1F680}  Running Storm Cloudflare Publish executor on the ${context.projectName} worker`);
+  if (!context.projectName || !context.projectsConfigurations?.projects || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
+    throw new Error("The executor requires projectsConfigurations.");
+  }
+  try {
+    const workspaceRoot = findWorkspaceRoot();
+    const config = await loadStormConfig(workspaceRoot);
+    const sourceRoot = context.projectsConfigurations.projects[context.projectName]?.sourceRoot ?? workspaceRoot;
+    const projectName = context.projectsConfigurations.projects[context.projectName]?.name ?? context.projectName;
+    const projectDetails = getPackageInfo(context.projectsConfigurations.projects[context.projectName]);
+    if (!projectDetails?.content) {
+      throw new Error(`Could not find the project details for ${context.projectName}`);
+    }
+    const args = createCliOptions({
+      ...options
+    });
+    if (isDryRun) {
+      args.push("--dry-run");
+    }
+    const cloudflareAccountId = process.env.STORM_BOT_CLOUDFLARE_ACCOUNT;
+    if (!options?.registry && !cloudflareAccountId) {
+      throw new Error("The Storm Registry URL is not set in the Storm config. Please set either the `extensions.cyclone.registry` or `config.extensions.cyclone.accountId` property in the Storm config.");
+    }
+    if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
+      throw new Error("The AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables are not set. Please set these environment variables to upload to the Cyclone Registry.");
+    }
+    const endpoint = options?.registry ? options.registry : `https://${cloudflareAccountId}.r2.cloudflarestorage.com`;
+    const projectGraph = readCachedProjectGraph();
+    if (!projectGraph) {
+      throw new Error("No project graph found in cache");
+    }
+    writeInfo(`Publishing ${context.projectName} to the Storm Registry at ${endpoint}`);
+    const s3Client = new S3({
+      region: "auto",
+      endpoint,
+      credentials: {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+      }
+    });
+    const version = projectDetails.content?.version;
+    writeInfo(`Generated component version: ${version}`);
+    const files = await glob(joinPathFragments(sourceRoot, "**/*"), {
+      ignore: "**/{*.stories.tsx,*.stories.ts,*.spec.tsx,*.spec.ts}"
+    });
+    const projectPath = `registry/${context.projectName}`;
+    const internalDependencies = await getInternalDependencies(context.projectName, projectGraph);
+    const dependencies = internalDependencies.filter((projectNode) => !projectNode.data.tags || projectNode.data.tags.every((tag) => tag.toLowerCase() !== "component")).reduce((ret, dep) => {
+      if (!ret[dep.name]) {
+        ret[dep.name] = "latest";
+      }
+      return ret;
+    }, projectDetails.content.dependencies ?? {});
+    const release = options.tag ?? execSync("npm config get tag").toString().trim();
+    writeInfo(`Clearing out existing items in ${projectPath}`);
+    if (!isDryRun) {
+      const response = await s3Client.listObjects({
+        Bucket: options.bucketId,
+        Prefix: projectPath
+      });
+      if (response?.Contents && response.Contents.length > 0) {
+        writeDebug(`Deleting the following existing items from the component registry: ${response.Contents.map((item) => item.Key).join(", ")}`);
+        await Promise.all(response.Contents.map((item) => s3Client.deleteObjects({
+          Bucket: options.bucketId,
+          Delete: {
+            Objects: [
+              {
+                Key: item.Key
+              }
+            ],
+            Quiet: false
+          }
+        })));
+      } else {
+        writeDebug(`No existing items to delete in the component registry path ${projectPath}`);
+      }
+    } else {
+      writeWarning("[Dry run]: skipping upload to the Cyclone Registry.");
+    }
+    const meta = {
+      name: context.projectName,
+      version,
+      release,
+      description: projectDetails.content.description,
+      tags: projectDetails.content.keywords,
+      dependencies,
+      devDependencies: null,
+      internalDependencies: internalDependencies.filter((projectNode) => projectNode.data.tags && projectNode.data.tags.some((tag) => tag.toLowerCase() === "component")).map((dep) => dep.name)
+    };
+    if (projectDetails.type === "package.json") {
+      meta.devDependencies = projectDetails.content.devDependencies;
+    }
+    const metaJson = JSON.stringify(meta);
+    writeInfo(`Generating meta.json file: 
+${metaJson}`);
+    await r2UploadFile(s3Client, options.bucketId, projectPath, "meta.json", version, metaJson, "application/json", isDryRun);
+    await Promise.all(files.map((file) => {
+      const fileName = file.replaceAll("\\", "/").replace(sourceRoot.replaceAll("\\", "/"), "");
+      return readFile(file, {
+        encoding: "utf8"
+      }).then((fileContent) => r2UploadFile(s3Client, options.bucketId, projectPath, fileName, version, fileContent, "text/plain", isDryRun));
+    }));
+    writeSuccess(`Successfully uploaded the ${projectName} component to the Cyclone Registry`, config);
+    return {
+      success: true
+    };
+  } catch (error) {
+    console.error("Failed to publish to Cloudflare Workers Registry");
+    console.error(error);
+    console.log("");
+    return {
+      success: false
+    };
+  }
+}
+__name(runExecutor, "runExecutor");
+
+export {
+  runExecutor
+};

package/dist/chunk-VTHBMY4B.js

@@ -0,0 +1,133 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJ5SB6L2Ljs = require('./chunk-J5SB6L2L.js');
+
+// ../workspace-tools/src/utils/create-cli-options.ts
+var _devkit = require('@nx/devkit');
+function createCliOptions(obj) {
+  const args = [];
+  for (const key in obj) {
+    const value = obj[key];
+    if (value) {
+      const arg = _devkit.names.call(void 0, key).fileName;
+      if (Array.isArray(value)) {
+        args.push(`--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`);
+      } else {
+        args.push(`--${arg.toLowerCase()}=${value}`);
+      }
+    }
+  }
+  return args;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, createCliOptions, "createCliOptions");
+
+// ../workspace-tools/src/utils/package-helpers.ts
+
+var _fs = require('fs');
+
+// ../workspace-tools/src/utils/project-tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  DistStyle: {
+    TAG_ID: "dist-style",
+    NORMAL: "normal",
+    CLEAN: "clean"
+  },
+  Provider: {
+    TAG_ID: "provider"
+  },
+  Platform: {
+    TAG_ID: "platform",
+    NODE: "node",
+    BROWSER: "browser",
+    NEUTRAL: "neutral",
+    WORKER: "worker"
+  },
+  Registry: {
+    TAG_ID: "registry",
+    CARGO: "cargo",
+    NPM: "npm",
+    CONTAINER: "container",
+    CYCLONE: "cyclone"
+  },
+  Plugin: {
+    TAG_ID: "plugin"
+  }
+};
+var formatProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (variant, value) => {
+  return `${variant}:${value}`;
+}, "formatProjectTag");
+var hasProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some((tag) => tag.startsWith(prefix) && tag.length > prefix.length);
+}, "hasProjectTag");
+var getProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return _optionalChain([tag, 'optionalAccess', _ => _.replace, 'call', _2 => _2(prefix, "")]);
+}, "getProjectTag");
+var isEqualProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && _optionalChain([tag, 'optionalAccess', _3 => _3.toUpperCase, 'call', _4 => _4()]) === value.toUpperCase());
+}, "isEqualProjectTag");
+var addProjectTag = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project, variant, value, options = {
+  overwrite: false
+}) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter((tag) => !tag.startsWith(formatProjectTag(variant, "")));
+    project.tags.push(formatProjectTag(variant, value));
+  }
+}, "addProjectTag");
+
+// ../workspace-tools/src/utils/toml.ts
+var _jtoml = require('@ltd/j-toml'); var _jtoml2 = _interopRequireDefault(_jtoml);
+
+function parseCargoToml(cargoString) {
+  if (!cargoString) {
+    throw new Error("Cargo.toml is empty");
+  }
+  return _jtoml2.default.parse(cargoString, {
+    x: {
+      comment: true
+    }
+  });
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, parseCargoToml, "parseCargoToml");
+
+// ../workspace-tools/src/utils/package-helpers.ts
+var getPackageInfo = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (project) => {
+  if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.RUST) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: parseCargoToml(_devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))
+    };
+  } else if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.TYPESCRIPT) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: _devkit.readJsonFile.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "package.json"))
+    };
+  }
+  return null;
+}, "getPackageInfo");
+
+
+
+
+
+
+exports.ProjectTagConstants = ProjectTagConstants; exports.addProjectTag = addProjectTag; exports.createCliOptions = createCliOptions; exports.getPackageInfo = getPackageInfo;

package/dist/chunk-VYOULWAK.mjs

@@ -0,0 +1,42 @@
+import {
+  writeDebug,
+  writeWarning
+} from "./chunk-NSLK6ZDO.mjs";
+import {
+  __name
+} from "./chunk-A7FFSBE6.mjs";
+
+// src/utils/r2-bucket-helpers.ts
+import { createHash } from "node:crypto";
+var r2UploadFile = /* @__PURE__ */ __name(async (client, bucketName, projectPath, fileName, version, fileContent, 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.");
+  }
+}, "r2UploadFile");
+var getInternalDependencies = /* @__PURE__ */ __name((projectName, graph) => {
+  const allDeps = graph.dependencies[projectName] ?? [];
+  return Array.from(allDeps.reduce((acc, node) => {
+    const found = graph.nodes[node.target];
+    if (found) acc.push(found);
+    return acc;
+  }, []));
+}, "getInternalDependencies");
+
+export {
+  r2UploadFile,
+  getInternalDependencies
+};

package/dist/chunk-XO66D74Z.js

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-XU6MTFCV.mjs

@@ -0,0 +1,133 @@
+import {
+  __name
+} from "./chunk-A7FFSBE6.mjs";
+
+// ../workspace-tools/src/utils/create-cli-options.ts
+import { names } from "@nx/devkit";
+function createCliOptions(obj) {
+  const args = [];
+  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;
+}
+__name(createCliOptions, "createCliOptions");
+
+// ../workspace-tools/src/utils/package-helpers.ts
+import { joinPathFragments, readJsonFile } from "@nx/devkit";
+import { existsSync } from "node:fs";
+
+// ../workspace-tools/src/utils/project-tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  DistStyle: {
+    TAG_ID: "dist-style",
+    NORMAL: "normal",
+    CLEAN: "clean"
+  },
+  Provider: {
+    TAG_ID: "provider"
+  },
+  Platform: {
+    TAG_ID: "platform",
+    NODE: "node",
+    BROWSER: "browser",
+    NEUTRAL: "neutral",
+    WORKER: "worker"
+  },
+  Registry: {
+    TAG_ID: "registry",
+    CARGO: "cargo",
+    NPM: "npm",
+    CONTAINER: "container",
+    CYCLONE: "cyclone"
+  },
+  Plugin: {
+    TAG_ID: "plugin"
+  }
+};
+var formatProjectTag = /* @__PURE__ */ __name((variant, value) => {
+  return `${variant}:${value}`;
+}, "formatProjectTag");
+var hasProjectTag = /* @__PURE__ */ __name((project, variant) => {
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some((tag) => tag.startsWith(prefix) && tag.length > prefix.length);
+}, "hasProjectTag");
+var getProjectTag = /* @__PURE__ */ __name((project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return tag?.replace(prefix, "");
+}, "getProjectTag");
+var isEqualProjectTag = /* @__PURE__ */ __name((project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
+}, "isEqualProjectTag");
+var addProjectTag = /* @__PURE__ */ __name((project, variant, value, options = {
+  overwrite: false
+}) => {
+  project.tags = project.tags ?? [];
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter((tag) => !tag.startsWith(formatProjectTag(variant, "")));
+    project.tags.push(formatProjectTag(variant, value));
+  }
+}, "addProjectTag");
+
+// ../workspace-tools/src/utils/toml.ts
+import TOML from "@ltd/j-toml";
+import { logger } from "@nx/devkit";
+function parseCargoToml(cargoString) {
+  if (!cargoString) {
+    throw new Error("Cargo.toml is empty");
+  }
+  return TOML.parse(cargoString, {
+    x: {
+      comment: true
+    }
+  });
+}
+__name(parseCargoToml, "parseCargoToml");
+
+// ../workspace-tools/src/utils/package-helpers.ts
+var getPackageInfo = /* @__PURE__ */ __name((project) => {
+  if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.RUST) && existsSync(joinPathFragments(project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: parseCargoToml(joinPathFragments(project.root, "Cargo.toml"))
+    };
+  } else if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.TYPESCRIPT) && existsSync(joinPathFragments(project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: readJsonFile(joinPathFragments(project.root, "package.json"))
+    };
+  }
+  return null;
+}, "getPackageInfo");
+
+export {
+  ProjectTagConstants,
+  addProjectTag,
+  createCliOptions,
+  getPackageInfo
+};