devflare 1.0.0-next.15 → 1.0.0-next.16

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

@@ -1,7 +1,8 @@
 import {
   getLocalD1DatabaseIdentifier,
+  getLocalKVNamespaceIdentifier,
   normalizeDOBinding
-} from "./index-tksw7gpy.js";
+} from "./index-43dq8yx8.js";
 import {
   __require
 } from "./index-37x76zdn.js";
@@ -197,74 +198,118 @@ function serializeR2Objects(result) {
 }
 `;
 }
-async function startMiniflare(options = {}) {
-  const { Miniflare, Log, LogLevel } = await import("miniflare");
-  const port = options.port ?? 8787;
-  const persistPath = options.persistPath ?? ".devflare/data";
-  const mfConfig = {
+function hasNamedBindings(bindings) {
+  if (!bindings) {
+    return false;
+  }
+  if (Array.isArray(bindings)) {
+    return bindings.length > 0;
+  }
+  return Object.keys(bindings).length > 0;
+}
+function resolvePersistPath(options) {
+  if (!options.persist) {
+    return;
+  }
+  if (typeof options.persist === "string" && options.persist.trim().length > 0) {
+    return options.persist;
+  }
+  return options.persistPath ?? ".devflare/data";
+}
+async function loadMiniflareRuntime() {
+  return await import("miniflare");
+}
+function createBaseMiniflareConfig(options, runtime) {
+  return {
     modules: true,
     script: generateGatewayScript(),
-    port,
+    port: options.port ?? 8787,
     host: "127.0.0.1",
-    log: options.verbose ? new Log(LogLevel.DEBUG) : new Log(LogLevel.WARN),
+    log: options.verbose ? new runtime.Log(runtime.LogLevel.DEBUG) : new runtime.Log(runtime.LogLevel.WARN),
     compatibilityDate: options.compatibilityDate ?? "2024-01-01",
     compatibilityFlags: options.compatibilityFlags ?? []
   };
-  const hasBindings = (val) => {
-    if (!val)
-      return false;
-    if (Array.isArray(val))
-      return val.length > 0;
-    return Object.keys(val).length > 0;
-  };
-  if (hasBindings(options.kvNamespaces)) {
-    mfConfig.kvNamespaces = options.kvNamespaces;
-    if (options.persist) {
-      mfConfig.kvPersist = `${persistPath}/kv`;
-    }
+}
+function applyKVNamespaceConfig(config, kvNamespaces, persistPath) {
+  if (!hasNamedBindings(kvNamespaces)) {
+    return;
   }
-  if (hasBindings(options.r2Buckets)) {
-    mfConfig.r2Buckets = options.r2Buckets;
-    if (options.persist) {
-      mfConfig.r2Persist = `${persistPath}/r2`;
-    }
+  config.kvNamespaces = kvNamespaces;
+  if (persistPath) {
+    config.kvPersist = `${persistPath}/kv`;
   }
-  if (hasBindings(options.d1Databases)) {
-    mfConfig.d1Databases = options.d1Databases;
-    if (options.persist) {
-      mfConfig.d1Persist = `${persistPath}/d1`;
-    }
+}
+function applyR2BucketConfig(config, r2Buckets, persistPath) {
+  if (!hasNamedBindings(r2Buckets)) {
+    return;
   }
-  if (options.durableObjects) {
-    mfConfig.durableObjects = options.durableObjects;
-    if (options.persist) {
-      mfConfig.durableObjectsPersist = `${persistPath}/do`;
-    }
+  config.r2Buckets = r2Buckets;
+  if (persistPath) {
+    config.r2Persist = `${persistPath}/r2`;
   }
-  if (options.sendEmail) {
-    mfConfig.email = {
-      send_email: Object.entries(options.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 applyD1DatabaseConfig(config, d1Databases, persistPath) {
+  if (!hasNamedBindings(d1Databases)) {
+    return;
+  }
+  config.d1Databases = d1Databases;
+  if (persistPath) {
+    config.d1Persist = `${persistPath}/d1`;
   }
-  if (options.bindings && Object.keys(options.bindings).length > 0) {
-    mfConfig.bindings = options.bindings;
+}
+function applyDurableObjectConfig(config, durableObjects, persistPath) {
+  if (!durableObjects) {
+    return;
   }
-  if (options.queues?.length) {
-    mfConfig.queueProducers = Object.fromEntries(options.queues.map((q) => [q, { queueName: q }]));
+  config.durableObjects = durableObjects;
+  if (persistPath) {
+    config.durableObjectsPersist = `${persistPath}/do`;
   }
-  const mf = new Miniflare(mfConfig);
-  await mf.ready;
+}
+function applySendEmailConfig(config, sendEmail) {
+  if (!sendEmail) {
+    return;
+  }
+  config.email = {
+    send_email: Object.entries(sendEmail).map(([name, emailConfig]) => ({
+      name,
+      ...emailConfig.destinationAddress && {
+        destination_address: emailConfig.destinationAddress
+      },
+      ...emailConfig.allowedDestinationAddresses && {
+        allowed_destination_addresses: emailConfig.allowedDestinationAddresses
+      },
+      ...emailConfig.allowedSenderAddresses && {
+        allowed_sender_addresses: emailConfig.allowedSenderAddresses
+      }
+    }))
+  };
+}
+function applyBindingsConfig(config, bindings) {
+  if (!bindings || Object.keys(bindings).length === 0) {
+    return;
+  }
+  config.bindings = bindings;
+}
+function applyQueueConfig(config, queues) {
+  if (!queues?.length) {
+    return;
+  }
+  config.queueProducers = Object.fromEntries(queues.map((queueName) => [queueName, { queueName }]));
+}
+function createMiniflareConfig(options, runtime) {
+  const persistPath = resolvePersistPath(options);
+  const config = createBaseMiniflareConfig(options, runtime);
+  applyKVNamespaceConfig(config, options.kvNamespaces, persistPath);
+  applyR2BucketConfig(config, options.r2Buckets, persistPath);
+  applyD1DatabaseConfig(config, options.d1Databases, persistPath);
+  applyDurableObjectConfig(config, options.durableObjects, persistPath);
+  applySendEmailConfig(config, options.sendEmail);
+  applyBindingsConfig(config, options.bindings);
+  applyQueueConfig(config, options.queues);
+  return config;
+}
+function createMiniflareInstanceHandle(mf) {
   return {
     ready: Promise.resolve(),
     async dispose() {
@@ -281,13 +326,21 @@ async function startMiniflare(options = {}) {
     _mf: mf
   };
 }
+async function startMiniflare(options = {}) {
+  const runtime = await loadMiniflareRuntime();
+  const mf = new runtime.Miniflare(createMiniflareConfig(options, runtime));
+  await mf.ready;
+  return createMiniflareInstanceHandle(mf);
+}
 async function startMiniflareFromConfig(config, options = {}) {
   const bindings = config.bindings ?? {};
   const mfOptions = {
     ...options,
     compatibilityDate: config.compatibilityDate,
     compatibilityFlags: config.compatibilityFlags,
-    kvNamespaces: bindings.kv ? bindings.kv : undefined,
+    kvNamespaces: bindings.kv ? Object.fromEntries(Object.entries(bindings.kv).map(([bindingName, bindingConfig]) => {
+      return [bindingName, getLocalKVNamespaceIdentifier(bindingConfig)];
+    })) : undefined,
     r2Buckets: bindings.r2 ? bindings.r2 : undefined,
     d1Databases: bindings.d1 ? Object.fromEntries(Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => {
       return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];