@cloudflare/workers-utils 0.0.2 → 0.1.0

package/dist/browser.d.mts

@@ -0,0 +1,3 @@
+export { g as constructWranglerConfig } from './browser-BbMtmAbH.mjs';
+import '@cloudflare/workers-shared';
+import 'cloudflare';

package/dist/browser.mjs

@@ -0,0 +1 @@
+export { constructWranglerConfig } from './chunk-LFBFF6MG.mjs';

package/dist/chunk-LFBFF6MG.mjs

@@ -0,0 +1,533 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/constants.ts
+var INHERIT_SYMBOL = Symbol.for("inherit_binding");
+var SERVICE_TAG_PREFIX = "cf:service=";
+var ENVIRONMENT_TAG_PREFIX = "cf:environment=";
+var PATH_TO_DEPLOY_CONFIG = ".wrangler/deploy/config.json";
+
+// src/format-compatibility-date.ts
+function formatCompatibilityDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+__name(formatCompatibilityDate, "formatCompatibilityDate");
+
+// src/assert-never.ts
+function assertNever(_value) {
+}
+__name(assertNever, "assertNever");
+
+// src/errors.ts
+var UserError = class extends Error {
+  static {
+    __name(this, "UserError");
+  }
+  telemetryMessage;
+  constructor(message, options) {
+    super(message, options);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.telemetryMessage = options?.telemetryMessage === true ? message : options?.telemetryMessage;
+  }
+};
+var DeprecationError = class extends UserError {
+  static {
+    __name(this, "DeprecationError");
+  }
+  constructor(message, options) {
+    super(`Deprecation:
+${message}`, options);
+  }
+};
+var FatalError = class extends UserError {
+  constructor(message, code, options) {
+    super(message, options);
+    this.code = code;
+  }
+  static {
+    __name(this, "FatalError");
+  }
+};
+var CommandLineArgsError = class extends UserError {
+  static {
+    __name(this, "CommandLineArgsError");
+  }
+};
+var JsonFriendlyFatalError = class extends FatalError {
+  constructor(message, code, options) {
+    super(message, code, options);
+    this.code = code;
+  }
+  static {
+    __name(this, "JsonFriendlyFatalError");
+  }
+};
+var MissingConfigError = class extends Error {
+  static {
+    __name(this, "MissingConfigError");
+  }
+  telemetryMessage;
+  constructor(key) {
+    super(`Missing config value for ${key}`);
+    this.telemetryMessage = `Missing config value for ${key}`;
+  }
+};
+function createFatalError(message, isJson, code, telemetryMessage) {
+  if (isJson) {
+    return new JsonFriendlyFatalError(
+      JSON.stringify(message),
+      code,
+      telemetryMessage
+    );
+  } else {
+    return new FatalError(`${message}`, code, telemetryMessage);
+  }
+}
+__name(createFatalError, "createFatalError");
+
+// src/map-worker-metadata-bindings.ts
+function mapWorkerMetadataBindings(bindings) {
+  return bindings.filter((binding) => binding.type !== "secret_text").reduce((configObj, binding) => {
+    switch (binding.type) {
+      case "plain_text":
+        {
+          configObj.vars = {
+            ...configObj.vars ?? {},
+            [binding.name]: binding.text
+          };
+        }
+        break;
+      case "json":
+        {
+          configObj.vars = {
+            ...configObj.vars ?? {},
+            name: binding.name,
+            json: binding.json
+          };
+        }
+        break;
+      case "kv_namespace":
+        {
+          configObj.kv_namespaces = [
+            ...configObj.kv_namespaces ?? [],
+            { id: binding.namespace_id, binding: binding.name }
+          ];
+        }
+        break;
+      case "durable_object_namespace":
+        {
+          configObj.durable_objects = {
+            bindings: [
+              ...configObj.durable_objects?.bindings ?? [],
+              {
+                name: binding.name,
+                class_name: binding.class_name,
+                script_name: binding.script_name,
+                environment: binding.environment
+              }
+            ]
+          };
+        }
+        break;
+      case "d1":
+        {
+          configObj.d1_databases = [
+            ...configObj.d1_databases ?? [],
+            {
+              binding: binding.name,
+              database_id: binding.id
+            }
+          ];
+        }
+        break;
+      case "browser":
+        {
+          configObj.browser = {
+            binding: binding.name
+          };
+        }
+        break;
+      case "ai":
+        {
+          configObj.ai = {
+            binding: binding.name
+          };
+        }
+        break;
+      case "images":
+        {
+          configObj.images = {
+            binding: binding.name
+          };
+        }
+        break;
+      case "media":
+        {
+          configObj.media = {
+            binding: binding.name
+          };
+        }
+        break;
+      case "r2_bucket":
+        {
+          configObj.r2_buckets = [
+            ...configObj.r2_buckets ?? [],
+            {
+              binding: binding.name,
+              bucket_name: binding.bucket_name,
+              jurisdiction: binding.jurisdiction
+            }
+          ];
+        }
+        break;
+      case "secrets_store_secret":
+        {
+          configObj.secrets_store_secrets = [
+            ...configObj.secrets_store_secrets ?? [],
+            {
+              binding: binding.name,
+              store_id: binding.store_id,
+              secret_name: binding.secret_name
+            }
+          ];
+        }
+        break;
+      case "unsafe_hello_world": {
+        configObj.unsafe_hello_world = [
+          ...configObj.unsafe_hello_world ?? [],
+          {
+            binding: binding.name,
+            enable_timer: binding.enable_timer
+          }
+        ];
+        break;
+      }
+      case "service":
+        {
+          configObj.services = [
+            ...configObj.services ?? [],
+            {
+              binding: binding.name,
+              service: binding.service,
+              environment: binding.environment,
+              entrypoint: binding.entrypoint
+            }
+          ];
+        }
+        break;
+      case "analytics_engine":
+        {
+          configObj.analytics_engine_datasets = [
+            ...configObj.analytics_engine_datasets ?? [],
+            { binding: binding.name, dataset: binding.dataset }
+          ];
+        }
+        break;
+      case "dispatch_namespace":
+        {
+          configObj.dispatch_namespaces = [
+            ...configObj.dispatch_namespaces ?? [],
+            {
+              binding: binding.name,
+              namespace: binding.namespace,
+              ...binding.outbound && {
+                outbound: {
+                  service: binding.outbound.worker.service,
+                  environment: binding.outbound.worker.environment,
+                  parameters: binding.outbound.params?.map((p) => p.name) ?? []
+                }
+              }
+            }
+          ];
+        }
+        break;
+      case "logfwdr":
+        {
+          configObj.logfwdr = {
+            bindings: [
+              ...configObj.logfwdr?.bindings ?? [],
+              { name: binding.name, destination: binding.destination }
+            ]
+          };
+        }
+        break;
+      case "wasm_module":
+        {
+          configObj.wasm_modules = {
+            ...configObj.wasm_modules ?? {},
+            [binding.name]: binding.part
+          };
+        }
+        break;
+      case "text_blob":
+        {
+          configObj.text_blobs = {
+            ...configObj.text_blobs ?? {},
+            [binding.name]: binding.part
+          };
+        }
+        break;
+      case "data_blob":
+        {
+          configObj.data_blobs = {
+            ...configObj.data_blobs ?? {},
+            [binding.name]: binding.part
+          };
+        }
+        break;
+      case "secret_text":
+        break;
+      case "version_metadata": {
+        {
+          configObj.version_metadata = {
+            binding: binding.name
+          };
+        }
+        break;
+      }
+      case "send_email": {
+        configObj.send_email = [
+          ...configObj.send_email ?? [],
+          {
+            name: binding.name,
+            destination_address: binding.destination_address,
+            allowed_destination_addresses: binding.allowed_destination_addresses,
+            allowed_sender_addresses: binding.allowed_sender_addresses
+          }
+        ];
+        break;
+      }
+      case "queue":
+        configObj.queues ??= { producers: [] };
+        configObj.queues.producers = [
+          ...configObj.queues.producers ?? [],
+          {
+            binding: binding.name,
+            queue: binding.queue_name,
+            delivery_delay: binding.delivery_delay
+          }
+        ];
+        break;
+      case "vectorize":
+        configObj.vectorize = [
+          ...configObj.vectorize ?? [],
+          {
+            binding: binding.name,
+            index_name: binding.index_name
+          }
+        ];
+        break;
+      case "hyperdrive":
+        configObj.hyperdrive = [
+          ...configObj.hyperdrive ?? [],
+          {
+            binding: binding.name,
+            id: binding.id
+          }
+        ];
+        break;
+      case "mtls_certificate":
+        configObj.mtls_certificates = [
+          ...configObj.mtls_certificates ?? [],
+          {
+            binding: binding.name,
+            certificate_id: binding.certificate_id
+          }
+        ];
+        break;
+      case "pipelines":
+        configObj.pipelines = [
+          ...configObj.pipelines ?? [],
+          {
+            binding: binding.name,
+            pipeline: binding.pipeline
+          }
+        ];
+        break;
+      case "assets":
+        throw new FatalError(
+          "`wrangler init --from-dash` is not yet supported for Workers with Assets"
+        );
+      case "inherit":
+        configObj.unsafe = {
+          bindings: [...configObj.unsafe?.bindings ?? [], binding],
+          metadata: configObj.unsafe?.metadata ?? void 0
+        };
+        break;
+      case "workflow":
+        {
+          configObj.workflows = [
+            ...configObj.workflows ?? [],
+            {
+              binding: binding.name,
+              name: binding.workflow_name,
+              class_name: binding.class_name,
+              script_name: binding.script_name
+            }
+          ];
+        }
+        break;
+      case "worker_loader":
+        {
+          configObj.worker_loaders = [
+            ...configObj.worker_loaders ?? [],
+            {
+              binding: binding.name
+            }
+          ];
+        }
+        break;
+      case "ratelimit":
+        {
+          configObj.ratelimits = [
+            ...configObj.ratelimits ?? [],
+            {
+              name: binding.name,
+              namespace_id: binding.namespace_id,
+              simple: {
+                limit: binding.simple.limit,
+                period: binding.simple.period
+              }
+            }
+          ];
+        }
+        break;
+      case "vpc_service":
+        {
+          configObj.vpc_services = [
+            ...configObj.vpc_services ?? [],
+            {
+              binding: binding.name,
+              service_id: binding.service_id
+            }
+          ];
+        }
+        break;
+      default: {
+        configObj.unsafe = {
+          bindings: [...configObj.unsafe?.bindings ?? [], binding],
+          metadata: configObj.unsafe?.metadata ?? void 0
+        };
+      }
+    }
+    return configObj;
+  }, {});
+}
+__name(mapWorkerMetadataBindings, "mapWorkerMetadataBindings");
+
+// src/construct-wrangler-config.ts
+function convertWorkerToWranglerConfig(config) {
+  const mappedBindings = mapWorkerMetadataBindings(config.bindings);
+  const durableObjectClassNames = config.bindings.filter(
+    (binding) => binding.type === "durable_object_namespace" && binding.script_name === config.name
+  ).map(
+    (durableObject) => durableObject.class_name
+  );
+  const allRoutes = [
+    ...config.routes.map((r) => ({
+      pattern: r.pattern,
+      zone_name: r.zone_name
+    })),
+    ...config.domains.map((c) => ({
+      pattern: c.hostname,
+      zone_name: c.zone_name,
+      custom_domain: true
+    }))
+  ];
+  return {
+    name: config.name,
+    main: config.entrypoint,
+    workers_dev: config.subdomain.enabled,
+    preview_urls: config.subdomain.previews_enabled,
+    compatibility_date: config.compatibility_date ?? formatCompatibilityDate(/* @__PURE__ */ new Date()),
+    compatibility_flags: config.compatibility_flags,
+    ...allRoutes.length ? { routes: allRoutes } : {},
+    placement: config.placement?.mode === "smart" ? { mode: "smart" } : void 0,
+    limits: config.limits,
+    ...durableObjectClassNames.length && config.migration_tag ? {
+      migrations: [
+        {
+          tag: config.migration_tag,
+          new_classes: durableObjectClassNames
+        }
+      ]
+    } : {},
+    ...config.schedules.length ? {
+      triggers: {
+        crons: config.schedules.map((scheduled) => scheduled.cron)
+      }
+    } : {},
+    tail_consumers: config.tail_consumers,
+    observability: config.observability,
+    ...mappedBindings
+  };
+}
+__name(convertWorkerToWranglerConfig, "convertWorkerToWranglerConfig");
+function constructWranglerConfig(workerOrWorkers) {
+  let workers;
+  if (Array.isArray(workerOrWorkers)) {
+    workers = workerOrWorkers;
+  } else {
+    workers = [workerOrWorkers];
+  }
+  const topLevelEnv = workers.find(
+    (w) => !w.tags?.some((t) => t.startsWith(ENVIRONMENT_TAG_PREFIX))
+  );
+  const workerName = topLevelEnv?.name ?? workers[0].name;
+  const entrypoint = topLevelEnv?.entrypoint ?? workers[0].entrypoint;
+  let combinedConfig;
+  if (topLevelEnv) {
+    combinedConfig = convertWorkerToWranglerConfig(topLevelEnv);
+  } else {
+    combinedConfig = {
+      name: workerName,
+      main: entrypoint
+    };
+  }
+  for (const env of workers) {
+    const serviceTag = env.tags?.find(
+      (t) => t === `${SERVICE_TAG_PREFIX}${workerName}`
+    );
+    const envTag = env.tags?.find((t) => t.startsWith(ENVIRONMENT_TAG_PREFIX));
+    if (serviceTag !== `${SERVICE_TAG_PREFIX}${workerName}` || envTag === void 0) {
+      continue;
+    }
+    const [_, envName] = envTag.split("=");
+    combinedConfig.env ??= {};
+    combinedConfig.env[envName] = convertWorkerToWranglerConfig(env);
+  }
+  return combinedConfig;
+}
+__name(constructWranglerConfig, "constructWranglerConfig");
+
+export { CommandLineArgsError, DeprecationError, ENVIRONMENT_TAG_PREFIX, FatalError, INHERIT_SYMBOL, JsonFriendlyFatalError, MissingConfigError, PATH_TO_DEPLOY_CONFIG, SERVICE_TAG_PREFIX, UserError, __commonJS, __name, __require, __toESM, assertNever, constructWranglerConfig, createFatalError, formatCompatibilityDate, mapWorkerMetadataBindings };