appflare 0.0.28 → 0.1.0

package/cli/templates/handlers/generators/handlers.ts

@@ -0,0 +1,13 @@
+import { generateTypes } from "../types";
+
+export function generateHandlersSource(schemaImportPath: string): string {
+	return `import type { Context } from "hono";
+import type { D1Database } from "@cloudflare/workers-types";
+import { drizzle } from "drizzle-orm/d1";
+import { z, type ZodRawShape } from "zod";
+import * as authSchema from "./auth.schema";
+import * as schema from "${schemaImportPath}";
+
+${generateTypes()}
+`;
+}

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}`;
+}