devflare 1.0.0-next.7 → 1.0.0-next.71

package/dist/index-p7g30wd2.js

@@ -1,281 +0,0 @@
-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-rbht7m9r.js

@@ -1,36 +0,0 @@
-// src/utils/glob.ts
-import { globby, globbySync } from "globby";
-var DEFAULT_DO_PATTERN = "**/do.*.{ts,js}";
-var DEFAULT_ENTRYPOINT_PATTERN = "**/ep.*.{ts,js}";
-async function findFiles(pattern, options) {
-  const { cwd, absolute = true, gitignore = true } = options;
-  return globby(pattern, {
-    cwd,
-    absolute,
-    gitignore,
-    ignore: [
-      "**/node_modules/**",
-      "**/.devflare/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/.git/**"
-    ]
-  });
-}
-function findFilesSync(pattern, options) {
-  const { cwd, absolute = true, gitignore = true } = options;
-  return globbySync(pattern, {
-    cwd,
-    absolute,
-    gitignore,
-    ignore: [
-      "**/node_modules/**",
-      "**/.devflare/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/.git/**"
-    ]
-  });
-}
-
-export { DEFAULT_DO_PATTERN, DEFAULT_ENTRYPOINT_PATTERN, findFiles, findFilesSync };