devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/index-thna1tkd.js

@@ -0,0 +1,280 @@
+import {
+  getSingleBrowserBindingName,
+  normalizeD1Binding,
+  normalizeDOBinding,
+  normalizeHyperdriveBinding,
+  normalizeKVBinding,
+  resolveConfigForEnvironment
+} from "./index-0apbm26n.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/config/compiler.ts
+import { basename, isAbsolute, relative, resolve } from "pathe";
+function getWranglerD1DatabaseId(bindingName, bindingConfig) {
+  const normalized = normalizeD1Binding(bindingConfig);
+  if (normalized.databaseId) {
+    return normalized.databaseId;
+  }
+  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 getWranglerKVNamespaceId(bindingName, bindingConfig) {
+  const normalized = normalizeKVBinding(bindingConfig);
+  if (normalized.namespaceId) {
+    return normalized.namespaceId;
+  }
+  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 getWranglerHyperdriveId(bindingName, bindingConfig) {
+  const normalized = normalizeHyperdriveBinding(bindingConfig);
+  if (normalized.configurationId) {
+    return normalized.configurationId;
+  }
+  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) {
+  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);
+  }
+  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) {
+  const wranglerConfig = compileConfig(config, environment);
+  return { ...wranglerConfig };
+}
+function compileBindings(bindings, result) {
+  if (bindings.kv) {
+    result.kv_namespaces = Object.entries(bindings.kv).map(([binding, namespace]) => ({
+      binding,
+      id: getWranglerKVNamespaceId(binding, namespace)
+    }));
+  }
+  if (bindings.d1) {
+    result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => ({
+      binding,
+      database_id: getWranglerD1DatabaseId(binding, database_id)
+    }));
+  }
+  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]) => ({
+      binding,
+      id: getWranglerHyperdriveId(binding, config)
+    }));
+  }
+  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;
+}
+export { compileConfig, compileToProgrammaticConfig, stringifyConfig, isolateViteBuildOutputPaths, rebaseWranglerConfigPaths, writeWranglerConfig };

package/dist/index-v5nmqthy.js

@@ -0,0 +1,74 @@
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./index-6psz1h4c.js";
+import {
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  getWorkspaceAccountId
+} from "./index-xk9djfjp.js";
+
+// src/cli/command-utils.ts
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function resolveNamedSelection(options) {
+  if (options.explicitValue) {
+    return {
+      value: options.explicitValue,
+      source: "option"
+    };
+  }
+  if (options.fallbackValue) {
+    return {
+      value: options.fallbackValue,
+      source: "arg"
+    };
+  }
+  if (options.configuredValue) {
+    return {
+      value: options.configuredValue,
+      source: "config"
+    };
+  }
+  return {
+    value: undefined,
+    source: "none"
+  };
+}
+async function getConfiguredAccountId(cwd) {
+  const workspaceAccountId = getWorkspaceAccountId();
+  if (workspaceAccountId) {
+    return workspaceAccountId;
+  }
+  const envAccountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+  if (envAccountId) {
+    return envAccountId;
+  }
+  const configPath = await resolveConfigPath(cwd);
+  if (!configPath) {
+    return;
+  }
+  try {
+    const config = await loadConfig({ cwd });
+    return config.accountId;
+  } catch {
+    return;
+  }
+}
+async function resolveCloudflareAccountId(options) {
+  if (options.explicitAccountId) {
+    return options.explicitAccountId;
+  }
+  if (options.configuredAccountId) {
+    return options.configuredAccountId;
+  }
+  const primaryAccount = await getPrimaryAccount(options.apiOptions);
+  if (!primaryAccount) {
+    return;
+  }
+  const effective = await getEffectiveAccountId(primaryAccount.id);
+  return effective.accountId;
+}
+
+export { asOptionalString, resolveNamedSelection, getConfiguredAccountId, resolveCloudflareAccountId };

package/dist/{index-n932ytmq.js → index-vt4yxkmf.js}

@@ -9,10 +9,10 @@ import {
   parseJsonMsg,
   serializeValue,
   stringifyJsonMsg
-} from "./index-59df49vn.js";
+} from "./index-9ba1etyz.js";
 import {
   normalizeSendEmailMessage
-} from "./index-fef08w43.js";
+} from "./index-h18pxvzs.js";
 
 // src/bridge/server.ts
 var server_default = {