devflare 1.0.0-next.4 → 1.0.0-next.40

package/dist/_chunks/doctor-DIG8DoFU.js

@@ -0,0 +1,219 @@
+import { r as loadConfig } from "./loader-DLXO60RO.js";
+import { d as green, f as logLine, g as yellow, m as red, n as bold, o as dim, r as createCliTheme } from "./ui-BUoZApvE.js";
+import { n as getPackageVersion } from "./package-metadata-DAuCkyvK.js";
+import { t as detectViteProject } from "./vite-utils-OVLMV605.js";
+import { t as getDependencies } from "./dependencies-C2oxFjU_.js";
+import { n as getGeneratedArtifactPaths } from "./generated-artifacts-dMJY4KAt.js";
+import { n as formatSupportedConfigFilenames, r as resolveConfigCandidatePath } from "./config-path-DCPto4XB.js";
+import { basename, dirname, relative, resolve } from "pathe";
+//#region src/cli/commands/doctor.ts
+async function runDoctorCommand(parsed, logger, options) {
+	const cwd = options.cwd || process.cwd();
+	const theme = createCliTheme(parsed.options);
+	const requestedConfigOption = parsed.options.config;
+	const scope = parsed.options.scope ?? "all";
+	if (![
+		"all",
+		"local",
+		"deploy"
+	].includes(scope)) {
+		logger.error(`Unsupported doctor scope: ${scope}`);
+		logger.info("Supported scopes: all, local, deploy");
+		return { exitCode: 1 };
+	}
+	const requestedConfigPath = requestedConfigOption ? resolve(cwd, requestedConfigOption) : cwd;
+	const checks = [];
+	const { fs } = await getDependencies();
+	const viteProject = await detectViteProject(cwd, fs);
+	logLine(logger);
+	logLine(logger, `${bold("doctor", theme)} ${dim("Running diagnostics", theme)}`);
+	logLine(logger);
+	const configPath = await resolveConfigCandidatePath(requestedConfigPath);
+	if (configPath) {
+		checks.push({
+			name: "Config File",
+			status: "pass",
+			message: `Found: ${configPath}`
+		});
+		try {
+			const config = requestedConfigOption ? await loadConfig({
+				cwd: dirname(configPath),
+				configFile: basename(configPath)
+			}) : await loadConfig({ cwd });
+			checks.push({
+				name: "Config Valid",
+				status: "pass",
+				message: `Project: ${config.name}`
+			});
+		} catch (error) {
+			checks.push({
+				name: "Config Valid",
+				status: "fail",
+				message: error instanceof Error ? error.message : "Unknown error"
+			});
+		}
+	} else checks.push({
+		name: "Config File",
+		status: "fail",
+		message: `${formatSupportedConfigFilenames()} not found. Run \`devflare init\` to create one.`
+	});
+	const packageJsonPath = resolve(cwd, "package.json");
+	try {
+		await fs.access(packageJsonPath);
+		const content = await fs.readFile(packageJsonPath, "utf-8");
+		const pkg = JSON.parse(content);
+		checks.push({
+			name: "package.json",
+			status: "pass",
+			message: `Found: ${pkg.name || "unnamed"}`
+		});
+		const deps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (deps.devflare) {
+			const resolvedVersion = await getPackageVersion();
+			checks.push({
+				name: "devflare dep",
+				status: "pass",
+				message: `package.json: ${deps.devflare}, resolved: ${resolvedVersion}`
+			});
+		} else checks.push({
+			name: "devflare dep",
+			status: "warn",
+			message: "devflare not in dependencies"
+		});
+	} catch {
+		checks.push({
+			name: "package.json",
+			status: "fail",
+			message: "package.json not found"
+		});
+	}
+	if (viteProject.wantsViteIntegration) {
+		checks.push({
+			name: "Vite Integration",
+			status: "pass",
+			message: "Enabled for this package"
+		});
+		if (viteProject.hasLocalViteDependency) checks.push({
+			name: "vite dep",
+			status: "pass",
+			message: "Found in package.json"
+		});
+		else checks.push({
+			name: "vite dep",
+			status: "warn",
+			message: "Not declared in this package.json (workspace-hoisted installs may still work)"
+		});
+		if (viteProject.hasLocalCloudflareVitePluginDependency) checks.push({
+			name: "@cloudflare/vite-plugin",
+			status: "pass",
+			message: "Found in package.json"
+		});
+		else checks.push({
+			name: "@cloudflare/vite-plugin",
+			status: "pass",
+			message: "Optional: not declared in this package.json. Install it only when your Vite config calls the Cloudflare Vite plugin directly."
+		});
+		if (viteProject.viteConfigPath) checks.push({
+			name: "Vite Config",
+			status: "pass",
+			message: `Found: ${viteProject.viteConfigPath}`
+		});
+		else checks.push({
+			name: "Vite Config",
+			status: "warn",
+			message: "No vite.config found. Create one with @cloudflare/vite-plugin"
+		});
+	} else checks.push({
+		name: "Vite Integration",
+		status: "pass",
+		message: "Not enabled for this package (worker-only mode)"
+	});
+	try {
+		await fs.access(resolve(cwd, "tsconfig.json"));
+		checks.push({
+			name: "tsconfig.json",
+			status: "pass",
+			message: "Found"
+		});
+	} catch {
+		checks.push({
+			name: "tsconfig.json",
+			status: "warn",
+			message: "tsconfig.json not found"
+		});
+	}
+	const artifactPaths = getGeneratedArtifactPaths(cwd);
+	if (scope === "all" || scope === "local") try {
+		await fs.access(artifactPaths.devWranglerConfigPath);
+		checks.push({
+			name: "Generated dev config",
+			status: "pass",
+			message: `Found: ${relative(cwd, artifactPaths.devWranglerConfigPath)}`
+		});
+	} catch {
+		checks.push({
+			name: "Generated dev config",
+			status: "warn",
+			message: "Local readiness: not found. Run `devflare dev` or start `devflare/vite` to populate `.devflare/wrangler.jsonc`."
+		});
+	}
+	if (scope === "all" || scope === "deploy") {
+		try {
+			await fs.access(artifactPaths.buildWranglerConfigPath);
+			checks.push({
+				name: "Generated deploy config",
+				status: "pass",
+				message: `Found: ${relative(cwd, artifactPaths.buildWranglerConfigPath)}`
+			});
+		} catch {
+			checks.push({
+				name: "Generated deploy config",
+				status: "warn",
+				message: "Deploy readiness: not found. Run `devflare build` or `devflare deploy` to generate `.devflare/build/wrangler.jsonc`."
+			});
+		}
+		try {
+			await fs.access(artifactPaths.deployRedirectPath);
+			checks.push({
+				name: "Wrangler deploy redirect",
+				status: "pass",
+				message: `Found: ${relative(cwd, artifactPaths.deployRedirectPath)}`
+			});
+		} catch {
+			checks.push({
+				name: "Wrangler deploy redirect",
+				status: "warn",
+				message: "Deploy readiness: not found. Run `devflare build` or `devflare deploy` to generate `.wrangler/deploy/config.json`."
+			});
+		}
+	}
+	let hasFailures = false;
+	let hasWarnings = false;
+	for (const check of checks) {
+		const icon = check.status === "pass" ? "✓" : check.status === "warn" ? "⚠" : "✗";
+		if (check.status === "pass") logLine(logger, `${green(icon, theme)} ${bold(check.name, theme)}${dim(" — ", theme)}${check.message}`);
+		else if (check.status === "warn") {
+			logLine(logger, `${yellow(icon, theme)} ${bold(check.name, theme)}${dim(" — ", theme)}${check.message}`);
+			hasWarnings = true;
+		} else {
+			logLine(logger, `${red(icon, theme)} ${bold(check.name, theme)}${dim(" — ", theme)}${check.message}`);
+			hasFailures = true;
+		}
+	}
+	logLine(logger);
+	if (hasFailures) {
+		logger.error("Some checks failed. Please fix the issues above.");
+		return { exitCode: 1 };
+	}
+	if (hasWarnings) {
+		logger.warn("All critical checks passed, but there are warnings.");
+		return { exitCode: 0 };
+	}
+	logger.success("All checks passed!");
+	return { exitCode: 0 };
+}
+//#endregion
+export { runDoctorCommand };

package/dist/_chunks/durable-object-DMtH0XYX.js

@@ -0,0 +1,234 @@
+import { t as __exportAll } from "./rolldown-runtime-CvQ6eiug.js";
+import MagicString from "magic-string";
+import ts from "typescript";
+//#region src/transform/durable-object.ts
+var durable_object_exports = /* @__PURE__ */ __exportAll({
+	findDurableObjectClasses: () => findDurableObjectClasses,
+	findDurableObjectClassesDetailed: () => findDurableObjectClassesDetailed,
+	transformDurableObject: () => transformDurableObject
+});
+/**
+* Returns the trailing identifier name of an expression used as a class base.
+* Handles `DurableObject`, `Cloudflare.DurableObject`, `DurableObject<Env>`.
+*/
+function getBaseIdentifierName(expr) {
+	if (ts.isIdentifier(expr)) return expr.text;
+	if (ts.isPropertyAccessExpression(expr)) return expr.name.text;
+}
+/**
+* Returns true when the given heritage clause expression refers to DurableObject.
+*/
+function extendsDurableObject(node) {
+	const clauses = node.heritageClauses;
+	if (!clauses) return false;
+	for (const clause of clauses) {
+		if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+		for (const type of clause.types) if (getBaseIdentifierName(type.expression) === "DurableObject") return true;
+	}
+	return false;
+}
+/**
+* Returns the `@durableObject` decorator (if any) on a class declaration,
+* preferring `ts.getDecorators` which understands both legacy and modifier-style decorators.
+*/
+function getDurableObjectDecorator(node) {
+	const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : void 0;
+	if (!decorators) return void 0;
+	for (const decorator of decorators) {
+		const expr = decorator.expression;
+		if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "durableObject") return decorator;
+		if (ts.isIdentifier(expr) && expr.text === "durableObject") return decorator;
+	}
+}
+/**
+* Parse the first argument of the `@durableObject(...)` decorator into a plain options object.
+* Only supports the shapes the runtime uses: boolean literals and arrays of string literals.
+*/
+function parseDecoratorOptions(decorator) {
+	const expr = decorator.expression;
+	if (!ts.isCallExpression(expr)) return void 0;
+	const arg = expr.arguments[0];
+	if (!arg || !ts.isObjectLiteralExpression(arg)) return void 0;
+	const result = {};
+	for (const prop of arg.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		let key;
+		if (ts.isIdentifier(prop.name)) key = prop.name.text;
+		else if (ts.isStringLiteral(prop.name)) key = prop.name.text;
+		if (!key) continue;
+		const value = prop.initializer;
+		if (value.kind === ts.SyntaxKind.TrueKeyword) result[key] = true;
+		else if (value.kind === ts.SyntaxKind.FalseKeyword) result[key] = false;
+		else if (ts.isStringLiteralLike(value)) result[key] = value.text;
+		else if (ts.isNumericLiteral(value)) result[key] = Number(value.text);
+		else if (ts.isArrayLiteralExpression(value)) {
+			const items = [];
+			for (const el of value.elements) if (ts.isStringLiteralLike(el)) items.push(el.text);
+			result[key] = items;
+		}
+	}
+	return result;
+}
+/**
+* Walk top-level statements and collect DO class information.
+*/
+function collectDurableObjectClasses(code) {
+	const sourceFile = ts.createSourceFile("durable-object.tsx", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	const classMap = /* @__PURE__ */ new Map();
+	const inspect = (node) => {
+		if (!node.name) return;
+		if (!((ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false)) return;
+		const name = node.name.text;
+		const extendsBase = extendsDurableObject(node);
+		const decorator = getDurableObjectDecorator(node);
+		const hasDecorator = decorator !== void 0;
+		if (!extendsBase && !hasDecorator) return;
+		const info = classMap.get(name) ?? {
+			name,
+			extendsBase: false,
+			hasDecorator: false
+		};
+		if (extendsBase) info.extendsBase = true;
+		if (hasDecorator) {
+			info.hasDecorator = true;
+			const options = parseDecoratorOptions(decorator);
+			if (options) info.decoratorOptions = options;
+		}
+		classMap.set(name, info);
+	};
+	for (const statement of sourceFile.statements) if (ts.isClassDeclaration(statement)) inspect(statement);
+	return Array.from(classMap.values());
+}
+/**
+* Finds all class names that extend DurableObject or have @durableObject decorator
+*/
+function findDurableObjectClasses(code) {
+	return collectDurableObjectClasses(code).map((info) => info.name);
+}
+/**
+* Finds detailed info about all Durable Object classes
+*/
+function findDurableObjectClassesDetailed(code) {
+	return collectDurableObjectClasses(code);
+}
+/**
+* Transforms a source file to wrap Durable Object classes
+*
+* @param code - Source code to transform
+* @param id - File path/id for source mapping
+* @returns Transformed code with source map, or null if no transforms needed
+*/
+async function transformDurableObject(code, id) {
+	const doClasses = findDurableObjectClassesDetailed(code);
+	if (doClasses.length === 0) return null;
+	const s = new MagicString(code);
+	for (const classInfo of doClasses) {
+		const className = classInfo.name;
+		if (classInfo.extendsBase) {
+			const exportPattern = new RegExp(`export\\s+class\\s+${className}\\s+extends\\s+DurableObject`, "g");
+			let match = exportPattern.exec(code);
+			while (match !== null) {
+				const start = match.index;
+				const exportKeywordEnd = start + 7;
+				s.overwrite(start, exportKeywordEnd, "");
+				const classNameStart = start + match[0].indexOf(className);
+				const classNameEnd = classNameStart + className.length;
+				s.overwrite(classNameStart, classNameEnd, `__Original${className}`);
+				match = exportPattern.exec(code);
+			}
+		} else if (classInfo.hasDecorator) {
+			const decoratorPattern = new RegExp(`@durableObject\\s*\\([^)]*\\)\\s*\\n?\\s*export\\s+class\\s+${className}(?:\\s+extends\\s+(\\w+))?`, "g");
+			let match = decoratorPattern.exec(code);
+			while (match !== null) {
+				const start = match.index;
+				const existingBaseClass = match[1];
+				const decoratorEnd = code.indexOf(")", start) + 1;
+				const exportStart = code.indexOf("export", decoratorEnd);
+				const classDefEnd = start + match[0].length;
+				s.overwrite(start, exportStart, "");
+				const classNameStart = code.indexOf(className, exportStart);
+				const classNameEnd = classNameStart + className.length;
+				if (existingBaseClass) s.overwrite(classNameStart, classNameEnd, `__Original${className}`);
+				else s.overwrite(classNameStart, classDefEnd, `__Original${className} extends DurableObject`);
+				match = decoratorPattern.exec(code);
+			}
+		}
+	}
+	s.prepend(`\nimport { createDurableObjectAlarmEvent, createDurableObjectFetchEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, createDurableObjectWebSocketMessageEvent, runWithEventContext } from 'devflare/runtime'\n`);
+	for (const classInfo of doClasses) {
+		const className = classInfo.name;
+		const options = classInfo.decoratorOptions || {};
+		const wrapper = generateWrapperCodeInternal(className, {
+			alarms: options.alarms === true,
+			websockets: options.websockets === true
+		});
+		s.append(wrapper);
+	}
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			source: id,
+			file: id + ".map",
+			includeContent: true
+		})
+	};
+}
+/**
+* Generate wrapper code for a DO class (internal - omits import since transform adds it)
+*/
+function generateWrapperCodeInternal(className, options) {
+	let wrapper = `
+
+// ============ Devflare DO Wrapper for ${className} ============
+class ${className}Wrapper extends __Original${className} {
+	async fetch(request: Request): Promise<Response> {
+		const __devflareEvent = createDurableObjectFetchEvent(request, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.fetch(__devflareEvent)
+		)
+	}
+`;
+	if (options.alarms) wrapper += `
+	async alarm(): Promise<void> {
+		const __devflareEvent = createDurableObjectAlarmEvent(this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.alarm?.(__devflareEvent) ?? Promise.resolve()
+		)
+	}
+`;
+	if (options.websockets) wrapper += `
+	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketMessageEvent(ws, message, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketMessage?.(__devflareEvent, message) ?? Promise.resolve()
+		)
+	}
+
+	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketClose?.(__devflareEvent, code, reason, wasClean) ?? Promise.resolve()
+		)
+	}
+
+	async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketErrorEvent(ws, error, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketError?.(__devflareEvent, error) ?? Promise.resolve()
+		)
+	}
+`;
+	wrapper += `}
+
+export { ${className}Wrapper as ${className} }
+// ============ End Devflare DO Wrapper ============
+`;
+	return wrapper;
+}
+//#endregion
+export { findDurableObjectClasses as n, transformDurableObject as r, durable_object_exports as t };

package/dist/_chunks/env-S0_nMVz1.js

@@ -0,0 +1,125 @@
+import { j as bridgeEnv, n as getContextOrNull } from "./context-CX50Y2Kb.js";
+//#region src/env.ts
+let testContextEnv = null;
+let testContextDispose = null;
+/**
+* Called by createTestContext to set up the unified env
+* @internal
+*/
+function __setTestContext(envBindings, dispose) {
+	testContextEnv = envBindings;
+	testContextDispose = dispose;
+}
+/**
+* Called after dispose to clear the test context
+* @internal
+*/
+function __clearTestContext() {
+	testContextEnv = null;
+	testContextDispose = null;
+}
+/**
+* Unified environment bindings proxy
+*
+* Automatically selects the right source:
+* - Request context (if inside a request handler)
+* - Test context (if set up by createTestContext)
+* - Bridge to Miniflare (if outside, in dev mode)
+*
+* Includes `dispose()` method for cleanup in tests.
+*
+* @example
+* ```ts
+* import { env } from 'devflare'
+*
+* // Works in request handlers
+* export default {
+*   async fetch(request) {
+*     const value = await env.MY_KV.get('key')
+*     return new Response(value)
+*   }
+* }
+*
+* // Also works in tests (after createTestContext)
+* beforeAll(() => createTestContext())
+* afterAll(() => env.dispose())
+* test('works', async () => {
+*   const result = await env.MY_BINDING.method()
+* })
+* ```
+*/
+const 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 source = getContextOrNull()?.env ?? testContextEnv ?? bridgeEnv;
+		return Reflect.getOwnPropertyDescriptor(source, prop);
+	}
+});
+/**
+* Unified runtime variables proxy.
+*
+* This reads from the same active environment object as {@link env}, but is
+* typed from config `vars` via generated `env.d.ts` declarations. It is useful
+* for nested typed values authored with `defineConfig({ vars })`.
+*/
+const vars = new Proxy({}, {
+	get(_target, prop) {
+		const ctx = getContextOrNull();
+		if (ctx?.env) return ctx.env[prop];
+		if (testContextEnv) return testContextEnv[prop];
+		return bridgeEnv[prop];
+	},
+	has(_target, prop) {
+		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) {
+		const source = getContextOrNull()?.env ?? testContextEnv ?? bridgeEnv;
+		return Reflect.getOwnPropertyDescriptor(source, prop);
+	},
+	set(_target, prop) {
+		throw new TypeError(`Cannot assign to '${String(prop)}' on 'vars' because it is read-only.`);
+	},
+	deleteProperty(_target, prop) {
+		throw new TypeError(`Cannot delete property '${String(prop)}' from 'vars' because it is read-only.`);
+	}
+});
+//#endregion
+export { vars as i, __setTestContext as n, env as r, __clearTestContext as t };