@danielfgray/pg-sourcerer 0.2.2 → 0.4.0

package/dist/plugins/http-hono.js

@@ -1,51 +1,61 @@
 /**
- * HTTP Hono Plugin - Generate Hono route handlers from query plugins
+ * Hono HTTP Plugin - Generates Hono route handlers from query symbols
  *
- * Consumes method symbols from sql-queries or kysely-queries via the symbol registry
- * and generates type-safe Hono HTTP route handlers.
+ * Consumes "queries" and "schema" capabilities (provider-agnostic).
+ * Works with any queries provider (kysely, drizzle, effect-sql, etc.)
+ * and any schema provider (zod, arktype, valibot, etc.).
  *
- * Schema validation is provided via @hono/standard-validator when a schema plugin
- * (zod, valibot, arktype) is configured. Without a schema plugin, routes are
- * generated without validation middleware.
+ * Uses the SymbolRegistry to resolve query functions and optionally
+ * schema symbols for request validation.
+ *
+ * For param/query validation, uses the SchemaBuilder service when available.
+ * For body validation, imports schema symbols via registry.
+ *
+ * Routes use @hono/standard-validator for middleware-based validation.
+ */
+import { Effect, Schema as S } from "effect";
+import { IR } from "../services/ir.js";
+import { Inflection } from "../services/inflection.js";
+import { SymbolRegistry } from "../runtime/registry.js";
+import { isTableEntity } from "../ir/semantic-ir.js";
+import { conjure, cast } from "../conjure/index.js";
+import { normalizeFileNaming } from "../runtime/file-assignment.js";
+const b = conjure.b;
+const PLUGIN_NAME = "hono-http";
+const DEFAULT_OUTPUT_DIR = "";
+const DEFAULT_ROUTES_FILE = "routes.ts";
+const DEFAULT_APP_FILE = "routes.ts";
+/**
+ * Coerce a URL param (always string) to the expected type.
+ * Returns an expression that wraps the identifier with the appropriate coercion.
+ */
+function coerceParam(paramName, paramType) {
+    const ident = b.identifier(paramName);
+    const lowerType = paramType.toLowerCase();
+    if (lowerType === "number" || lowerType === "int" || lowerType === "integer" || lowerType === "bigint") {
+        return b.callExpression(b.identifier("Number"), [ident]);
+    }
+    if (lowerType === "date" || lowerType.includes("timestamp") || lowerType.includes("datetime")) {
+        return b.newExpression(b.identifier("Date"), [ident]);
+    }
+    if (lowerType === "boolean" || lowerType === "bool") {
+        return b.binaryExpression("===", ident, b.stringLiteral("true"));
+    }
+    return ident;
+}
+function needsCoercion(param) {
+    return (param.source === "pk" ||
+        param.source === "fk" ||
+        param.source === "lookup" ||
+        param.source === "pagination");
+}
+/**
+ * Schema-validated portion of the config (simple types only).
  */
-import { Schema as S } from "effect";
-import { definePlugin } from "../services/plugin.js";
-import { conjure, cast } from "../lib/conjure.js";
-import { inflect } from "../services/inflection.js";
-import { SCHEMA_BUILDER_KIND, } from "../ir/extensions/schema-builder.js";
-import { getTableEntities } from "../ir/semantic-ir.js";
-import { TsType } from "../services/pg-types.js";
-const { b, stmt } = conjure;
-// ============================================================================
-// Configuration
-// ============================================================================
 const HttpHonoConfigSchema = S.Struct({
-    /** Output directory for generated route files. Default: "routes" */
-    outputDir: S.optionalWith(S.String, { default: () => "routes" }),
-    /** Base path for all routes. Default: "/api" */
-    basePath: S.optionalWith(S.String, { default: () => "/api" }),
-    /** Header content to prepend to each generated file */
-    header: S.optional(S.String),
-    /**
-     * Name of the aggregated router export.
-     * Default: "api"
-     */
-    aggregatorName: S.optionalWith(S.String, { default: () => "api" }),
+    outputDir: S.optionalWith(S.String, { default: () => DEFAULT_OUTPUT_DIR }),
+    basePath: S.optionalWith(S.String, { default: () => "" }),
 });
-// ============================================================================
-// String Helpers
-// ============================================================================
-/** Convert PascalCase/camelCase to kebab-case */
-const toKebabCase = (str) => str
-    .replace(/([a-z])([A-Z])/g, "$1-$2")
-    .replace(/_/g, "-")
-    .toLowerCase();
-/** Convert entity name to URL path segment (kebab-case plural) */
-const entityToPathSegment = (entityName) => inflect.pluralize(toKebabCase(entityName));
-// ============================================================================
-// Route Generation Helpers
-// ============================================================================
-/** Map query method kind to HTTP method */
 const kindToHttpMethod = (kind) => {
     switch (kind) {
         case "read":
@@ -62,8 +72,7 @@ const kindToHttpMethod = (kind) => {
             return "post";
     }
 };
-/** Get the route path for a method */
-const getRoutePath = (method) => {
+const getRoutePath = (method, entityName, inflection) => {
     switch (method.kind) {
         case "read":
         case "update":
@@ -73,113 +82,36 @@ const getRoutePath = (method) => {
             return `/:${paramName}`;
         }
         case "list":
+            if (/ListBy/i.test(method.name) || /listBy/i.test(method.name)) {
+                const match = method.name.match(/(?:ListBy|listBy)(.+)/i);
+                if (match && match[1]) {
+                    const columnKebab = inflection.kebabCase(match[1]);
+                    return `/by-${columnKebab}`;
+                }
+            }
+            return "/";
         case "create":
             return "/";
         case "lookup": {
             const field = method.lookupField ?? "field";
-            const fieldKebab = toKebabCase(field);
+            const fieldKebab = inflection.kebabCase(field);
             const lookupParam = method.params.find((p) => p.source === "lookup" || p.source === "fk");
             const paramName = lookupParam?.name ?? field;
             return `/by-${fieldKebab}/:${paramName}`;
         }
         case "function": {
-            return `/${toKebabCase(method.name)}`;
+            return `/${inflection.kebabCase(method.name)}`;
         }
     }
 };
-/**
- * Build sValidator('target', schema) middleware call
- */
-const buildSValidator = (target, schema) => b.callExpression(b.identifier("sValidator"), [b.stringLiteral(target), cast.toExpr(schema)]);
-/**
- * Determine if a method needs body validation and which schema to use.
- */
-const getBodySchemaImport = (method, entityName) => {
-    if (method.kind === "create") {
-        return { entity: entityName, shape: "insert", schemaName: `${entityName}Insert` };
-    }
-    if (method.kind === "update") {
-        return { entity: entityName, shape: "update", schemaName: `${entityName}Update` };
-    }
-    return null;
-};
-// ============================================================================
-// Handler Body Generation
-// ============================================================================
-/**
- * Build the handler function body for a query method.
- *
- * When hasValidation is true, uses c.req.valid() for validated data.
- * Otherwise falls back to manual extraction via c.req.param/query/json.
- */
-const buildHandlerBody = (method, hasValidation) => {
-    const statements = [];
+function buildHandlerBody(method) {
     const callSig = method.callSignature ?? { style: "named" };
-    const pathParams = method.params.filter((p) => p.source === "pk" || p.source === "fk" || p.source === "lookup");
-    const queryParams = method.params.filter((p) => p.source === "pagination");
-    const needsBody = method.params.some((p) => p.source === "body") ||
-        method.kind === "create" ||
-        method.kind === "update" ||
-        (method.kind === "function" && method.params.some((p) => !p.source));
-    if (hasValidation) {
-        // Use c.req.valid() for validated data
-        if (pathParams.length > 0) {
-            // const { id, slug } = c.req.valid('param')
-            const paramPattern = b.objectPattern(pathParams.map((p) => {
-                const prop = b.property("init", b.identifier(p.name), b.identifier(p.name));
-                prop.shorthand = true;
-                return prop;
-            }));
-            const validCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("c"), b.identifier("req")), b.identifier("valid")), [b.stringLiteral("param")]);
-            statements.push(b.variableDeclaration("const", [b.variableDeclarator(paramPattern, validCall)]));
-        }
-        if (queryParams.length > 0) {
-            // const { limit, offset } = c.req.valid('query')
-            const queryPattern = b.objectPattern(queryParams.map((p) => {
-                const prop = b.property("init", b.identifier(p.name), b.identifier(p.name));
-                prop.shorthand = true;
-                return prop;
-            }));
-            const validCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("c"), b.identifier("req")), b.identifier("valid")), [b.stringLiteral("query")]);
-            statements.push(b.variableDeclaration("const", [b.variableDeclarator(queryPattern, validCall)]));
-        }
-        if (needsBody) {
-            // const body = c.req.valid('json')
-            const validCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("c"), b.identifier("req")), b.identifier("valid")), [b.stringLiteral("json")]);
-            statements.push(stmt.const("body", validCall));
-        }
-    }
-    else {
-        // No validation - manual extraction
-        for (const param of pathParams) {
-            const paramCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("c"), b.identifier("req")), b.identifier("param")), [b.stringLiteral(param.name)]);
-            statements.push(stmt.const(param.name, paramCall));
-        }
-        for (const param of queryParams) {
-            const queryCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("c"), b.identifier("req")), b.identifier("query")), [b.stringLiteral(param.name)]);
-            // Parse as number if needed
-            if (param.type === TsType.Number) {
-                const parsed = b.callExpression(b.identifier("Number"), [queryCall]);
-                statements.push(stmt.const(param.name, parsed));
-            }
-            else {
-                statements.push(stmt.const(param.name, queryCall));
-            }
-        }
-        if (needsBody) {
-            const jsonCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("c"), b.identifier("req")), b.identifier("json")), []);
-            statements.push(stmt.const("body", b.awaitExpression(jsonCall)));
-        }
-    }
-    // Build the function call arguments
+    const statements = [];
     const args = [];
     if (callSig.style === "positional") {
         for (const param of method.params) {
-            if (param.source === "pk" ||
-                param.source === "fk" ||
-                param.source === "lookup" ||
-                param.source === "pagination") {
-                args.push(b.identifier(param.name));
+            if (needsCoercion(param)) {
+                args.push(coerceParam(param.name, param.type));
             }
             else if (param.source === "body") {
                 args.push(b.identifier("body"));
@@ -197,11 +129,8 @@ const buildHandlerBody = (method, hasValidation) => {
         else if (bodyParam && callSig.bodyStyle === "property") {
             let objBuilder = conjure.obj();
             for (const param of method.params) {
-                if (param.source === "pk" ||
-                    param.source === "fk" ||
-                    param.source === "lookup" ||
-                    param.source === "pagination") {
-                    objBuilder = objBuilder.shorthand(param.name);
+                if (needsCoercion(param)) {
+                    objBuilder = objBuilder.prop(param.name, coerceParam(param.name, param.type));
                 }
             }
             objBuilder = objBuilder.prop(bodyParam.name, b.identifier("body"));
@@ -210,11 +139,8 @@ const buildHandlerBody = (method, hasValidation) => {
         else {
             let objBuilder = conjure.obj();
             for (const param of method.params) {
-                if (param.source === "pk" ||
-                    param.source === "fk" ||
-                    param.source === "lookup" ||
-                    param.source === "pagination") {
-                    objBuilder = objBuilder.shorthand(param.name);
+                if (needsCoercion(param)) {
+                    objBuilder = objBuilder.prop(param.name, coerceParam(param.name, param.type));
                 }
             }
             if (method.params.length > 0) {
@@ -222,15 +148,16 @@ const buildHandlerBody = (method, hasValidation) => {
             }
         }
     }
-    // Build: const result = await Queries.queryFn(args)
-    const queryCall = b.callExpression(b.memberExpression(b.identifier("Queries"), b.identifier(method.name)), args.map(cast.toExpr));
-    statements.push(stmt.const("result", b.awaitExpression(queryCall)));
-    // Handle 404 for read/lookup that returns null
+    const queryCall = b.callExpression(b.identifier(method.name), args.map(cast.toExpr));
+    const awaitExpr = b.awaitExpression(queryCall);
+    statements.push(conjure.stmt.const("result", awaitExpr));
     if (method.kind === "read" || (method.kind === "lookup" && method.isUniqueLookup)) {
-        const notFoundResponse = b.callExpression(b.memberExpression(b.identifier("c"), b.identifier("json")), [conjure.obj().prop("error", b.stringLiteral("Not found")).build(), b.numericLiteral(404)]);
+        const notFoundResponse = b.callExpression(b.memberExpression(b.identifier("c"), b.identifier("json")), [
+            conjure.obj().prop("error", b.stringLiteral("Not found")).build(),
+            b.numericLiteral(404),
+        ].map(cast.toExpr));
         statements.push(b.ifStatement(b.unaryExpression("!", b.identifier("result")), b.returnStatement(notFoundResponse)));
     }
-    // return c.json(result) or c.json(result, 201) for create
     const statusCode = method.kind === "create" ? 201 : undefined;
     const jsonArgs = [b.identifier("result")];
     if (statusCode) {
@@ -239,215 +166,264 @@ const buildHandlerBody = (method, hasValidation) => {
     const jsonResponse = b.callExpression(b.memberExpression(b.identifier("c"), b.identifier("json")), jsonArgs.map(cast.toExpr));
     statements.push(b.returnStatement(jsonResponse));
     return statements;
-};
-// ============================================================================
-// Route Validation Builders
-// ============================================================================
+}
+const stmt = conjure.stmt;
+function getBodySchemaName(method, entityName) {
+    if (method.kind === "create") {
+        return `${entityName}Insert`;
+    }
+    if (method.kind === "update") {
+        return `${entityName}Update`;
+    }
+    return null;
+}
 /**
- * Build validators for a route method.
- *
- * Returns:
- * - validators: Array of sValidator() middleware expressions
- * - needsSValidator: Whether to import sValidator from @hono/standard-validator
- * - bodySchema: Body schema symbol import info (for symbol registry lookup)
- * - schemaBuilderImport: Import spec for the schema library (zod, valibot, etc.)
+ * Build sValidator('target', schema) middleware call.
+ */
+function buildSValidator(target, schema) {
+    return b.callExpression(b.identifier("sValidator"), [b.stringLiteral(target), cast.toExpr(schema)]);
+}
+/**
+ * Build a single route with optional validation middleware.
  */
-const buildRouteValidators = (method, entityName, requestSchema, hasSchemaProvider) => {
+function buildRouteCall(method, entityName, inflection, schemaBuilder) {
+    const httpMethod = kindToHttpMethod(method.kind);
+    const path = getRoutePath(method, entityName, inflection);
     const validators = [];
-    let needsSValidator = false;
-    let schemaBuilderImport = null;
-    // Build param validator for path parameters
     const pathParams = method.params.filter((p) => p.source === "pk" || p.source === "fk" || p.source === "lookup");
-    if (pathParams.length > 0) {
-        const schemaResult = requestSchema(pathParams);
-        if (schemaResult) {
-            validators.push(buildSValidator("param", schemaResult.ast));
-            needsSValidator = true;
-            schemaBuilderImport = schemaResult.importSpec;
+    if (pathParams.length > 0 && schemaBuilder) {
+        const request = { variant: "params", params: pathParams };
+        const result = schemaBuilder.build(request);
+        if (result) {
+            validators.push(buildSValidator("param", result.ast));
         }
     }
-    // Build query validator for pagination parameters
     const queryParams = method.params.filter((p) => p.source === "pagination");
-    if (queryParams.length > 0) {
-        const schemaResult = requestSchema(queryParams);
-        if (schemaResult) {
-            validators.push(buildSValidator("query", schemaResult.ast));
-            needsSValidator = true;
-            if (!schemaBuilderImport) {
-                schemaBuilderImport = schemaResult.importSpec;
-            }
+    if (queryParams.length > 0 && schemaBuilder) {
+        const request = { variant: "query", params: queryParams };
+        const result = schemaBuilder.build(request);
+        if (result) {
+            validators.push(buildSValidator("query", result.ast));
         }
     }
-    // Body validation - use imported schema from schema provider
-    const bodySchemaInfo = getBodySchemaImport(method, entityName);
-    let bodySchema = null;
-    if (bodySchemaInfo && hasSchemaProvider) {
-        // Import schema from schema provider and use it
-        bodySchema = bodySchemaInfo;
-        validators.push(buildSValidator("json", b.identifier(bodySchema.schemaName)));
-        needsSValidator = true;
+    const bodySchemaName = getBodySchemaName(method, entityName);
+    if (bodySchemaName) {
+        validators.push(buildSValidator("json", b.identifier(bodySchemaName)));
     }
-    return { validators, needsSValidator, bodySchema, schemaBuilderImport };
-};
-/**
- * Build a single route with optional validation middleware.
- */
-const buildRouteCall = (method, entityName, requestSchema, hasSchemaProvider) => {
-    const httpMethod = kindToHttpMethod(method.kind);
-    const path = getRoutePath(method);
-    const { validators, needsSValidator, bodySchema, schemaBuilderImport } = buildRouteValidators(method, entityName, requestSchema, hasSchemaProvider);
-    // Build handler with or without validation
-    const hasValidation = validators.length > 0;
-    const handlerBody = buildHandlerBody(method, hasValidation);
+    const handlerBody = buildHandlerBody(method);
     const handler = b.arrowFunctionExpression([b.identifier("c")], b.blockStatement(handlerBody.map(cast.toStmt)));
     handler.async = true;
-    return { httpMethod, path, handler, validators, needsSValidator, bodySchema, schemaBuilderImport };
-};
-// ============================================================================
-// Plugin Definition
-// ============================================================================
-export function httpHono(config = {}) {
-    const parsed = S.decodeUnknownSync(HttpHonoConfigSchema)(config);
-    return definePlugin({
-        name: "http-hono",
-        kind: "http-routes",
-        singleton: true,
-        canProvide: () => true,
-        requires: () => [{ kind: "queries", params: {} }],
-        optionalRequires: () => [{ kind: "schemas", params: {} }],
-        provide: (_params, _deps, ctx) => {
-            const { outputDir, basePath, header, aggregatorName } = parsed;
-            const entityNames = ctx.symbols.getEntitiesWithMethods();
-            if (entityNames.length === 0) {
-                return;
+    return { httpMethod, path, handler, validators, bodySchemaName };
+}
+/**
+ * Generate Hono routes for an entity.
+ */
+function generateHonoRoutes(entityName, queries, config, registry, inflection) {
+    const routesVarName = inflection.variableName(entityName, "HonoRoutes");
+    let chainExpr = b.newExpression(b.identifier("Hono"), []);
+    const schemaCapabilities = [];
+    for (const method of queries.methods) {
+        const methodCapability = `queries:${entityName}:${getMethodCapabilitySuffix(method, inflection)}`;
+        if (registry.has(methodCapability)) {
+            registry.import(methodCapability).ref();
+        }
+        const schemaBuilder = getSchemaBuilder(registry);
+        const { httpMethod, path, handler, validators, bodySchemaName } = buildRouteCall(method, entityName, inflection, schemaBuilder);
+        if (bodySchemaName) {
+            const schemaCapability = `schema:${bodySchemaName}`;
+            if (registry.has(schemaCapability)) {
+                registry.import(schemaCapability).ref();
+                schemaCapabilities.push(schemaCapability);
+            }
+        }
+        const callArgs = [b.stringLiteral(path), ...validators, handler];
+        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier(httpMethod)), callArgs.map(cast.toExpr));
+    }
+    const variableDeclarator = b.variableDeclarator(b.identifier(routesVarName), cast.toExpr(chainExpr));
+    const variableDeclaration = b.variableDeclaration("const", [variableDeclarator]);
+    const externalImports = [{ from: "hono", names: ["Hono"] }];
+    const needsSValidator = schemaCapabilities.length > 0 ||
+        queries.methods.some(m => m.params.some(p => p.source === "pk" || p.source === "fk" || p.source === "lookup" || p.source === "pagination"));
+    return {
+        statements: [variableDeclaration],
+        externalImports,
+        needsSValidator,
+    };
+}
+/**
+ * Get the capability suffix for a query method.
+ */
+function getMethodCapabilitySuffix(method, inflection) {
+    switch (method.kind) {
+        case "read":
+            return "findById";
+        case "list":
+            return "list";
+        case "create":
+            return "create";
+        case "update":
+            return "update";
+        case "delete":
+            return "delete";
+        case "lookup":
+            if (method.lookupField) {
+                const pascalField = inflection.pascalCase(method.lookupField);
+                return `findBy${pascalField}`;
             }
-            const generatedRoutes = [];
-            const tableEntities = getTableEntities(ctx.ir);
-            for (const entityName of entityNames) {
-                const entityMethods = ctx.symbols.getEntityMethods(entityName);
-                if (!entityMethods || entityMethods.methods.length === 0)
+            return "lookup";
+        case "function":
+            return method.name;
+    }
+}
+/**
+ * Get the schema builder from registry if available.
+ */
+function getSchemaBuilder(registry) {
+    const schemaBuilders = registry.query("schema:").filter(decl => decl.capability.endsWith(":builder"));
+    if (schemaBuilders.length === 0)
+        return undefined;
+    const metadata = registry.getMetadata(schemaBuilders[0].capability);
+    if (metadata && typeof metadata === "object" && "builder" in metadata) {
+        return metadata.builder;
+    }
+    return undefined;
+}
+function generateAggregator(entities, config, registry, inflection) {
+    const entityEntries = Array.from(entities.entries());
+    if (entityEntries.length === 0) {
+        return { statements: [], externalImports: [] };
+    }
+    let chainExpr = b.newExpression(b.identifier("Hono"), []);
+    const basePath = config.basePath.replace(/^\/+|\/+$/g, "");
+    if (basePath) {
+        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("basePath")), [b.stringLiteral(`/${basePath}`)].map(cast.toExpr));
+    }
+    const externalImports = [{ from: "hono", names: ["Hono"] }];
+    for (const [entityName] of entityEntries) {
+        const routesVarName = inflection.variableName(entityName, "HonoRoutes");
+        const routeCapability = `http-routes:hono:${entityName}`;
+        const prefix = inflection.entityRoutePath(entityName);
+        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("route")), [b.stringLiteral(prefix), b.identifier(routesVarName)].map(cast.toExpr));
+        if (registry.has(routeCapability)) {
+            registry.import(routeCapability).ref();
+        }
+    }
+    const variableDeclarator = b.variableDeclarator(b.identifier("app"), cast.toExpr(chainExpr));
+    const variableDeclaration = b.variableDeclaration("const", [variableDeclarator]);
+    return {
+        statements: [variableDeclaration],
+        externalImports,
+    };
+}
+export function hono(config) {
+    const schemaConfig = S.decodeSync(HttpHonoConfigSchema)(config ?? {});
+    const resolvedConfig = {
+        outputDir: schemaConfig.outputDir,
+        basePath: schemaConfig.basePath,
+        routesFile: normalizeFileNaming(config?.routesFile, DEFAULT_ROUTES_FILE),
+        appFile: normalizeFileNaming(config?.appFile, DEFAULT_APP_FILE),
+    };
+    return {
+        name: PLUGIN_NAME,
+        provides: [],
+        fileDefaults: [
+            {
+                pattern: "http-routes:hono:",
+                outputDir: resolvedConfig.outputDir,
+                fileNaming: resolvedConfig.routesFile,
+            },
+            {
+                pattern: "http-routes:hono:app",
+                outputDir: resolvedConfig.outputDir,
+                fileNaming: resolvedConfig.appFile,
+            },
+        ],
+        declare: Effect.gen(function* () {
+            const ir = yield* IR;
+            const inflection = yield* Inflection;
+            const declarations = [];
+            for (const entity of ir.entities.values()) {
+                if (!isTableEntity(entity))
                     continue;
-                const entity = tableEntities.find((e) => e.name === entityName);
-                const pathSegment = entityToPathSegment(entityName);
-                const filePath = `${outputDir}/${inflect.uncapitalize(entityName)}.ts`;
-                const routesVarName = `${inflect.uncapitalize(entityName)}Routes`;
-                const file = ctx.file(filePath);
-                if (header) {
-                    file.header(header);
-                }
-                // Import Hono
-                file.import({ kind: "package", names: ["Hono"], from: "hono" });
-                // Import queries as namespace
-                const queriesImportPath = `../${entityMethods.importPath.replace(/\.ts$/, ".js")}`;
-                file.import({
-                    kind: "relative",
-                    namespace: "Queries",
-                    from: queriesImportPath,
-                });
-                // Create a schema builder function that requests from the service registry
-                const requestSchema = (params) => {
-                    if (params.length === 0)
-                        return undefined;
-                    try {
-                        const request = { variant: "params", params };
-                        return ctx.request(SCHEMA_BUILDER_KIND, request);
-                    }
-                    catch {
-                        // No schema-builder registered, skip validation
-                        return undefined;
-                    }
-                };
-                // Check if a schema provider is available for body validation
-                // by checking if insert schema is registered in symbol registry
-                const hasSchemaProvider = ctx.symbols.resolve({
-                    capability: "schemas",
-                    entity: entityName,
-                    shape: "insert",
-                }) !== undefined;
-                // Build the Hono route chain
-                let chainExpr = b.newExpression(b.identifier("Hono"), []);
-                let fileNeedsSValidator = false;
-                const bodySchemaImports = [];
-                let schemaLibraryImport = null;
-                for (const method of entityMethods.methods) {
-                    const { httpMethod, path, handler, validators, needsSValidator, bodySchema, schemaBuilderImport } = buildRouteCall(method, entityName, requestSchema, hasSchemaProvider);
-                    if (needsSValidator)
-                        fileNeedsSValidator = true;
-                    if (bodySchema)
-                        bodySchemaImports.push(bodySchema);
-                    if (schemaBuilderImport)
-                        schemaLibraryImport = schemaBuilderImport;
-                    // Build route call: .get('/path', validator1, validator2, handler)
-                    const callArgs = [b.stringLiteral(path), ...validators, handler];
-                    chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier(httpMethod)), callArgs.map(cast.toExpr));
-                }
-                // Add imports based on what we need
-                if (fileNeedsSValidator) {
-                    file.import({ kind: "package", names: ["sValidator"], from: "@hono/standard-validator" });
-                }
-                // Import schema library (e.g., { z } from 'zod') if using schema-builder
-                if (schemaLibraryImport) {
-                    if (schemaLibraryImport.names) {
-                        file.import({
-                            kind: "package",
-                            names: [...schemaLibraryImport.names],
-                            from: schemaLibraryImport.from,
-                        });
-                    }
-                    else if (schemaLibraryImport.namespace) {
-                        file.import({
-                            kind: "package",
-                            namespace: schemaLibraryImport.namespace,
-                            from: schemaLibraryImport.from,
-                        });
-                    }
-                }
-                // Import body schemas from schema plugins via symbol registry
-                for (const schemaImport of bodySchemaImports) {
-                    file.import({
-                        kind: "symbol",
-                        ref: {
-                            capability: "schemas",
-                            entity: schemaImport.entity,
-                            shape: schemaImport.shape,
-                        },
+                if (entity.tags.omit === true)
+                    continue;
+                const hasAnyPermissions = entity.permissions.canSelect ||
+                    entity.permissions.canInsert ||
+                    entity.permissions.canUpdate ||
+                    entity.permissions.canDelete;
+                if (hasAnyPermissions) {
+                    declarations.push({
+                        name: inflection.variableName(entity.name, "HonoRoutes"),
+                        capability: `http-routes:hono:${entity.name}`,
+                        baseEntityName: entity.name,
                     });
                 }
-                const exportStmt = conjure.export.const(routesVarName, chainExpr);
-                file.ast(conjure.program(exportStmt)).emit();
-                generatedRoutes.push({
-                    fileName: `${inflect.uncapitalize(entityName)}.js`,
-                    exportName: routesVarName,
-                    pathSegment,
-                });
             }
-            // Generate aggregator index.ts
-            if (generatedRoutes.length > 0) {
-                const indexPath = `${outputDir}/index.ts`;
-                const indexFile = ctx.file(indexPath);
-                if (header) {
-                    indexFile.header(header);
-                }
-                indexFile.import({ kind: "package", names: ["Hono"], from: "hono" });
-                for (const route of generatedRoutes) {
-                    indexFile.import({
-                        kind: "relative",
-                        names: [route.exportName],
-                        from: `./${route.fileName}`,
-                    });
+            declarations.push({
+                name: "honoApp",
+                capability: "http-routes:hono:app",
+            });
+            return declarations;
+        }),
+        render: Effect.gen(function* () {
+            const ir = yield* IR;
+            const registry = yield* SymbolRegistry;
+            const inflection = yield* Inflection;
+            const rendered = [];
+            const entityQueries = new Map();
+            const queryCapabilities = registry.query("queries:");
+            for (const decl of queryCapabilities) {
+                const parts = decl.capability.split(":");
+                if (parts.length !== 3)
+                    continue;
+                const entityName = parts[2];
+                const metadata = registry.getMetadata(decl.capability);
+                if (metadata && typeof metadata === "object" && "methods" in metadata) {
+                    entityQueries.set(entityName, metadata);
                 }
-                // Build: new Hono().basePath('/api').route('/users', userRoutes).route('/posts', postRoutes)...
-                let chainExpr = b.newExpression(b.identifier("Hono"), []);
-                // Add basePath
-                chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("basePath")), [b.stringLiteral(basePath)]);
-                // Add routes
-                for (const route of generatedRoutes) {
-                    chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("route")), [b.stringLiteral(`/${route.pathSegment}`), b.identifier(route.exportName)]);
+            }
+            const allNeedsSValidator = new Set();
+            for (const [entityName, queries] of entityQueries) {
+                const entity = ir.entities.get(entityName);
+                if (!entity || !isTableEntity(entity))
+                    continue;
+                const capability = `http-routes:hono:${entityName}`;
+                const { statements, externalImports, needsSValidator } = registry.forSymbol(capability, () => generateHonoRoutes(entityName, queries, resolvedConfig, registry, inflection));
+                if (needsSValidator) {
+                    allNeedsSValidator.add(capability);
                 }
-                const exportStmt = conjure.export.const(aggregatorName, chainExpr);
-                indexFile.ast(conjure.program(exportStmt)).emit();
+                rendered.push({
+                    name: inflection.variableName(entityName, "HonoRoutes"),
+                    capability,
+                    node: statements[0],
+                    exports: "named",
+                    externalImports,
+                });
             }
-        },
-    });
+            if (entityQueries.size > 0) {
+                const appCapability = "http-routes:hono:app";
+                const { statements, externalImports } = registry.forSymbol(appCapability, () => generateAggregator(entityQueries, resolvedConfig, registry, inflection));
+                rendered.push({
+                    name: "honoApp",
+                    capability: appCapability,
+                    node: statements[0],
+                    exports: "named",
+                    externalImports,
+                });
+            }
+            return rendered.map((r) => {
+                const needsSValidator = allNeedsSValidator.has(r.capability);
+                return {
+                    ...r,
+                    externalImports: needsSValidator
+                        ? [
+                            ...(r.externalImports ?? []),
+                            { from: "@hono/standard-validator", names: ["sValidator"] },
+                        ]
+                        : r.externalImports,
+                };
+            });
+        }),
+    };
 }
 //# sourceMappingURL=http-hono.js.map