devflare 1.0.0-next.5 → 1.0.0-next.6

package/dist/index-npc1c8jx.js

@@ -0,0 +1,44 @@
+// src/runtime/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage;
+function runWithContext(env, ctx, request, fn, type = "fetch") {
+  const context = {
+    env,
+    ctx,
+    request,
+    locals: {},
+    type
+  };
+  return storage.run(context, fn);
+}
+function getContext() {
+  const context = storage.getStore();
+  if (!context) {
+    throw new ContextUnavailableError;
+  }
+  return context;
+}
+function getContextOrNull() {
+  const context = storage.getStore();
+  return context ?? null;
+}
+function hasContext() {
+  return storage.getStore() !== undefined;
+}
+
+class ContextUnavailableError extends Error {
+  code = "CONTEXT_UNAVAILABLE";
+  constructor() {
+    super(`Context not available. This usually means one of:
+
+` + `1. Accessing context at module top-level (runs at cold start, not per-request)
+` + `2. Accessing context in setTimeout/setInterval callbacks
+` + `3. Missing 'nodejs_compat' compatibility flag in your worker config
+
+` + `Fix: Move the access inside your fetch handler or middleware.
+` + `Learn more: https://devflare.dev/docs/context-errors`);
+    this.name = "ContextUnavailableError";
+  }
+}
+
+export { runWithContext, getContext, getContextOrNull, hasContext, ContextUnavailableError };

package/dist/index-p7g30wd2.js

@@ -0,0 +1,281 @@
+import {
+  normalizeDOBinding
+} from "./index-hcex3rgh.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]
+	
+	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])
+	
+	// Generic fallback
+	if (typeof binding[methodName] === 'function') {
+		return binding[methodName](...params)
+	}
+	
+	throw new Error(\`Unknown method: \${method}\`)
+}
+
+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.bindings) {
+    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),
+    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-ep3445yc.js → index-rprrn24p.js}

@@ -1,3 +1,7 @@
+import {
+  getRemoteModeStatus,
+  isRemoteModeActive
+} from "./index-d8bdkx2h.js";
 import {
   transformWorkerEntrypoint
 } from "./index-z14anrqp.js";
@@ -6,9 +10,12 @@ import {
   resolvePackageSpecifier
 } from "./index-tk6ej9dj.js";
 import {
-  getRemoteModeStatus,
-  isRemoteModeActive
-} from "./index-d8bdkx2h.js";
+  __clearTestContext,
+  __setTestContext
+} from "./index-9ats0s83.js";
+import {
+  runWithContext
+} from "./index-npc1c8jx.js";
 import {
   DEFAULT_DO_PATTERN,
   findFiles,
@@ -18,13 +25,14 @@ import {
   findDurableObjectClasses
 } from "./index-gz1gndna.js";
 import {
-  BridgeClient,
-  bridgeEnv,
-  createEnvProxy,
-  setBindingHints,
   startMiniflare,
   startMiniflareFromConfig
-} from "./index-pf5s73n9.js";
+} from "./index-p7g30wd2.js";
+import {
+  BridgeClient,
+  createEnvProxy,
+  setBindingHints
+} from "./index-ccrh4w3t.js";
 import {
   loadConfig,
   normalizeDOBinding
@@ -574,86 +582,6 @@ export default {
   }
 }
 
-// src/runtime/context.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage;
-function runWithContext(env, ctx, request, fn, type = "fetch") {
-  const context = {
-    env,
-    ctx,
-    request,
-    locals: {},
-    type
-  };
-  return storage.run(context, fn);
-}
-function getContextOrNull() {
-  const context = storage.getStore();
-  return context ?? null;
-}
-
-// 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);
-  }
-});
-
 // src/test/queue.ts
 import { join as join2 } from "path";
 var queueHandlerPath = null;
@@ -740,8 +668,8 @@ Or: export async function queue(batch, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter();
-  await queueHandler(batch, env2, ctx);
+  const env = testEnvGetter();
+  await queueHandler(batch, env, ctx);
   await Promise.all(waitUntilPromises);
   const acked = [];
   const retried = [];
@@ -820,9 +748,9 @@ Or: export async function scheduled(controller, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter2();
+  const env = testEnvGetter2();
   try {
-    await scheduledHandler(controller, env2, ctx);
+    await scheduledHandler(controller, env, ctx);
     await Promise.all(waitUntilPromises);
     return {
       success: true,
@@ -903,8 +831,8 @@ Or: export async function fetch(request, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter3();
-  const response = await fetchHandler(req, env2, ctx);
+  const env = testEnvGetter3();
+  const response = await fetchHandler(req, env, ctx);
   return response;
 }
 async function get(path, headers) {
@@ -994,9 +922,9 @@ Or: export async function tail(events, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter4();
+  const env = testEnvGetter4();
   try {
-    await tailHandler(traceItems, env2, ctx);
+    await tailHandler(traceItems, env, ctx);
     await Promise.all(waitUntilPromises);
     return {
       success: true,
@@ -2222,4 +2150,4 @@ var testEnv = new Proxy({}, {
 function isKVNamespace(binding) {
   return typeof binding === "object" && binding !== null && "get" in binding && "put" in binding && "delete" in binding && "list" in binding;
 }
-export { env, clearBundleCache, hasServiceBindings, resolveServiceBindings, hasCrossWorkerDOs, resolveDOBindings, queue, scheduled, worker, tail, email, createTestContext, cf, createMultiWorkerContext, createEntrypointScript, isRemoteModeEnabled, shouldSkip, createMockTestContext, withTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv };
+export { clearBundleCache, hasServiceBindings, resolveServiceBindings, hasCrossWorkerDOs, resolveDOBindings, queue, scheduled, worker, tail, email, createTestContext, cf, createMultiWorkerContext, createEntrypointScript, isRemoteModeEnabled, shouldSkip, createMockTestContext, withTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv };

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.js

@@ -1,3 +1,6 @@
+import {
+  workerName
+} from "./index-62b3gt2g.js";
 import {
   createBridgeTestContext,
   createMockD1,
@@ -7,12 +10,12 @@ import {
   createMockR2,
   createMockTestContext,
   createTestContext,
-  env,
   getBridgeTestContext,
   stopBridgeTestContext,
   testEnv,
   withTestContext
-} from "./index-ep3445yc.js";
+} from "./index-rprrn24p.js";
+import"./index-d8bdkx2h.js";
 import {
   findExportedFunctions,
   generateRpcInterface,
@@ -20,7 +23,10 @@ import {
   transformWorkerEntrypoint
 } from "./index-z14anrqp.js";
 import"./index-tk6ej9dj.js";
-import"./index-d8bdkx2h.js";
+import {
+  env
+} from "./index-9ats0s83.js";
+import"./index-npc1c8jx.js";
 import"./index-rbht7m9r.js";
 import {
   findDurableObjectClasses,
@@ -30,24 +36,27 @@ import {
 } from "./index-gz1gndna.js";
 import {
   server_default
-} from "./index-m2q41jwa.js";
+} from "./index-n3np2d6t.js";
 import {
-  BridgeClient,
-  createEnvProxy,
-  getClient,
   getMiniflare,
-  initEnv,
-  setBindingHints,
   startMiniflare,
   startMiniflareFromConfig,
   stopMiniflare
-} from "./index-pf5s73n9.js";
+} from "./index-p7g30wd2.js";
+import"./index-k7r18na8.js";
+import {
+  BridgeClient,
+  createEnvProxy,
+  getClient,
+  initEnv,
+  setBindingHints
+} from "./index-ccrh4w3t.js";
 import {
   defineConfig,
   ref,
   resolveRef,
   serviceBinding
-} from "./index-07q6yxyc.js";
+} from "./index-v8vvsn9x.js";
 import {
   compileConfig,
   stringifyConfig
@@ -66,16 +75,6 @@ import {
 import {
   __require
 } from "./index-37x76zdn.js";
-// src/workerName.ts
-var workerName = (() => {
-  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
-    return __DEVFLARE_WORKER_NAME__;
-  }
-  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
-    return process.env.DEVFLARE_WORKER_NAME;
-  }
-  return "unknown";
-})();
 // src/cli/index.ts
 import { createConsola } from "consola";
 var COMMANDS = ["init", "dev", "build", "deploy", "types", "doctor", "account", "ai", "remote", "help", "version"];
@@ -216,23 +215,23 @@ async function runInit(parsed, logger, options) {
   return runInitCommand(parsed, logger, options);
 }
 async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-b9dmrj7b.js");
+  const { runDevCommand } = await import("./dev-7agn9g5s.js");
   return runDevCommand(parsed, logger, options);
 }
 async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-mnf6v8gd.js");
+  const { runBuildCommand } = await import("./build-nz5yrj7f.js");
   return runBuildCommand(parsed, logger, options);
 }
 async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-nhceck39.js");
+  const { runDeployCommand } = await import("./deploy-a5pcxd5w.js");
   return runDeployCommand(parsed, logger, options);
 }
 async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-5nyrz1sz.js");
+  const { runTypesCommand } = await import("./types-vss6vrz7.js");
   return runTypesCommand(parsed, logger, options);
 }
 async function runDoctor(parsed, logger, options) {
-  const { runDoctorCommand } = await import("./doctor-fmgb3d28.js");
+  const { runDoctorCommand } = await import("./doctor-v7jy4s3r.js");
   return runDoctorCommand(parsed, logger, options);
 }
 async function runAccount(parsed, logger, options) {

package/dist/runtime/index.d.ts

@@ -1,3 +1,5 @@
+export { env, ctx, event, locals, type EventContext } from './exports';
+export { runWithContext, getContext, getContextOrNull, hasContext, ContextUnavailableError, type RequestContext } from './context';
 export { createContextProxy, ContextAccessError } from './validation';
 export { sequence, resolve, pipe, type Middleware, type Handler } from './middleware';
 export { durableObject, getDurableObjectOptions, type DurableObjectOptions } from '../decorators';

package/dist/runtime/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAGrE,OAAO,EACN,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,aAAa,EACb,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACN,GAAG,EACH,GAAG,EACH,KAAK,EACL,MAAM,EACN,KAAK,YAAY,EACjB,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,UAAU,EACV,uBAAuB,EACvB,KAAK,cAAc,EACnB,MAAM,WAAW,CAAA;AAGlB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAGrE,OAAO,EACN,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,aAAa,EACb,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,MAAM,eAAe,CAAA"}