devflare 1.0.0-next.13 → 1.0.0-next.15

package/dist/{index-nb0bqtx7.js → index-001mw014.js}

@@ -12,6 +12,310 @@ import {
 // src/bundler/worker-bundler.ts
 import { fileURLToPath } from "node:url";
 import { dirname, resolve } from "pathe";
+
+// src/bundler/worker-compat.ts
+import MagicString from "magic-string";
+import ts from "typescript";
+var WORKER_DYNAMIC_IMPORT_ERROR = "Devflare worker bundles cannot contain unresolved dynamic import() expressions because Miniflare/workerd reject dynamic module specifiers";
+function getScriptKind(id) {
+  if (id.endsWith(".tsx")) {
+    return ts.ScriptKind.TSX;
+  }
+  if (id.endsWith(".ts") || id.endsWith(".mts") || id.endsWith(".cts")) {
+    return ts.ScriptKind.TS;
+  }
+  if (id.endsWith(".jsx")) {
+    return ts.ScriptKind.JSX;
+  }
+  return ts.ScriptKind.JS;
+}
+function createSourceFile(code, id) {
+  return ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true, getScriptKind(id));
+}
+function hasExportModifier(node) {
+  if (!ts.canHaveModifiers(node)) {
+    return false;
+  }
+  return ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isConstVariableStatement(statement) {
+  return ts.isVariableStatement(statement) && (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+}
+function quoteString(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, `\\'`)}'`;
+}
+function resolveLiteralImportSpecifier(expression, constStrings) {
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isParenthesizedExpression(expression)) {
+    return resolveLiteralImportSpecifier(expression.expression, constStrings);
+  }
+  if (ts.isIdentifier(expression)) {
+    return constStrings.get(expression.text) ?? null;
+  }
+  return null;
+}
+function collectTopLevelConstStrings(sourceFile) {
+  const constStrings = new Map;
+  for (const statement of sourceFile.statements) {
+    if (!isConstVariableStatement(statement)) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+        continue;
+      }
+      const literal = resolveLiteralImportSpecifier(declaration.initializer, constStrings);
+      if (literal !== null) {
+        constStrings.set(declaration.name.text, literal);
+      }
+    }
+  }
+  return constStrings;
+}
+function unwrapDynamicImportExpression(expression) {
+  if (ts.isParenthesizedExpression(expression)) {
+    return unwrapDynamicImportExpression(expression.expression);
+  }
+  if (ts.isAwaitExpression(expression)) {
+    return unwrapDynamicImportExpression(expression.expression);
+  }
+  if (!ts.isCallExpression(expression) || expression.expression.kind !== ts.SyntaxKind.ImportKeyword) {
+    return null;
+  }
+  return expression;
+}
+function getWrapperBodyExpression(body) {
+  if (!body) {
+    return null;
+  }
+  if (!ts.isBlock(body)) {
+    return body;
+  }
+  if (body.statements.length !== 1) {
+    return null;
+  }
+  const [statement] = body.statements;
+  if (!ts.isReturnStatement(statement) || !statement.expression) {
+    return null;
+  }
+  return statement.expression;
+}
+function createImportWrapper(name, parameterName, body, sourceFile) {
+  const bodyExpression = getWrapperBodyExpression(body);
+  if (!bodyExpression) {
+    return null;
+  }
+  const importExpression = unwrapDynamicImportExpression(bodyExpression);
+  if (!importExpression || importExpression.arguments.length < 1) {
+    return null;
+  }
+  const [importArgument] = importExpression.arguments;
+  if (!ts.isIdentifier(importArgument) || importArgument.text !== parameterName || !body) {
+    return null;
+  }
+  return {
+    name,
+    parameterName,
+    bodyStart: body.getStart(sourceFile),
+    bodyEnd: body.getEnd(),
+    specifiers: new Set,
+    hasUnsupportedCalls: false
+  };
+}
+function collectImportWrappers(sourceFile) {
+  const wrappers = new Map;
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name && !hasExportModifier(statement) && statement.parameters.length === 1 && ts.isIdentifier(statement.parameters[0]?.name)) {
+      const wrapper = createImportWrapper(statement.name.text, statement.parameters[0].name.text, statement.body, sourceFile);
+      if (wrapper) {
+        wrappers.set(wrapper.name, wrapper);
+      }
+    }
+    if (!isConstVariableStatement(statement) || hasExportModifier(statement)) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+        continue;
+      }
+      if (!ts.isArrowFunction(declaration.initializer) && !ts.isFunctionExpression(declaration.initializer)) {
+        continue;
+      }
+      if (declaration.initializer.parameters.length !== 1 || !ts.isIdentifier(declaration.initializer.parameters[0]?.name)) {
+        continue;
+      }
+      const wrapper = createImportWrapper(declaration.name.text, declaration.initializer.parameters[0].name.text, declaration.initializer.body, sourceFile);
+      if (wrapper) {
+        wrappers.set(wrapper.name, wrapper);
+      }
+    }
+  }
+  return wrappers;
+}
+function collectWrapperCallSpecifiers(sourceFile, wrappers, constStrings) {
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const wrapper = wrappers.get(node.expression.text);
+      if (wrapper) {
+        if (node.arguments.length !== 1) {
+          wrapper.hasUnsupportedCalls = true;
+        } else {
+          const specifier = resolveLiteralImportSpecifier(node.arguments[0], constStrings);
+          if (specifier === null) {
+            wrapper.hasUnsupportedCalls = true;
+          } else {
+            wrapper.specifiers.add(specifier);
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+}
+function createImportIdentifier(specifierToIdentifier, specifier) {
+  const existing = specifierToIdentifier.get(specifier);
+  if (existing) {
+    return existing;
+  }
+  const identifier = `__devflareDynamicImport${specifierToIdentifier.size}`;
+  specifierToIdentifier.set(specifier, identifier);
+  return identifier;
+}
+function buildWrapperBody(wrapper, specifierToIdentifier) {
+  const cases = Array.from(wrapper.specifiers).sort((left, right) => left.localeCompare(right)).map((specifier) => {
+    const identifier = createImportIdentifier(specifierToIdentifier, specifier);
+    return `		case ${quoteString(specifier)}:
+			return Promise.resolve(${identifier})`;
+  }).join(`
+`);
+  return `{
+		switch (${wrapper.parameterName}) {
+${cases}
+			default:
+				return Promise.reject(new Error(\`Unsupported dynamic import in Devflare worker bundle: \${${wrapper.parameterName}}\`))
+		}
+	}`;
+}
+function findContainingWrapper(callExpression, wrappers, sourceFile) {
+  const start = callExpression.getStart(sourceFile);
+  const end = callExpression.getEnd();
+  for (const wrapper of wrappers) {
+    if (start >= wrapper.bodyStart && end <= wrapper.bodyEnd) {
+      return wrapper;
+    }
+  }
+  return null;
+}
+function transformWorkerDynamicImports(code, id) {
+  const sourceFile = createSourceFile(code, id);
+  const constStrings = collectTopLevelConstStrings(sourceFile);
+  const wrappers = collectImportWrappers(sourceFile);
+  collectWrapperCallSpecifiers(sourceFile, wrappers, constStrings);
+  const transformableWrappers = Array.from(wrappers.values()).filter((wrapper) => {
+    return !wrapper.hasUnsupportedCalls && wrapper.specifiers.size > 0;
+  });
+  const replacements = [];
+  const specifierToIdentifier = new Map;
+  function visit(node) {
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const containingWrapper = findContainingWrapper(node, transformableWrappers, sourceFile);
+      if (containingWrapper && node.arguments.length === 1 && ts.isIdentifier(node.arguments[0]) && node.arguments[0].text === containingWrapper.parameterName) {
+        return;
+      }
+      const [argument] = node.arguments;
+      if (!argument) {
+        return;
+      }
+      const specifier = resolveLiteralImportSpecifier(argument, constStrings);
+      if (specifier !== null) {
+        replacements.push({
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          text: `Promise.resolve(${createImportIdentifier(specifierToIdentifier, specifier)})`
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (replacements.length === 0 && transformableWrappers.length === 0) {
+    return null;
+  }
+  const s = new MagicString(code);
+  for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+    s.overwrite(replacement.start, replacement.end, replacement.text);
+  }
+  for (const wrapper of transformableWrappers.sort((left, right) => right.bodyStart - left.bodyStart)) {
+    s.overwrite(wrapper.bodyStart, wrapper.bodyEnd, buildWrapperBody(wrapper, specifierToIdentifier));
+  }
+  if (specifierToIdentifier.size > 0) {
+    const importBlock = Array.from(specifierToIdentifier.entries()).map(([specifier, identifier]) => `import * as ${identifier} from ${quoteString(specifier)}`).join(`
+`);
+    const importInsertPosition = code.startsWith("#!") ? code.indexOf(`
+`) === -1 ? code.length : code.indexOf(`
+`) + 1 : 0;
+    s.appendLeft(importInsertPosition, `${importBlock}
+`);
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({
+      source: id,
+      file: `${id}.map`,
+      includeContent: true
+    })
+  };
+}
+function findDynamicImportCalls(sourceFile) {
+  const calls = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      calls.push(node);
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return calls;
+}
+async function assertWorkerBundleHasNoDynamicImports(bundlePath) {
+  const fs = await import("node:fs/promises");
+  const code = await fs.readFile(bundlePath, "utf-8");
+  const sourceFile = createSourceFile(code, bundlePath);
+  const dynamicImports = findDynamicImportCalls(sourceFile);
+  if (dynamicImports.length === 0) {
+    return;
+  }
+  const examples = dynamicImports.slice(0, 3).map((callExpression) => {
+    const start = callExpression.getStart(sourceFile);
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+    const snippet = code.slice(start, callExpression.getEnd()).replace(/\s+/g, " ").trim();
+    return `- ${line + 1}:${character + 1} ${snippet}`;
+  }).join(`
+`);
+  throw new Error([
+    WORKER_DYNAMIC_IMPORT_ERROR,
+    `Bundle: ${bundlePath}`,
+    `Examples:
+${examples}`,
+    "Devflare can normalize literal import() calls and simple helper wrappers whose call sites are literal strings, but truly runtime-computed specifiers must be converted to static imports for worker bundles."
+  ].join(`
+
+`));
+}
+function createWorkerDynamicImportPlugin() {
+  return {
+    name: "devflare-worker-dynamic-imports",
+    transform(code, id) {
+      const result = transformWorkerDynamicImports(code, id);
+      return result ?? null;
+    }
+  };
+}
+
+// src/bundler/worker-bundler.ts
 function toArray(value) {
   return Array.isArray(value) ? value : [value];
 }
@@ -176,7 +480,7 @@ function resolveWorkerRolldownConfig(options) {
       target: userTarget ?? options.target,
       tsconfig: userTsconfig ?? resolve(options.cwd, "tsconfig.json"),
       external: mergeExternalOptions(defaultExternalModules, userExternal),
-      plugins: mergePluginOptions(undefined, userPlugins),
+      plugins: mergePluginOptions(createWorkerDynamicImportPlugin(), userPlugins),
       resolve: mergeResolveOptions({
         alias: options.alias
       }, userResolve)
@@ -214,6 +518,7 @@ async function bundleWorkerEntry(options) {
   const bundle = await rolldown(inputOptions);
   try {
     await bundle.write(outputOptions);
+    await assertWorkerBundleHasNoDynamicImports(options.outFile);
   } finally {
     await bundle.close();
   }
@@ -368,7 +673,7 @@ function resolveDOBundleRolldownConfig(options) {
       platform: "neutral",
       tsconfig: userTsconfig ?? resolve2(options.cwd, "tsconfig.json"),
       external: mergeExternalOptions2(defaultExternalModules, userExternal),
-      plugins: mergePluginOptions2(undefined, userPlugins),
+      plugins: mergePluginOptions2(createWorkerDynamicImportPlugin(), userPlugins),
       resolve: mergeResolveOptions2({
         alias: {
           debug: options.debugShimPath
@@ -437,6 +742,7 @@ export default createDebug
   });
   const bundle = await rolldown(inputOptions);
   await bundle.write(outputOptions);
+  await assertWorkerBundleHasNoDynamicImports(outFile);
   await bundle.close();
   try {
     await fs.unlink(tempFilePath);

package/dist/{index-xxwbb2nt.js → index-0rsa2c1t.js}

@@ -1,6 +1,7 @@
 import {
+  getLocalD1DatabaseIdentifier,
   normalizeDOBinding
-} from "./index-wyf3s77s.js";
+} from "./index-tksw7gpy.js";
 import {
   __require
 } from "./index-37x76zdn.js";
@@ -288,7 +289,9 @@ async function startMiniflareFromConfig(config, options = {}) {
     compatibilityFlags: config.compatibilityFlags,
     kvNamespaces: bindings.kv ? bindings.kv : undefined,
     r2Buckets: bindings.r2 ? bindings.r2 : undefined,
-    d1Databases: bindings.d1 ? bindings.d1 : undefined,
+    d1Databases: bindings.d1 ? Object.fromEntries(Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => {
+      return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
+    })) : undefined,
     queues: bindings.queues?.consumers?.map((c) => c.queue),
     sendEmail: bindings.sendEmail ? bindings.sendEmail : undefined,
     bindings: config.vars,

package/dist/{index-0kzg8wed.js → index-3a4mmn57.js}

@@ -42,7 +42,7 @@ import {
 import {
   startMiniflare,
   startMiniflareFromConfig
-} from "./index-xxwbb2nt.js";
+} from "./index-0rsa2c1t.js";
 import {
   BridgeClient,
   createEnvProxy,
@@ -53,17 +53,20 @@ import {
   wrapEnvSendEmailBindings
 } from "./index-fef08w43.js";
 import {
+  getLocalD1DatabaseIdentifier,
   loadConfig,
   normalizeDOBinding,
   resolveConfigPath
-} from "./index-wyf3s77s.js";
+} from "./index-tksw7gpy.js";
+import {
+  canProceedWithTest
+} from "./index-7bq4xq84.js";
 import {
-  canProceedWithTest,
   getApiToken,
   getEffectiveAccountId,
   getPrimaryAccount,
   isAuthenticated
-} from "./index-tfyxa77h.js";
+} from "./index-xdq9ery1.js";
 import {
   __require
 } from "./index-37x76zdn.js";
@@ -1350,8 +1353,11 @@ async function createTestContext(configPath) {
     mfConfig.kvNamespaces = Object.keys(config.bindings.kv);
   if (config.bindings?.r2)
     mfConfig.r2Buckets = Object.keys(config.bindings.r2);
-  if (config.bindings?.d1)
-    mfConfig.d1Databases = Object.keys(config.bindings.d1);
+  if (config.bindings?.d1) {
+    mfConfig.d1Databases = Object.fromEntries(Object.entries(config.bindings.d1).map(([bindingName, bindingConfig]) => {
+      return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
+    }));
+  }
   if (config.bindings?.queues?.producers) {
     const queueProducers = {};
     for (const [bindingName, queueName] of Object.entries(config.bindings.queues.producers)) {

package/dist/{index-rfhx0yd5.js → index-5s1bz1e0.js}

@@ -1,20 +1,20 @@
 import {
-  normalizeDOBinding
-} from "./index-wyf3s77s.js";
+  normalizeD1Binding,
+  normalizeDOBinding,
+  resolveConfigForEnvironment
+} from "./index-tksw7gpy.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
-// src/config/resolve.ts
-import { defu } from "defu";
-function resolveConfigForEnvironment(config, environment) {
-  if (environment && config.env?.[environment]) {
-    return defu(config.env[environment], config);
+// src/config/compiler.ts
+function getWranglerD1DatabaseId(bindingName, bindingConfig) {
+  const normalized = normalizeD1Binding(bindingConfig);
+  if (normalized.databaseId) {
+    return normalized.databaseId;
   }
-  return config;
+  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.`);
 }
-
-// src/config/compiler.ts
 function compileConfig(config, environment) {
   const mergedConfig = resolveConfigForEnvironment(config, environment);
   const result = {
@@ -93,7 +93,7 @@ function compileBindings(bindings, result) {
   if (bindings.d1) {
     result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => ({
       binding,
-      database_id
+      database_id: getWranglerD1DatabaseId(binding, database_id)
     }));
   }
   if (bindings.r2) {
@@ -199,4 +199,4 @@ async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
   await fs.writeFile(wranglerPath, content, "utf-8");
   return wranglerPath;
 }
-export { resolveConfigForEnvironment, compileConfig, compileToProgrammaticConfig, stringifyConfig, writeWranglerConfig };
+export { compileConfig, compileToProgrammaticConfig, stringifyConfig, writeWranglerConfig };

package/dist/{index-n7rs26ft.js → index-6nb7w45m.js}

@@ -1,40 +1,42 @@
 import {
   canProceedWithTest,
+  getAllUsageSummaries,
+  getLimits,
+  getUsage,
+  getUsageSummary,
+  isWithinLimits,
+  recordTestUsage,
+  recordUsage,
+  resetUsage,
+  setLimits,
+  setLimitsEnabled,
+  shouldSkip
+} from "./index-7bq4xq84.js";
+import {
   clearGlobalDefaultAccountId,
   getAccountById,
   getAccountSummary,
   getAccounts,
   getAllServiceStatus,
-  getAllUsageSummaries,
   getApiToken,
   getEffectiveAccountId,
   getGlobalDefaultAccountId,
-  getLimits,
   getPrimaryAccount,
   getServiceStatus,
-  getUsage,
-  getUsageSummary,
   getWorkspaceAccountId,
   getWranglerAuth,
   hasService,
   hasWranglerConfig,
   isAuthenticated,
-  isWithinLimits,
   listAIModels,
   listD1Databases,
   listKVNamespaces,
   listR2Buckets,
   listVectorizeIndexes,
   listWorkers,
-  recordTestUsage,
-  recordUsage,
-  resetUsage,
   setGlobalDefaultAccountId,
-  setLimits,
-  setLimitsEnabled,
-  setWorkspaceAccountId,
-  shouldSkip
-} from "./index-tfyxa77h.js";
+  setWorkspaceAccountId
+} from "./index-xdq9ery1.js";
 
 // src/cloudflare/index.ts
 var account = {