devflare 1.0.0-next.10 → 1.0.0-next.12

package/dist/index-ws68xvq2.js

@@ -1,311 +0,0 @@
-import {
-  discoverRoutes
-} from "./index-1p814k7s.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/worker-entry/composed-worker.ts
-import { defu } from "defu";
-import { dirname, relative, resolve } from "pathe";
-var DEFAULT_FETCH_ENTRY_FILES = [
-  "src/fetch.ts",
-  "src/fetch.js",
-  "src/fetch.mts",
-  "src/fetch.mjs"
-];
-var DEFAULT_QUEUE_ENTRY_FILES = [
-  "src/queue.ts",
-  "src/queue.js",
-  "src/queue.mts",
-  "src/queue.mjs"
-];
-var DEFAULT_SCHEDULED_ENTRY_FILES = [
-  "src/scheduled.ts",
-  "src/scheduled.js",
-  "src/scheduled.mts",
-  "src/scheduled.mjs"
-];
-var DEFAULT_EMAIL_ENTRY_FILES = [
-  "src/email.ts",
-  "src/email.js",
-  "src/email.mts",
-  "src/email.mjs"
-];
-function resolveConfigForEnvironment(config, environment) {
-  if (environment && config.env?.[environment]) {
-    return defu(config.env[environment], config);
-  }
-  return config;
-}
-async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries) {
-  if (configuredPath === false) {
-    return null;
-  }
-  const fs = await import("node:fs/promises");
-  const candidates = new Set;
-  if (typeof configuredPath === "string" && configuredPath) {
-    candidates.add(configuredPath);
-  }
-  for (const defaultEntry of defaultEntries) {
-    candidates.add(defaultEntry);
-  }
-  for (const candidate of candidates) {
-    const absolutePath = resolve(cwd, candidate);
-    try {
-      await fs.access(absolutePath);
-      return absolutePath;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-async function resolveWorkerSurfacePaths(cwd, config) {
-  return {
-    fetch: await resolveWorkerHandlerPath(cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES),
-    queue: await resolveWorkerHandlerPath(cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES),
-    scheduled: await resolveWorkerHandlerPath(cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES),
-    email: await resolveWorkerHandlerPath(cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES)
-  };
-}
-function toImportSpecifier(fromFilePath, toFilePath) {
-  const specifier = relative(dirname(fromFilePath), toFilePath).replace(/\\/g, "/");
-  return specifier.startsWith(".") ? specifier : `./${specifier}`;
-}
-function createGeneratedRouteModuleImports(entryPath, routeDiscovery) {
-  if (!routeDiscovery) {
-    return [];
-  }
-  return routeDiscovery.routes.map((route, index) => ({
-    identifier: `__devflareRouteModule${index}`,
-    importPath: toImportSpecifier(entryPath, route.absolutePath),
-    filePath: route.filePath,
-    routePath: route.routePath,
-    segmentsJson: JSON.stringify(route.segments)
-  }));
-}
-function needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery) {
-  return Boolean(surfacePaths.fetch || surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email || routeDiscovery?.routes.length);
-}
-function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, routeImports = [], options = {}) {
-  const importLines = [`import { createEmailEvent, createFetchEvent, createQueueEvent, createRouteResolve, createScheduledEvent, invokeFetchModule, matchFetchRoute, runWithEventContext, setLocalSendEmailBindings } from 'devflare/runtime'`];
-  const moduleFallbackLines = [];
-  const localSendEmailBindings = JSON.stringify(configuredLocalSendEmailBindings);
-  const routeManifestEntries = routeImports.map(({ identifier, filePath, routePath, segmentsJson }) => {
-    return `	{ filePath: ${JSON.stringify(filePath)}, routePath: ${JSON.stringify(routePath)}, segments: ${segmentsJson}, module: ${identifier} }`;
-  });
-  const registerSurfaceModule = (identifier, importPath) => {
-    if (importPath) {
-      importLines.push(`import * as ${identifier} from '${importPath}'`);
-      return;
-    }
-    moduleFallbackLines.push(`const ${identifier} = {}`);
-  };
-  registerSurfaceModule("__devflareFetchModule", surfaceImportPaths.fetch);
-  registerSurfaceModule("__devflareQueueModule", surfaceImportPaths.queue);
-  registerSurfaceModule("__devflareScheduledModule", surfaceImportPaths.scheduled);
-  registerSurfaceModule("__devflareEmailModule", surfaceImportPaths.email);
-  for (const routeImport of routeImports) {
-    importLines.push(`import * as ${routeImport.identifier} from '${routeImport.importPath}'`);
-  }
-  const includeDevInternalEmail = options.devInternalEmail === true;
-  const devInternalEmailHelpers = includeDevInternalEmail ? `
-function __devflareCreateEmailHeaders(rawBody) {
-	const headers = new Headers()
-	const lines = rawBody.split(/\\r?\\n/)
-
-	for (const line of lines) {
-		if (line.trim() === '') {
-			break
-		}
-
-		const colonIndex = line.indexOf(':')
-		if (colonIndex <= 0) {
-			continue
-		}
-
-		headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim())
-	}
-
-	return headers
-}
-
-function __devflareCreateEmailRawStream(rawBody) {
-	return new ReadableStream({
-		start(controller) {
-			controller.enqueue(new TextEncoder().encode(rawBody))
-			controller.close()
-		}
-	})
-}
-
-async function __devflareHandleInternalEmail(request, env, ctx) {
-	if (!__devflareEmailHandler) {
-		return new Response('Email handler not configured', { status: 501 })
-	}
-
-	const from = request.headers.get('x-devflare-email-from') || 'unknown@example.com'
-	const to = request.headers.get('x-devflare-email-to') || 'worker@example.com'
-	const rawBody = await request.text()
-	const emailMessage = {
-		from,
-		to,
-		headers: __devflareCreateEmailHeaders(rawBody),
-		raw: __devflareCreateEmailRawStream(rawBody),
-		rawSize: rawBody.length,
-		setReject(reason) {
-			console.warn('[Devflare email rejected]', reason)
-		},
-		async forward(rcptTo) {
-			console.log('[Devflare email forwarded]', rcptTo)
-			return Promise.resolve()
-		},
-		async reply(message) {
-			console.log('[Devflare email reply sent]', message?.from)
-			return Promise.resolve()
-		}
-	}
-
-	const __devflareEvent = createEmailEvent(emailMessage, env, ctx)
-
-	await runWithEventContext(
-		__devflareEvent,
-		() => __devflareEmailHandler(__devflareEvent, env, ctx)
-	)
-
-	return new Response(JSON.stringify({ ok: true, from, to }), {
-		headers: { 'Content-Type': 'application/json' }
-	})
-}
-` : "";
-  return `
-${importLines.join(`
-`)}
-${moduleFallbackLines.join(`
-`)}
-
-setLocalSendEmailBindings(${localSendEmailBindings})
-
-const __devflareHasFetchModule = ${surfaceImportPaths.fetch ? "true" : "false"}
-const __devflareRoutes = [
-${routeManifestEntries.join(`,
-`)}
-]
-const __devflareHasRoutes = __devflareRoutes.length > 0
-
-const __devflareResolveHandler = (module, namedExport) => {
-	const defaultExport = module.default
-
-	if (typeof defaultExport === 'function') {
-		return defaultExport
-	}
-
-	if (defaultExport && typeof defaultExport[namedExport] === 'function') {
-		return defaultExport[namedExport].bind(defaultExport)
-	}
-
-	if (typeof module[namedExport] === 'function') {
-		return module[namedExport]
-	}
-
-	return null
-}
-
-const __devflareQueueHandler = __devflareResolveHandler(__devflareQueueModule, 'queue')
-const __devflareScheduledHandler = __devflareResolveHandler(__devflareScheduledModule, 'scheduled')
-const __devflareEmailHandler = __devflareResolveHandler(__devflareEmailModule, 'email')
-${devInternalEmailHelpers}
-
-export default {
-	...(${surfaceImportPaths.fetch || routeImports.length > 0 || includeDevInternalEmail ? "true" : "false"}
-		? {
-			async fetch(request, env, ctx) {
-				${includeDevInternalEmail ? `const url = new URL(request.url)
-
-				if (
-					request.headers.get('x-devflare-event') === 'email'
-					&& url.pathname === '/_devflare/internal/email'
-				) {
-					return __devflareHandleInternalEmail(request, env, ctx)
-				}
-
-				` : ""}const __devflareInitialRouteMatch = __devflareHasRoutes ? matchFetchRoute(__devflareRoutes, request) : null
-				const __devflareEvent = createFetchEvent(request, env, ctx, {
-					params: __devflareInitialRouteMatch?.params ?? {}
-				})
-				return runWithEventContext(
-					__devflareEvent,
-					() => invokeFetchModule(
-						__devflareFetchModule,
-						__devflareEvent,
-						__devflareHasRoutes
-							? createRouteResolve(__devflareRoutes, __devflareEvent)
-							: undefined
-					)
-				)
-			}
-		}
-		: {}),
-	...(__devflareQueueHandler
-		? {
-			async queue(batch, env, ctx) {
-				const __devflareEvent = createQueueEvent(batch, env, ctx)
-				return runWithEventContext(
-					__devflareEvent,
-					() => __devflareQueueHandler(__devflareEvent, env, ctx)
-				)
-			}
-		}
-		: {}),
-	...(__devflareScheduledHandler
-		? {
-			async scheduled(controller, env, ctx) {
-				const __devflareEvent = createScheduledEvent(controller, env, ctx)
-				return runWithEventContext(
-					__devflareEvent,
-					() => __devflareScheduledHandler(__devflareEvent, env, ctx)
-				)
-			}
-		}
-		: {}),
-	...(__devflareEmailHandler
-		? {
-			async email(message, env, ctx) {
-				const __devflareEvent = createEmailEvent(message, env, ctx)
-				return runWithEventContext(
-					__devflareEvent,
-					() => __devflareEmailHandler(__devflareEvent, env, ctx)
-				)
-			}
-		}
-		: {})
-}
-`.trimStart();
-}
-async function prepareComposedWorkerEntrypoint(cwd, config, environment, options = {}) {
-  const resolvedConfig = resolveConfigForEnvironment(config, environment);
-  if (resolvedConfig.wrangler?.passthrough && Object.prototype.hasOwnProperty.call(resolvedConfig.wrangler.passthrough, "main")) {
-    return null;
-  }
-  const surfacePaths = await resolveWorkerSurfacePaths(cwd, resolvedConfig);
-  const routeDiscovery = await discoverRoutes(cwd, resolvedConfig);
-  if (!needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery)) {
-    return null;
-  }
-  const fs = await import("node:fs/promises");
-  const entryDir = resolve(cwd, ".devflare", "worker-entrypoints");
-  const entryPath = resolve(entryDir, "main.ts");
-  await fs.mkdir(entryDir, { recursive: true });
-  const surfaceImportPaths = {
-    fetch: surfacePaths.fetch ? toImportSpecifier(entryPath, surfacePaths.fetch) : null,
-    queue: surfacePaths.queue ? toImportSpecifier(entryPath, surfacePaths.queue) : null,
-    scheduled: surfacePaths.scheduled ? toImportSpecifier(entryPath, surfacePaths.scheduled) : null,
-    email: surfacePaths.email ? toImportSpecifier(entryPath, surfacePaths.email) : null
-  };
-  const routeImports = createGeneratedRouteModuleImports(entryPath, routeDiscovery);
-  await fs.writeFile(entryPath, getComposedWorkerEntrypointSource(surfaceImportPaths, resolvedConfig.bindings?.sendEmail ?? {}, routeImports, options));
-  return ".devflare/worker-entrypoints/main.ts";
-}
-
-export { prepareComposedWorkerEntrypoint };