appflare 0.0.28 → 0.1.1

package/cli/templates/handlers/generators/types/query-runtime.ts

@@ -0,0 +1,417 @@
+export function generateTypesQueryRuntimeSection(): string {
+	return `export function createQueryDb(
+	$db: AppflareDb,
+	options?: QueryDbOptions,
+): AppflareQueryDb {
+	const cache = new Map<string, unknown>();
+	const onMutation = options?.onMutation;
+	const queryDb = $db.query as Record<
+		string,
+		{
+			findMany: (args?: unknown) => Promise<unknown>;
+			findFirst: (args?: unknown) => Promise<unknown>;
+		}
+	>;
+
+	return new Proxy({} as AppflareQueryDb, {
+		get: (_target, property) => {
+			const tableName = String(property);
+			if (cache.has(tableName)) {
+				return cache.get(tableName);
+			}
+
+			const queryTable = queryDb[tableName];
+			if (!queryTable) {
+				return undefined;
+			}
+
+			const table = (mergedSchema as Record<string, unknown>)[tableName];
+
+			const emitMutation = (
+				kind: DbMutationKind,
+				args: Record<string, unknown>,
+				rows: unknown[],
+			): void => {
+				onMutation?.({
+					kind,
+					table: tableName,
+					args,
+					rows,
+				});
+			};
+
+			const tableApi = {
+				findMany: (args?: Record<string, unknown>) => {
+					const where = isRecord(args?.where)
+						? (args?.where as Record<string, unknown>)
+						: undefined;
+					const whereFilter = buildWhereFilter(table, where, tableName);
+					const withValue = args?.with;
+					const transformedWithResult =
+						withValue === undefined
+							? {
+								with: undefined,
+								aggregatePlan: undefined,
+							}
+							: transformWithRelationsAndExtractAggregates(withValue);
+					const transformedWith = transformedWithResult.with;
+					const aggregatePlan = transformedWithResult.aggregatePlan;
+					if (!whereFilter && transformedWith === withValue && !aggregatePlan) {
+						return queryTable.findMany(args);
+					}
+
+					const queryPromise = queryTable.findMany({
+						...(args ?? {}),
+						...(whereFilter ? { where: () => whereFilter } : {}),
+						...(transformedWith !== undefined ? { with: transformedWith } : {}),
+					});
+
+					if (!aggregatePlan) {
+						return queryPromise;
+					}
+
+					return queryPromise.then((result) =>
+						applyRelationAggregatePlanToResult(result, aggregatePlan),
+					);
+				},
+				findFirst: (args?: Record<string, unknown>) => {
+					const where = isRecord(args?.where)
+						? (args?.where as Record<string, unknown>)
+						: undefined;
+					const whereFilter = buildWhereFilter(table, where, tableName);
+					const withValue = args?.with;
+					const transformedWithResult =
+						withValue === undefined
+							? {
+								with: undefined,
+								aggregatePlan: undefined,
+							}
+							: transformWithRelationsAndExtractAggregates(withValue);
+					const transformedWith = transformedWithResult.with;
+					const aggregatePlan = transformedWithResult.aggregatePlan;
+					if (!whereFilter && transformedWith === withValue && !aggregatePlan) {
+						return queryTable.findFirst(args);
+					}
+
+					const queryPromise = queryTable.findFirst({
+						...(args ?? {}),
+						...(whereFilter ? { where: () => whereFilter } : {}),
+						...(transformedWith !== undefined ? { with: transformedWith } : {}),
+					});
+
+					if (!aggregatePlan) {
+						return queryPromise;
+					}
+
+					return queryPromise.then((result) =>
+						applyRelationAggregatePlanToResult(result, aggregatePlan),
+					);
+				},
+				insert: async (args: QueryInsertArgs<TableName>) => {
+					let insertQuery: any = ($db as any)
+						.insert(table as any)
+						.values(args.values as any);
+
+					if (typeof insertQuery.returning === "function") {
+						insertQuery = insertQuery.returning();
+					}
+
+					const rows = (await insertQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"insert",
+						{ values: args.values as unknown as Record<string, unknown> },
+						rows,
+					);
+					return rows;
+				},
+				update: async (args: QueryUpdateArgs<TableName>) => {
+					const whereFilter = buildWhereFilter(
+						table,
+						args.where as Record<string, unknown> | undefined,
+						tableName,
+					);
+					let updateQuery: any = ($db as any)
+						.update(table as any)
+						.set(args.set as any);
+
+					if (whereFilter) {
+						updateQuery = updateQuery.where(whereFilter);
+					}
+					if (typeof args.limit === "number" && typeof updateQuery.limit === "function") {
+						updateQuery = updateQuery.limit(args.limit);
+					}
+					if (typeof updateQuery.returning === "function") {
+						updateQuery = updateQuery.returning();
+					}
+
+					const rows = (await updateQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"update",
+						{
+							set: args.set as unknown as Record<string, unknown>,
+							where: (args.where ?? undefined) as unknown as Record<string, unknown>,
+							limit: args.limit,
+						},
+						rows,
+					);
+					return rows;
+				},
+				upsert: async (args: QueryUpsertArgs<TableName>) => {
+					const valuesArray = Array.isArray(args.values)
+						? args.values
+						: [args.values];
+					const values = Array.isArray(args.values)
+						? args.values
+						: args.values;
+
+					const targets = args.target
+						? Array.isArray(args.target)
+							? args.target
+							: [args.target]
+						: inferConflictTarget(table);
+
+					if (targets.length === 0) {
+						throw new Error(
+							"Unable to infer conflict target for table " + tableName + ". Provide target explicitly.",
+						);
+					}
+
+					const tableColumns = getTableColumns(table as never) as Record<string, unknown>;
+					const targetColumns = targets
+						.map((target) => tableColumns[target])
+						.filter(Boolean);
+
+					if (targetColumns.length === 0) {
+						throw new Error(
+							"Invalid conflict target for table " + tableName + ".",
+						);
+					}
+
+					const setPayload = args.set ?? valuesArray[0] ?? {};
+					let upsertQuery: any = ($db as any)
+						.insert(table as any)
+						.values(values as any)
+						.onConflictDoUpdate({
+							target: targetColumns as any,
+							set: setPayload as any,
+						});
+
+					if (typeof upsertQuery.returning === "function") {
+						upsertQuery = upsertQuery.returning();
+					}
+
+					const rows = (await upsertQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"upsert",
+						{
+							values: args.values as unknown as Record<string, unknown>,
+							target: targets as unknown as Record<string, unknown>,
+							set: (args.set ?? undefined) as unknown as Record<string, unknown>,
+						},
+						rows,
+					);
+					return rows;
+				},
+				delete: async (args?: QueryDeleteArgs<TableName>) => {
+					const whereFilter = buildWhereFilter(
+						table,
+						args?.where as Record<string, unknown> | undefined,
+						tableName,
+					);
+					let deleteQuery: any = ($db as any).delete(table as any);
+
+					if (whereFilter) {
+						deleteQuery = deleteQuery.where(whereFilter);
+					}
+					if (typeof args?.limit === "number" && typeof deleteQuery.limit === "function") {
+						deleteQuery = deleteQuery.limit(args.limit);
+					}
+					if (typeof deleteQuery.returning === "function") {
+						deleteQuery = deleteQuery.returning();
+					}
+
+					const rows = (await deleteQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"delete",
+						{
+							where: (args?.where ?? undefined) as unknown as Record<string, unknown>,
+							limit: args?.limit,
+						},
+						rows,
+					);
+					return rows;
+				},
+				count: async (args?: QueryCountArgs<TableName>) => {
+					const withValue = args?.with;
+					const pathSegments = args?.field
+						? splitAggregateFieldPath(String(args.field))
+						: [];
+					if (args?.field && pathSegments.length === 0) {
+						throw new Error(
+							"Invalid count field for table " + tableName + ": " + String(args.field),
+						);
+					}
+
+					if (withValue !== undefined || pathSegments.length > 1) {
+						const whereFilter = buildWhereFilter(
+							table,
+							args?.where as Record<string, unknown> | undefined,
+							tableName,
+						);
+						const transformedWith =
+							withValue === undefined
+								? undefined
+								: transformWithRelations(withValue);
+						const rawRows = await queryTable.findMany({
+							...(whereFilter ? { where: () => whereFilter } : {}),
+							...(transformedWith !== undefined ? { with: transformedWith } : {}),
+						});
+						const rows = Array.isArray(rawRows) ? rawRows : [];
+						const constrainedRows = hasAggregateWithConstraints(withValue)
+							? rows.filter((row) =>
+									rowMatchesAggregateWithConstraints(row, withValue),
+								)
+							: rows;
+
+						if (!args?.field) {
+							return constrainedRows.length;
+						}
+
+						const values = constrainedRows.flatMap((row) =>
+							collectValuesFromPath(row, pathSegments),
+						);
+						const useDistinct = args?.distinct ?? withValue !== undefined;
+						return countAggregateValues(values, useDistinct);
+					}
+
+					const whereFilter = buildWhereFilter(
+						table,
+						args?.where as Record<string, unknown> | undefined,
+						tableName,
+					);
+					const tableColumns = getTableColumns(table as never) as Record<string, unknown>;
+					const selectedField = args?.field
+						? tableColumns[String(args.field)]
+						: undefined;
+
+					if (args?.field && !selectedField) {
+						throw new Error(
+							"Invalid count field for table " + tableName + ": " + args.field,
+						);
+					}
+
+					let expression: SQL;
+					if (selectedField) {
+						expression = args?.distinct
+							? sql\`count(distinct \${selectedField as never})\`
+							: sql\`count(\${selectedField as never})\`;
+					} else {
+						expression = sql\`count(*)\`;
+					}
+
+					let query = ($db as any)
+						.select({ value: expression })
+						.from(table as any);
+
+					if (whereFilter) {
+						query = query.where(whereFilter);
+					}
+
+					const rows = (await query) as Array<{ value: unknown }>;
+					const value = Number(rows[0]?.value ?? 0);
+					return Number.isFinite(value) ? value : 0;
+				},
+				avg: async (args: QueryAvgArgs<TableName>) => {
+					const withValue = args.with;
+					const pathSegments = splitAggregateFieldPath(String(args.field));
+					if (pathSegments.length === 0) {
+						throw new Error(
+							"Invalid avg field for table " + tableName + ": " + String(args.field),
+						);
+					}
+
+					if (withValue !== undefined || pathSegments.length > 1) {
+						const whereFilter = buildWhereFilter(
+							table,
+							args.where as Record<string, unknown> | undefined,
+							tableName,
+						);
+						const transformedWith =
+							withValue === undefined
+								? undefined
+								: transformWithRelations(withValue);
+						const rawRows = await queryTable.findMany({
+							...(whereFilter ? { where: () => whereFilter } : {}),
+							...(transformedWith !== undefined ? { with: transformedWith } : {}),
+						});
+						const rows = Array.isArray(rawRows) ? rawRows : [];
+						const constrainedRows = hasAggregateWithConstraints(withValue)
+							? rows.filter((row) =>
+									rowMatchesAggregateWithConstraints(row, withValue),
+								)
+							: rows;
+						const numericValues = constrainedRows
+							.flatMap((row) => collectValuesFromPath(row, pathSegments))
+							.map((value) => toFiniteNumber(value))
+							.filter((value): value is number => value !== null);
+						const values = args.distinct
+							? Array.from(new Set<number>(numericValues))
+							: numericValues;
+						return averageAggregateValues(values);
+					}
+
+					const whereFilter = buildWhereFilter(
+						table,
+						args.where as Record<string, unknown> | undefined,
+						tableName,
+					);
+					const tableColumns = getTableColumns(table as never) as Record<string, unknown>;
+					const selectedField = tableColumns[String(args.field)];
+
+					if (!selectedField) {
+						throw new Error(
+							"Invalid avg field for table " + tableName + ": " + String(args.field),
+						);
+					}
+
+					const expression = args.distinct
+						? sql\`avg(distinct \${selectedField as never})\`
+						: sql\`avg(\${selectedField as never})\`;
+
+					let query = ($db as any)
+						.select({ value: expression })
+						.from(table as any);
+
+					if (whereFilter) {
+						query = query.where(whereFilter);
+					}
+
+					const rows = (await query) as Array<{ value: unknown }>;
+					const rawValue = rows[0]?.value;
+					if (rawValue === null || rawValue === undefined) {
+						return null;
+					}
+
+					const value = Number(rawValue);
+					return Number.isFinite(value) ? value : null;
+				},
+			};
+
+			cache.set(tableName, tableApi);
+			return tableApi;
+		},
+	}) as AppflareQueryDb;
+}
+
+export class AppflareHandledError extends Error {
+	public readonly status: number;
+	public readonly payload: unknown;
+
+	public constructor(status: number, payload: unknown) {
+		super(typeof payload === "object" ? "Handled error" : String(payload));
+		this.status = status;
+		this.payload = payload;
+	}
+}
+`;
+}

package/cli/templates/handlers/index.ts

@@ -0,0 +1,43 @@
+import { DiscoveredHandlerOperation } from "../../utils/handler-discovery";
+import { generateContextSource } from "./generators/context";
+import { generateExecutionSource } from "./generators/execution";
+import { generateHandlersSource } from "./generators/handlers";
+import { generateRegistration } from "./registration";
+
+export type GeneratedHandlerArtifact = {
+	relativePath: string;
+	source: string;
+};
+
+export function generateHandlersArtifacts(
+	schemaImportPath: string,
+	operations: DiscoveredHandlerOperation[],
+	defaultR2Binding?: string,
+): GeneratedHandlerArtifact[] {
+	const handlersSource = generateHandlersSource(schemaImportPath);
+
+	const contextSource = generateContextSource(defaultR2Binding);
+
+	const executionSource = generateExecutionSource();
+
+	const routesSource = generateRegistration(operations);
+
+	return [
+		{
+			relativePath: "handlers.ts",
+			source: handlersSource,
+		},
+		{
+			relativePath: "handlers.context.ts",
+			source: contextSource,
+		},
+		{
+			relativePath: "handlers.execution.ts",
+			source: executionSource,
+		},
+		{
+			relativePath: "handlers.routes.ts",
+			source: routesSource,
+		},
+	];
+}

package/cli/templates/handlers/operations.ts

@@ -0,0 +1,116 @@
+import {
+	toPascalCase,
+	singularize,
+	zodForColumn,
+	zodForQueryColumn,
+} from "./utils";
+import type {
+	DiscoveredColumn,
+	DiscoveredTable,
+} from "../../utils/schema-discovery";
+
+function createArgsShape(columns: DiscoveredColumn[]): string {
+	const creatableColumns = columns.filter(
+		(column) => !(column.primaryKey && column.autoIncrement),
+	);
+	if (creatableColumns.length === 0) {
+		return "{}";
+	}
+
+	return `{
+${creatableColumns.map((column) => `\t\t${column.name}: ${zodForColumn(column)},`).join("\n")}
+\t}`;
+}
+
+function createInsertValues(columns: DiscoveredColumn[]): string {
+	const creatableColumns = columns.filter(
+		(column) => !(column.primaryKey && column.autoIncrement),
+	);
+
+	if (creatableColumns.length === 0) {
+		return "{}";
+	}
+
+	return `{
+${creatableColumns.map((column) => `\t\t\t${column.name}: args.${column.name},`).join("\n")}
+\t\t}`;
+}
+
+function createQueryBlock(table: DiscoveredTable): string {
+	const idColumn = table.columns.find((column) => column.name === "id");
+	const queryName = `get${toPascalCase(table.exportName)}`;
+	const args = idColumn
+		? `{
+		id: ${zodForQueryColumn(idColumn)},
+\t}`
+		: "{}";
+	const queryBody = idColumn
+		? `if (args.id !== undefined) {
+			return ctx.$db.select().from(schema.${table.exportName}).where(eq(schema.${table.exportName}.id, args.id));
+\t\t}
+\n\t\treturn ctx.$db.select().from(schema.${table.exportName});`
+		: `return ctx.$db.select().from(schema.${table.exportName});`;
+
+	return `export const ${queryName} = query({
+\targs: ${args},
+\thandler: async (ctx, args) => {
+\t\t${queryBody}
+\t},
+});`;
+}
+
+function createMutationBlock(table: DiscoveredTable): string {
+	const mutationName = `create${toPascalCase(singularize(table.exportName))}`;
+	const argsShape = createArgsShape(table.columns);
+	const values = createInsertValues(table.columns);
+
+	return `export const ${mutationName} = mutation({
+\targs: ${argsShape},
+\thandler: async (ctx, args) => {
+		const [created] = await ctx.$db
+\t\t\t.insert(schema.${table.exportName})
+\t\t\t.values(${values})
+\t\t\t.returning();
+
+\n\t\treturn created ?? null;
+\t},
+});`;
+}
+
+function createRegistry(tableNames: string[]): string {
+	const queryEntries = tableNames.map((name) => {
+		return `\t${`get${toPascalCase(name)}`},`;
+	});
+	const mutationEntries = tableNames.map((name) => {
+		return `\t${`create${toPascalCase(singularize(name))}`},`;
+	});
+
+	return `const generatedQueries = {
+${queryEntries.join("\n")}
+} as const;
+
+const generatedMutations = {
+${mutationEntries.join("\n")}
+} as const;`;
+}
+
+export function generateOperations(tables: DiscoveredTable[]): string {
+	if (tables.length === 0) {
+		return `const generatedQueries = {} as const;
+const generatedMutations = {} as const;`;
+	}
+
+	const queryBlocks = tables
+		.map((table) => createQueryBlock(table))
+		.join("\n\n");
+	const mutationBlocks = tables
+		.map((table) => createMutationBlock(table))
+		.join("\n\n");
+	const registry = createRegistry(tables.map((table) => table.exportName));
+
+	return `${queryBlocks}
+
+${mutationBlocks}
+
+${registry}`;
+}

package/cli/templates/handlers/registration.ts

@@ -0,0 +1,83 @@
+import type { DiscoveredHandlerOperation } from "../../utils/handler-discovery";
+import { buildRegistrationTemplateSections } from "./generators/registration/sections";
+import { realtimeModule } from "./generators/registration/modules/realtime";
+import { storageModule } from "./generators/registration/modules/storage";
+import { schedulerModule } from "./generators/registration/modules/scheduler";
+import { cronModule } from "./generators/registration/modules/cron";
+
+export function generateRegistration(
+	operations: DiscoveredHandlerOperation[],
+): string {
+	const {
+		imports,
+		operationSchemas,
+		schedulerSchemas,
+		queryRoutes,
+		mutationRoutes,
+		queryRegistryEntries,
+		schedulerEntries,
+		schedulerPayloadMapEntries,
+		cronEntries,
+		storageHandlersEntries,
+	} = buildRegistrationTemplateSections(operations);
+
+	return `import { sValidator } from "@hono/standard-validator";
+import type { Hono } from "hono";
+import type { D1Database, IncomingRequestCfProperties, KVNamespace } from "@cloudflare/workers-types";
+import { ZodError, z } from "zod";
+import {
+	AppflareHandledError,
+	type AppflareContext,
+	type DbMutationEvent,
+	createDb,
+	createQueryDb,
+	setStorageHandlers,
+	type RegisterHandlersOptions,
+	type StorageMethod,
+	type WorkerEnv,
+} from "./handlers";
+import { createExecutionContext, createSchedulerExecutionContext, resolveSession } from "./handlers.context";
+import { executeOperation, handleOperationError } from "./handlers.execution";
+${imports ? `\n${imports}` : ""}
+
+${operationSchemas}
+${schedulerSchemas}
+
+const realtimeQueryHandlers = {${queryRegistryEntries || "\n"}
+} as const;
+
+const schedulerHandlers = {${schedulerEntries || "\n"}
+} as const;
+
+type GeneratedSchedulerPayloadMap = {${
+		schedulerPayloadMapEntries ? `\n${schedulerPayloadMapEntries}\n` : ""
+	}};
+
+declare global {
+	interface AppflareSchedulerHandlerMap extends GeneratedSchedulerPayloadMap {}
+}
+
+const cronHandlers = [${cronEntries || "\n"}
+] as const;
+
+const storageHandlers = [${storageHandlersEntries || "\n"}
+] as const;
+
+setStorageHandlers([...storageHandlers]);
+
+${schedulerModule}
+
+${realtimeModule}
+
+export function registerGeneratedHandlers(
+	app: Hono<WorkerEnv>,
+	options: RegisterHandlersOptions,
+): void {
+	registerRealtimeRoutes(app, options);${queryRoutes || "\n\t// No query handlers discovered under scanDir/queries.\n"}${mutationRoutes || "\n\t// No mutation handlers discovered under scanDir/mutations.\n"}
+}
+
+${storageModule}
+
+${cronModule}
+`;
+}

package/cli/templates/handlers/types.ts

@@ -0,0 +1,15 @@
+import { generateTypesCoreSection } from "./generators/types/core";
+import { generateTypesQueryDefinitionsSection } from "./generators/types/query-definitions";
+import { generateTypesQueryRuntimeSection } from "./generators/types/query-runtime";
+import { generateTypesContextSection } from "./generators/types/context";
+import { generateTypesOperationsSection } from "./generators/types/operations";
+
+export function generateTypes(): string {
+	return [
+		generateTypesCoreSection(),
+		generateTypesQueryDefinitionsSection(),
+		generateTypesQueryRuntimeSection(),
+		generateTypesContextSection(),
+		generateTypesOperationsSection(),
+	].join("\n\n");
+}