@danielfgray/pg-sourcerer 0.2.2 → 0.4.0

package/dist/plugins/http-express.js

@@ -1,57 +1,70 @@
 /**
- * HTTP Express Plugin - Generate Express route handlers from query plugins
+ * HTTP Express Plugin - Generates Express route handlers from query symbols
  *
- * Consumes method symbols from sql-queries or kysely-queries via the symbol registry
- * and generates type-safe Express 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, effect, etc.).
  *
- * Supports validation via schema plugins (zod, valibot, arktype):
- * - Body validation: imports entity schemas (UserInsert, UserUpdate) and uses .parse(req.body)
- * - Path/query param validation: uses schema builder for type coercion
+ * Uses the SymbolRegistry to resolve query functions and optionally
+ * schema symbols for request validation.
+ *
+ * Imports are resolved via the cross-reference system:
+ * - Calls registry.import(queryCapability).ref() during render
+ * - Emit phase generates imports from the recorded references
  */
-import { Schema as S } from "effect";
-import { definePlugin } from "../services/plugin.js";
-import { conjure, cast } from "../lib/conjure.js";
+import { Effect, Schema as S } from "effect";
+import { IR } from "../services/ir.js";
+import { Inflection } from "../services/inflection.js";
 import { inflect } from "../services/inflection.js";
-const { b, stmt } = conjure;
-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;
-};
-// ============================================================================
-// Configuration
-// ============================================================================
+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 = "express-http";
+const DEFAULT_OUTPUT_DIR = "";
+const DEFAULT_ROUTES_FILE = "routes.ts";
+const DEFAULT_APP_FILE = "index.ts";
+/**
+ * Schema-validated portion of the config (simple types only).
+ * FileNaming functions are handled separately since Schema can't validate functions.
+ */
 const HttpExpressConfigSchema = 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 */
+/**
+ * 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();
+    // Numeric types
+    if (lowerType === "number" || lowerType === "int" || lowerType === "integer" || lowerType === "bigint") {
+        return b.callExpression(b.identifier("Number"), [ident]);
+    }
+    // Date types
+    if (lowerType === "date" || lowerType.includes("timestamp") || lowerType.includes("datetime")) {
+        return b.newExpression(b.identifier("Date"), [ident]);
+    }
+    // Boolean
+    if (lowerType === "boolean" || lowerType === "bool") {
+        // "true" -> true, anything else -> false
+        return b.binaryExpression("===", ident, b.stringLiteral("true"));
+    }
+    // String, UUID, and other types - no coercion needed
+    return ident;
+}
+/**
+ * Check if a param needs coercion (comes from URL string).
+ */
+function needsCoercion(param) {
+    return (param.source === "pk" ||
+        param.source === "fk" ||
+        param.source === "lookup" ||
+        param.source === "pagination");
+}
 const kindToHttpMethod = (kind) => {
     switch (kind) {
         case "read":
@@ -68,136 +81,81 @@ 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":
         case "delete": {
-            const pkParam = method.params.find(p => p.source === "pk");
+            const pkParam = method.params.find((p) => p.source === "pk");
             const paramName = pkParam?.name ?? "id";
             return `/:${paramName}`;
         }
         case "list":
+            return "/";
         case "create":
             return "/";
         case "lookup": {
             const field = method.lookupField ?? "field";
-            const fieldKebab = toKebabCase(field);
-            const lookupParam = method.params.find(p => p.source === "lookup" || p.source === "fk");
+            const lookupParam = method.params.find((p) => p.source === "lookup" || p.source === "fk");
             const paramName = lookupParam?.name ?? field;
-            return `/by-${fieldKebab}/:${paramName}`;
+            const kebab = inflection.kebabCase(field);
+            return `/by-${kebab}/:${paramName}`;
         }
         case "function": {
-            return `/${toKebabCase(method.name)}`;
+            return `/${inflection.kebabCase(method.name)}`;
         }
     }
 };
+const stmt = conjure.stmt;
 /**
- * Build the handler function body for a query method.
- * In Express, we use req.params, req.query, req.body, res.json()
- *
- * When validation is enabled, uses schema.parse() for body and converts path params.
+ * Get the body schema name for a method if it needs validation.
  */
-const buildHandlerBody = (method, entityName, options) => {
-    const statements = [];
-    const callSig = method.callSignature ?? { style: "named" };
-    const { hasSchemaProvider, bodySchema, pathParams } = options;
-    // Extract path params with validation if schema provider available
-    if (pathParams.length > 0 && hasSchemaProvider) {
-        const firstParam = pathParams[0];
-        // Use schema builder to validate and coerce path params
-        // const _params = UserIdParams["~standard"].validate({ id: req.params.id });
-        // if (_params.issues) return res.status(400).json({ error: _params.issues });
-        // const { id } = _params.value;
-        const paramsObject = b.objectExpression([
-            b.property("init", b.stringLiteral(firstParam.name), b.memberExpression(b.memberExpression(b.identifier("req"), b.identifier("params")), b.identifier(firstParam.name))),
-        ]);
-        const paramsSchemaName = `${entityName}${firstParam.name.charAt(0).toUpperCase() + firstParam.name.slice(1)}Params`;
-        const standardMember = b.memberExpression(b.identifier(paramsSchemaName), b.stringLiteral("~standard"), true);
-        const validateCall = b.memberExpression(cast.toExpr(standardMember), b.identifier("validate"));
-        const validationExpr = b.callExpression(validateCall, [paramsObject]);
-        const validationVar = b.variableDeclarator(b.identifier("_params"), b.awaitExpression(validationExpr));
-        statements.push(b.variableDeclaration("const", [validationVar]));
-        // if (_params.issues) return res.status(400).json({ error: _params.issues });
-        const errorResponse = b.callExpression(b.memberExpression(b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("status")), [b.numericLiteral(400)]), b.identifier("json")), [b.objectExpression([b.property("init", b.stringLiteral("error"), b.memberExpression(b.identifier("_params"), b.identifier("issues")))])]);
-        const ifStatement = b.ifStatement(b.memberExpression(b.identifier("_params"), b.identifier("issues")), b.blockStatement([b.returnStatement(errorResponse)]));
-        statements.push(ifStatement);
-        // Destructure validated params: const { id } = _params.value;
-        const pattern = b.objectPattern(pathParams.map(p => {
-            const prop = b.property("init", b.identifier(p.name), b.identifier(p.name));
-            prop.shorthand = true;
-            return prop;
-        }));
-        statements.push(b.variableDeclaration("const", [
-            b.variableDeclarator(pattern, b.memberExpression(b.identifier("_params"), b.identifier("value"))),
-        ]));
+function getBodySchemaName(method, entityName) {
+    if (method.kind === "create") {
+        return `${entityName}Insert`;
+    }
+    if (method.kind === "update") {
+        return `${entityName}Update`;
     }
-    else if (pathParams.length > 0) {
-        // No schema provider - just extract without validation
-        const pattern = b.objectPattern(pathParams.map(p => {
+    return null;
+}
+function buildHandlerBody(method, inflection) {
+    const callSig = method.callSignature ?? { style: "named" };
+    const statements = [];
+    // Extract path params: const { id } = req.params
+    const pathParams = method.params.filter((p) => p.source === "pk" || p.source === "fk" || p.source === "lookup");
+    if (pathParams.length > 0) {
+        const pattern = b.objectPattern(pathParams.map((p) => {
             const prop = b.property("init", b.identifier(p.name), b.identifier(p.name));
             prop.shorthand = true;
             return prop;
         }));
-        statements.push(b.variableDeclaration("const", [
-            b.variableDeclarator(pattern, b.memberExpression(b.identifier("req"), b.identifier("params"))),
-        ]));
+        statements.push(stmt.const(pathParams.map(p => p.name).join(", "), b.memberExpression(b.identifier("req"), b.identifier("params"))));
     }
     // Extract query params: const { limit, offset } = req.query
-    const queryParams = method.params.filter(p => p.source === "pagination");
+    const queryParams = method.params.filter((p) => p.source === "pagination");
     if (queryParams.length > 0) {
-        const pattern = b.objectPattern(queryParams.map(p => {
+        const pattern = b.objectPattern(queryParams.map((p) => {
             const prop = b.property("init", b.identifier(p.name), b.identifier(p.name));
             prop.shorthand = true;
             return prop;
         }));
-        statements.push(b.variableDeclaration("const", [
-            b.variableDeclarator(pattern, b.memberExpression(b.identifier("req"), b.identifier("query"))),
-        ]));
+        statements.push(stmt.const(queryParams.map(p => p.name).join(", "), b.memberExpression(b.identifier("req"), b.identifier("query"))));
     }
-    // Extract body with optional validation
-    const needsBody = method.params.some(p => p.source === "body") ||
+    // Extract body: const body = req.body
+    const needsBody = method.params.some((p) => p.source === "body") ||
         method.kind === "create" ||
         method.kind === "update" ||
-        (method.kind === "function" && method.params.some(p => !p.source));
+        (method.kind === "function" && method.params.some((p) => !p.source));
     if (needsBody) {
-        if (bodySchema && hasSchemaProvider) {
-            // Validation handled below using Standard Schema interface
-        }
-        else {
-            // const body = req.body
-            statements.push(stmt.const("body", b.memberExpression(b.identifier("req"), b.identifier("body"))));
-        }
-    }
-    // Validate body using Standard Schema interface (works with zod, valibot, arktype)
-    if (bodySchema && hasSchemaProvider) {
-        // const validation = UserInsert["~standard"].validate(req.body);
-        // if (validation.issues) throw new Error("Validation failed");
-        // const body = validation.value;
-        const standardMember = b.memberExpression(b.identifier(bodySchema.schemaName), b.stringLiteral("~standard"), true);
-        const validateCall = b.memberExpression(cast.toExpr(standardMember), b.identifier("validate"));
-        const validationExpr = b.callExpression(validateCall, [
-            b.memberExpression(b.identifier("req"), b.identifier("body")),
-        ]);
-        const validationVar = b.variableDeclarator(b.identifier("validation"), b.awaitExpression(validationExpr));
-        statements.push(b.variableDeclaration("const", [validationVar]));
-        // if (validation.issues) return res.status(400).json({ error: validation.issues });
-        const errorResponse = b.callExpression(b.memberExpression(b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("status")), [b.numericLiteral(400)]), b.identifier("json")), [b.objectExpression([b.property("init", b.stringLiteral("error"), b.memberExpression(b.identifier("validation"), b.identifier("issues")))])]);
-        const ifStatement = b.ifStatement(b.memberExpression(b.identifier("validation"), b.identifier("issues")), b.blockStatement([b.returnStatement(errorResponse)]));
-        statements.push(ifStatement);
-        // const body = validation.value;
-        statements.push(stmt.const("body", b.memberExpression(b.identifier("validation"), b.identifier("value"))));
+        statements.push(stmt.const("body", b.memberExpression(b.identifier("req"), b.identifier("body"))));
     }
     // Build the function call arguments
     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"));
@@ -208,18 +166,15 @@ const buildHandlerBody = (method, entityName, options) => {
         }
     }
     else {
-        const bodyParam = method.params.find(p => p.source === "body");
+        const bodyParam = method.params.find((p) => p.source === "body");
         if (bodyParam && callSig.bodyStyle === "spread") {
             args.push(b.identifier("body"));
         }
         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"));
@@ -228,11 +183,8 @@ const buildHandlerBody = (method, entityName, options) => {
         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) {
@@ -240,149 +192,210 @@ const buildHandlerBody = (method, entityName, options) => {
             }
         }
     }
-    // Build: const result = await Queries.queryFn(args)
-    const queryCall = b.callExpression(b.memberExpression(b.identifier("Queries"), b.identifier(method.name)), args.map(cast.toExpr));
+    // Call the query function: const result = await Queries.queryFn(args)
+    const queryCall = b.callExpression(b.identifier(method.name), args.map(cast.toExpr));
     statements.push(stmt.const("result", b.awaitExpression(queryCall)));
-    // Handle 404 for read/lookup that returns null
+    // Handle 404 for read/lookup that returns null/undefined
     if (method.kind === "read" || (method.kind === "lookup" && method.isUniqueLookup)) {
-        // if (!result) return res.status(404).json({ error: 'Not found' })
-        const notFoundResponse = b.callExpression(b.memberExpression(b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("status")), [
-            b.numericLiteral(404),
-        ]), b.identifier("json")), [conjure.obj().prop("error", b.stringLiteral("Not found")).build()]);
+        const notFoundResponse = b.callExpression(b.memberExpression(b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("status")), [b.numericLiteral(404)]), b.identifier("json")), [
+            conjure
+                .obj()
+                .prop("error", b.stringLiteral("Not found"))
+                .build(),
+        ]);
         statements.push(b.ifStatement(b.unaryExpression("!", b.identifier("result")), b.returnStatement(notFoundResponse)));
     }
-    // return res.json(result) or res.status(201).json(result) for create
+    // Return response: res.json(result) or res.status(201).json(result) for create
     let responseExpr;
     if (method.kind === "create") {
-        // res.status(201).json(result)
-        responseExpr = b.callExpression(b.memberExpression(b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("status")), [
-            b.numericLiteral(201),
-        ]), b.identifier("json")), [b.identifier("result")]);
+        responseExpr = b.callExpression(b.memberExpression(b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("status")), [b.numericLiteral(201)]), b.identifier("json")), [b.identifier("result")]);
     }
     else {
-        // res.json(result)
-        responseExpr = b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("json")), [
-            b.identifier("result"),
-        ]);
+        responseExpr = b.callExpression(b.memberExpression(b.identifier("res"), b.identifier("json")), [b.identifier("result")]);
     }
     statements.push(b.returnStatement(cast.toExpr(responseExpr)));
     return statements;
-};
-/**
- * Build a single route method call: router.get('/path', handler)
- */
-const buildRouteCall = (method, entityName, options) => {
+}
+function buildRouteCall(method, entityName, inflection) {
     const httpMethod = kindToHttpMethod(method.kind);
-    const path = getRoutePath(method);
-    // Build handler: async (req, res) => { ... }
-    const handlerBody = buildHandlerBody(method, entityName, options);
+    const path = getRoutePath(method, entityName, inflection);
+    const handlerBody = buildHandlerBody(method, inflection);
     const handler = b.arrowFunctionExpression([b.identifier("req"), b.identifier("res")], b.blockStatement(handlerBody.map(cast.toStmt)));
     handler.async = true;
     return { httpMethod, path, handler };
-};
-// ============================================================================
-// Plugin Definition
-// ============================================================================
-export function httpExpress(config = {}) {
-    const parsed = S.decodeUnknownSync(HttpExpressConfigSchema)(config);
-    return definePlugin({
-        name: "http-express",
-        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;
+}
+/**
+ * Generate Express routes for an entity.
+ *
+ * @param entityName - The entity name
+ * @param queries - Query extension metadata
+ * @param config - Plugin config
+ * @param registry - Symbol registry for recording cross-references
+ * @param inflection - Inflection service for naming
+ */
+function generateExpressRoutes(entityName, queries, config, registry, inflection) {
+    const routesVarName = `${inflect.uncapitalize(entityName)}Routes`;
+    let chainExpr = b.callExpression(b.identifier("Router"), []);
+    for (const method of queries.methods) {
+        const methodCapability = `queries:${entityName}:${getMethodCapabilitySuffix(method, inflection)}`;
+        if (registry.has(methodCapability)) {
+            registry.import(methodCapability).ref();
+        }
+        const { httpMethod, path, handler } = buildRouteCall(method, entityName, inflection);
+        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier(httpMethod)), [b.stringLiteral(path), handler]);
+    }
+    const variableDeclarator = b.variableDeclarator(b.identifier(routesVarName), cast.toExpr(chainExpr));
+    const variableDeclaration = b.variableDeclaration("const", [variableDeclarator]);
+    const externalImports = [
+        { from: "express", names: ["Router"] },
+    ];
+    return {
+        statements: [variableDeclaration],
+        externalImports,
+    };
+}
+/**
+ * Get the capability suffix for a query method.
+ * E.g., "findById", "list", "create", "update", "delete", "findByEmail"
+ */
+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 = [];
-            for (const entityName of entityNames) {
-                const entityMethods = ctx.symbols.getEntityMethods(entityName);
-                if (!entityMethods || entityMethods.methods.length === 0)
+            return "lookup";
+        case "function":
+            return method.name;
+    }
+}
+function generateAggregator(entities, config, registry, inflection) {
+    const entityEntries = Array.from(entities.entries());
+    if (entityEntries.length === 0) {
+        return { statements: [], externalImports: [] };
+    }
+    let chainExpr = b.callExpression(b.identifier("Router"), []);
+    const externalImports = [{ from: "express", names: ["Router"] }];
+    for (const [entityName, queries] of entityEntries) {
+        const routesVarName = `${inflect.uncapitalize(entityName)}Routes`;
+        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("use")), [b.identifier(routesVarName)]);
+        const routeCapability = `http-routes:express:${entityName}`;
+        if (registry.has(routeCapability)) {
+            registry.import(routeCapability).ref();
+        }
+    }
+    const variableDeclarator = b.variableDeclarator(b.identifier("api"), cast.toExpr(chainExpr));
+    const variableDeclaration = b.variableDeclaration("const", [variableDeclarator]);
+    return {
+        statements: [variableDeclaration],
+        externalImports,
+    };
+}
+export function express(config) {
+    const schemaConfig = S.decodeSync(HttpExpressConfigSchema)(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:express:",
+                outputDir: resolvedConfig.outputDir,
+                fileNaming: resolvedConfig.routesFile,
+            },
+            {
+                pattern: "http-routes:express: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 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 Router from express
-                file.import({ kind: "package", names: ["Router"], from: "express" });
-                // Import queries as namespace
-                const queriesImportPath = `../${entityMethods.importPath.replace(/\.ts$/, ".js")}`;
-                file.import({
-                    kind: "relative",
-                    namespace: "Queries",
-                    from: queriesImportPath,
-                });
-                // Check if a schema provider is available for body validation
-                const hasSchemaProvider = ctx.symbols.resolve({
-                    capability: "schemas",
-                    entity: entityName,
-                    shape: "insert",
-                }) !== undefined;
-                // Collect body schemas needed for imports
-                const bodySchemasNeeded = [];
-                // Build the Express router chain
-                // Router().get('/path', handler).post('/path', handler)...
-                let chainExpr = b.callExpression(b.identifier("Router"), []);
-                for (const method of entityMethods.methods) {
-                    const pathParams = method.params.filter(p => p.source === "pk" || p.source === "fk" || p.source === "lookup");
-                    const bodySchema = getBodySchemaImport(method, entityName);
-                    if (bodySchema && hasSchemaProvider) {
-                        bodySchemasNeeded.push(bodySchema);
-                    }
-                    const { httpMethod, path, handler } = buildRouteCall(method, entityName, {
-                        hasSchemaProvider,
-                        bodySchema,
-                        pathParams,
+                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: `${inflect.uncapitalize(entity.name)}Routes`,
+                        capability: `http-routes:express:${entity.name}`,
+                        baseEntityName: entity.name,
                     });
-                    chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier(httpMethod)), [b.stringLiteral(path), handler]);
                 }
-                // Import schemas needed for body validation
-                for (const schema of bodySchemasNeeded) {
-                    file.import({
-                        kind: "symbol",
-                        ref: { capability: "schemas", entity: schema.entity, shape: schema.shape },
-                    });
+            }
+            declarations.push({
+                name: "api",
+                capability: "http-routes:express: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);
                 }
-                const exportStmt = conjure.export.const(routesVarName, chainExpr);
-                file.ast(conjure.program(exportStmt)).emit();
-                generatedRoutes.push({
-                    fileName: `${inflect.uncapitalize(entityName)}.js`,
-                    exportName: routesVarName,
-                    pathSegment,
+            }
+            for (const [entityName, queries] of entityQueries) {
+                const entity = ir.entities.get(entityName);
+                if (!entity || !isTableEntity(entity))
+                    continue;
+                const capability = `http-routes:express:${entityName}`;
+                const { statements, externalImports } = registry.forSymbol(capability, () => generateExpressRoutes(entityName, queries, resolvedConfig, registry, inflection));
+                rendered.push({
+                    name: `${inflect.uncapitalize(entityName)}Routes`,
+                    capability,
+                    node: statements[0],
+                    exports: "named",
+                    externalImports,
                 });
             }
-            // 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: ["Router"], from: "express" });
-                for (const route of generatedRoutes) {
-                    indexFile.import({
-                        kind: "relative",
-                        names: [route.exportName],
-                        from: `./${route.fileName}`,
-                    });
-                }
-                // Build: Router().use('/users', userRoutes).use('/posts', postRoutes)...
-                let chainExpr = b.callExpression(b.identifier("Router"), []);
-                // Add routes with their path prefixes
-                for (const route of generatedRoutes) {
-                    chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("use")), [b.stringLiteral(`${basePath}/${route.pathSegment}`), b.identifier(route.exportName)]);
-                }
-                const exportStmt = conjure.export.const(aggregatorName, chainExpr);
-                indexFile.ast(conjure.program(exportStmt)).emit();
+            if (entityQueries.size > 0) {
+                const appCapability = "http-routes:express:app";
+                const { statements, externalImports } = registry.forSymbol(appCapability, () => generateAggregator(entityQueries, resolvedConfig, registry, inflection));
+                rendered.push({
+                    name: "api",
+                    capability: appCapability,
+                    node: statements[0],
+                    exports: "default",
+                    externalImports,
+                });
             }
-        },
-    });
+            return rendered;
+        }),
+    };
 }
 //# sourceMappingURL=http-express.js.map