devflare 1.0.0-next.19 → 1.0.0-next.20

package/dist/index-z40mjts9.js

@@ -0,0 +1,212 @@
+// src/config/preview.ts
+var PREVIEW_SCOPED_NAME_PREFIX = "__DEVFLARE_PREVIEW_SCOPE__:";
+function getPreviewScopedSeparator(options) {
+  return options?.separator ?? "-";
+}
+function encodePreviewScopedName(value) {
+  return `${PREVIEW_SCOPED_NAME_PREFIX}${JSON.stringify(value)}`;
+}
+function invalidPreviewScopedName(reason) {
+  throw new Error(`Invalid Devflare preview-scoped value: ${reason}. Recreate it with preview.scope(...) instead of constructing preview markers manually.`);
+}
+function decodePreviewScopedName(value) {
+  const payload = value.slice(PREVIEW_SCOPED_NAME_PREFIX.length);
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    invalidPreviewScopedName("the encoded payload is not valid JSON");
+  }
+  const baseName = typeof parsed.baseName === "string" ? parsed.baseName : "";
+  if (!baseName.trim()) {
+    invalidPreviewScopedName("the encoded payload is missing a non-empty baseName");
+  }
+  return {
+    baseName,
+    separator: typeof parsed.separator === "string" && parsed.separator.length > 0 ? parsed.separator : "-"
+  };
+}
+function normalizePreviewFragment(rawValue) {
+  let normalized = rawValue.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  if (!normalized) {
+    normalized = "preview";
+  }
+  if (!/^[a-z]/.test(normalized)) {
+    normalized = `b-${normalized}`;
+  }
+  return normalized;
+}
+function getPreviewIdentifierFromEnv(env) {
+  const explicitIdentifier = env.DEVFLARE_PREVIEW_IDENTIFIER?.trim();
+  if (explicitIdentifier) {
+    return {
+      identifier: normalizePreviewFragment(explicitIdentifier),
+      source: "env-identifier"
+    };
+  }
+  const previewPr = env.DEVFLARE_PREVIEW_PR?.trim();
+  if (previewPr) {
+    return {
+      identifier: normalizePreviewFragment(`pr-${previewPr}`),
+      source: "env-pr"
+    };
+  }
+  const previewBranch = env.DEVFLARE_PREVIEW_BRANCH?.trim();
+  if (previewBranch) {
+    return {
+      identifier: normalizePreviewFragment(previewBranch),
+      source: "env-branch"
+    };
+  }
+  return {
+    identifier: undefined,
+    source: "none"
+  };
+}
+function resolvePreviewIdentifier(options = {}) {
+  if (options.identifier?.trim()) {
+    return {
+      identifier: normalizePreviewFragment(options.identifier),
+      source: "identifier"
+    };
+  }
+  const env = options.env ?? process.env;
+  const envIdentifier = getPreviewIdentifierFromEnv(env);
+  if (envIdentifier.identifier) {
+    return envIdentifier;
+  }
+  return options.environment === "preview" ? {
+    identifier: "preview",
+    source: "environment"
+  } : {
+    identifier: undefined,
+    source: "none"
+  };
+}
+function mapRecordValues(record, mapper) {
+  return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, mapper(value)]));
+}
+var preview = {
+  scope(defaults = {}) {
+    return (baseName, options = {}) => {
+      if (!baseName.trim()) {
+        throw new Error("preview.scope(...) requires a non-empty baseName.");
+      }
+      return encodePreviewScopedName({
+        baseName,
+        separator: getPreviewScopedSeparator({
+          ...defaults,
+          ...options
+        })
+      });
+    };
+  }
+};
+function isPreviewScopedName(value) {
+  return typeof value === "string" && value.startsWith(PREVIEW_SCOPED_NAME_PREFIX);
+}
+function materializePreviewScopedString(value, options = {}) {
+  if (!isPreviewScopedName(value)) {
+    return value;
+  }
+  const scoped = decodePreviewScopedName(value);
+  const previewIdentifier = resolvePreviewIdentifier(options).identifier;
+  return previewIdentifier ? `${scoped.baseName}${scoped.separator}${previewIdentifier}` : scoped.baseName;
+}
+function materializePreviewScopedConfig(config, options = {}) {
+  if (!config.bindings) {
+    return config;
+  }
+  const bindings = config.bindings;
+  const hasPreviewIdentifier = Boolean(resolvePreviewIdentifier(options).identifier);
+  return {
+    ...config,
+    bindings: {
+      ...bindings,
+      ...bindings.kv ? {
+        kv: mapRecordValues(bindings.kv, (binding) => {
+          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+        })
+      } : {},
+      ...bindings.d1 ? {
+        d1: mapRecordValues(bindings.d1, (binding) => {
+          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+        })
+      } : {},
+      ...bindings.r2 ? {
+        r2: mapRecordValues(bindings.r2, (binding) => {
+          return materializePreviewScopedString(binding, options);
+        })
+      } : {},
+      ...bindings.queues ? {
+        queues: {
+          ...bindings.queues,
+          ...bindings.queues.producers ? {
+            producers: mapRecordValues(bindings.queues.producers, (queueName) => {
+              return materializePreviewScopedString(queueName, options);
+            })
+          } : {},
+          ...bindings.queues.consumers ? {
+            consumers: bindings.queues.consumers.map((consumer) => ({
+              ...consumer,
+              queue: materializePreviewScopedString(consumer.queue, options),
+              ...consumer.deadLetterQueue ? {
+                deadLetterQueue: materializePreviewScopedString(consumer.deadLetterQueue, options)
+              } : {}
+            }))
+          } : {}
+        }
+      } : {},
+      ...bindings.services ? {
+        services: mapRecordValues(bindings.services, (binding) => ({
+          ...binding,
+          service: materializePreviewScopedString(binding.service, options)
+        }))
+      } : {},
+      ...bindings.vectorize ? {
+        vectorize: mapRecordValues(bindings.vectorize, (binding) => ({
+          ...binding,
+          indexName: materializePreviewScopedString(binding.indexName, options)
+        }))
+      } : {},
+      ...bindings.hyperdrive ? {
+        hyperdrive: mapRecordValues(bindings.hyperdrive, (binding) => {
+          if (typeof binding === "string") {
+            return materializePreviewScopedString(binding, options);
+          }
+          if (binding && typeof binding === "object" && "name" in binding && typeof binding.name === "string") {
+            if (hasPreviewIdentifier && binding.previewId) {
+              return {
+                id: binding.previewId,
+                ...binding.localConnectionString && {
+                  localConnectionString: binding.localConnectionString
+                },
+                ...!binding.localConnectionString && binding.previewLocalConnectionString && {
+                  localConnectionString: binding.previewLocalConnectionString
+                }
+              };
+            }
+            return {
+              ...binding,
+              name: materializePreviewScopedString(binding.name, options)
+            };
+          }
+          return binding;
+        })
+      } : {},
+      ...bindings.browser ? {
+        browser: mapRecordValues(bindings.browser, (binding) => {
+          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+        })
+      } : {},
+      ...bindings.analyticsEngine ? {
+        analyticsEngine: mapRecordValues(bindings.analyticsEngine, (binding) => ({
+          ...binding,
+          dataset: materializePreviewScopedString(binding.dataset, options)
+        }))
+      } : {}
+    }
+  };
+}
+
+export { resolvePreviewIdentifier, preview, isPreviewScopedName, materializePreviewScopedString, materializePreviewScopedConfig };