devflare 1.0.0-next.1 → 1.0.0-next.10

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

@@ -9,7 +9,10 @@ import {
   parseJsonMsg,
   serializeValue,
   stringifyJsonMsg
-} from "./index-pf5s73n9.js";
+} from "./index-59df49vn.js";
+import {
+  normalizeSendEmailMessage
+} from "./index-fef08w43.js";
 
 // src/bridge/server.ts
 var server_default = {
@@ -176,6 +179,8 @@ async function executeRpcMethod(method, params, env, ctx) {
       return executeDoFetch(env, params[0], params[1], params[2]);
     case "stub.rpc":
       return executeDoRpc(env, params[0], params[1], params[2], params[3]);
+    case "email.send":
+      return executeSendEmail(binding, params[0]);
     case "send":
       return binding.send(params[0], params[1]);
     case "sendBatch":
@@ -189,6 +194,9 @@ async function executeRpcMethod(method, params, env, ctx) {
       throw new Error(`Unknown operation: ${method}`);
   }
 }
+async function executeSendEmail(binding, message) {
+  return binding.send(normalizeSendEmailMessage(message));
+}
 function serializeR2Object(obj) {
   if (!obj)
     return null;

package/dist/index-pwgyy2q9.js

@@ -0,0 +1,39 @@
+import {
+  resolveConfigPath
+} from "./index-1phx14av.js";
+
+// src/cli/config-path.ts
+import { stat } from "node:fs/promises";
+var CONFIG_FILE_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+var SUPPORTED_CONFIG_FILENAMES = CONFIG_FILE_EXTENSIONS.map((extension) => `devflare.config${extension}`);
+function hasKnownConfigExtension(filePath) {
+  return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+async function getExistingFilePath(filePath) {
+  try {
+    const fileStat = await stat(filePath);
+    return fileStat.isFile() ? filePath : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveConfigCandidatePath(candidatePath) {
+  const candidates = [candidatePath];
+  if (!hasKnownConfigExtension(candidatePath)) {
+    for (const extension of CONFIG_FILE_EXTENSIONS) {
+      candidates.push(`${candidatePath}${extension}`);
+    }
+  }
+  for (const candidate of candidates) {
+    const existingFilePath = await getExistingFilePath(candidate);
+    if (existingFilePath) {
+      return existingFilePath;
+    }
+  }
+  return await resolveConfigPath(candidatePath) ?? null;
+}
+function formatSupportedConfigFilenames() {
+  return SUPPORTED_CONFIG_FILENAMES.join(", ");
+}
+
+export { resolveConfigCandidatePath, formatSupportedConfigFilenames };

package/dist/{index-07q6yxyc.js → index-v8vvsn9x.js}

@@ -165,4 +165,5 @@ function serviceBinding(refOrLegacy, options) {
     __ref: refOrLegacy
   };
 }
+
 export { defineConfig, ref, resolveRef, serviceBinding };

package/dist/index-vky23txa.js

@@ -0,0 +1,70 @@
+import {
+  getContextOrNull
+} from "./index-5yxg30va.js";
+import {
+  bridgeEnv
+} from "./index-59df49vn.js";
+
+// src/env.ts
+var testContextEnv = null;
+var testContextDispose = null;
+function __setTestContext(envBindings, dispose) {
+  testContextEnv = envBindings;
+  testContextDispose = dispose;
+}
+function __clearTestContext() {
+  testContextEnv = null;
+  testContextDispose = null;
+}
+var env = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "dispose") {
+      return async () => {
+        if (testContextDispose) {
+          await testContextDispose();
+          __clearTestContext();
+        }
+      };
+    }
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return ctx.env[prop];
+    }
+    if (testContextEnv) {
+      return testContextEnv[prop];
+    }
+    return bridgeEnv[prop];
+  },
+  has(_target, prop) {
+    if (prop === "dispose")
+      return true;
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return prop in ctx.env;
+    }
+    if (testContextEnv) {
+      return prop in testContextEnv;
+    }
+    return prop in bridgeEnv;
+  },
+  ownKeys(_target) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return Reflect.ownKeys(ctx.env);
+    }
+    if (testContextEnv) {
+      return Reflect.ownKeys(testContextEnv);
+    }
+    return Reflect.ownKeys(bridgeEnv);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    if (prop === "dispose") {
+      return { configurable: true, enumerable: false, writable: false };
+    }
+    const ctx = getContextOrNull();
+    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
+    return Reflect.getOwnPropertyDescriptor(source, prop);
+  }
+});
+
+export { __setTestContext, __clearTestContext, env };

package/dist/index-vs49yxn4.js

@@ -0,0 +1,322 @@
+import {
+  normalizeDOBinding
+} from "./index-1phx14av.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/bridge/miniflare.ts
+function generateGatewayScript() {
+  return `
+// Gateway Worker — Provides RPC access to all bindings
+export default {
+	async fetch(request, env, ctx) {
+		const url = new URL(request.url)
+		
+		// Health check
+		if (url.pathname === '/_devflare/health') {
+			return new Response(JSON.stringify({ status: 'ok', bindings: Object.keys(env) }), {
+				headers: { 'Content-Type': 'application/json' }
+			})
+		}
+		
+		// RPC endpoint
+		if (url.pathname === '/_devflare/rpc' && request.method === 'POST') {
+			try {
+				const { method, params } = await request.json()
+				const result = await executeRpc(env, method, params)
+				return new Response(JSON.stringify({ ok: true, result }), {
+					headers: { 'Content-Type': 'application/json' }
+				})
+			} catch (error) {
+				return new Response(JSON.stringify({
+					ok: false,
+					error: { code: 'RPC_ERROR', message: error.message }
+				}), {
+					status: 500,
+					headers: { 'Content-Type': 'application/json' }
+				})
+			}
+		}
+		
+		return new Response('Devflare Gateway', { status: 200 })
+	}
+}
+
+async function executeRpc(env, method, params) {
+	const [bindingName, ...methodPath] = method.split('.')
+	const binding = env[bindingName]
+	const RAW_EMAIL = 'EmailMessage::raw'
+	
+	if (!binding) {
+		throw new Error(\`Binding "\${bindingName}" not found\`)
+	}
+	
+	const methodName = methodPath.join('.')
+	
+	// KV operations
+	if (methodName === 'get') return binding.get(params[0], params[1])
+	if (methodName === 'put') return binding.put(params[0], params[1], params[2])
+	if (methodName === 'delete') return binding.delete(params[0])
+	if (methodName === 'list') return binding.list(params[0])
+	if (methodName === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
+	
+	// R2 operations
+	if (methodName === 'head') return binding.head(params[0])
+	if (methodName === 'r2.get') return serializeR2Object(await binding.get(params[0], params[1]))
+	if (methodName === 'r2.put') return serializeR2Object(await binding.put(params[0], params[1], params[2]))
+	if (methodName === 'r2.delete') return binding.delete(params[0])
+	if (methodName === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
+	
+	// D1 operations
+	if (methodName === 'exec') return binding.exec(params[0])
+	if (methodName === 'batch') {
+		const statements = params[0].map(s => binding.prepare(s.sql).bind(...(s.bindings || [])))
+		return binding.batch(statements)
+	}
+	if (methodName.startsWith('stmt.')) {
+		const [, stmtMethod] = methodName.split('.')
+		const [sql, ...bindings] = params
+		const stmt = binding.prepare(sql).bind(...bindings.slice(0, -1))
+		
+		if (stmtMethod === 'first') return stmt.first(bindings[bindings.length - 1])
+		if (stmtMethod === 'all') return stmt.all()
+		if (stmtMethod === 'run') return stmt.run()
+		if (stmtMethod === 'raw') return stmt.raw(bindings[bindings.length - 1])
+	}
+	
+	// DO operations
+	if (methodName === 'idFromName') {
+		const id = binding.idFromName(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'idFromString') {
+		const id = binding.idFromString(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'newUniqueId') {
+		const id = binding.newUniqueId(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'stub.fetch') {
+		const [, doId, serializedReq] = params
+		const id = binding.idFromString(doId.hex)
+		const stub = binding.get(id)
+		const response = await stub.fetch(new Request(serializedReq.url, {
+			method: serializedReq.method,
+			headers: serializedReq.headers,
+			body: serializedReq.body?.type === 'bytes' ? atob(serializedReq.body.data) : undefined
+		}))
+		return serializeResponse(response)
+	}
+	if (methodName === 'stub.rpc') {
+		// DO RPC: Call a method on the DO instance
+		const [, doId, rpcMethod, rpcParams] = params
+		const id = binding.idFromString(doId.hex)
+		const stub = binding.get(id)
+		
+		// Use fetch to call the RPC endpoint
+		const response = await stub.fetch(new Request('http://do/_rpc', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ method: rpcMethod, params: rpcParams })
+		}))
+		
+		const result = await response.json()
+		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
+		return result.result
+	}
+	
+	// Queue operations
+	if (methodName === 'send') return binding.send(params[0], params[1])
+	if (methodName === 'sendBatch') return binding.sendBatch(params[0], params[1])
+
+	// Send Email operations
+	if (methodName === 'email.send') {
+		const message = params[0]
+		if (message && typeof message === 'object' && 'from' in message && 'to' in message && 'raw' in message) {
+			return binding.send({
+				from: message.from,
+				to: message.to,
+				[RAW_EMAIL]: createEmailMessageRaw(message.raw)
+			})
+		}
+		return binding.send(message)
+	}
+	
+	// Generic fallback
+	if (typeof binding[methodName] === 'function') {
+		return binding[methodName](...params)
+	}
+	
+	throw new Error(\`Unknown method: \${method}\`)
+}
+
+function createEmailMessageRaw(raw) {
+	if (typeof raw === 'string' || raw instanceof ReadableStream) {
+		return raw
+	}
+	if (raw instanceof ArrayBuffer || raw instanceof Uint8Array) {
+		return new Response(raw).body
+	}
+	throw new Error('Unsupported EmailMessage raw payload')
+}
+
+function serializeResponse(response) {
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: [...response.headers.entries()],
+		body: null // Will be streamed separately for large bodies
+	}
+}
+
+function serializeR2Object(obj) {
+	if (!obj) return null
+	return {
+		key: obj.key,
+		version: obj.version,
+		size: obj.size,
+		etag: obj.etag,
+		httpEtag: obj.httpEtag,
+		uploaded: obj.uploaded?.toISOString(),
+		httpMetadata: obj.httpMetadata,
+		customMetadata: obj.customMetadata
+	}
+}
+
+function serializeR2Objects(result) {
+	if (!result) return null
+	return {
+		objects: result.objects.map(serializeR2Object),
+		truncated: result.truncated,
+		cursor: result.cursor,
+		delimitedPrefixes: result.delimitedPrefixes
+	}
+}
+`;
+}
+async function startMiniflare(options = {}) {
+  const { Miniflare, Log, LogLevel } = await import("miniflare");
+  const port = options.port ?? 8787;
+  const persistPath = options.persistPath ?? ".devflare/data";
+  const mfConfig = {
+    modules: true,
+    script: generateGatewayScript(),
+    port,
+    host: "127.0.0.1",
+    log: options.verbose ? new Log(LogLevel.DEBUG) : new Log(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`;
+    }
+  }
+  if (hasBindings(options.r2Buckets)) {
+    mfConfig.r2Buckets = options.r2Buckets;
+    if (options.persist) {
+      mfConfig.r2Persist = `${persistPath}/r2`;
+    }
+  }
+  if (hasBindings(options.d1Databases)) {
+    mfConfig.d1Databases = options.d1Databases;
+    if (options.persist) {
+      mfConfig.d1Persist = `${persistPath}/d1`;
+    }
+  }
+  if (options.durableObjects) {
+    mfConfig.durableObjects = options.durableObjects;
+    if (options.persist) {
+      mfConfig.durableObjectsPersist = `${persistPath}/do`;
+    }
+  }
+  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
+        }
+      }))
+    };
+  }
+  if (options.bindings && Object.keys(options.bindings).length > 0) {
+    mfConfig.bindings = options.bindings;
+  }
+  if (options.queues?.length) {
+    mfConfig.queueProducers = Object.fromEntries(options.queues.map((q) => [q, { queueName: q }]));
+  }
+  const mf = new Miniflare(mfConfig);
+  await mf.ready;
+  return {
+    ready: Promise.resolve(),
+    async dispose() {
+      await mf.dispose();
+    },
+    async getBindings() {
+      return mf.getBindings();
+    },
+    getKVNamespace: mf.getKVNamespace.bind(mf),
+    getR2Bucket: mf.getR2Bucket.bind(mf),
+    getD1Database: mf.getD1Database.bind(mf),
+    getDurableObjectNamespace: mf.getDurableObjectNamespace.bind(mf),
+    dispatchFetch: mf.dispatchFetch.bind(mf),
+    _mf: 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,
+    r2Buckets: bindings.r2 ? bindings.r2 : undefined,
+    d1Databases: bindings.d1 ? bindings.d1 : undefined,
+    queues: bindings.queues?.consumers?.map((c) => c.queue),
+    sendEmail: bindings.sendEmail ? bindings.sendEmail : undefined,
+    bindings: config.vars,
+    durableObjects: bindings.durableObjects ? Object.fromEntries(Object.entries(bindings.durableObjects).map(([bindingName, doConfig]) => {
+      const normalized = normalizeDOBinding(doConfig);
+      return [
+        bindingName,
+        {
+          className: normalized.className,
+          scriptPath: normalized.scriptName
+        }
+      ];
+    })) : undefined
+  };
+  return startMiniflare(mfOptions);
+}
+var globalMiniflare = null;
+async function getMiniflare(options) {
+  if (!globalMiniflare) {
+    globalMiniflare = await startMiniflare(options);
+  }
+  return globalMiniflare;
+}
+async function stopMiniflare() {
+  if (globalMiniflare) {
+    await globalMiniflare.dispose();
+    globalMiniflare = null;
+  }
+}
+
+export { startMiniflare, startMiniflareFromConfig, getMiniflare, stopMiniflare };

package/dist/{index-z14anrqp.js → index-wfbfz02q.js}

@@ -95,11 +95,16 @@ function transformWorkerEntrypoint(code, id, options = {}) {
   }
   const fetchFn = functions.find((f) => f.name === "fetch");
   const rpcMethods = functions.filter((f) => f.name !== "fetch");
+  const needsFetchHelpers = Boolean(fetchFn);
   const s = new MagicString(code);
   const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
 `;
-  if (injectContext) {
-    s.prepend(`import { runWithContext } from 'devflare/runtime'
+  if (needsFetchHelpers) {
+    const runtimeImports = ["createFetchEvent", "invokeFetchHandler"];
+    if (injectContext) {
+      runtimeImports.push("runWithEventContext");
+    }
+    s.prepend(`import { ${runtimeImports.join(", ")} } from 'devflare/runtime'
 `);
   }
   s.prepend(importStatement);
@@ -123,29 +128,23 @@ function transformWorkerEntrypoint(code, id, options = {}) {
 class ${className} extends WorkerEntrypoint {
 `;
   if (fetchFn) {
-    if (injectContext) {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return runWithContext(
+    classBody += `	async fetch(request: Request): Promise<Response> {
 `;
-      classBody += `			this.env,
+    classBody += `		const __devflareEvent = createFetchEvent(request, this.env, this.ctx)
 `;
-      classBody += `			this.ctx,
-`;
-      classBody += `			request,
+    if (injectContext) {
+      classBody += `		return runWithEventContext(
 `;
-      classBody += `			() => __originalFetch(request, this.env, this.ctx),
+      classBody += `			__devflareEvent,
 `;
-      classBody += `			'fetch'
+      classBody += `			() => invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `		)
 `;
       classBody += `	}
 `;
     } else {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return __originalFetch(request, this.env, this.ctx)
+      classBody += `		return invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `	}
 `;