@danielfgray/pg-sourcerer 0.2.2 → 0.4.0

package/dist/plugins/http-elysia.js

@@ -1,48 +1,73 @@
 /**
- * HTTP Elysia Plugin - Generate Elysia route handlers from query plugins
+ * Elysia HTTP Plugin - Generates Elysia route handlers from query symbols
  *
- * Consumes method symbols from sql-queries or kysely-queries via the symbol registry
- * and generates type-safe Elysia 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.).
+ *
+ * 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 { 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 = "elysia-http";
+/**
+ * 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 DEFAULT_OUTPUT_DIR = "";
+const DEFAULT_ROUTES_FILE = "routes.ts";
+const DEFAULT_APP_FILE = "routes.ts";
+/**
+ * Schema-validated portion of the config (simple types only).
+ * FileNaming functions are handled separately since Schema can't validate functions.
  */
-import { Option, pipe, 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, getEnumEntities, } from "../ir/semantic-ir.js";
-import { resolveFieldType, isUuidType, isDateType, isEnumType, getPgTypeName, } from "../lib/field-utils.js";
-import { findEnumByPgName, TsType } from "../services/pg-types.js";
-const { b, stmt } = conjure;
-// ============================================================================
-// Configuration
-// ============================================================================
 const HttpElysiaConfigSchema = 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 */
+// Manual casing helpers removed - now using inflection service:
+// - inflection.kebabCase(), inflection.pascalCase() for primitives
+// - inflection.elysiaRoutesName() for route variable names
+// - inflection.entityRoutePath() for entity path segments
 const kindToHttpMethod = (kind) => {
     switch (kind) {
         case "read":
@@ -52,15 +77,14 @@ const kindToHttpMethod = (kind) => {
         case "create":
             return "post";
         case "update":
-            return "put";
+            return "patch";
         case "delete":
             return "delete";
         case "function":
             return "post";
     }
 };
-/** Get the route path for a method */
-const getRoutePath = (method) => {
+const getRoutePath = (method, entityName, inflection) => {
     switch (method.kind) {
         case "read":
         case "update":
@@ -70,208 +94,73 @@ const getRoutePath = (method) => {
             return `/:${paramName}`;
         }
         case "list":
+            // Check if this is a cursor pagination method (listBy{Column})
+            // These methods have names like: "postListByCreatedAt" -> should be "/by-created-at"
+            // Regular list methods (if any existed) would be just: "postList" -> "/"
+            if (/ListBy/i.test(method.name) || /listBy/i.test(method.name)) {
+                // Extract column name after the list pattern
+                // Handles both "postListByCreatedAt" and "postlistByCreatedAt"
+                const match = method.name.match(/(?:ListBy|listBy)(.+)/i);
+                if (match && match[1]) {
+                    const columnKebab = inflection.kebabCase(match[1]);
+                    return `/by-${columnKebab}`;
+                }
+            }
+            // Standard list route
+            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 a TypeBox type call: t.String(), t.Number(), etc.
- */
-const buildTypeBoxCall = (methodName, args = []) => b.callExpression(b.memberExpression(b.identifier("t"), b.identifier(methodName)), args.map(cast.toExpr));
-/**
- * Map TypeScript type string to TypeBox method name.
- * For path params (strings from URL), numeric types use t.Numeric() for coercion.
- */
-const tsTypeToTypeBoxMethod = (tsType, forPathParam) => {
-    switch (tsType) {
-        case TsType.String:
-            return "String";
-        case TsType.Number:
-            // t.Numeric() coerces string to number (for path/query params)
-            return forPathParam ? "Numeric" : "Number";
-        case TsType.Boolean:
-            return "Boolean";
-        case TsType.BigInt:
-            // BigInt comes as string from URL params
-            return forPathParam ? "String" : "BigInt";
-        case TsType.Date:
-            // Dates come as strings, need string schema
-            return "String";
-        case TsType.Buffer:
-        case TsType.Unknown:
-        default:
-            return "Unknown";
-    }
-};
-/**
- * Build TypeBox enum schema: t.Union([t.Literal('a'), t.Literal('b'), ...])
- */
-const buildTypeBoxEnum = (values) => {
-    const literals = values.map((v) => buildTypeBoxCall("Literal", [b.stringLiteral(v)]));
-    return buildTypeBoxCall("Union", [b.arrayExpression(literals.map(cast.toExpr))]);
-};
-/**
- * Build TypeBox array schema: t.Array(<inner>)
- */
-const buildTypeBoxArray = (inner) => buildTypeBoxCall("Array", [cast.toExpr(inner)]);
-/**
- * Build TypeBox optional schema: t.Optional(<inner>)
- */
-const buildTypeBoxOptional = (inner) => buildTypeBoxCall("Optional", [cast.toExpr(inner)]);
-/**
- * Build TypeBox union with null: t.Union([<inner>, t.Null()])
- */
-const buildTypeBoxNullable = (inner) => buildTypeBoxCall("Union", [
-    b.arrayExpression([cast.toExpr(inner), cast.toExpr(buildTypeBoxCall("Null"))]),
-]);
-/**
- * Resolve a Field to its TypeBox schema expression.
- *
- * @param field - The IR field to resolve
- * @param ctx - Context with enums and extensions
- * @param forInsert - True if generating for insert shape (fields with defaults are optional)
- */
-const resolveFieldTypeBoxSchema = (field, ctx, forInsert) => {
-    let baseSchema;
-    // 1. UUID types - still strings
-    if (isUuidType(field)) {
-        baseSchema = buildTypeBoxCall("String");
-    }
-    // 2. Date types - accept string or Date
-    else if (isDateType(field)) {
-        baseSchema = buildTypeBoxCall("Union", [
-            b.arrayExpression([
-                cast.toExpr(buildTypeBoxCall("String")),
-                cast.toExpr(buildTypeBoxCall("Date")),
-            ]),
-        ]);
-    }
-    // 3. Enum types - union of literals
-    else if (isEnumType(field)) {
-        const pgTypeName = getPgTypeName(field);
-        const enumDef = pgTypeName
-            ? pipe(findEnumByPgName(ctx.enums, pgTypeName), Option.getOrUndefined)
-            : undefined;
-        if (enumDef) {
-            baseSchema = buildTypeBoxEnum(enumDef.values);
-        }
-        else {
-            baseSchema = buildTypeBoxCall("Unknown");
-        }
-    }
-    // 4. Fallback to resolved TypeScript type
-    else {
-        const resolved = resolveFieldType(field, ctx.enums, ctx.extensions);
-        const typeBoxMethod = tsTypeToTypeBoxMethod(resolved.tsType, false);
-        baseSchema = buildTypeBoxCall(typeBoxMethod);
-    }
-    // Wrap with array if needed
-    if (field.isArray) {
-        baseSchema = buildTypeBoxArray(baseSchema);
-    }
-    // Apply nullable
-    if (field.nullable) {
-        baseSchema = buildTypeBoxNullable(baseSchema);
-    }
-    // Apply optional (for insert shapes: fields with defaults are optional)
-    if (forInsert && field.optional) {
-        baseSchema = buildTypeBoxOptional(baseSchema);
-    }
-    return baseSchema;
-};
-/**
- * Build TypeBox object schema for an entity shape.
- *
- * @param entity - The entity to build schema for
- * @param shapeKind - Which shape to use (insert or update)
- * @param ctx - Context with enums and extensions
- */
-const buildEntityTypeBoxSchema = (entity, shapeKind, ctx) => {
-    const shape = shapeKind === "insert" ? entity.shapes.insert : entity.shapes.update;
-    if (!shape) {
-        // Fallback to row shape if specific shape doesn't exist
-        return buildTypeBoxCall("Unknown");
-    }
-    let objBuilder = conjure.obj();
-    for (const field of shape.fields) {
-        // For update shapes, ALL fields are optional (patch semantics)
-        // For insert shapes, only fields with defaults/nullable are optional (already marked in IR)
-        const applyOptional = shapeKind === "update" || (shapeKind === "insert" && field.optional);
-        let fieldSchema = resolveFieldTypeBoxSchema(field, ctx, false); // Don't apply optional inside
-        if (applyOptional) {
-            fieldSchema = buildTypeBoxOptional(fieldSchema);
-        }
-        objBuilder = objBuilder.prop(field.name, fieldSchema);
-    }
-    return buildTypeBoxCall("Object", [objBuilder.build()]);
-};
-/**
- * Build TypeBox schema for a path/query parameter based on its type string.
- *
- * @param param - The query method param
- */
-const buildParamTypeBoxSchema = (param) => {
-    const typeBoxMethod = tsTypeToTypeBoxMethod(param.type, true);
-    return buildTypeBoxCall(typeBoxMethod);
-};
-/**
- * Build the handler function body for a query method.
- * Params/query are destructured in the handler signature, so we reference them directly.
- */
-const buildHandlerBody = (method) => {
+function buildHandlerBody(method) {
     const callSig = method.callSignature ?? { style: "named" };
-    // Build the function call arguments based on callSignature
     const args = [];
     if (callSig.style === "positional") {
-        // Positional: fn(a, b, c) - params are already destructured
         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)) {
+                // URL params need coercion to their expected type
+                args.push(coerceParam(param.name, param.type));
             }
             else if (param.source === "body") {
                 args.push(b.identifier("body"));
             }
             else {
-                // No source specified - get from body (body is not destructured)
                 args.push(b.memberExpression(b.identifier("body"), b.identifier(param.name)));
             }
         }
     }
     else {
-        // Named: fn({ a, b, c }) or fn({ id, data: body })
         const bodyParam = method.params.find((p) => p.source === "body");
         if (bodyParam && callSig.bodyStyle === "spread") {
-            // Body fields spread directly: fn(body)
             args.push(b.identifier("body"));
         }
         else if (bodyParam && callSig.bodyStyle === "property") {
-            // Body wrapped in property: fn({ id, data: body })
             let objBuilder = conjure.obj();
             for (const param of method.params) {
-                if (param.source === "pk" || param.source === "fk" || param.source === "lookup" || param.source === "pagination") {
-                    // Params are destructured, use shorthand: { id }
-                    objBuilder = objBuilder.shorthand(param.name);
+                if (needsCoercion(param)) {
+                    // URL params need coercion - use prop() instead of shorthand()
+                    objBuilder = objBuilder.prop(param.name, coerceParam(param.name, param.type));
                 }
             }
             objBuilder = objBuilder.prop(bodyParam.name, b.identifier("body"));
             args.push(objBuilder.build());
         }
         else {
-            // Build object from path/pagination params using shorthand
             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)) {
+                    // URL params need coercion - use prop() instead of shorthand()
+                    objBuilder = objBuilder.prop(param.name, coerceParam(param.name, param.type));
                 }
             }
             if (method.params.length > 0) {
@@ -279,129 +168,47 @@ const buildHandlerBody = (method) => {
             }
         }
     }
-    // Build: const result = await Queries.queryFn(args)
-    const queryCall = b.callExpression(b.memberExpression(b.identifier("Queries"), b.identifier(method.name)), args.map(cast.toExpr));
-    const awaitExpr = b.awaitExpression(queryCall);
+    // Call the query function directly since we use named imports
+    const queryCall = b.callExpression(b.identifier(method.name), args.map(cast.toExpr));
+    // Add the appropriate .execute*() method based on query kind
+    // - read/lookup(unique): .executeTakeFirst() - returns single row or undefined
+    // - list/lookup(non-unique): .execute() - returns array
+    // - create/update: .executeTakeFirstOrThrow() - returns single row, throws if not found
+    // - delete: .execute() - just executes
+    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);
     const resultDecl = stmt.const("result", awaitExpr);
-    // Handle 404 for read/lookup that returns null
     if (method.kind === "read" || (method.kind === "lookup" && method.isUniqueLookup)) {
-        // if (!result) return status(404, 'Not found');
         const statusCall = b.callExpression(b.identifier("status"), [b.numericLiteral(404), b.stringLiteral("Not found")]);
         const notFoundCheck = b.ifStatement(b.unaryExpression("!", b.identifier("result")), b.returnStatement(statusCall));
         return [resultDecl, notFoundCheck, b.returnStatement(b.identifier("result"))];
     }
     return [resultDecl, b.returnStatement(b.identifier("result"))];
-};
+}
+const stmt = conjure.stmt;
 /**
- * Determine if a method needs body validation and which schema to use.
- * Returns the schema import info or null if no body validation needed.
+ * 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 the route options object (params/body/query validation schemas).
- * Returns the options object expression, whether it needs 't' import, body schema info,
- * and any schema builder imports needed.
- *
- * @param hasSchemaProvider - Whether a schema provider is registered for body validation
- * @param entity - The entity for inline TypeBox body schema generation (when no schema provider)
- * @param typeBoxCtx - Context for TypeBox field resolution
- */
-const buildRouteOptions = (method, entityName, requestSchema, hasSchemaProvider, entity, typeBoxCtx) => {
-    let objBuilder = conjure.obj();
-    let hasOptions = false;
-    let needsElysiaT = false;
-    let schemaBuilderImport = null;
-    let inlineBodySchema = null;
-    // Build params schema 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) {
-            objBuilder = objBuilder.prop("params", schemaResult.ast);
-            schemaBuilderImport = schemaResult.importSpec;
-        }
-        else {
-            // Fallback to TypeBox t.Object({ ... }) with proper type coercion
-            needsElysiaT = true;
-            let paramsBuilder = conjure.obj();
-            for (const param of pathParams) {
-                // Use buildParamTypeBoxSchema to get correct type (t.Numeric for numbers)
-                paramsBuilder = paramsBuilder.prop(param.name, buildParamTypeBoxSchema(param));
-            }
-            const paramsSchema = b.callExpression(b.memberExpression(b.identifier("t"), b.identifier("Object")), [paramsBuilder.build()]);
-            objBuilder = objBuilder.prop("params", paramsSchema);
-        }
-        hasOptions = true;
-    }
-    // Build query schema for pagination params
-    const queryParams = method.params.filter((p) => p.source === "pagination");
-    if (queryParams.length > 0) {
-        const schemaResult = requestSchema(queryParams);
-        if (schemaResult) {
-            objBuilder = objBuilder.prop("query", schemaResult.ast);
-            schemaBuilderImport = schemaResult.importSpec;
-        }
-        else {
-            // Fallback to TypeBox t.Object({ ... })
-            needsElysiaT = true;
-            let queryBuilder = conjure.obj();
-            for (const param of queryParams) {
-                const tNumeric = b.callExpression(b.memberExpression(b.identifier("t"), b.identifier("Numeric")), []);
-                const tOptional = b.callExpression(b.memberExpression(b.identifier("t"), b.identifier("Optional")), [tNumeric]);
-                queryBuilder = queryBuilder.prop(param.name, tOptional);
-            }
-            const querySchema = b.callExpression(b.memberExpression(b.identifier("t"), b.identifier("Object")), [queryBuilder.build()]);
-            objBuilder = objBuilder.prop("query", querySchema);
-        }
-        hasOptions = true;
-    }
-    // Body validation
-    const bodySchemaInfo = getBodySchemaImport(method, entityName);
-    let bodySchema = null;
-    if (bodySchemaInfo) {
-        if (hasSchemaProvider) {
-            // Use imported schema from schema provider (Zod, Valibot, etc.)
-            bodySchema = bodySchemaInfo;
-            objBuilder = objBuilder.prop("body", b.identifier(bodySchema.schemaName));
-            hasOptions = true;
-        }
-        else if (entity) {
-            // Generate inline TypeBox schema from IR
-            needsElysiaT = true;
-            inlineBodySchema = buildEntityTypeBoxSchema(entity, bodySchemaInfo.shape, typeBoxCtx);
-            objBuilder = objBuilder.prop("body", inlineBodySchema);
-            hasOptions = true;
-        }
-        // If neither schema provider nor entity, skip body validation (body will be unknown)
-    }
-    return {
-        options: hasOptions ? objBuilder.build() : null,
-        needsElysiaT,
-        bodySchema,
-        schemaBuilderImport,
-        inlineBodySchema,
-    };
-};
-/**
- * Build a single route method call: .get('/path', handler, options)
- */
-const buildRouteCall = (method, entityName, requestSchema, hasSchemaProvider, entity, typeBoxCtx) => {
+}
+function buildRouteCall(method, entityName, inflection) {
     const httpMethod = kindToHttpMethod(method.kind);
-    const path = getRoutePath(method);
-    // Build handler: async ({ params: { id }, body, query: { limit }, status }) => { ... }
+    const path = getRoutePath(method, entityName, inflection);
     const handlerProps = [];
-    // Collect path params (pk, fk, lookup) for destructuring
     const pathParams = method.params.filter((p) => p.source === "pk" || p.source === "fk" || p.source === "lookup");
     if (pathParams.length > 0) {
-        // params: { id, slug, ... }
         const paramsPattern = b.objectPattern(pathParams.map((p) => {
             const prop = b.property("init", b.identifier(p.name), b.identifier(p.name));
             prop.shorthand = true;
@@ -409,7 +216,6 @@ const buildRouteCall = (method, entityName, requestSchema, hasSchemaProvider, en
         }));
         handlerProps.push(b.property("init", b.identifier("params"), paramsPattern));
     }
-    // Add body if: explicit body param, create/update method, or function with params (no source = from body)
     const needsBody = method.params.some((p) => p.source === "body") ||
         method.kind === "create" ||
         method.kind === "update" ||
@@ -419,10 +225,8 @@ const buildRouteCall = (method, entityName, requestSchema, hasSchemaProvider, en
         prop.shorthand = true;
         handlerProps.push(prop);
     }
-    // Collect pagination params for destructuring
     const paginationParams = method.params.filter((p) => p.source === "pagination");
     if (paginationParams.length > 0) {
-        // query: { limit, offset, ... }
         const queryPattern = b.objectPattern(paginationParams.map((p) => {
             const prop = b.property("init", b.identifier(p.name), b.identifier(p.name));
             prop.shorthand = true;
@@ -439,175 +243,246 @@ const buildRouteCall = (method, entityName, requestSchema, hasSchemaProvider, en
     const handlerBody = buildHandlerBody(method);
     const handler = b.arrowFunctionExpression([handlerParamPattern], b.blockStatement(handlerBody.map(cast.toStmt)));
     handler.async = true;
-    const { options, needsElysiaT, bodySchema, schemaBuilderImport } = buildRouteOptions(method, entityName, requestSchema, hasSchemaProvider, entity, typeBoxCtx);
-    return { httpMethod, path, handler, options, needsElysiaT, bodySchema, schemaBuilderImport };
-};
-// ============================================================================
-// Plugin Definition
-// ============================================================================
-export function httpElysia(config) {
-    const parsed = S.decodeUnknownSync(HttpElysiaConfigSchema)(config);
-    return definePlugin({
-        name: "http-elysia",
-        kind: "http-routes",
-        singleton: true,
-        canProvide: () => true,
-        // Declare dependencies: queries required, schemas optional (falls back to TypeBox)
-        requires: () => [
-            { kind: "queries", params: {} },
-        ],
-        optionalRequires: () => [
-            { kind: "schemas", params: {} },
-        ],
-        provide: (_params, _deps, ctx) => {
-            const { outputDir, basePath, header, aggregatorName } = parsed;
-            // Get all entities with registered query methods
-            const entityNames = ctx.symbols.getEntitiesWithMethods();
-            if (entityNames.length === 0) {
-                // No query methods registered - nothing to generate
-                return;
+    // Build route options with body schema validation
+    const bodySchemaName = getBodySchemaName(method, entityName);
+    let options = null;
+    if (bodySchemaName) {
+        // { body: EntityInsert } or { body: EntityUpdate }
+        options = conjure
+            .obj()
+            .prop("body", b.identifier(bodySchemaName))
+            .build();
+    }
+    return { httpMethod, path, handler, needsBody, bodySchemaName, options };
+}
+/**
+ * Generate Elysia 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
+ */
+function generateElysiaRoutes(entityName, queries, config, registry, inflection) {
+    // Use inflection.entityRoutePath which handles pluralization and kebab-casing
+    const prefix = inflection.entityRoutePath(entityName);
+    // Use same name as the symbol declaration for consistency with cross-references
+    const routesVarName = inflection.variableName(entityName, "ElysiaRoutes");
+    // Build prefix: ensure proper slashes with basePath
+    const basePath = config.basePath.replace(/^\/+|\/+$/g, ""); // trim slashes
+    const fullPrefix = basePath ? `/${basePath}${prefix}` : prefix;
+    let chainExpr = b.newExpression(b.identifier("Elysia"), [
+        conjure
+            .obj()
+            .prop("prefix", b.stringLiteral(fullPrefix))
+            .build(),
+    ]);
+    for (const method of queries.methods) {
+        // Record cross-reference for this query method via registry
+        // This allows emit phase to generate the import automatically
+        // Use generic prefix - registry resolves to implementation (e.g., queries:kysely:...)
+        const methodCapability = `queries:${entityName}:${getMethodCapabilitySuffix(method, inflection)}`;
+        if (registry.has(methodCapability)) {
+            registry.import(methodCapability).ref();
+        }
+        const { httpMethod, path, handler, bodySchemaName, options } = buildRouteCall(method, entityName, inflection);
+        if (bodySchemaName) {
+            // Use registry to import schema - this ensures correct relative path resolution
+            // Use generic prefix - registry resolves to implementation (e.g., schema:zod:...)
+            const schemaCapability = `schema:${bodySchemaName}`;
+            if (registry.has(schemaCapability)) {
+                registry.import(schemaCapability).ref();
             }
-            // Track generated routes for aggregator index
-            const generatedRoutes = [];
-            // Build TypeBox context for inline schema generation (when no schema plugin)
-            const enumEntities = getEnumEntities(ctx.ir);
-            const tableEntities = getTableEntities(ctx.ir);
-            const typeBoxCtx = {
-                enums: enumEntities,
-                extensions: ctx.ir.extensions,
-            };
-            // Generate routes for each entity
-            for (const entityName of entityNames) {
-                const entityMethods = ctx.symbols.getEntityMethods(entityName);
-                if (!entityMethods || entityMethods.methods.length === 0)
+        }
+        // Build route call: .get(path, handler) or .post(path, handler, { body: Schema })
+        const callArgs = [b.stringLiteral(path), handler];
+        if (options) {
+            callArgs.push(options);
+        }
+        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]);
+    // Only external package imports go here; query and schema imports are handled via cross-references
+    const externalImports = [
+        { from: "elysia", names: ["Elysia"] },
+    ];
+    return {
+        statements: [variableDeclaration],
+        externalImports,
+    };
+}
+/**
+ * Get the capability suffix for a query method.
+ * E.g., "findById", "list", "create", "update", "delete", "findByEmail"
+ */
+function getMethodCapabilitySuffix(method, inflection) {
+    // The capability suffix is derived from the method name
+    // e.g., "userFindById" -> "findById", "userList" -> "list"
+    // We use generic capabilities that the registry resolves to the implementation.
+    // Generic capabilities (resolved by registry):
+    // - queries:User:findById → queries:kysely:User:findById (if kysely provides)
+    // - queries:User:list → queries:kysely:User:list
+    // - queries:User:create → queries:kysely:User:create
+    // - queries:User:update → queries:kysely:User:update
+    // - queries:User:delete → queries:kysely:User:delete
+    // - queries:User:findByEmail → queries:kysely:User:findByEmail
+    // The method.name is like "userFindById", "userList", etc.
+    // We need to extract just the operation part
+    // Method kinds map to capability suffixes:
+    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":
+            // For lookups, the suffix is like "findByEmail" where Email is the field
+            if (method.lookupField) {
+                const pascalField = inflection.pascalCase(method.lookupField);
+                return `findBy${pascalField}`;
+            }
+            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.newExpression(b.identifier("Elysia"), []);
+    const externalImports = [{ from: "elysia", names: ["Elysia"] }];
+    for (const [entityName, queries] of entityEntries) {
+        // Use same name as the symbol declaration for consistency with cross-references
+        const routesVarName = inflection.variableName(entityName, "ElysiaRoutes");
+        chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("use")), [b.identifier(routesVarName)]);
+        // Record cross-reference to the entity's routes capability
+        // The emit phase will generate the import automatically
+        const routeCapability = `http-routes:elysia:${entityName}`;
+        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 elysia(config) {
+    const schemaConfig = S.decodeSync(HttpElysiaConfigSchema)(config ?? {});
+    // Resolve FileNaming functions (Schema can't validate these)
+    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: [
+            // Entity routes use routesFile config
+            {
+                pattern: "http-routes:elysia:",
+                outputDir: resolvedConfig.outputDir,
+                fileNaming: resolvedConfig.routesFile,
+            },
+            // App aggregator uses appFile config (more specific pattern wins)
+            {
+                pattern: "http-routes:elysia:app",
+                outputDir: resolvedConfig.outputDir,
+                fileNaming: resolvedConfig.appFile,
+            },
+        ],
+        declare: Effect.gen(function* () {
+            const ir = yield* IR;
+            const inflection = yield* Inflection;
+            const declarations = [];
+            // Declare routes for all table entities that might have queries
+            // The actual routes generated depend on what queries exist at render time
+            for (const entity of ir.entities.values()) {
+                if (!isTableEntity(entity))
                     continue;
-                // Find the entity in the IR for inline TypeBox body schema generation
-                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 Elysia
-                file.import({ kind: "package", names: ["Elysia"], from: "elysia" });
-                // Import queries as namespace
-                const queriesImportPath = `../${entityMethods.importPath.replace(/\.ts$/, ".js")}`;
-                file.import({
-                    kind: "relative",
-                    namespace: "Queries",
-                    from: queriesImportPath,
-                });
-                // Build the Elysia route chain
-                // new Elysia({ prefix: '/api/users' }).get(...).post(...)
-                const prefixPath = `${basePath}/${pathSegment}`;
-                const elysiaConfig = conjure.obj().prop("prefix", b.stringLiteral(prefixPath)).build();
-                let chainExpr = b.newExpression(b.identifier("Elysia"), [elysiaConfig]);
-                let fileNeedsElysiaT = false;
-                const bodySchemaImports = [];
-                let schemaLibraryImport = null;
-                // 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, will fall back to TypeBox
-                        return undefined;
-                    }
-                };
-                // Check if a schema provider is available for body validation
-                // We probe by checking if the schema-builder service exists
-                let hasSchemaProvider = false;
-                try {
-                    // Try to request an entity schema - if it succeeds, we have a provider
-                    ctx.request(SCHEMA_BUILDER_KIND, { variant: "entity", entity: entityName, shape: "insert" });
-                    hasSchemaProvider = true;
-                }
-                catch {
-                    // No schema provider registered
-                }
-                for (const method of entityMethods.methods) {
-                    const { httpMethod, path, handler, options, needsElysiaT, bodySchema, schemaBuilderImport } = buildRouteCall(method, entityName, requestSchema, hasSchemaProvider, entity, typeBoxCtx);
-                    if (needsElysiaT)
-                        fileNeedsElysiaT = true;
-                    if (bodySchema)
-                        bodySchemaImports.push(bodySchema);
-                    if (schemaBuilderImport)
-                        schemaLibraryImport = schemaBuilderImport;
-                    const callArgs = [b.stringLiteral(path), handler];
-                    if (options) {
-                        callArgs.push(options);
-                    }
-                    chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier(httpMethod)), callArgs.map(cast.toExpr));
-                }
-                if (fileNeedsElysiaT) {
-                    file.import({ kind: "package", names: ["t"], from: "elysia" });
-                }
-                // Import schema library (e.g., Zod) if using schema-builder for params
-                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 (Zod, Valibot, etc.)
-                // These are resolved via the symbol registry's "schemas" capability
-                for (const schemaImport of bodySchemaImports) {
-                    file.import({
-                        kind: "symbol",
-                        ref: {
-                            capability: "schemas",
-                            entity: schemaImport.entity,
-                            shape: schemaImport.shape,
-                        },
+                if (entity.tags.omit === true)
+                    continue;
+                // If entity has any CRUD permissions, it could have queries
+                const hasAnyPermissions = entity.permissions.canSelect ||
+                    entity.permissions.canInsert ||
+                    entity.permissions.canUpdate ||
+                    entity.permissions.canDelete;
+                if (hasAnyPermissions) {
+                    declarations.push({
+                        name: inflection.variableName(entity.name, "ElysiaRoutes"),
+                        capability: `http-routes:elysia:${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,
-                });
             }
-            // Generate aggregator index.ts
-            if (generatedRoutes.length > 0) {
-                const indexPath = `${outputDir}/index.ts`;
-                const indexFile = ctx.file(indexPath);
-                if (header) {
-                    indexFile.header(header);
+            // Also declare the aggregator
+            declarations.push({
+                name: "elysiaApp",
+                capability: "http-routes:elysia: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
+            // Use generic prefix - registry resolves to implementation provider
+            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; // Skip method-specific capabilities
+                const entityName = parts[2];
+                const metadata = registry.getMetadata(decl.capability);
+                if (metadata && typeof metadata === "object" && "methods" in metadata) {
+                    entityQueries.set(entityName, metadata);
                 }
-                indexFile.import({ kind: "package", names: ["Elysia"], from: "elysia" });
-                for (const route of generatedRoutes) {
-                    indexFile.import({
-                        kind: "relative",
-                        names: [route.exportName],
-                        from: `./${route.fileName}`,
-                    });
-                }
-                // Build: new Elysia().use(userRoutes).use(postRoutes)...
-                let chainExpr = b.newExpression(b.identifier("Elysia"), []);
-                for (const route of generatedRoutes) {
-                    chainExpr = b.callExpression(b.memberExpression(cast.toExpr(chainExpr), b.identifier("use")), [b.identifier(route.exportName)]);
-                }
-                const exportStmt = conjure.export.const(aggregatorName, chainExpr);
-                indexFile.ast(conjure.program(exportStmt)).emit();
             }
-        },
-    });
+            for (const [entityName, queries] of entityQueries) {
+                const entity = ir.entities.get(entityName);
+                if (!entity || !isTableEntity(entity))
+                    continue;
+                const capability = `http-routes:elysia:${entityName}`;
+                // Scope cross-references to this specific capability
+                const { statements, externalImports } = registry.forSymbol(capability, () => generateElysiaRoutes(entityName, queries, resolvedConfig, registry, inflection));
+                rendered.push({
+                    name: inflection.variableName(entityName, "ElysiaRoutes"),
+                    capability,
+                    node: statements[0],
+                    exports: "named",
+                    externalImports,
+                });
+            }
+            if (entityQueries.size > 0) {
+                const appCapability = "http-routes:elysia:app";
+                // Scope cross-references to the app capability
+                const { statements, externalImports } = registry.forSymbol(appCapability, () => generateAggregator(entityQueries, resolvedConfig, registry, inflection));
+                rendered.push({
+                    name: "elysiaApp",
+                    capability: appCapability,
+                    node: statements[0],
+                    exports: "named",
+                    externalImports,
+                });
+            }
+            return rendered;
+        }),
+    };
 }
 //# sourceMappingURL=http-elysia.js.map