appflare 0.0.1

package/cli/README.md

@@ -0,0 +1,101 @@
+# Appflare CLI
+
+This folder contains the build toolchain that turns an Appflare project (schema + query/mutation handlers) into a fully generated API surface (typed client, Hono server, websocket durable object, and optional JS/.d.ts emit). The CLI is Bun-based and is intended to run inside a project that exports `appflare.config.ts`.
+
+## Command surface
+
+- **build**: entrypoint defined in [packages/appflare/cli/index.ts](packages/appflare/cli/index.ts). Generates all artifacts into the configured `outDir` and optionally emits compiled output.
+  - `-c, --config <path>`: path to the config file (defaults to `appflare.config.ts`).
+  - `--emit`: after generation, run `bunx tsc` with a temporary tsconfig to emit JS and .d.ts into `outDir/dist`.
+
+### Config shape
+
+`appflare.config.ts` must default-export an object with:
+
+```ts
+export default {
+	dir: "./app", // Root folder containing your handlers
+	schema: "./schema.ts", // Path to the Zod schema file
+	outDir: "./_generated", // Where generated files are written
+};
+```
+
+The loader in [packages/appflare/cli/core/config.ts](packages/appflare/cli/core/config.ts) validates presence and types of `dir`, `schema`, and `outDir` and resolves paths relative to the config file location.
+
+## Build pipeline
+
+The build orchestrator in [packages/appflare/cli/core/build.ts](packages/appflare/cli/core/build.ts) performs the following steps when `build` runs:
+
+1. Resolve absolute paths for `dir`, `schema`, and `outDir`; ensure `dir` and `schema` exist.
+2. Create `outDir/src` and `outDir/server` if missing.
+3. Generate typed schema helpers into `outDir/src/schema-types.ts` using [packages/appflare/cli/schema/schema.ts](packages/appflare/cli/schema/schema.ts). This produces table doc interfaces, `TableNames`, `Id`, query helpers, and convenience types from [packages/appflare/cli/schema/schema-static-types.ts](packages/appflare/cli/schema/schema-static-types.ts).
+4. Generate built-in CRUD handlers for every table into `outDir/src/handlers/<table>.ts` plus an index via [packages/appflare/cli/generators/generate-db-handlers.ts](packages/appflare/cli/generators/generate-db-handlers.ts). These include `find*`, `findOne*`, `insert*`, `update*`, and `delete*` operations backed by the generated schema types.
+5. Discover user-defined handlers under `dir` with [packages/appflare/cli/core/discover-handlers.ts](packages/appflare/cli/core/discover-handlers.ts):
+   - Recurses through `.ts` files (excluding `node_modules`, `.git`, `dist`, `build`, and the configured `outDir`).
+   - Recognizes handlers declared as `export const <name> = query(` or `export const <name> = mutation(`.
+   - Skips the schema file and the config file; deduplicates by kind/file/name.
+6. Generate a typed client at `outDir/src/api.ts` via [packages/appflare/cli/generators/generate-api-client.ts](packages/appflare/cli/generators/generate-api-client.ts):
+   - Produces `createAppflareApi()` with `queries` and `mutations` collections keyed by `<file>/<handler>`.
+   - Each handler function wraps `fetch` (default `better-fetch`) and carries metadata: Zod schema, websocket helper, and route path.
+   - Realtime helpers build websocket URLs for subscriptions, normalizing `ws`/`wss` bases and providing hooks (`onOpen`, `onMessage`, `onData`, etc.).
+7. Generate a Hono server at `outDir/server/server.ts` with [packages/appflare/cli/generators/generate-hono-server.ts](packages/appflare/cli/generators/generate-hono-server.ts):
+   - Routes: `GET /queries/<file>/<name>` and `POST /mutations/<file>/<name>`.
+   - Uses `@hono/standard-validator` + Zod arg schemas and wraps Mongo via `createMongoDbContext` from `appflare/server/db`.
+   - Supports optional mutation notifications for realtime (custom notifier or Durable Object hook).
+8. Generate a websocket Durable Object shim at `outDir/server/websocket-hibernation-server.ts` via [packages/appflare/cli/generators/generate-websocket-durable-object.ts](packages/appflare/cli/generators/generate-websocket-durable-object.ts):
+   - Implements `WebSocketHibernationServer` to handle subscriptions at `/ws` and mutation notifications at `/notify`.
+   - Selects a default query handler per table (or a specific handler) and re-fetches data on mutation notifications, emitting `data` messages to subscribers.
+9. If `--emit` is set, remove any previous `outDir/dist`, write a temporary tsconfig (includes generated schema types and handlers only), and run `bunx tsc` to emit JS + .d.ts into `outDir/dist` (logic in [packages/appflare/cli/utils/tsc.ts](packages/appflare/cli/utils/tsc.ts)).
+
+## Handler authoring guidelines
+
+- Handlers must be exported as `query({ args, handler })` or `mutation({ args, handler })` objects.
+- Filenames become the first route/path segment and grouping key in the client (`<file>/<handler>`).
+- Arguments are validated with Zod; the client infers optional vs required keys and provides typed `args` for both client and server.
+- The discovery step ignores `.d.ts` files and anything outside the configured `dir`.
+
+## Generated layout (relative to `outDir`)
+
+```
+src/
+  schema-types.ts          # Typed schema exports, helpers, and Zod-powered validator types
+  handlers/               # Auto CRUD handlers per table + index
+    <table>.ts
+    index.ts
+  api.ts                  # Typed queries/mutations client with realtime helpers
+server/
+  server.ts               # Hono server that wires handlers + Mongo context
+  websocket-hibernation-server.ts # Durable Object websocket bridge
+```
+
+## Realtime and Durable Object flow
+
+- Client websockets are created via `handler.websocket(args?, options?)`, building URLs against `realtime.baseUrl` (or handler override) and defaulting the `table` and `handler` params based on the handler’s file/name.
+- The Durable Object handles `/ws` upgrades, parses subscription params (`table`, `handler`, `where`, `orderBy`, `take`, `skip`, `select`, `include`, `args`), and caches subscriptions. On `/notify` payloads, it re-runs the relevant query or table fetch and pushes a `data` message to connected sockets.
+- Mutation notifications can be sent by the generated Hono server (if `realtime.notify` or `realtime.durableObject` is provided) so subscriptions stay in sync.
+
+## Error handling and safeguards
+
+- Config, schema, and project directories are validated before generation; missing paths throw with readable errors.
+- Build de-duplicates discovered handlers to avoid duplicate route generation.
+- `--emit` uses a scoped tsconfig that only references generated files to prevent user code outside `rootDir` from breaking emit.
+- Generated files include `/* eslint-disable */` headers to avoid lint noise.
+
+## Typical usage
+
+```sh
+# From the repo root (config defaults to ./appflare.config.ts)
+bunx appflare build
+
+# Custom config location and emit compiled JS
+bunx appflare build --config ./config/appflare.config.ts --emit
+```
+
+After running, import the generated client/server:
+
+```ts
+import { createAppflareApi } from "./_generated/src/api";
+import server from "./_generated/server/server";
+```
+
+Use the client in web/React or server contexts, and deploy the generated Hono server + Durable Object to your runtime of choice (e.g., Cloudflare Workers with Mongo).

package/cli/core/build.ts

@@ -0,0 +1,136 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import {
+	AppflareConfig,
+	assertDirExists,
+	assertFileExists,
+} from "../utils/utils";
+import { getSchemaTableNames, generateSchemaTypes } from "../schema/schema";
+import {
+	generateDbHandlers,
+	discoverHandlers,
+	generateApiClient,
+	generateHonoServer,
+	generateWebsocketDurableObject,
+} from "./handlers";
+
+export async function buildFromConfig(params: {
+	config: AppflareConfig;
+	configDirAbs: string;
+	configPathAbs: string;
+	emit: boolean;
+}): Promise<void> {
+	const { config, configDirAbs, emit, configPathAbs } = params;
+
+	const projectDirAbs = path.resolve(configDirAbs, config.dir);
+	const schemaPathAbs = path.resolve(configDirAbs, config.schema);
+	const outDirAbs = path.resolve(configDirAbs, config.outDir);
+
+	await assertDirExists(
+		projectDirAbs,
+		`Project dir not found: ${projectDirAbs}`
+	);
+	await assertFileExists(schemaPathAbs, `Schema not found: ${schemaPathAbs}`);
+
+	await fs.mkdir(path.join(outDirAbs, "src"), { recursive: true });
+	await fs.mkdir(path.join(outDirAbs, "server"), { recursive: true });
+
+	const schemaTypesTs = await generateSchemaTypes({ schemaPathAbs });
+	await fs.writeFile(
+		path.join(outDirAbs, "src", "schema-types.ts"),
+		schemaTypesTs
+	);
+
+	// (Re)generate built-in DB handlers based on the schema tables.
+	const schemaTableNames = await getSchemaTableNames(schemaPathAbs);
+	await generateDbHandlers({ outDirAbs, tableNames: schemaTableNames });
+
+	const handlers = await discoverHandlers({
+		projectDirAbs,
+		schemaPathAbs,
+		outDirAbs,
+		configPathAbs,
+	});
+
+	const apiTs = generateApiClient({ handlers, outDirAbs });
+	await fs.writeFile(path.join(outDirAbs, "src", "api.ts"), apiTs);
+
+	const serverTs = generateHonoServer({
+		handlers,
+		outDirAbs,
+		schemaPathAbs,
+	});
+	await fs.writeFile(path.join(outDirAbs, "server", "server.ts"), serverTs);
+
+	const websocketDoTs = generateWebsocketDurableObject({
+		handlers,
+		outDirAbs,
+		schemaPathAbs,
+	});
+	await fs.writeFile(
+		path.join(outDirAbs, "server", "websocket-hibernation-server.ts"),
+		websocketDoTs
+	);
+
+	if (emit) {
+		// Remove previous emit output to avoid stale files lingering.
+		await fs.rm(path.join(outDirAbs, "dist"), { recursive: true, force: true });
+
+		// Emit only the files that don't pull in user code outside rootDir.
+		// This avoids TS rootDir issues and dist overwrite issues caused by user modules.
+		const emitTsconfigAbs = await writeEmitTsconfig({
+			configDirAbs,
+			outDirAbs,
+		});
+		await runTscEmit(emitTsconfigAbs);
+	}
+}
+
+async function writeEmitTsconfig(params: {
+	configDirAbs: string;
+	outDirAbs: string;
+}): Promise<string> {
+	const outDirRel =
+		path.relative(params.configDirAbs, params.outDirAbs).replace(/\\/g, "/") ||
+		"./_generated";
+	const tsconfigPathAbs = path.join(
+		params.configDirAbs,
+		".appflare.tsconfig.emit.json"
+	);
+	const content = {
+		compilerOptions: {
+			noEmit: false,
+			declaration: true,
+			emitDeclarationOnly: false,
+			outDir: `./${outDirRel}/dist`,
+			rootDir: `./${outDirRel}/src`,
+			sourceMap: false,
+			declarationMap: false,
+			skipLibCheck: true,
+			target: "ES2022",
+			module: "ES2022",
+			moduleResolution: "Bundler",
+			types: [],
+		},
+		include: [
+			`./${outDirRel}/src/schema-types.ts`,
+			`./${outDirRel}/src/handlers/**/*`,
+		],
+	};
+	await fs.writeFile(tsconfigPathAbs, JSON.stringify(content, null, 2));
+	return tsconfigPathAbs;
+}
+
+async function runTscEmit(tsconfigPathAbs: string): Promise<void> {
+	await new Promise<void>((resolve, reject) => {
+		const child = spawn("bunx", ["tsc", "-p", tsconfigPathAbs], {
+			stdio: "inherit",
+		});
+		child.on("error", reject);
+		child.on("exit", (code) => {
+			if (code === 0) resolve();
+			reject(new Error(`tsc exited with code ${code}`));
+		});
+	});
+}

package/cli/core/config.ts

@@ -0,0 +1,29 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { AppflareConfig, assertFileExists } from "../utils/utils";
+
+export async function loadConfig(
+	configPathAbs: string
+): Promise<{ config: AppflareConfig; configDirAbs: string }> {
+	await assertFileExists(configPathAbs, `Config not found: ${configPathAbs}`);
+	const configDirAbs = path.dirname(configPathAbs);
+
+	const mod = await import(pathToFileURL(configPathAbs).href);
+	const config = (mod?.default ?? mod) as Partial<AppflareConfig>;
+	if (!config || typeof config !== "object") {
+		throw new Error(
+			`Invalid config export in ${configPathAbs} (expected default export object)`
+		);
+	}
+	if (typeof config.dir !== "string" || !config.dir) {
+		throw new Error(`Invalid config.dir in ${configPathAbs}`);
+	}
+	if (typeof config.schema !== "string" || !config.schema) {
+		throw new Error(`Invalid config.schema in ${configPathAbs}`);
+	}
+	if (typeof config.outDir !== "string" || !config.outDir) {
+		throw new Error(`Invalid config.outDir in ${configPathAbs}`);
+	}
+	return { config: config as AppflareConfig, configDirAbs };
+}

package/cli/core/discover-handlers.ts

@@ -0,0 +1,61 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import {
+	DiscoveredHandler,
+	HandlerKind,
+	walkTsFiles,
+	groupBy,
+} from "../utils/utils";
+
+export async function discoverHandlers(params: {
+	projectDirAbs: string;
+	schemaPathAbs: string;
+	outDirAbs: string;
+	configPathAbs: string;
+}): Promise<DiscoveredHandler[]> {
+	const ignoreDirs = new Set([
+		"node_modules",
+		".git",
+		"dist",
+		"build",
+		path.basename(params.outDirAbs),
+	]);
+
+	const files = await walkTsFiles(params.projectDirAbs, ignoreDirs);
+
+	const handlers: DiscoveredHandler[] = [];
+	for (const fileAbs of files) {
+		if (path.resolve(fileAbs) === path.resolve(params.schemaPathAbs)) continue;
+		if (path.resolve(fileAbs) === path.resolve(params.configPathAbs)) continue;
+
+		const content = await fs.readFile(fileAbs, "utf8");
+		const regex =
+			/export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(query|mutation)\s*\(/g;
+		let match: RegExpExecArray | null;
+		while ((match = regex.exec(content)) !== null) {
+			handlers.push({
+				fileName: path.basename(fileAbs, ".ts"),
+				name: match[1],
+				kind: match[2] as HandlerKind,
+				sourceFileAbs: fileAbs,
+			});
+		}
+	}
+
+	// De-dupe: keep first occurrence
+	const seen = new Set<string>();
+	const unique = handlers.filter((h) => {
+		const key = `${h.kind}:${h.fileName}:${h.name}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+
+	unique.sort((a, b) => {
+		if (a.kind !== b.kind) return a.kind.localeCompare(b.kind);
+		if (a.fileName !== b.fileName) return a.fileName.localeCompare(b.fileName);
+		return a.name.localeCompare(b.name);
+	});
+
+	return unique;
+}

package/cli/core/handlers.ts

@@ -0,0 +1,5 @@
+export { discoverHandlers } from "./discover-handlers";
+export { generateDbHandlers } from "../generators/generate-db-handlers";
+export { generateApiClient } from "../generators/generate-api-client";
+export { generateHonoServer } from "../generators/generate-hono-server";
+export { generateWebsocketDurableObject } from "../generators/generate-websocket-durable-object";

package/cli/core/index.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+	discoverHandlers,
+	generateApiClient,
+	generateDbHandlers,
+	generateHonoServer,
+	generateWebsocketDurableObject,
+} from "./handlers";
+import { generateSchemaTypes, getSchemaTableNames } from "../schema/schema";
+import { runTscEmit, writeEmitTsconfig } from "../utils/tsc";
+import { assertDirExists, assertFileExists } from "../utils/utils";
+
+type AppflareConfig = {
+	dir: string;
+	schema: string;
+	outDir: string;
+};
+
+const program = new Command();
+
+program.name("appflare").description("Appflare CLI").version("0.0.0");
+
+program
+	.command("build")
+	.description(
+		"Generate typed schema + query/mutation client/server into outDir"
+	)
+	.option(
+		"-c, --config <path>",
+		"Path to appflare.config.ts",
+		"appflare.config.ts"
+	)
+	.option("--emit", "Also run tsc to emit JS + .d.ts into outDir/dist")
+	.action(async (options: { config: string; emit?: boolean }) => {
+		try {
+			const configPath = path.resolve(process.cwd(), options.config);
+			const { config, configDirAbs } = await loadConfig(configPath);
+			await buildFromConfig({
+				config,
+				configDirAbs,
+				configPathAbs: configPath,
+				emit: Boolean(options.emit),
+			});
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error(message);
+			process.exitCode = 1;
+		}
+	});
+
+void main();
+
+async function main(): Promise<void> {
+	await program.parseAsync(process.argv);
+}
+
+async function loadConfig(
+	configPathAbs: string
+): Promise<{ config: AppflareConfig; configDirAbs: string }> {
+	await assertFileExists(configPathAbs, `Config not found: ${configPathAbs}`);
+	const configDirAbs = path.dirname(configPathAbs);
+
+	const mod = await import(pathToFileURL(configPathAbs).href);
+	const config = (mod?.default ?? mod) as Partial<AppflareConfig>;
+	if (!config || typeof config !== "object") {
+		throw new Error(
+			`Invalid config export in ${configPathAbs} (expected default export object)`
+		);
+	}
+	if (typeof config.dir !== "string" || !config.dir) {
+		throw new Error(`Invalid config.dir in ${configPathAbs}`);
+	}
+	if (typeof config.schema !== "string" || !config.schema) {
+		throw new Error(`Invalid config.schema in ${configPathAbs}`);
+	}
+	if (typeof config.outDir !== "string" || !config.outDir) {
+		throw new Error(`Invalid config.outDir in ${configPathAbs}`);
+	}
+	return { config: config as AppflareConfig, configDirAbs };
+}
+
+async function buildFromConfig(params: {
+	config: AppflareConfig;
+	configDirAbs: string;
+	configPathAbs: string;
+	emit: boolean;
+}): Promise<void> {
+	const { config, configDirAbs, emit, configPathAbs } = params;
+
+	const projectDirAbs = path.resolve(configDirAbs, config.dir);
+	const schemaPathAbs = path.resolve(configDirAbs, config.schema);
+	const outDirAbs = path.resolve(configDirAbs, config.outDir);
+
+	await assertDirExists(
+		projectDirAbs,
+		`Project dir not found: ${projectDirAbs}`
+	);
+	await assertFileExists(schemaPathAbs, `Schema not found: ${schemaPathAbs}`);
+
+	await fs.mkdir(path.join(outDirAbs, "src"), { recursive: true });
+	await fs.mkdir(path.join(outDirAbs, "server"), { recursive: true });
+
+	const schemaTypesTs = await generateSchemaTypes({ schemaPathAbs });
+	await fs.writeFile(
+		path.join(outDirAbs, "src", "schema-types.ts"),
+		schemaTypesTs
+	);
+
+	// (Re)generate built-in DB handlers based on the schema tables.
+	const schemaTableNames = await getSchemaTableNames(schemaPathAbs);
+	await generateDbHandlers({ outDirAbs, tableNames: schemaTableNames });
+
+	const handlers = await discoverHandlers({
+		projectDirAbs,
+		schemaPathAbs,
+		outDirAbs,
+		configPathAbs,
+	});
+
+	const apiTs = generateApiClient({ handlers, outDirAbs });
+	await fs.writeFile(path.join(outDirAbs, "src", "api.ts"), apiTs);
+
+	const serverTs = generateHonoServer({
+		handlers,
+		outDirAbs,
+		schemaPathAbs,
+	});
+	await fs.writeFile(path.join(outDirAbs, "server", "server.ts"), serverTs);
+
+	const websocketDoTs = generateWebsocketDurableObject({
+		handlers,
+		outDirAbs,
+		schemaPathAbs,
+	});
+	await fs.writeFile(
+		path.join(outDirAbs, "server", "websocket-hibernation-server.ts"),
+		websocketDoTs
+	);
+
+	if (emit) {
+		// Remove previous emit output to avoid stale files lingering.
+		await fs.rm(path.join(outDirAbs, "dist"), { recursive: true, force: true });
+
+		// Emit only the files that don't pull in user code outside rootDir.
+		// This avoids TS rootDir issues and dist overwrite issues caused by user modules.
+		const emitTsconfigAbs = await writeEmitTsconfig({
+			configDirAbs,
+			outDirAbs,
+		});
+		await runTscEmit(emitTsconfigAbs);
+	}
+}

package/cli/generators/generate-api-client/client.ts

@@ -0,0 +1,93 @@
+import { DiscoveredHandler } from "../../utils/utils";
+import {
+	handlerTypePrefix,
+	normalizeTableName,
+	renderObjectKey,
+	sortedEntries,
+} from "./utils";
+
+export function generateQueriesClientLines(
+	queriesByFile: Map<string, DiscoveredHandler[]>,
+	importAliasBySource: Map<string, string>
+): string {
+	return sortedEntries(queriesByFile)
+		.map(([fileName, list]) => {
+			const fileKey = renderObjectKey(fileName);
+			const inner = list
+				.slice()
+				.sort((a, b) => a.name.localeCompare(b.name))
+				.map((h) => {
+					const pascal = handlerTypePrefix(h);
+					const route = `/queries/${fileName}/${h.name}`;
+					const importAlias = importAliasBySource.get(h.sourceFileAbs)!;
+					const handlerAccessor = `${importAlias}.${h.name}`;
+					return (
+						`\t\t${h.name}: withHandlerMetadata<${pascal}Definition>(\n` +
+						`\t\t\tasync (args: ${pascal}Args, init) => {\n` +
+						`\t\t\t\tconst url = buildQueryUrl(baseUrl, ${JSON.stringify(route)}, args);\n` +
+						`\t\t\t\tconst response = await request(url, {\n` +
+						`\t\t\t\t\t...(init ?? {}),\n` +
+						`\t\t\t\t\tmethod: "GET",\n` +
+						`\t\t\t\t});\n` +
+						`\t\t\t\treturn parseJson<${pascal}Result>(response);\n` +
+						`\t\t\t},\n` +
+						`\t\t\t{\n` +
+						`\t\t\t\tschema: createHandlerSchema(${handlerAccessor}.args),\n` +
+						`\t\t\t\twebsocket: createHandlerWebsocket<${pascal}Args, ${pascal}Result>(realtime, {\n` +
+						`\t\t\t\t\tdefaultTable: ${JSON.stringify(normalizeTableName(fileName))},\n` +
+						`\t\t\t\t\tdefaultHandler: { file: ${JSON.stringify(fileName)}, name: ${JSON.stringify(h.name)} },\n` +
+						`\t\t\t\t}),\n` +
+						`\t\t\t\tpath: ${JSON.stringify(route)},\n` +
+						`\t\t\t}\n` +
+						`\t\t),`
+					);
+				})
+				.join("\n");
+			return `\t${fileKey}: {\n${inner || "\t\t// (none)"}\n\t},`;
+		})
+		.join("\n");
+}
+
+export function generateMutationsClientLines(
+	mutationsByFile: Map<string, DiscoveredHandler[]>,
+	importAliasBySource: Map<string, string>
+): string {
+	return sortedEntries(mutationsByFile)
+		.map(([fileName, list]) => {
+			const fileKey = renderObjectKey(fileName);
+			const inner = list
+				.slice()
+				.sort((a, b) => a.name.localeCompare(b.name))
+				.map((h) => {
+					const pascal = handlerTypePrefix(h);
+					const route = `/mutations/${fileName}/${h.name}`;
+					const importAlias = importAliasBySource.get(h.sourceFileAbs)!;
+					const handlerAccessor = `${importAlias}.${h.name}`;
+					return (
+						`\t\t${h.name}: withHandlerMetadata<${pascal}Definition>(\n` +
+						`\t\t\tasync (args: ${pascal}Args, init) => {\n` +
+						`\t\t\t\tconst url = buildUrl(baseUrl, ${JSON.stringify(route)});\n` +
+						`\t\t\t\tconst response = await request(url, {\n` +
+						`\t\t\t\t\t...(init ?? {}),\n` +
+						`\t\t\t\t\tmethod: "POST",\n` +
+						`\t\t\t\t\theaders: ensureJsonHeaders(init?.headers),\n` +
+						`\t\t\t\t\tbody: JSON.stringify(args),\n` +
+						`\t\t\t\t});\n` +
+						`\t\t\t\treturn parseJson<${pascal}Result>(response);\n` +
+						`\t\t\t},\n` +
+						`\t\t\t{\n` +
+						`\t\t\t\tschema: createHandlerSchema(${handlerAccessor}.args),\n` +
+						`\t\t\t\twebsocket: createHandlerWebsocket<${pascal}Args, ${pascal}Result>(realtime, {\n` +
+						`\t\t\t\t\tdefaultTable: ${JSON.stringify(normalizeTableName(fileName))},\n` +
+						`\t\t\t\t\tdefaultHandler: { file: ${JSON.stringify(fileName)}, name: ${JSON.stringify(h.name)} },\n` +
+						`\t\t\t\t}),\n` +
+						`\t\t\t\tpath: ${JSON.stringify(route)},\n` +
+						`\t\t\t}\n` +
+						`\t\t),`
+					);
+				})
+				.join("\n");
+			return `\t${fileKey}: {\n${inner || "\t\t// (none)"}\n\t},`;
+		})
+		.join("\n");
+}