@danielfgray/pg-sourcerer 0.2.2 → 0.4.0

package/dist/plugins/http-orpc.js

@@ -1,101 +1,76 @@
 /**
- * HTTP oRPC Plugin - Generate oRPC routers from query plugins
+ * HTTP oRPC Plugin - Generates oRPC routers from query symbols
  *
- * Consumes method symbols from sql-queries or kysely-queries via the symbol registry
- * and generates type-safe oRPC procedures using @orpc/server.
+ * 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.).
  *
- * Uses oRPC's `type()` utility for simple params (type-only, no runtime validation)
- * and imports body schemas from whatever plugin provides the "schemas" capability
- * (zod, arktype, valibot, etc.) for runtime validation.
+ * 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 { inflect } from "../services/inflection.js";
-const { b } = conjure;
+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 stmt = conjure.stmt;
+const PLUGIN_NAME = "orpc-http";
 // ============================================================================
-// Configuration Schema
+// Configuration
 // ============================================================================
+const DEFAULT_OUTPUT_DIR = "";
+const DEFAULT_ROUTES_FILE = "orpc.ts";
+const DEFAULT_APP_FILE = "orpc.ts";
+/**
+ * Schema-validated portion of the config (simple types only).
+ */
 const HttpOrpcConfigSchema = S.Struct({
-    /** Output directory for generated router files. Default: "orpc" */
-    outputDir: S.optionalWith(S.String, { default: () => "orpc" }),
-    /**
-     * Header content to prepend to each generated file.
-     * MUST import `os` from @orpc/server.
-     *
-     * @example
-     * ```typescript
-     * header: `import { os } from "@orpc/server";`
-     * ```
-     */
-    header: S.String,
+    outputDir: S.optionalWith(S.String, { default: () => DEFAULT_OUTPUT_DIR }),
     /** Name of the aggregated router export. Default: "appRouter" */
     aggregatorName: S.optionalWith(S.String, { default: () => "appRouter" }),
 });
 // ============================================================================
-// Type String Builders (for oRPC type<>() utility)
+// Procedure Builders
 // ============================================================================
 /**
- * Convert a QueryMethodParam to a TypeScript type string for use in type<>().
+ * Build Zod type expression for a param.
  */
-const paramToTypeString = (param) => {
-    const baseType = param.type.replace(/\[\]$/, "").replace(/\?$/, "").toLowerCase();
-    let tsType;
+function buildZodParamType(param) {
+    const baseType = param.type.toLowerCase();
+    let zodCall;
     switch (baseType) {
         case "number":
-        case "int":
-        case "integer":
-        case "float":
-        case "double":
-            tsType = "number";
+            zodCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("z"), b.identifier("coerce")), b.identifier("number")), []);
             break;
         case "boolean":
-        case "bool":
-            tsType = "boolean";
+            zodCall = b.callExpression(b.memberExpression(b.identifier("z"), b.identifier("boolean")), []);
             break;
         case "date":
-            tsType = "Date";
+            zodCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("z"), b.identifier("coerce")), b.identifier("date")), []);
             break;
         case "string":
         default:
-            tsType = "string";
+            zodCall = b.callExpression(b.memberExpression(b.identifier("z"), b.identifier("string")), []);
             break;
     }
-    // Handle arrays
-    if (param.type.endsWith("[]")) {
-        tsType = `${tsType}[]`;
-    }
-    // Handle optionality
     if (!param.required) {
-        tsType = `${tsType} | undefined`;
+        zodCall = b.callExpression(b.memberExpression(cast.toExpr(zodCall), b.identifier("optional")), []);
     }
-    return tsType;
-};
-/**
- * Build a TypeScript object type literal string for type<>().
- * Returns something like "{ id: number; name?: string }"
- */
-const buildTypeObjectString = (params) => {
-    if (params.length === 0)
-        return "{}";
-    const fields = params.map((param) => {
-        const typeStr = paramToTypeString(param);
-        const optional = !param.required ? "?" : "";
-        return `${param.name}${optional}: ${typeStr.replace(" | undefined", "")}`;
-    });
-    return `{ ${fields.join("; ")} }`;
-};
-// ============================================================================
-// Procedure Builders
-// ============================================================================
+    return zodCall;
+}
 /**
- * Build the handler function body for a procedure.
- * oRPC handlers receive { input, context } and return data directly.
+ * Build the handler function body for an oRPC procedure.
+ * oRPC handlers receive { input } and return data directly.
  */
-const buildProcedureBody = (queryFnName, method) => {
+function buildProcedureBody(method) {
     const callSig = method.callSignature ?? { style: "named" };
-    const statements = [];
-    // Build the function call arguments based on callSignature
     const args = [];
     if (callSig.style === "positional") {
         // Positional: fn(a, b, c)
@@ -104,7 +79,7 @@ const buildProcedureBody = (queryFnName, method) => {
         }
     }
     else {
-        // Named: fn({ a, b, c }) or fn(input) for body
+        // Named style
         const bodyParam = method.params.find((p) => p.source === "body");
         if (bodyParam && callSig.bodyStyle === "spread") {
             // Body fields spread directly: fn(input)
@@ -112,29 +87,19 @@ const buildProcedureBody = (queryFnName, method) => {
         }
         else if (bodyParam && callSig.bodyStyle === "property") {
             // Body wrapped in property: fn({ id, data })
-            // Collect non-body params that need to be extracted from input
             const nonBodyParams = method.params.filter((p) => p.source === "pk" || p.source === "fk" || p.source === "lookup" || p.source === "pagination");
             if (nonBodyParams.length > 0) {
-                // Generate: const { id, ...data } = input;
-                const destructureProps = nonBodyParams.map((p) => b.property.from({ kind: "init", key: b.identifier(p.name), value: b.identifier(p.name), shorthand: true }));
-                const restId = b.identifier(bodyParam.name);
-                const restElem = b.restElement(restId);
-                const pattern = b.objectPattern([...destructureProps, restElem]);
-                const destructureDecl = b.variableDeclaration("const", [
-                    b.variableDeclarator(pattern, b.identifier("input")),
-                ]);
-                statements.push(destructureDecl);
-                // Build: { id, data } using the destructured variables
+                // Build object with non-body params + body property
                 let objBuilder = conjure.obj();
                 for (const param of nonBodyParams) {
-                    objBuilder = objBuilder.shorthand(param.name);
+                    objBuilder = objBuilder.prop(param.name, b.memberExpression(b.identifier("input"), b.identifier(param.name)));
                 }
-                objBuilder = objBuilder.shorthand(bodyParam.name);
+                objBuilder = objBuilder.prop(bodyParam.name, b.memberExpression(b.identifier("input"), b.identifier(bodyParam.name)));
                 args.push(objBuilder.build());
             }
             else {
-                // No non-body params, just wrap input: fn({ data: input })
-                args.push(conjure.obj().prop(bodyParam.name, b.identifier("input")).build());
+                // No non-body params, just pass input
+                args.push(b.identifier("input"));
             }
         }
         else if (method.params.length > 0) {
@@ -142,229 +107,352 @@ const buildProcedureBody = (queryFnName, method) => {
             args.push(b.identifier("input"));
         }
     }
-    // Build: return await queryFn(args)
-    const queryCall = b.callExpression(b.identifier(queryFnName), args.map(cast.toExpr));
-    const awaitExpr = b.awaitExpression(queryCall);
+    // Build: queryFn(args)
+    const queryCall = b.callExpression(b.identifier(method.name), args.map(cast.toExpr));
+    // Add the appropriate .execute*() method based on query kind
+    const executeMethod = method.kind === "read" || (method.kind === "lookup" && method.isUniqueLookup)
+        ? "executeTakeFirst"
+        : method.kind === "create" || method.kind === "update"
+            ? "executeTakeFirstOrThrow"
+            : "execute";
+    const queryWithExecute = b.callExpression(b.memberExpression(queryCall, b.identifier(executeMethod)), []);
+    const awaitExpr = b.awaitExpression(queryWithExecute);
+    // For delete, return success object
     if (method.kind === "delete") {
-        statements.push(b.expressionStatement(awaitExpr));
-        statements.push(b.returnStatement(conjure.obj().prop("success", b.booleanLiteral(true)).build()));
-        return statements;
+        return [
+            b.expressionStatement(awaitExpr),
+            b.returnStatement(conjure.obj().prop("success", b.booleanLiteral(true)).build()),
+        ];
     }
-    statements.push(b.returnStatement(awaitExpr));
-    return statements;
-};
+    return [b.returnStatement(awaitExpr)];
+}
 /**
- * Determine if a method needs body validation and which schema to use.
+ * Get the body schema name for a method if it needs validation.
  */
-const getBodySchemaImport = (method, entityName) => {
+function getBodySchemaName(method, entityName) {
     if (method.kind === "create") {
-        return { entity: entityName, shape: "insert", schemaName: `${entityName}Insert` };
+        return `${entityName}Insert`;
     }
     if (method.kind === "update") {
-        return { entity: entityName, shape: "update", schemaName: `${entityName}Update` };
+        return `${entityName}Update`;
     }
     return null;
-};
+}
 /**
- * Build Zod type expression for a param.
+ * Build input schema expression for a procedure.
+ * Returns the schema expression and whether we need z import.
  */
-const buildZodParamType = (param) => {
-    const baseType = param.type.toLowerCase();
-    let zodCall;
-    switch (baseType) {
-        case "number":
-            zodCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("z"), b.identifier("coerce")), b.identifier("number")), []);
-            break;
-        case "boolean":
-            zodCall = b.callExpression(b.memberExpression(b.identifier("z"), b.identifier("boolean")), []);
-            break;
-        case "date":
-            zodCall = b.callExpression(b.memberExpression(b.memberExpression(b.identifier("z"), b.identifier("coerce")), b.identifier("date")), []);
-            break;
-        case "string":
-        default:
-            zodCall = b.callExpression(b.memberExpression(b.identifier("z"), b.identifier("string")), []);
-            break;
+function buildInputSchema(method, entityName) {
+    const bodySchemaName = getBodySchemaName(method, entityName);
+    const nonBodyParams = method.params.filter((p) => p.source !== "body");
+    const callSig = method.callSignature ?? { style: "named" };
+    // For update with bodyStyle: "property", merge PK params with body schema
+    if (bodySchemaName && nonBodyParams.length > 0 && callSig.bodyStyle === "property") {
+        let objBuilder = conjure.obj();
+        for (const p of nonBodyParams) {
+            objBuilder = objBuilder.prop(p.name, buildZodParamType(p));
+        }
+        const zodObject = b.callExpression(b.memberExpression(b.identifier("z"), b.identifier("object")), [cast.toExpr(objBuilder.build())]);
+        const mergedSchema = b.callExpression(b.memberExpression(zodObject, b.identifier("merge")), [b.identifier(bodySchemaName)]);
+        return {
+            inputExpr: mergedSchema,
+            bodySchemaName,
+            needsZodImport: true,
+            needsTypeImport: false,
+        };
     }
-    if (!param.required) {
-        zodCall = b.callExpression(b.memberExpression(cast.toExpr(zodCall), b.identifier("optional")), []);
+    // Body params only use imported entity schemas
+    if (bodySchemaName) {
+        return {
+            inputExpr: b.identifier(bodySchemaName),
+            bodySchemaName,
+            needsZodImport: false,
+            needsTypeImport: false,
+        };
     }
-    return zodCall;
-};
+    // Non-body params: build inline z.object
+    if (nonBodyParams.length === 0) {
+        return { inputExpr: null, bodySchemaName: null, needsZodImport: false, needsTypeImport: false };
+    }
+    let objBuilder = conjure.obj();
+    for (const param of nonBodyParams) {
+        const zodType = buildZodParamType(param);
+        objBuilder = objBuilder.prop(param.name, zodType);
+    }
+    return {
+        inputExpr: b.callExpression(b.memberExpression(b.identifier("z"), b.identifier("object")), [cast.toExpr(objBuilder.build())]),
+        bodySchemaName: null,
+        needsZodImport: true,
+        needsTypeImport: false,
+    };
+}
 /**
- * Build a single oRPC procedure.
- * Returns: os.input(type<InputType>()).handler(async ({ input }) => { ... })
- * Or for body schemas: os.input(BodySchema).handler(...)
+ * Build a single oRPC procedure expression.
  */
-const buildProcedure = (method, entityName, queryFnName) => {
-    const bodySchema = getBodySchemaImport(method, entityName);
-    let needsType = false;
-    let needsZMerge = false;
+function buildProcedure(method, entityName) {
+    // Start with os
     let chainExpr = b.identifier("os");
-    if (method.params.length > 0) {
-        let inputSchema;
-        // Check for non-body params (PK, FK, lookup, pagination)
-        const nonBodyParams = method.params.filter(p => p.source !== "body");
-        const callSig = method.callSignature ?? { style: "named" };
-        if (bodySchema && nonBodyParams.length > 0 && callSig.bodyStyle === "property") {
-            // For update-style operations with bodyStyle: "property", we need to merge
-            // the PK/FK params with the body schema: z.object({ id: z.number() }).merge(PostUpdate)
-            needsZMerge = true;
-            // Build: z.object({ id: z.coerce.number() })
-            let objBuilder = conjure.obj();
-            for (const p of nonBodyParams) {
-                objBuilder = objBuilder.prop(p.name, buildZodParamType(p));
-            }
-            const zodObject = b.callExpression(b.memberExpression(b.identifier("z"), b.identifier("object")), [cast.toExpr(objBuilder.build())]);
-            // Build: z.object({ id: ... }).merge(PostUpdate)
-            inputSchema = b.callExpression(b.memberExpression(zodObject, b.identifier("merge")), [b.identifier(bodySchema.schemaName)]);
-        }
-        else if (bodySchema) {
-            inputSchema = b.identifier(bodySchema.schemaName);
-        }
-        else {
-            needsType = true;
-            const typeStr = buildTypeObjectString(method.params);
-            inputSchema = b.identifier(`type<${typeStr}>()`);
-        }
-        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("input")), [cast.toExpr(inputSchema)]);
+    // Build input schema
+    const { inputExpr, bodySchemaName, needsZodImport, needsTypeImport } = buildInputSchema(method, entityName);
+    // Add .input(schema) if there are params
+    if (inputExpr) {
+        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("input")), [cast.toExpr(inputExpr)]);
     }
+    // Build the handler: async ({ input }) => { ... }
     const handlerParams = [];
     if (method.params.length > 0) {
         const inputProp = b.objectProperty(b.identifier("input"), b.identifier("input"));
         inputProp.shorthand = true;
         handlerParams.push(inputProp);
     }
-    const handlerBody = buildProcedureBody(queryFnName, method);
+    const handlerBody = buildProcedureBody(method);
     const handler = b.arrowFunctionExpression([b.objectPattern(handlerParams)], b.blockStatement(handlerBody.map(cast.toStmt)));
     handler.async = true;
+    // Add .handler()
     chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("handler")), [handler]);
-    return { procedureExpr: chainExpr, bodySchema, needsType, needsZMerge };
-};
+    return { procedureExpr: chainExpr, bodySchemaName, needsZodImport, needsTypeImport };
+}
+/**
+ * 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}`;
+            }
+            return "lookup";
+        case "function":
+            return method.name;
+    }
+}
+/**
+ * Generate oRPC router for an entity.
+ */
+function generateOrpcRouter(entityName, queries, config, registry, inflection) {
+    const routerName = inflection.variableName(entityName, "Router");
+    let needsZodImport = false;
+    let needsTypeImport = false;
+    const bodySchemaNames = [];
+    // Build router object
+    let routerObjBuilder = conjure.obj();
+    for (const method of queries.methods) {
+        // Record cross-reference for this query method
+        const methodCapability = `queries:${entityName}:${getMethodCapabilitySuffix(method, inflection)}`;
+        if (registry.has(methodCapability)) {
+            registry.import(methodCapability).ref();
+        }
+        const { procedureExpr, bodySchemaName, needsZodImport: methodNeedsZod, needsTypeImport: methodNeedsType } = buildProcedure(method, entityName);
+        if (bodySchemaName && !bodySchemaNames.includes(bodySchemaName)) {
+            bodySchemaNames.push(bodySchemaName);
+            // Import schema via cross-reference system
+            const schemaCapability = `schema:${bodySchemaName}`;
+            if (registry.has(schemaCapability)) {
+                registry.import(schemaCapability).ref();
+            }
+        }
+        if (methodNeedsZod)
+            needsZodImport = true;
+        if (methodNeedsType)
+            needsTypeImport = true;
+        routerObjBuilder = routerObjBuilder.prop(method.name, procedureExpr);
+    }
+    // Build: export const userRouter = { ... }
+    const variableDeclarator = b.variableDeclarator(b.identifier(routerName), cast.toExpr(routerObjBuilder.build()));
+    const variableDeclaration = b.variableDeclaration("const", [variableDeclarator]);
+    const externalImports = [];
+    if (needsZodImport) {
+        externalImports.push({ from: "zod", names: ["z"] });
+    }
+    if (needsTypeImport) {
+        externalImports.push({ from: "@orpc/server", names: ["type"] });
+    }
+    return {
+        statements: [variableDeclaration],
+        externalImports,
+    };
+}
+/**
+ * Generate aggregator router that combines all entity routers.
+ */
+function generateAggregator(entities, config, registry, inflection) {
+    const entityEntries = Array.from(entities.entries());
+    if (entityEntries.length === 0) {
+        return { statements: [], externalImports: [] };
+    }
+    // Build: { user: userRouter, post: postRouter, ... }
+    let routerObjBuilder = conjure.obj();
+    for (const [entityName] of entityEntries) {
+        const routerName = inflection.variableName(entityName, "Router");
+        const key = inflection.variableName(entityName, "");
+        routerObjBuilder = routerObjBuilder.prop(key, b.identifier(routerName));
+        // Record cross-reference to the entity's router capability
+        const routeCapability = `http-routes:orpc:${entityName}`;
+        if (registry.has(routeCapability)) {
+            registry.import(routeCapability).ref();
+        }
+    }
+    const variableDeclarator = b.variableDeclarator(b.identifier(config.aggregatorName), cast.toExpr(routerObjBuilder.build()));
+    const variableDeclaration = b.variableDeclaration("const", [variableDeclarator]);
+    // Also export the type: export type AppRouter = typeof appRouter
+    const typeExport = b.exportNamedDeclaration(b.tsTypeAliasDeclaration(b.identifier("AppRouter"), b.tsTypeQuery(b.identifier(config.aggregatorName))));
+    return {
+        statements: [variableDeclaration, typeExport],
+        externalImports: [],
+    };
+}
 // ============================================================================
 // Plugin Definition
 // ============================================================================
 /**
- * Create an http-orpc provider that generates oRPC routers.
+ * Create an http-orpc plugin that generates oRPC routers.
  *
  * @example
  * ```typescript
- * import { httpOrpc } from "pg-sourcerer"
+ * import { orpc } from "pg-sourcerer"
  *
  * export default defineConfig({
  *   plugins: [
  *     zod(),
- *     sqlQueries(),
- *     httpOrpc({
- *       header: `import { os } from "@orpc/server";`,
+ *     kyselyQueries(),
+ *     orpc({
+ *       aggregatorName: "appRouter",
  *     }),
  *   ],
  * })
  * ```
  */
-export function httpOrpc(config) {
-    const parsed = S.decodeUnknownSync(HttpOrpcConfigSchema)(config);
-    return definePlugin({
-        name: "http-orpc",
-        kind: "http-routes",
-        singleton: true,
-        canProvide: () => true,
-        requires: () => [
-            { kind: "queries", params: {} },
-            { kind: "schemas", params: {} },
+export function orpc(config) {
+    const schemaConfig = S.decodeSync(HttpOrpcConfigSchema)(config ?? {});
+    const resolvedConfig = {
+        outputDir: schemaConfig.outputDir,
+        aggregatorName: schemaConfig.aggregatorName,
+        routesFile: normalizeFileNaming(config?.routesFile, DEFAULT_ROUTES_FILE),
+        appFile: normalizeFileNaming(config?.appFile, DEFAULT_APP_FILE),
+        orpcImport: config?.orpcImport,
+    };
+    return {
+        name: PLUGIN_NAME,
+        provides: [],
+        fileDefaults: [
+            // Entity routers use routesFile config
+            {
+                pattern: "http-routes:orpc:",
+                outputDir: resolvedConfig.outputDir,
+                fileNaming: resolvedConfig.routesFile,
+            },
+            // App aggregator uses appFile config (more specific pattern wins)
+            {
+                pattern: "http-routes:orpc:app",
+                outputDir: resolvedConfig.outputDir,
+                fileNaming: resolvedConfig.appFile,
+            },
         ],
-        provide: (_params, _deps, ctx) => {
-            const { outputDir, header, aggregatorName } = parsed;
-            // Get all entities with registered query methods
-            const entityNames = ctx.symbols.getEntitiesWithMethods();
-            if (entityNames.length === 0) {
-                return;
-            }
-            // Track generated routers for aggregator
-            const generatedRouters = [];
-            // Generate router for each entity
-            for (const entityName of entityNames) {
-                const entityMethods = ctx.symbols.getEntityMethods(entityName);
-                if (!entityMethods || entityMethods.methods.length === 0)
+        declare: Effect.gen(function* () {
+            const ir = yield* IR;
+            const inflection = yield* Inflection;
+            const declarations = [];
+            // Declare routers for all table entities that might have queries
+            for (const entity of ir.entities.values()) {
+                if (!isTableEntity(entity))
                     continue;
-                const filePath = `${outputDir}/${inflect.uncapitalize(entityName)}.ts`;
-                const routerName = `${inflect.uncapitalize(entityName)}Router`;
-                const file = ctx.file(filePath);
-                // Header provides os import
-                file.header(header);
-                const queriesImportPath = `../${entityMethods.importPath.replace(/\.ts$/, ".js")}`;
-                file.import({
-                    kind: "relative",
-                    namespace: "Queries",
-                    from: queriesImportPath,
-                });
-                const bodySchemaImports = [];
-                let fileNeedsType = false;
-                let fileNeedsZod = false;
-                let routerObjBuilder = conjure.obj();
-                for (const method of entityMethods.methods) {
-                    const queryFnName = `Queries.${method.name}`;
-                    const { procedureExpr, bodySchema, needsType, needsZMerge } = buildProcedure(method, entityName, queryFnName);
-                    if (bodySchema)
-                        bodySchemaImports.push(bodySchema);
-                    if (needsType)
-                        fileNeedsType = true;
-                    if (needsZMerge)
-                        fileNeedsZod = true;
-                    routerObjBuilder = routerObjBuilder.prop(method.name, procedureExpr);
-                }
-                // Import type utility if needed
-                if (fileNeedsType) {
-                    file.import({ kind: "package", names: ["type"], from: "@orpc/server" });
-                }
-                // Import zod if needed for merged schemas
-                if (fileNeedsZod) {
-                    file.import({ kind: "package", names: ["z"], from: "zod" });
-                }
-                // Import body schemas
-                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, "Router"),
+                        capability: `http-routes:orpc:${entity.name}`,
+                        baseEntityName: entity.name,
                     });
                 }
-                const routerExport = conjure.export.const(routerName, routerObjBuilder.build());
-                // Emit router export
-                file.ast(conjure.program(routerExport)).emit();
-                generatedRouters.push({
-                    fileName: `${inflect.uncapitalize(entityName)}.js`,
-                    routerName,
+            }
+            // Also declare the aggregator
+            declarations.push({
+                name: resolvedConfig.aggregatorName,
+                capability: "http-routes:orpc:app",
+            });
+            return declarations;
+        }),
+        render: Effect.gen(function* () {
+            const ir = yield* IR;
+            const registry = yield* SymbolRegistry;
+            const inflection = yield* Inflection;
+            const rendered = [];
+            // Query the registry for all entity query capabilities
+            const entityQueries = new Map();
+            const queryCapabilities = registry.query("queries:");
+            for (const decl of queryCapabilities) {
+                // Only look at aggregate capabilities (queries:impl:EntityName, not queries:impl:EntityName:method)
+                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);
+                }
+            }
+            // User module imports for oRPC builder (if configured)
+            const orpcUserImports = resolvedConfig.orpcImport
+                ? [resolvedConfig.orpcImport]
+                : undefined;
+            for (const [entityName, queries] of entityQueries) {
+                const entity = ir.entities.get(entityName);
+                if (!entity || !isTableEntity(entity))
+                    continue;
+                const capability = `http-routes:orpc:${entityName}`;
+                // Scope cross-references to this specific capability
+                const { statements, externalImports } = registry.forSymbol(capability, () => generateOrpcRouter(entityName, queries, resolvedConfig, registry, inflection));
+                rendered.push({
+                    name: inflection.variableName(entityName, "Router"),
+                    capability,
+                    node: statements[0],
+                    exports: "named",
+                    externalImports,
+                    userImports: orpcUserImports,
                 });
             }
-            // Generate aggregator index.ts
-            if (generatedRouters.length > 0) {
-                const indexPath = `${outputDir}/index.ts`;
-                const indexFile = ctx.file(indexPath);
-                // Header provides os import
-                indexFile.header(header);
-                for (const route of generatedRouters) {
-                    indexFile.import({
-                        kind: "relative",
-                        names: [route.routerName],
-                        from: `./${route.fileName}`,
+            if (entityQueries.size > 0) {
+                const appCapability = "http-routes:orpc:app";
+                // Scope cross-references to the app capability
+                const { statements, externalImports } = registry.forSymbol(appCapability, () => generateAggregator(entityQueries, resolvedConfig, registry, inflection));
+                // The aggregator has multiple statements (const + type export)
+                rendered.push({
+                    name: resolvedConfig.aggregatorName,
+                    capability: appCapability,
+                    node: statements[0], // The const declaration
+                    exports: "named",
+                    externalImports,
+                    userImports: orpcUserImports,
+                });
+                // Add the type export as a separate rendered symbol
+                if (statements[1]) {
+                    rendered.push({
+                        name: "AppRouter",
+                        capability: "http-routes:orpc:app:type",
+                        node: statements[1],
+                        exports: false, // Already has export in the node
+                        // No userImports needed for type export
                     });
                 }
-                // Build: export const appRouter = { user: userRouter, ... }
-                let routerObjBuilder = conjure.obj();
-                for (const route of generatedRouters) {
-                    const key = route.routerName.replace(/Router$/, "");
-                    routerObjBuilder = routerObjBuilder.prop(key, b.identifier(route.routerName));
-                }
-                const routerExport = conjure.export.const(aggregatorName, routerObjBuilder.build());
-                // Also export the type
-                const typeExport = b.exportNamedDeclaration(b.tsTypeAliasDeclaration(b.identifier("AppRouter"), b.tsTypeQuery(b.identifier(aggregatorName))));
-                indexFile.ast(conjure.program(routerExport, typeExport)).emit();
             }
-        },
-    });
+            return rendered;
+        }),
+    };
 }
 //# sourceMappingURL=http-orpc.js.map