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

package/dist/_chunks/worker-entrypoint-C8j23t6d.js

@@ -0,0 +1,247 @@
+import { t as __exportAll } from "./rolldown-runtime-CvQ6eiug.js";
+import MagicString from "magic-string";
+import ts from "typescript";
+//#region src/worker-entry/extensions.ts
+/** Extensions accepted as worker source modules. */
+const SUPPORTED_WORKER_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs",
+	".js",
+	".jsx"
+];
+/** Subset of {@link SUPPORTED_WORKER_EXTENSIONS} that may host TypeScript-only syntax. */
+const TS_WORKER_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+];
+//#endregion
+//#region src/transform/worker-entrypoint.ts
+var worker_entrypoint_exports = /* @__PURE__ */ __exportAll({
+	findExportedFunctions: () => findExportedFunctions,
+	shouldEmitTsSyntax: () => shouldEmitTsSyntax,
+	shouldTransformWorker: () => shouldTransformWorker,
+	transformWorkerEntrypoint: () => transformWorkerEntrypoint
+});
+/**
+* Find all exported functions in a worker.ts file using TypeScript AST
+*/
+function findExportedFunctions(code) {
+	const functions = [];
+	const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	function visit(node) {
+		if (ts.isFunctionDeclaration(node) && node.name) {
+			const modifiers = ts.getModifiers(node);
+			const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+			const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+			if (isExported) {
+				const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+				const funcName = isDefault ? "fetch" : node.name.text;
+				const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+				const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : void 0;
+				functions.push({
+					name: funcName,
+					isAsync,
+					params,
+					returnType,
+					start: node.getStart(sourceFile),
+					end: node.getEnd(),
+					isDefault
+				});
+			}
+		}
+		if (ts.isFunctionDeclaration(node) && !node.name) {
+			const modifiers = ts.getModifiers(node);
+			const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+			const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+			if (isExported && isDefault) {
+				const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+				const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+				const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : void 0;
+				functions.push({
+					name: "fetch",
+					isAsync,
+					params,
+					returnType,
+					start: node.getStart(sourceFile),
+					end: node.getEnd(),
+					isDefault: true
+				});
+			}
+		}
+		if (ts.isVariableStatement(node)) {
+			if (ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+				for (const decl of node.declarationList.declarations) if (ts.isIdentifier(decl.name) && decl.initializer) {
+					let funcExpr;
+					if (ts.isFunctionExpression(decl.initializer)) funcExpr = decl.initializer;
+					else if (ts.isArrowFunction(decl.initializer)) funcExpr = decl.initializer;
+					if (funcExpr) {
+						const isAsync = ts.getModifiers(funcExpr)?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? (ts.isArrowFunction(funcExpr) && funcExpr.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) ?? false;
+						const params = funcExpr.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+						const returnType = funcExpr.type ? code.substring(funcExpr.type.getStart(sourceFile), funcExpr.type.getEnd()) : void 0;
+						functions.push({
+							name: decl.name.text,
+							isAsync,
+							params,
+							returnType,
+							start: node.getStart(sourceFile),
+							end: node.getEnd()
+						});
+					}
+				}
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return functions;
+}
+/**
+* Returns true when the filename has an extension that permits TS-only syntax.
+* Gates injection of interfaces and type annotations into emitted worker code.
+*/
+function shouldEmitTsSyntax(filename) {
+	const lower = filename.toLowerCase();
+	return TS_WORKER_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+/**
+* Check if a file should be transformed as a worker entrypoint
+* Returns true if the file has exported functions that could be RPC methods
+*/
+function shouldTransformWorker(code, filePath) {
+	const lower = filePath.toLowerCase();
+	if (!SUPPORTED_WORKER_EXTENSIONS.some((ext) => lower.endsWith(`worker${ext}`))) return false;
+	return findExportedFunctions(code).length > 0;
+}
+/**
+* Transform a worker.ts file into a WorkerEntrypoint class
+*
+* @param code - Source code to transform
+* @param id - File path/id for source mapping
+* @param options - Transform options
+* @returns Transformed code with source map
+*/
+function transformWorkerEntrypoint(code, id, options = {}) {
+	const className = options.className ?? "Worker";
+	const injectContext = options.injectContext ?? true;
+	const emitTs = shouldEmitTsSyntax(id);
+	const functions = findExportedFunctions(code);
+	if (functions.length === 0) return null;
+	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'\n`;
+	if (needsFetchHelpers) {
+		const runtimeImports = ["createFetchEvent", "invokeFetchHandler"];
+		if (injectContext) runtimeImports.push("runWithEventContext");
+		s.prepend(`import { ${runtimeImports.join(", ")} } from 'devflare/runtime'\n`);
+	}
+	s.prepend(importStatement);
+	const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const internalNameFor = (name) => name === "fetch" ? "__originalFetch" : `__original_${name}`;
+	function visit(node) {
+		if (ts.isFunctionDeclaration(node)) {
+			const modifiers = ts.getModifiers(node);
+			const exportMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+			const defaultMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+			const asyncMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+			if (exportMod) {
+				const isDefault = Boolean(defaultMod);
+				const logicalName = isDefault ? "fetch" : node.name?.text;
+				if (logicalName) {
+					const internal = internalNameFor(logicalName);
+					if (isDefault && !node.name) {
+						const funcKeyword = node.getChildren(sourceFile).find((c) => c.kind === ts.SyntaxKind.FunctionKeyword);
+						if (funcKeyword) {
+							const asyncKw = asyncMod ? "async " : "";
+							s.overwrite(node.getStart(sourceFile), funcKeyword.getStart(sourceFile), `const ${internal} = ${asyncKw}`);
+						}
+					} else if (node.name) {
+						s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
+						if (defaultMod) s.remove(defaultMod.getStart(sourceFile), defaultMod.getEnd());
+						s.overwrite(node.name.getStart(sourceFile), node.name.getEnd(), internal);
+					}
+				}
+			}
+		} else if (ts.isVariableStatement(node)) {
+			const exportMod = ts.getModifiers(node)?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+			if (exportMod) {
+				let rewroteAny = false;
+				for (const decl of node.declarationList.declarations) if (ts.isIdentifier(decl.name) && decl.initializer && (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer))) {
+					const internal = internalNameFor(decl.name.text);
+					s.overwrite(decl.name.getStart(sourceFile), decl.name.getEnd(), internal);
+					rewroteAny = true;
+				}
+				if (rewroteAny) s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	let classBody = `\n\n// ============ Devflare WorkerEntrypoint ============\nclass ${className} extends WorkerEntrypoint {\n`;
+	if (fetchFn) {
+		classBody += `\t${emitTs ? "async fetch(request: Request): Promise<Response>" : "async fetch(request)"} {\n`;
+		classBody += `\t\tconst __devflareEvent = createFetchEvent(request, this.env, this.ctx)\n`;
+		if (injectContext) {
+			classBody += `\t\treturn runWithEventContext(\n`;
+			classBody += `\t\t\t__devflareEvent,\n`;
+			classBody += `\t\t\t() => invokeFetchHandler(__originalFetch, __devflareEvent)\n`;
+			classBody += `\t\t)\n`;
+			classBody += `\t}\n`;
+		} else {
+			classBody += `\t\treturn invokeFetchHandler(__originalFetch, __devflareEvent)\n`;
+			classBody += `\t}\n`;
+		}
+	}
+	for (const fn of rpcMethods) {
+		const asyncPrefix = fn.isAsync ? "async " : "";
+		const paramNames = extractParamNames(fn.params);
+		const signatureParams = emitTs ? fn.params : paramNames;
+		const returnType = emitTs && fn.returnType ? `: ${fn.returnType}` : "";
+		classBody += `\n\t${asyncPrefix}${fn.name}(${signatureParams})${returnType} {\n`;
+		classBody += `\t\treturn __original_${fn.name}(${paramNames})\n`;
+		classBody += `\t}\n`;
+	}
+	classBody += `}\n\n`;
+	classBody += `export { ${className} }\n`;
+	classBody += `export { ${className} as default }\n`;
+	classBody += `// ============ End Devflare WorkerEntrypoint ============\n`;
+	s.append(classBody);
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			source: id,
+			file: id + ".map",
+			includeContent: true
+		}),
+		rpcMethods: rpcMethods.map((fn) => fn.name),
+		className
+	};
+}
+/**
+* Extract parameter names from a parameter string
+* "a: number, b: string" -> "a, b"
+*/
+function extractParamNames(params) {
+	if (!params.trim()) return "";
+	const tempCode = `function f(${params}) {}`;
+	const sourceFile = ts.createSourceFile("temp.ts", tempCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const names = [];
+	function visit(node) {
+		if (ts.isFunctionDeclaration(node)) {
+			for (const param of node.parameters) if (ts.isIdentifier(param.name)) names.push(param.name.text);
+			else if (ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)) names.push(tempCode.substring(param.name.getStart(sourceFile), param.name.getEnd()));
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return names.join(", ");
+}
+//#endregion
+export { worker_entrypoint_exports as n, SUPPORTED_WORKER_EXTENSIONS as r, transformWorkerEntrypoint as t };

package/dist/_chunks/workerName-kEXwmV2m.js

@@ -0,0 +1,23 @@
+//#region src/workerName.ts
+/**
+* The current worker's name from devflare.config.ts
+*
+* This value is injected at build time by the devflare bundler.
+* In development (non-bundled), it will be 'unknown' or throw an error.
+*
+* @example
+* import { workerName } from 'devflare'
+*
+* export default {
+*   fetch(request) {
+*     return new Response(`Hello from ${workerName}`)
+*   }
+* }
+*/
+const 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";
+})();
+//#endregion
+export { workerName as t };