appflare 0.2.41 → 0.2.43

package/cli/utils/handler-discovery.ts

@@ -1,466 +1,466 @@
-import { readdir } from "node:fs/promises";
-import { extname, relative, resolve } from "node:path";
-import * as ts from "typescript";
-import type { LoadedAppflareConfig } from "../types";
-import { ensureRelativeImportPath } from "./path-utils";
-
-export type HandlerKind =
-	| "query"
-	| "mutation"
-	| "scheduler"
-	| "cron"
-	| "storage";
-
-export type DiscoveredArgField = {
-	name: string;
-	type: "string" | "number" | "boolean" | "unknown";
-	optional: boolean;
-	defaultValue?: string;
-};
-
-export type DiscoveredHandlerOperation = {
-	kind: HandlerKind;
-	exportName: string;
-	filePath: string;
-	importPath: string;
-	clientImportPath: string;
-	routePath: string;
-	handlerName?: string;
-	clientSegments?: string[];
-	taskName?: string;
-	cronTriggers?: string[];
-	args?: DiscoveredArgField[];
-};
-
-const supportedExtensions = new Set([".ts", ".tsx", ".mts", ".cts"]);
-
-async function discoverFiles(dirPath: string): Promise<string[]> {
-	const entries = await readdir(dirPath, { withFileTypes: true });
-	const files: string[] = [];
-
-	for (const entry of entries) {
-		if (entry.name.startsWith(".")) {
-			continue;
-		}
-		if (entry.name === "node_modules" || entry.name === "_generated") {
-			continue;
-		}
-
-		const entryPath = resolve(dirPath, entry.name);
-		if (entry.isDirectory()) {
-			files.push(...(await discoverFiles(entryPath)));
-			continue;
-		}
-
-		if (entry.isFile() && supportedExtensions.has(extname(entry.name))) {
-			files.push(entryPath);
-		}
-	}
-
-	return files;
-}
-
-function withoutExtension(filePath: string): string {
-	return filePath.replace(/\.[cm]?tsx?$/, "");
-}
-
-type DiscoveredExport = {
-	exportName: string;
-	kind: HandlerKind;
-	cronTriggers: string[];
-	args: DiscoveredArgField[];
-};
-
-/**
- * Walk a Zod call chain like z.string().optional().default("x")
- * and return the base type name + whether optional/default are applied.
- */
-function readZodArgField(
-	expression: ts.Expression,
-	name: string,
-): DiscoveredArgField {
-	let node: ts.Expression = expression;
-	let optional = false;
-	let defaultValue: string | undefined;
-	let baseType: DiscoveredArgField["type"] = "unknown";
-
-	// Walk the call chain: z.string().optional().default("x")
-	// Each iteration processes one layer (e.g. .default, .optional, .string)
-	while (ts.isCallExpression(node)) {
-		const expr = node.expression;
-		if (!ts.isPropertyAccessExpression(expr)) break;
-
-		const prop = expr.name.text;
-
-		if (prop === "optional" || prop === "nullable") {
-			optional = true;
-			node = expr.expression;
-		} else if (prop === "default") {
-			optional = true;
-			const arg = node.arguments[0];
-			if (arg) {
-				if (ts.isStringLiteral(arg)) defaultValue = arg.text;
-				else if (ts.isNumericLiteral(arg)) defaultValue = arg.text;
-				else if (arg.kind === ts.SyntaxKind.TrueKeyword) defaultValue = "true";
-				else if (arg.kind === ts.SyntaxKind.FalseKeyword)
-					defaultValue = "false";
-			}
-			node = expr.expression;
-		} else if (
-			prop === "string" ||
-			prop === "uuid" ||
-			prop === "email" ||
-			prop === "url"
-		) {
-			baseType = "string";
-			break;
-		} else if (prop === "number" || prop === "int" || prop === "float") {
-			baseType = "number";
-			break;
-		} else if (prop === "boolean") {
-			baseType = "boolean";
-			break;
-		} else {
-			// unknown modifier (.min, .max, .trim, etc.) — keep walking inward
-			node = expr.expression;
-		}
-	}
-
-	return { name, type: baseType, optional, defaultValue };
-}
-
-function readArgsFields(
-	definitionArg: ts.Expression | undefined,
-): DiscoveredArgField[] {
-	if (!definitionArg || !ts.isObjectLiteralExpression(definitionArg)) {
-		return [];
-	}
-
-	const argsProp = definitionArg.properties.find(
-		(p): p is ts.PropertyAssignment =>
-			ts.isPropertyAssignment(p) &&
-			ts.isIdentifier(p.name) &&
-			p.name.text === "args",
-	);
-
-	if (!argsProp || !ts.isObjectLiteralExpression(argsProp.initializer)) {
-		return [];
-	}
-
-	const fields: DiscoveredArgField[] = [];
-	for (const prop of argsProp.initializer.properties) {
-		if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) {
-			continue;
-		}
-		fields.push(readZodArgField(prop.initializer, prop.name.text));
-	}
-	return fields;
-}
-
-function isExportedConst(
-	statement: ts.Statement,
-): statement is ts.VariableStatement {
-	if (!ts.isVariableStatement(statement)) {
-		return false;
-	}
-
-	return (
-		statement.modifiers?.some(
-			(modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
-		) ?? false
-	);
-}
-
-function readIdentifierText(expression: ts.Expression): string | null {
-	if (ts.isIdentifier(expression)) {
-		return expression.text;
-	}
-
-	if (ts.isParenthesizedExpression(expression)) {
-		return readIdentifierText(expression.expression);
-	}
-
-	return null;
-}
-
-function readCronTriggers(argument: ts.Expression | undefined): string[] {
-	if (!argument || !ts.isObjectLiteralExpression(argument)) {
-		return [];
-	}
-
-	const cronProperty = argument.properties.find((property) => {
-		if (!ts.isPropertyAssignment(property)) {
-			return false;
-		}
-
-		if (!ts.isIdentifier(property.name)) {
-			return false;
-		}
-
-		return property.name.text === "cronTrigger";
-	});
-
-	if (!cronProperty || !ts.isPropertyAssignment(cronProperty)) {
-		return [];
-	}
-
-	const initializer = cronProperty.initializer;
-	if (
-		ts.isStringLiteral(initializer) ||
-		ts.isNoSubstitutionTemplateLiteral(initializer)
-	) {
-		return [initializer.text.trim()].filter((value) => value.length > 0);
-	}
-
-	if (ts.isArrayLiteralExpression(initializer)) {
-		return initializer.elements
-			.map((element) => {
-				if (
-					ts.isStringLiteral(element) ||
-					ts.isNoSubstitutionTemplateLiteral(element)
-				) {
-					return element.text.trim();
-				}
-				return "";
-			})
-			.filter((value) => value.length > 0);
-	}
-
-	return [];
-}
-
-function discoverExports(source: string, filePath: string): DiscoveredExport[] {
-	const sourceFile = ts.createSourceFile(
-		filePath,
-		source,
-		ts.ScriptTarget.Latest,
-		true,
-		ts.ScriptKind.TS,
-	);
-	const exports: DiscoveredExport[] = [];
-
-	for (const statement of sourceFile.statements) {
-		if (!isExportedConst(statement)) {
-			continue;
-		}
-
-		for (const declaration of statement.declarationList.declarations) {
-			if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
-				continue;
-			}
-
-			if (!ts.isCallExpression(declaration.initializer)) {
-				continue;
-			}
-
-			const callee = readIdentifierText(declaration.initializer.expression);
-			if (
-				callee !== "query" &&
-				callee !== "mutation" &&
-				callee !== "scheduler" &&
-				callee !== "cron" &&
-				callee !== "storageManager"
-			) {
-				continue;
-			}
-
-			exports.push({
-				exportName: declaration.name.text,
-				kind: callee === "storageManager" ? "storage" : callee,
-				cronTriggers:
-					callee === "cron"
-						? readCronTriggers(declaration.initializer.arguments[0])
-						: [],
-				args:
-					callee === "query" || callee === "mutation"
-						? readArgsFields(declaration.initializer.arguments[0])
-						: [],
-			});
-		}
-	}
-
-	return exports;
-}
-
-function buildRoutePath(
-	kindDirectory: "queries" | "mutations",
-	relativeFilePath: string,
-	exportName: string,
-): string {
-	const normalizedRelativePath = relativeFilePath.replace(/\\/g, "/");
-	const relativeWithoutExtension = withoutExtension(normalizedRelativePath);
-	const segments = relativeWithoutExtension.split("/").filter(Boolean);
-	const routeSegments = [kindDirectory, ...segments, exportName]
-		.filter(Boolean)
-		.map((segment) => segment.trim())
-		.filter((segment) => segment.length > 0);
-
-	return `/${routeSegments.join("/")}`;
-}
-
-function relativePathForKind(
-	relativeToScanDir: string,
-	kindDirectory: "queries" | "mutations" | "schedulers" | "crons",
-): string {
-	const normalized = relativeToScanDir.replace(/\\/g, "/");
-	const marker = `${kindDirectory}/`;
-	const markerIndex = normalized.indexOf(marker);
-
-	if (markerIndex >= 0) {
-		return normalized.slice(markerIndex + marker.length);
-	}
-
-	if (normalized === kindDirectory) {
-		return "index.ts";
-	}
-
-	return normalized;
-}
-
-function buildTaskName(relativeFilePath: string, exportName: string): string {
-	const normalizedRelativePath = relativeFilePath.replace(/\\/g, "/");
-	const relativeWithoutExtension = withoutExtension(normalizedRelativePath);
-	const segments = relativeWithoutExtension.split("/").filter(Boolean);
-	const fileName = segments[segments.length - 1] ?? "index";
-	const dirName = segments.length > 1 ? segments[segments.length - 2] : "root";
-
-	return [dirName, fileName, exportName]
-		.map((segment) => segment.trim())
-		.filter((segment) => segment.length > 0)
-		.join("/");
-}
-
-export async function discoverHandlerOperations(
-	loadedConfig: LoadedAppflareConfig,
-): Promise<DiscoveredHandlerOperation[]> {
-	const operations: DiscoveredHandlerOperation[] = [];
-
-	const files = await discoverFiles(loadedConfig.scanDirAbs).catch(() => []);
-	for (const filePath of files) {
-		const sourceFile = Bun.file(filePath);
-		if (!(await sourceFile.exists())) {
-			continue;
-		}
-
-		const source = await sourceFile.text();
-		const relativeToScanDir = relative(loadedConfig.scanDirAbs, filePath);
-		const discoveredExports = discoverExports(source, filePath);
-
-		const discoveredKinds: Array<{
-			kind: HandlerKind;
-			kindDirectory: "queries" | "mutations" | "schedulers" | "crons";
-			exports: DiscoveredExport[];
-		}> = [
-			{
-				kind: "query",
-				kindDirectory: "queries",
-				exports: discoveredExports.filter((entry) => entry.kind === "query"),
-			},
-			{
-				kind: "mutation",
-				kindDirectory: "mutations",
-				exports: discoveredExports.filter((entry) => entry.kind === "mutation"),
-			},
-			{
-				kind: "scheduler",
-				kindDirectory: "schedulers",
-				exports: discoveredExports.filter(
-					(entry) => entry.kind === "scheduler",
-				),
-			},
-			{
-				kind: "cron",
-				kindDirectory: "crons",
-				exports: discoveredExports.filter((entry) => entry.kind === "cron"),
-			},
-			{
-				kind: "storage",
-				kindDirectory: "queries",
-				exports: discoveredExports.filter((entry) => entry.kind === "storage"),
-			},
-		];
-
-		for (const discovered of discoveredKinds) {
-			if (discovered.exports.length === 0) {
-				continue;
-			}
-
-			const relativeForKind = relativePathForKind(
-				relativeToScanDir,
-				discovered.kindDirectory,
-			);
-
-			for (const discoveredExport of discovered.exports) {
-				const handlerName =
-					discovered.kind === "query" || discovered.kind === "mutation"
-						? buildTaskName(relativeForKind, discoveredExport.exportName)
-						: undefined;
-				const taskName =
-					discovered.kind === "scheduler" || discovered.kind === "cron"
-						? buildTaskName(relativeForKind, discoveredExport.exportName)
-						: undefined;
-				const clientSegments =
-					discovered.kind === "query" || discovered.kind === "mutation"
-						? [
-								...withoutExtension(relativeForKind).split("/").filter(Boolean),
-								discoveredExport.exportName,
-							]
-						: undefined;
-				const routePath =
-					discovered.kind === "query"
-						? buildRoutePath(
-								"queries",
-								relativeForKind,
-								discoveredExport.exportName,
-							)
-						: discovered.kind === "mutation"
-							? buildRoutePath(
-									"mutations",
-									relativeForKind,
-									discoveredExport.exportName,
-								)
-							: discovered.kind === "storage"
-								? `/storage/managers/${discoveredExport.exportName}`
-								: `/${discovered.kindDirectory}/${taskName}`;
-
-				operations.push({
-					kind: discovered.kind,
-					exportName: discoveredExport.exportName,
-					filePath,
-					importPath: ensureRelativeImportPath(
-						loadedConfig.outDirAbs,
-						filePath,
-					),
-					clientImportPath: ensureRelativeImportPath(
-						resolve(loadedConfig.outDirAbs, "client"),
-						filePath,
-					),
-					routePath,
-					handlerName,
-					clientSegments,
-					taskName,
-					cronTriggers: discoveredExport.cronTriggers,
-					args: discoveredExport.args,
-				});
-			}
-		}
-	}
-
-	operations.sort((a, b) => a.routePath.localeCompare(b.routePath));
-
-	const seen = new Map<string, string>();
-	for (const operation of operations) {
-		const uniqueKey = operation.taskName
-			? `task:${operation.taskName}`
-			: `route:${operation.routePath}`;
-		const previous = seen.get(uniqueKey);
-		if (previous) {
-			throw new Error(
-				`Duplicate handler operation discovered: ${operation.taskName ?? operation.routePath} (${previous} and ${operation.filePath}#${operation.exportName}).`,
-			);
-		}
-		seen.set(uniqueKey, `${operation.filePath}#${operation.exportName}`);
-	}
-
-	return operations;
-}
+import { readdir } from "node:fs/promises";
+import { extname, relative, resolve } from "node:path";
+import * as ts from "typescript";
+import type { LoadedAppflareConfig } from "../types";
+import { ensureRelativeImportPath } from "./path-utils";
+
+export type HandlerKind =
+	| "query"
+	| "mutation"
+	| "scheduler"
+	| "cron"
+	| "storage";
+
+export type DiscoveredArgField = {
+	name: string;
+	type: "string" | "number" | "boolean" | "unknown";
+	optional: boolean;
+	defaultValue?: string;
+};
+
+export type DiscoveredHandlerOperation = {
+	kind: HandlerKind;
+	exportName: string;
+	filePath: string;
+	importPath: string;
+	clientImportPath: string;
+	routePath: string;
+	handlerName?: string;
+	clientSegments?: string[];
+	taskName?: string;
+	cronTriggers?: string[];
+	args?: DiscoveredArgField[];
+};
+
+const supportedExtensions = new Set([".ts", ".tsx", ".mts", ".cts"]);
+
+async function discoverFiles(dirPath: string): Promise<string[]> {
+	const entries = await readdir(dirPath, { withFileTypes: true });
+	const files: string[] = [];
+
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) {
+			continue;
+		}
+		if (entry.name === "node_modules" || entry.name === "_generated") {
+			continue;
+		}
+
+		const entryPath = resolve(dirPath, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...(await discoverFiles(entryPath)));
+			continue;
+		}
+
+		if (entry.isFile() && supportedExtensions.has(extname(entry.name))) {
+			files.push(entryPath);
+		}
+	}
+
+	return files;
+}
+
+function withoutExtension(filePath: string): string {
+	return filePath.replace(/\.[cm]?tsx?$/, "");
+}
+
+type DiscoveredExport = {
+	exportName: string;
+	kind: HandlerKind;
+	cronTriggers: string[];
+	args: DiscoveredArgField[];
+};
+
+/**
+ * Walk a Zod call chain like z.string().optional().default("x")
+ * and return the base type name + whether optional/default are applied.
+ */
+function readZodArgField(
+	expression: ts.Expression,
+	name: string,
+): DiscoveredArgField {
+	let node: ts.Expression = expression;
+	let optional = false;
+	let defaultValue: string | undefined;
+	let baseType: DiscoveredArgField["type"] = "unknown";
+
+	// Walk the call chain: z.string().optional().default("x")
+	// Each iteration processes one layer (e.g. .default, .optional, .string)
+	while (ts.isCallExpression(node)) {
+		const expr = node.expression;
+		if (!ts.isPropertyAccessExpression(expr)) break;
+
+		const prop = expr.name.text;
+
+		if (prop === "optional" || prop === "nullable") {
+			optional = true;
+			node = expr.expression;
+		} else if (prop === "default") {
+			optional = true;
+			const arg = node.arguments[0];
+			if (arg) {
+				if (ts.isStringLiteral(arg)) defaultValue = arg.text;
+				else if (ts.isNumericLiteral(arg)) defaultValue = arg.text;
+				else if (arg.kind === ts.SyntaxKind.TrueKeyword) defaultValue = "true";
+				else if (arg.kind === ts.SyntaxKind.FalseKeyword)
+					defaultValue = "false";
+			}
+			node = expr.expression;
+		} else if (
+			prop === "string" ||
+			prop === "uuid" ||
+			prop === "email" ||
+			prop === "url"
+		) {
+			baseType = "string";
+			break;
+		} else if (prop === "number" || prop === "int" || prop === "float") {
+			baseType = "number";
+			break;
+		} else if (prop === "boolean") {
+			baseType = "boolean";
+			break;
+		} else {
+			// unknown modifier (.min, .max, .trim, etc.) — keep walking inward
+			node = expr.expression;
+		}
+	}
+
+	return { name, type: baseType, optional, defaultValue };
+}
+
+function readArgsFields(
+	definitionArg: ts.Expression | undefined,
+): DiscoveredArgField[] {
+	if (!definitionArg || !ts.isObjectLiteralExpression(definitionArg)) {
+		return [];
+	}
+
+	const argsProp = definitionArg.properties.find(
+		(p): p is ts.PropertyAssignment =>
+			ts.isPropertyAssignment(p) &&
+			ts.isIdentifier(p.name) &&
+			p.name.text === "args",
+	);
+
+	if (!argsProp || !ts.isObjectLiteralExpression(argsProp.initializer)) {
+		return [];
+	}
+
+	const fields: DiscoveredArgField[] = [];
+	for (const prop of argsProp.initializer.properties) {
+		if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) {
+			continue;
+		}
+		fields.push(readZodArgField(prop.initializer, prop.name.text));
+	}
+	return fields;
+}
+
+function isExportedConst(
+	statement: ts.Statement,
+): statement is ts.VariableStatement {
+	if (!ts.isVariableStatement(statement)) {
+		return false;
+	}
+
+	return (
+		statement.modifiers?.some(
+			(modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+		) ?? false
+	);
+}
+
+function readIdentifierText(expression: ts.Expression): string | null {
+	if (ts.isIdentifier(expression)) {
+		return expression.text;
+	}
+
+	if (ts.isParenthesizedExpression(expression)) {
+		return readIdentifierText(expression.expression);
+	}
+
+	return null;
+}
+
+function readCronTriggers(argument: ts.Expression | undefined): string[] {
+	if (!argument || !ts.isObjectLiteralExpression(argument)) {
+		return [];
+	}
+
+	const cronProperty = argument.properties.find((property) => {
+		if (!ts.isPropertyAssignment(property)) {
+			return false;
+		}
+
+		if (!ts.isIdentifier(property.name)) {
+			return false;
+		}
+
+		return property.name.text === "cronTrigger";
+	});
+
+	if (!cronProperty || !ts.isPropertyAssignment(cronProperty)) {
+		return [];
+	}
+
+	const initializer = cronProperty.initializer;
+	if (
+		ts.isStringLiteral(initializer) ||
+		ts.isNoSubstitutionTemplateLiteral(initializer)
+	) {
+		return [initializer.text.trim()].filter((value) => value.length > 0);
+	}
+
+	if (ts.isArrayLiteralExpression(initializer)) {
+		return initializer.elements
+			.map((element) => {
+				if (
+					ts.isStringLiteral(element) ||
+					ts.isNoSubstitutionTemplateLiteral(element)
+				) {
+					return element.text.trim();
+				}
+				return "";
+			})
+			.filter((value) => value.length > 0);
+	}
+
+	return [];
+}
+
+function discoverExports(source: string, filePath: string): DiscoveredExport[] {
+	const sourceFile = ts.createSourceFile(
+		filePath,
+		source,
+		ts.ScriptTarget.Latest,
+		true,
+		ts.ScriptKind.TS,
+	);
+	const exports: DiscoveredExport[] = [];
+
+	for (const statement of sourceFile.statements) {
+		if (!isExportedConst(statement)) {
+			continue;
+		}
+
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+				continue;
+			}
+
+			if (!ts.isCallExpression(declaration.initializer)) {
+				continue;
+			}
+
+			const callee = readIdentifierText(declaration.initializer.expression);
+			if (
+				callee !== "query" &&
+				callee !== "mutation" &&
+				callee !== "scheduler" &&
+				callee !== "cron" &&
+				callee !== "storageManager"
+			) {
+				continue;
+			}
+
+			exports.push({
+				exportName: declaration.name.text,
+				kind: callee === "storageManager" ? "storage" : callee,
+				cronTriggers:
+					callee === "cron"
+						? readCronTriggers(declaration.initializer.arguments[0])
+						: [],
+				args:
+					callee === "query" || callee === "mutation"
+						? readArgsFields(declaration.initializer.arguments[0])
+						: [],
+			});
+		}
+	}
+
+	return exports;
+}
+
+function buildRoutePath(
+	kindDirectory: "queries" | "mutations",
+	relativeFilePath: string,
+	exportName: string,
+): string {
+	const normalizedRelativePath = relativeFilePath.replace(/\\/g, "/");
+	const relativeWithoutExtension = withoutExtension(normalizedRelativePath);
+	const segments = relativeWithoutExtension.split("/").filter(Boolean);
+	const routeSegments = [kindDirectory, ...segments, exportName]
+		.filter(Boolean)
+		.map((segment) => segment.trim())
+		.filter((segment) => segment.length > 0);
+
+	return `/${routeSegments.join("/")}`;
+}
+
+function relativePathForKind(
+	relativeToScanDir: string,
+	kindDirectory: "queries" | "mutations" | "schedulers" | "crons",
+): string {
+	const normalized = relativeToScanDir.replace(/\\/g, "/");
+	const marker = `${kindDirectory}/`;
+	const markerIndex = normalized.indexOf(marker);
+
+	if (markerIndex >= 0) {
+		return normalized.slice(markerIndex + marker.length);
+	}
+
+	if (normalized === kindDirectory) {
+		return "index.ts";
+	}
+
+	return normalized;
+}
+
+function buildTaskName(relativeFilePath: string, exportName: string): string {
+	const normalizedRelativePath = relativeFilePath.replace(/\\/g, "/");
+	const relativeWithoutExtension = withoutExtension(normalizedRelativePath);
+	const segments = relativeWithoutExtension.split("/").filter(Boolean);
+	const fileName = segments[segments.length - 1] ?? "index";
+	const dirName = segments.length > 1 ? segments[segments.length - 2] : "root";
+
+	return [dirName, fileName, exportName]
+		.map((segment) => segment.trim())
+		.filter((segment) => segment.length > 0)
+		.join("/");
+}
+
+export async function discoverHandlerOperations(
+	loadedConfig: LoadedAppflareConfig,
+): Promise<DiscoveredHandlerOperation[]> {
+	const operations: DiscoveredHandlerOperation[] = [];
+
+	const files = await discoverFiles(loadedConfig.scanDirAbs).catch(() => []);
+	for (const filePath of files) {
+		const sourceFile = Bun.file(filePath);
+		if (!(await sourceFile.exists())) {
+			continue;
+		}
+
+		const source = await sourceFile.text();
+		const relativeToScanDir = relative(loadedConfig.scanDirAbs, filePath);
+		const discoveredExports = discoverExports(source, filePath);
+
+		const discoveredKinds: Array<{
+			kind: HandlerKind;
+			kindDirectory: "queries" | "mutations" | "schedulers" | "crons";
+			exports: DiscoveredExport[];
+		}> = [
+			{
+				kind: "query",
+				kindDirectory: "queries",
+				exports: discoveredExports.filter((entry) => entry.kind === "query"),
+			},
+			{
+				kind: "mutation",
+				kindDirectory: "mutations",
+				exports: discoveredExports.filter((entry) => entry.kind === "mutation"),
+			},
+			{
+				kind: "scheduler",
+				kindDirectory: "schedulers",
+				exports: discoveredExports.filter(
+					(entry) => entry.kind === "scheduler",
+				),
+			},
+			{
+				kind: "cron",
+				kindDirectory: "crons",
+				exports: discoveredExports.filter((entry) => entry.kind === "cron"),
+			},
+			{
+				kind: "storage",
+				kindDirectory: "queries",
+				exports: discoveredExports.filter((entry) => entry.kind === "storage"),
+			},
+		];
+
+		for (const discovered of discoveredKinds) {
+			if (discovered.exports.length === 0) {
+				continue;
+			}
+
+			const relativeForKind = relativePathForKind(
+				relativeToScanDir,
+				discovered.kindDirectory,
+			);
+
+			for (const discoveredExport of discovered.exports) {
+				const handlerName =
+					discovered.kind === "query" || discovered.kind === "mutation"
+						? buildTaskName(relativeForKind, discoveredExport.exportName)
+						: undefined;
+				const taskName =
+					discovered.kind === "scheduler" || discovered.kind === "cron"
+						? buildTaskName(relativeForKind, discoveredExport.exportName)
+						: undefined;
+				const clientSegments =
+					discovered.kind === "query" || discovered.kind === "mutation"
+						? [
+								...withoutExtension(relativeForKind).split("/").filter(Boolean),
+								discoveredExport.exportName,
+							]
+						: undefined;
+				const routePath =
+					discovered.kind === "query"
+						? buildRoutePath(
+								"queries",
+								relativeForKind,
+								discoveredExport.exportName,
+							)
+						: discovered.kind === "mutation"
+							? buildRoutePath(
+									"mutations",
+									relativeForKind,
+									discoveredExport.exportName,
+								)
+							: discovered.kind === "storage"
+								? `/storage/managers/${discoveredExport.exportName}`
+								: `/${discovered.kindDirectory}/${taskName}`;
+
+				operations.push({
+					kind: discovered.kind,
+					exportName: discoveredExport.exportName,
+					filePath,
+					importPath: ensureRelativeImportPath(
+						loadedConfig.outDirAbs,
+						filePath,
+					),
+					clientImportPath: ensureRelativeImportPath(
+						resolve(loadedConfig.outDirAbs, "client"),
+						filePath,
+					),
+					routePath,
+					handlerName,
+					clientSegments,
+					taskName,
+					cronTriggers: discoveredExport.cronTriggers,
+					args: discoveredExport.args,
+				});
+			}
+		}
+	}
+
+	operations.sort((a, b) => a.routePath.localeCompare(b.routePath));
+
+	const seen = new Map<string, string>();
+	for (const operation of operations) {
+		const uniqueKey = operation.taskName
+			? `task:${operation.taskName}`
+			: `route:${operation.routePath}`;
+		const previous = seen.get(uniqueKey);
+		if (previous) {
+			throw new Error(
+				`Duplicate handler operation discovered: ${operation.taskName ?? operation.routePath} (${previous} and ${operation.filePath}#${operation.exportName}).`,
+			);
+		}
+		seen.set(uniqueKey, `${operation.filePath}#${operation.exportName}`);
+	}
+
+	return operations;
+}