devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/index-47w35sft.js

@@ -0,0 +1,244 @@
+import {
+  normalizeArtifactsBinding,
+  normalizeDispatchNamespaceBinding,
+  normalizeHyperdriveBinding,
+  normalizeImagesBinding,
+  normalizeMediaBinding,
+  normalizeMtlsCertificateBinding,
+  normalizePipelineBinding,
+  normalizeSecretsStoreBinding,
+  normalizeWorkflowBinding
+} from "./index-syscwrjp.js";
+
+// src/dev-server/miniflare-bindings.ts
+function buildQueueProducers(bindings) {
+  if (!bindings.queues?.producers) {
+    return;
+  }
+  const producers = {};
+  for (const [bindingName, queueName] of Object.entries(bindings.queues.producers)) {
+    producers[bindingName] = { queueName };
+  }
+  return producers;
+}
+function buildQueueConsumers(bindings) {
+  if (!bindings.queues?.consumers || bindings.queues.consumers.length === 0) {
+    return;
+  }
+  const consumers = {};
+  for (const consumer of bindings.queues.consumers) {
+    consumers[consumer.queue] = {
+      ...consumer.maxBatchSize !== undefined && { maxBatchSize: consumer.maxBatchSize },
+      ...consumer.maxBatchTimeout !== undefined && { maxBatchTimeout: consumer.maxBatchTimeout },
+      ...consumer.maxRetries !== undefined && { maxRetries: consumer.maxRetries },
+      ...consumer.deadLetterQueue && { deadLetterQueue: consumer.deadLetterQueue },
+      ...consumer.maxConcurrency !== undefined && { maxConcurrency: consumer.maxConcurrency },
+      ...consumer.retryDelay !== undefined && { retryDelay: consumer.retryDelay }
+    };
+  }
+  return consumers;
+}
+function buildRateLimitsConfig(bindings) {
+  if (!bindings.rateLimits) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.rateLimits).map(([name, binding]) => [
+    name,
+    {
+      simple: {
+        limit: binding.simple.limit,
+        period: binding.simple.period
+      }
+    }
+  ]));
+}
+function buildVersionMetadataConfig(bindings) {
+  return bindings.versionMetadata?.binding;
+}
+function buildWorkerLoadersConfig(bindings) {
+  if (!bindings.workerLoaders) {
+    return;
+  }
+  return Object.fromEntries(Object.keys(bindings.workerLoaders).map((bindingName) => [bindingName, {}]));
+}
+function buildMtlsCertificatesConfig(bindings) {
+  if (!bindings.mtlsCertificates) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.mtlsCertificates).map(([bindingName, binding]) => {
+    const normalized = normalizeMtlsCertificateBinding(binding);
+    return [
+      bindingName,
+      {
+        certificate_id: normalized.certificateId
+      }
+    ];
+  }));
+}
+function buildDispatchNamespacesConfig(bindings) {
+  if (!bindings.dispatchNamespaces) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.dispatchNamespaces).map(([bindingName, binding]) => {
+    const normalized = normalizeDispatchNamespaceBinding(binding);
+    return [
+      bindingName,
+      {
+        namespace: normalized.namespace
+      }
+    ];
+  }));
+}
+function buildWorkflowsConfig(bindings) {
+  if (!bindings.workflows) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.workflows).map(([bindingName, binding]) => {
+    const normalized = normalizeWorkflowBinding(binding);
+    return [
+      bindingName,
+      {
+        name: normalized.name,
+        className: normalized.className,
+        ...normalized.scriptName && { scriptName: normalized.scriptName },
+        ...normalized.limits && { stepLimit: normalized.limits.steps }
+      }
+    ];
+  }));
+}
+function buildPipelinesConfig(bindings) {
+  if (!bindings.pipelines) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.pipelines).map(([bindingName, binding]) => {
+    const normalized = normalizePipelineBinding(binding);
+    return [
+      bindingName,
+      typeof binding === "string" ? normalized.pipeline : { pipeline: normalized.pipeline }
+    ];
+  }));
+}
+function getHyperdriveLocalConnectionString(bindingName, binding) {
+  const cloudflareEnvName = `CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_${bindingName}`;
+  const wranglerEnvName = `WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_${bindingName}`;
+  const envValue = process.env[cloudflareEnvName] ?? process.env[wranglerEnvName];
+  if (envValue?.trim()) {
+    return envValue;
+  }
+  const normalized = normalizeHyperdriveBinding(binding);
+  return normalized.localConnectionString;
+}
+function buildHyperdrivesConfig(bindings) {
+  if (!bindings.hyperdrive) {
+    return;
+  }
+  const hyperdrives = Object.fromEntries(Object.entries(bindings.hyperdrive).map(([bindingName, binding]) => {
+    const localConnectionString = getHyperdriveLocalConnectionString(bindingName, binding);
+    return localConnectionString ? [bindingName, localConnectionString] : null;
+  }).filter((entry) => entry !== null));
+  return Object.keys(hyperdrives).length > 0 ? hyperdrives : undefined;
+}
+function buildImagesConfig(bindings) {
+  if (!bindings.images) {
+    return;
+  }
+  const [entry] = Object.entries(bindings.images);
+  if (!entry) {
+    return;
+  }
+  const [bindingName, binding] = entry;
+  const normalized = normalizeImagesBinding(bindingName, binding);
+  return {
+    binding: normalized.binding
+  };
+}
+function buildMediaConfig(bindings) {
+  if (!bindings.media) {
+    return;
+  }
+  const [entry] = Object.entries(bindings.media);
+  if (!entry) {
+    return;
+  }
+  const [bindingName, binding] = entry;
+  const normalized = normalizeMediaBinding(bindingName, binding);
+  return {
+    binding: normalized.binding
+  };
+}
+function buildArtifactsConfig(bindings) {
+  if (!bindings.artifacts) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.artifacts).map(([bindingName, binding]) => {
+    const normalized = normalizeArtifactsBinding(binding);
+    return [
+      bindingName,
+      {
+        namespace: normalized.namespace
+      }
+    ];
+  }));
+}
+function buildAiSearchNamespacesConfig(bindings) {
+  if (!bindings.aiSearchNamespaces) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.aiSearchNamespaces).map(([bindingName, binding]) => [
+    bindingName,
+    {
+      namespace: binding.namespace
+    }
+  ]));
+}
+function buildAiSearchInstancesConfig(bindings) {
+  if (!bindings.aiSearch) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(bindings.aiSearch).map(([bindingName, binding]) => [
+    bindingName,
+    {
+      instance_name: binding.instanceName
+    }
+  ]));
+}
+function buildSecretsStoreConfig(bindings, defaultSecretsStoreId, excludedBindingNames = new Set) {
+  if (!bindings.secretsStore) {
+    return;
+  }
+  const entries = Object.entries(bindings.secretsStore).flatMap(([bindingName, binding]) => {
+    if (excludedBindingNames.has(bindingName)) {
+      return [];
+    }
+    const normalized = normalizeSecretsStoreBinding(binding, defaultSecretsStoreId, bindingName);
+    return [[
+      bindingName,
+      {
+        store_id: normalized.storeId,
+        secret_name: normalized.secretName
+      }
+    ]];
+  });
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function buildSendEmailConfig(bindings) {
+  if (!bindings.sendEmail) {
+    return;
+  }
+  return {
+    send_email: Object.entries(bindings.sendEmail).map(([name, binding]) => ({
+      name,
+      ...binding.destinationAddress && {
+        destination_address: binding.destinationAddress
+      },
+      ...binding.allowedDestinationAddresses && {
+        allowed_destination_addresses: binding.allowedDestinationAddresses
+      },
+      ...binding.allowedSenderAddresses && {
+        allowed_sender_addresses: binding.allowedSenderAddresses
+      }
+    }))
+  };
+}
+
+export { buildQueueProducers, buildQueueConsumers, buildRateLimitsConfig, buildVersionMetadataConfig, buildWorkerLoadersConfig, buildMtlsCertificatesConfig, buildDispatchNamespacesConfig, buildWorkflowsConfig, buildPipelinesConfig, buildHyperdrivesConfig, buildImagesConfig, buildMediaConfig, buildArtifactsConfig, buildAiSearchNamespacesConfig, buildAiSearchInstancesConfig, buildSecretsStoreConfig, buildSendEmailConfig };

package/dist/index-48rxsj95.js

@@ -0,0 +1,365 @@
+import {
+  getSingleBrowserBindingName,
+  normalizeD1Binding,
+  normalizeDOBinding,
+  normalizeHyperdriveBinding,
+  normalizeKVBinding,
+  resolveConfigForEnvironment
+} from "./index-bc5pvbbd.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/config/compiler.ts
+import { basename, isAbsolute, relative, resolve } from "pathe";
+function getWranglerD1DatabaseBinding(bindingName, bindingConfig, options = {}) {
+  const normalized = normalizeD1Binding(bindingConfig);
+  if (normalized.databaseId) {
+    return {
+      binding: bindingName,
+      database_id: normalized.databaseId
+    };
+  }
+  if (options.preserveNamedBindings && normalized.name) {
+    return {
+      binding: bindingName,
+      database_name: normalized.name
+    };
+  }
+  throw new Error(`D1 binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerKVNamespaceBinding(bindingName, bindingConfig, options = {}) {
+  const normalized = normalizeKVBinding(bindingConfig);
+  if (normalized.namespaceId) {
+    return {
+      binding: bindingName,
+      id: normalized.namespaceId
+    };
+  }
+  if (options.preserveNamedBindings && normalized.name) {
+    return {
+      binding: bindingName,
+      name: normalized.name
+    };
+  }
+  throw new Error(`KV binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerHyperdriveBinding(bindingName, bindingConfig, options = {}) {
+  const normalized = normalizeHyperdriveBinding(bindingConfig);
+  if (normalized.configurationId) {
+    return {
+      binding: bindingName,
+      id: normalized.configurationId
+    };
+  }
+  if (options.preserveNamedBindings && normalized.name) {
+    return {
+      binding: bindingName,
+      name: normalized.name
+    };
+  }
+  throw new Error(`Hyperdrive binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerBrowserBinding(browserBindings) {
+  const bindingName = getSingleBrowserBindingName(browserBindings);
+  return bindingName ? { binding: bindingName } : undefined;
+}
+function compileWranglerMigrations(migrations) {
+  return migrations.map((migration) => ({
+    tag: migration.tag,
+    ...migration.new_classes && { new_classes: migration.new_classes },
+    ...migration.renamed_classes && {
+      renamed_classes: migration.renamed_classes.map((renamedClass) => ({
+        from: renamedClass.from,
+        to: renamedClass.to
+      }))
+    },
+    ...migration.deleted_classes && { deleted_classes: migration.deleted_classes },
+    ...migration.new_sqlite_classes && { new_sqlite_classes: migration.new_sqlite_classes }
+  }));
+}
+function compileConfig(config, environment) {
+  return compileConfigInternal(config, environment);
+}
+function compileBuildConfig(config, environment) {
+  return compileConfigInternal(config, environment, {
+    preserveNamedBindings: true
+  });
+}
+function compileConfigInternal(config, environment, options = {}) {
+  const mergedConfig = resolveConfigForEnvironment(config, environment);
+  const result = {
+    name: mergedConfig.name,
+    compatibility_date: mergedConfig.compatibilityDate,
+    preview_urls: true,
+    workers_dev: true
+  };
+  if (mergedConfig.accountId) {
+    result.account_id = mergedConfig.accountId;
+  }
+  const mainEntry = mergedConfig.files?.fetch;
+  if (typeof mainEntry === "string") {
+    result.main = mainEntry;
+  }
+  if (mergedConfig.compatibilityFlags && mergedConfig.compatibilityFlags.length > 0) {
+    result.compatibility_flags = mergedConfig.compatibilityFlags;
+  }
+  if (mergedConfig.bindings) {
+    compileBindings(mergedConfig.bindings, result, options);
+  }
+  if (mergedConfig.triggers?.crons && mergedConfig.triggers.crons.length > 0) {
+    result.triggers = { crons: mergedConfig.triggers.crons };
+  }
+  if (mergedConfig.vars && Object.keys(mergedConfig.vars).length > 0) {
+    result.vars = mergedConfig.vars;
+  }
+  if (mergedConfig.routes && mergedConfig.routes.length > 0) {
+    result.routes = mergedConfig.routes.map((route) => ({
+      pattern: route.pattern,
+      ...route.zone_name && { zone_name: route.zone_name },
+      ...route.zone_id && { zone_id: route.zone_id },
+      ...route.custom_domain !== undefined && { custom_domain: route.custom_domain }
+    }));
+  }
+  if (mergedConfig.assets && mergedConfig.assets.directory) {
+    result.assets = {
+      directory: mergedConfig.assets.directory,
+      ...mergedConfig.assets.binding && { binding: mergedConfig.assets.binding }
+    };
+  }
+  if (mergedConfig.observability) {
+    result.observability = mergedConfig.observability;
+  }
+  if (mergedConfig.limits) {
+    result.limits = mergedConfig.limits;
+  }
+  if (mergedConfig.migrations && mergedConfig.migrations.length > 0) {
+    result.migrations = compileWranglerMigrations(mergedConfig.migrations);
+  }
+  if (mergedConfig.wrangler?.passthrough) {
+    Object.assign(result, mergedConfig.wrangler.passthrough);
+  }
+  return result;
+}
+function compileToProgrammaticConfig(config, environment, options = {}) {
+  return options.preserveNamedBindings ? compileBuildConfig(config, environment) : compileConfig(config, environment);
+}
+function compileBindings(bindings, result, options = {}) {
+  if (bindings.kv) {
+    result.kv_namespaces = Object.entries(bindings.kv).map(([binding, namespace]) => {
+      return getWranglerKVNamespaceBinding(binding, namespace, options);
+    });
+  }
+  if (bindings.d1) {
+    result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => {
+      return getWranglerD1DatabaseBinding(binding, database_id, options);
+    });
+  }
+  if (bindings.r2) {
+    result.r2_buckets = Object.entries(bindings.r2).map(([binding, bucket_name]) => ({
+      binding,
+      bucket_name
+    }));
+  }
+  if (bindings.durableObjects) {
+    result.durable_objects = {
+      bindings: Object.entries(bindings.durableObjects).map(([name, config]) => {
+        const normalized = normalizeDOBinding(config);
+        const binding = {
+          name,
+          class_name: normalized.className
+        };
+        if (normalized.scriptName) {
+          binding.script_name = normalized.scriptName;
+        }
+        return binding;
+      })
+    };
+  }
+  if (bindings.queues) {
+    result.queues = {};
+    if (bindings.queues.producers) {
+      result.queues.producers = Object.entries(bindings.queues.producers).map(([binding, queue]) => ({ binding, queue }));
+    }
+    if (bindings.queues.consumers) {
+      result.queues.consumers = bindings.queues.consumers.map((consumer) => ({
+        queue: consumer.queue,
+        ...consumer.maxBatchSize && { max_batch_size: consumer.maxBatchSize },
+        ...consumer.maxBatchTimeout && { max_batch_timeout: consumer.maxBatchTimeout },
+        ...consumer.maxRetries && { max_retries: consumer.maxRetries },
+        ...consumer.deadLetterQueue && { dead_letter_queue: consumer.deadLetterQueue },
+        ...consumer.maxConcurrency && { max_concurrency: consumer.maxConcurrency },
+        ...consumer.retryDelay && { retry_delay: consumer.retryDelay }
+      }));
+    }
+  }
+  if (bindings.services) {
+    result.services = Object.entries(bindings.services).map(([binding, config]) => ({
+      binding,
+      service: config.service,
+      ...config.entrypoint && { entrypoint: config.entrypoint },
+      ...config.environment && { environment: config.environment }
+    }));
+  }
+  if (bindings.ai && bindings.ai.binding) {
+    result.ai = { binding: bindings.ai.binding };
+  }
+  if (bindings.vectorize) {
+    result.vectorize = Object.entries(bindings.vectorize).map(([binding, config]) => ({
+      binding,
+      index_name: config.indexName
+    }));
+  }
+  if (bindings.hyperdrive) {
+    result.hyperdrive = Object.entries(bindings.hyperdrive).map(([binding, config]) => {
+      return getWranglerHyperdriveBinding(binding, config, options);
+    });
+  }
+  const browserBinding = getWranglerBrowserBinding(bindings.browser);
+  if (browserBinding) {
+    result.browser = browserBinding;
+  }
+  if (bindings.analyticsEngine) {
+    result.analytics_engine_datasets = Object.entries(bindings.analyticsEngine).map(([binding, config]) => ({
+      binding,
+      dataset: config.dataset
+    }));
+  }
+  if (bindings.sendEmail) {
+    result.send_email = Object.entries(bindings.sendEmail).map(([name, config]) => ({
+      name,
+      ...config.destinationAddress && {
+        destination_address: config.destinationAddress
+      },
+      ...config.allowedDestinationAddresses && {
+        allowed_destination_addresses: config.allowedDestinationAddresses
+      },
+      ...config.allowedSenderAddresses && {
+        allowed_sender_addresses: config.allowedSenderAddresses
+      }
+    }));
+  }
+}
+function stringifyConfig(config) {
+  const header = `// Generated by devflare — Do not edit directly
+// Edit devflare.config.ts instead
+
+`;
+  return header + JSON.stringify(config, null, "\t");
+}
+function rebasePathForConfigDir(projectRoot, configDir, pathValue) {
+  const absolutePath = isAbsolute(pathValue) ? pathValue : resolve(projectRoot, pathValue);
+  return relative(configDir, absolutePath).replace(/\\/g, "/");
+}
+function pathIsInsideDirectory(directoryPath, candidatePath) {
+  const normalizedDirectoryPath = directoryPath.replace(/\\/g, "/");
+  const normalizedCandidatePath = candidatePath.replace(/\\/g, "/");
+  return normalizedCandidatePath === normalizedDirectoryPath || normalizedCandidatePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+function isolateViteBuildOutputPaths(projectRoot, config) {
+  const assetsDirectory = config.assets?.directory;
+  if (!assetsDirectory) {
+    return config;
+  }
+  const isolatedAssetsDirectoryPath = resolve(projectRoot, ".devflare", "vite-build-output", basename(assetsDirectory));
+  const isolatedAssetsDirectory = relative(projectRoot, isolatedAssetsDirectoryPath).replace(/\\/g, "/");
+  const isolatedConfig = {
+    ...config,
+    assets: config.assets ? {
+      ...config.assets,
+      directory: isolatedAssetsDirectory
+    } : config.assets
+  };
+  if (!config.main) {
+    return isolatedConfig;
+  }
+  const originalAssetsDirectoryPath = resolve(projectRoot, assetsDirectory);
+  const originalMainEntryPath = resolve(projectRoot, config.main);
+  if (!pathIsInsideDirectory(originalAssetsDirectoryPath, originalMainEntryPath)) {
+    return isolatedConfig;
+  }
+  const relativeMainEntryPath = relative(originalAssetsDirectoryPath, originalMainEntryPath);
+  const isolatedMainEntryPath = resolve(isolatedAssetsDirectoryPath, relativeMainEntryPath);
+  return {
+    ...isolatedConfig,
+    main: relative(projectRoot, isolatedMainEntryPath).replace(/\\/g, "/")
+  };
+}
+function rebaseWranglerConfigPaths(projectRoot, configDir, config) {
+  return {
+    ...config,
+    ...config.main ? { main: rebasePathForConfigDir(projectRoot, configDir, config.main) } : {},
+    ...config.assets?.directory ? {
+      assets: {
+        ...config.assets,
+        directory: rebasePathForConfigDir(projectRoot, configDir, config.assets.directory)
+      }
+    } : {}
+  };
+}
+async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
+  const { resolve: resolve2 } = await import("pathe");
+  const fs = await import("node:fs/promises");
+  try {
+    await fs.mkdir(cwd, { recursive: true });
+  } catch {}
+  const content = stringifyConfig(config);
+  const wranglerPath = resolve2(cwd, filename);
+  await fs.writeFile(wranglerPath, content, "utf-8");
+  return wranglerPath;
+}
+async function readWranglerConfig(filePath) {
+  const fs = await import("node:fs/promises");
+  const { parse } = await import("jsonc-parser");
+  const content = await fs.readFile(filePath, "utf-8");
+  const parsedConfig = parse(content);
+  if (!parsedConfig || typeof parsedConfig !== "object") {
+    throw new Error(`Could not parse Wrangler config at ${filePath}.`);
+  }
+  return parsedConfig;
+}
+
+// src/config/service-bindings-validation.ts
+class ServiceBindingValidationError extends Error {
+  code = "SERVICE_BINDING_VALIDATION_ERROR";
+  missing;
+  constructor(missing, accountId) {
+    super(`Service binding(s) reference worker(s) that do not exist in Cloudflare account ${accountId}: ` + missing.join(", ") + `. Check the 'services' map in devflare.config.ts for typos or deploy the target worker(s) first.`);
+    this.name = "ServiceBindingValidationError";
+    this.missing = missing;
+  }
+}
+function collectReferencedServiceNames(config) {
+  const services = config.bindings?.services;
+  if (!services) {
+    return [];
+  }
+  const names = new Set;
+  for (const binding of Object.values(services)) {
+    if (binding && typeof binding === "object" && typeof binding.service === "string") {
+      const name = binding.service.trim();
+      if (name.length > 0) {
+        names.add(name);
+      }
+    }
+  }
+  return [...names];
+}
+async function validateServiceBindings(config, accountId, options) {
+  const referenced = collectReferencedServiceNames(config);
+  if (referenced.length === 0) {
+    return;
+  }
+  const selfName = options.selfWorkerName?.trim();
+  const toValidate = selfName ? referenced.filter((name) => name !== selfName) : referenced;
+  if (toValidate.length === 0) {
+    return;
+  }
+  const workers = await options.listWorkers(accountId);
+  const workerNames = new Set(workers.map((worker) => worker.name));
+  const missing = toValidate.filter((name) => !workerNames.has(name));
+  if (missing.length > 0) {
+    throw new ServiceBindingValidationError(missing, accountId);
+  }
+}
+export { compileConfig, compileBuildConfig, compileToProgrammaticConfig, stringifyConfig, isolateViteBuildOutputPaths, rebaseWranglerConfigPaths, writeWranglerConfig, readWranglerConfig, ServiceBindingValidationError, validateServiceBindings };