devflare 1.0.0-next.21 → 1.0.0-next.23

package/dist/index-c8p4njqy.js

@@ -0,0 +1,479 @@
+// src/config/env-vars.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "pathe";
+var ENV_DESCRIPTOR_FLAG = "__devflareEnvDescriptor";
+function createDescriptor(state) {
+  const descriptor = {
+    [ENV_DESCRIPTOR_FLAG]: true,
+    __state: state,
+    optional() {
+      return createDescriptor({
+        ...state,
+        optional: true
+      });
+    },
+    parse(parser) {
+      return createDescriptor({
+        ...state,
+        parser
+      });
+    },
+    parser(parser) {
+      return this.parse(parser);
+    },
+    default(value) {
+      return createDescriptor({
+        ...state,
+        defaultValue: value,
+        hasDefault: true,
+        optional: false
+      });
+    },
+    dev(value) {
+      return createDescriptor({
+        ...state,
+        devValue: value,
+        hasDevDefault: true
+      });
+    }
+  };
+  return descriptor;
+}
+function createEnvVarDescriptor(name) {
+  return createDescriptor({
+    name,
+    optional: false,
+    hasDefault: false,
+    hasDevDefault: false
+  });
+}
+var env = new Proxy({}, {
+  get(_target, prop) {
+    if (typeof prop !== "string") {
+      return;
+    }
+    return createEnvVarDescriptor(prop);
+  }
+});
+function isEnvVarDescriptor(value) {
+  return Boolean(value && typeof value === "object" && value[ENV_DESCRIPTOR_FLAG] === true);
+}
+function parseEnvValue(rawValue) {
+  const trimmed = rawValue.trim();
+  const quote = trimmed[0];
+  if ((quote === '"' || quote === "'" || quote === "`") && trimmed.endsWith(quote) && trimmed.length >= 2) {
+    const inner = trimmed.slice(1, -1);
+    if (quote !== '"') {
+      return inner;
+    }
+    return inner.replace(/\\n/g, `
+`).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return trimmed;
+}
+function parseDevflareEnvFile(contents) {
+  const values = {};
+  for (const line of contents.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const assignment = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trimStart() : trimmed;
+    const equalsIndex = assignment.indexOf("=");
+    if (equalsIndex <= 0) {
+      continue;
+    }
+    const key = assignment.slice(0, equalsIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      continue;
+    }
+    values[key] = parseEnvValue(assignment.slice(equalsIndex + 1));
+  }
+  return values;
+}
+function collectAncestorDirectories(startDir) {
+  const directories = [];
+  let current = resolve(startDir);
+  while (true) {
+    directories.push(current);
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return directories.reverse();
+}
+function getDevflareDotenvPaths(startDir) {
+  return collectAncestorDirectories(startDir).flatMap((directory) => [
+    resolve(directory, ".env.dev"),
+    resolve(directory, ".env")
+  ]);
+}
+async function loadDevflareDotenv(startDir) {
+  const values = {};
+  const files = [];
+  for (const filePath of getDevflareDotenvPaths(startDir)) {
+    if (!existsSync(filePath)) {
+      continue;
+    }
+    Object.assign(values, parseDevflareEnvFile(await readFile(filePath, "utf8")));
+    files.push(filePath);
+  }
+  return { values, files };
+}
+async function loadDevflareDotenvIntoProcess(startDir) {
+  const loaded = await loadDevflareDotenv(startDir);
+  for (const [key, value] of Object.entries(loaded.values)) {
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+  return loaded;
+}
+function formatMissingEnvTree(missing) {
+  const root = {};
+  for (const item of missing) {
+    let current = root;
+    for (const segment of item.path.slice(0, -1)) {
+      const next = current[segment];
+      if (!next || typeof next !== "object") {
+        current[segment] = {};
+      }
+      current = current[segment];
+    }
+    current[item.path[item.path.length - 1] ?? item.name] = item.name;
+  }
+  const lines = [];
+  const writeNode = (node, depth) => {
+    const indent = "\t".repeat(depth);
+    for (const [key, value] of Object.entries(node)) {
+      if (value && typeof value === "object") {
+        lines.push(`${indent}${key}:`);
+        writeNode(value, depth + 1);
+      } else {
+        lines.push(`${indent}${key}: ${String(value)}`);
+      }
+    }
+  };
+  writeNode(root, 1);
+  return lines.join(`
+`);
+}
+
+class EnvVarResolutionError extends Error {
+  missing;
+  mode;
+  code = "ENV_VARS_MISSING";
+  constructor(missing, mode) {
+    super([
+      "These environment variables are missing:",
+      "",
+      formatMissingEnvTree(missing)
+    ].join(`
+`));
+    this.missing = missing;
+    this.mode = mode;
+    this.name = "EnvVarResolutionError";
+  }
+}
+
+class EnvVarParseError extends Error {
+  variableName;
+  path;
+  code = "ENV_VAR_PARSE_FAILED";
+  constructor(variableName, path, cause) {
+    super(`Could not parse environment variable ${variableName} for vars.${path.join(".")}.
+` + `Parser error: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.variableName = variableName;
+    this.path = path;
+    this.name = "EnvVarParseError";
+  }
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || isEnvVarDescriptor(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var OMIT_VALUE = Symbol("omit optional env var");
+function resolveDescriptorValue(descriptor, sources, path, mode, missing) {
+  const state = descriptor.__state;
+  const rawValue = sources[state.name];
+  if (rawValue !== undefined) {
+    try {
+      return state.parser ? state.parser(rawValue) : rawValue;
+    } catch (error) {
+      throw new EnvVarParseError(state.name, path, error);
+    }
+  }
+  if (mode === "dev" && state.hasDevDefault) {
+    return state.devValue;
+  }
+  if (state.hasDefault) {
+    return state.defaultValue;
+  }
+  if (state.optional) {
+    return OMIT_VALUE;
+  }
+  missing.push({ path, name: state.name });
+  return OMIT_VALUE;
+}
+function resolveVarValue(value, sources, path, mode, missing) {
+  if (isEnvVarDescriptor(value)) {
+    return resolveDescriptorValue(value, sources, path, mode, missing);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => resolveVarValue(item, sources, [...path, String(index)], mode, missing)).filter((item) => item !== OMIT_VALUE);
+  }
+  if (isPlainObject(value)) {
+    const resolved = {};
+    for (const [key, childValue] of Object.entries(value)) {
+      const child = resolveVarValue(childValue, sources, [...path, key], mode, missing);
+      if (child !== OMIT_VALUE) {
+        resolved[key] = child;
+      }
+    }
+    return resolved;
+  }
+  return value;
+}
+function resolveVarsObject(vars, sources, mode, missing) {
+  if (!vars) {
+    return vars;
+  }
+  const resolved = resolveVarValue(vars, sources, [], mode, missing);
+  return resolved === OMIT_VALUE ? undefined : resolved;
+}
+async function resolveConfigEnvVars(config, options) {
+  const startDir = options.configPath ? dirname(resolve(options.cwd, options.configPath)) : options.cwd;
+  const dotenv = await loadDevflareDotenv(startDir);
+  const sources = {
+    ...dotenv.values,
+    ...process.env
+  };
+  const missing = [];
+  const vars = resolveVarsObject(config.vars, sources, options.mode, missing);
+  if (missing.length > 0) {
+    throw new EnvVarResolutionError(missing, options.mode);
+  }
+  return vars === config.vars ? config : {
+    ...config,
+    vars
+  };
+}
+
+// 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(env2) {
+  const explicitIdentifier = env2.DEVFLARE_PREVIEW_IDENTIFIER?.trim();
+  if (explicitIdentifier) {
+    return {
+      identifier: normalizePreviewFragment(explicitIdentifier),
+      source: "env-identifier"
+    };
+  }
+  const previewPr = env2.DEVFLARE_PREVIEW_PR?.trim();
+  if (previewPr) {
+    return {
+      identifier: normalizePreviewFragment(`pr-${previewPr}`),
+      source: "env-pr"
+    };
+  }
+  const previewBranch = env2.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 env2 = options.env ?? process.env;
+  const envIdentifier = getPreviewIdentifierFromEnv(env2);
+  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 { env, isEnvVarDescriptor, getDevflareDotenvPaths, loadDevflareDotenvIntoProcess, EnvVarResolutionError, resolveConfigEnvVars, resolvePreviewIdentifier, preview, isPreviewScopedName, materializePreviewScopedString, materializePreviewScopedConfig };