prisma-generator-express 1.62.3 → 1.63.0

package/README.md

@@ -12,7 +12,7 @@ Running `npx prisma generate` produces:
 - Handler functions for all Prisma operations (findMany, create, update, delete, etc.)
 - Schema-level `findManyPaginated` execution mode selection (`Promise.all` or interactive transaction)
 - Per-route and per-endpoint pagination config, including optional materialized-view count sources
-- Router generator with middleware support (before/after hooks per operation)
+- Router generator with operation-wide and per-variant before/after hooks
 - POST read endpoints for all read operations (for complex queries exceeding URL length limits)
 - Express-only progressive read streaming over Server-Sent Events (SSE), using manual stages or auto-include splitting for supported relation reads, including unguarded deep `findMany` / `findManyPaginated` auto-include paths and guarded single-record auto-include paths
 - Express-only standalone materialized view router for read-only access to registered PostgreSQL materialized views
@@ -503,13 +503,27 @@ app.route('/', UserRouter(userConfig))
 
 Hono route hooks return `void` to continue. Return a `Response` (e.g. `c.json({...}, 403)`) or throw `HTTPException` to short-circuit — subsequent hooks and the handler will not run.
 
+### Hook execution contract
+
+Operation-level hooks run for every successfully routed variant. Variant hooks run only for the selected declared variant key.
+
+```text
+operation before-hooks
+variant before-hooks
+generated handler
+variant after-hooks
+operation after-hooks
+```
+
+A terminal response or an error stops the remaining hooks in that phase. Operation after-hooks are not cleanup or `finally` handlers and are not guaranteed to run. Caller-routing failures are surfaced after operation before-hooks and before variant before-hooks, preserving operation-wide logging and authentication timing.
+
 Only operations listed in the config (or all when `enableAll: true`) are registered. Operations not listed produce no routes.
 
 ## Guard shapes (prisma-guard integration)
 
-prisma-generator-express integrates with [prisma-guard](https://github.com/multipliedtwice/prisma-guard) to enforce input validation, query shape restrictions, and tenant isolation on generated routes. When a `shape` is configured on an operation, the handler calls `prisma.model.guard(shape, caller).method(args)` instead of `prisma.model.method(args)`.
+prisma-generator-express integrates with [prisma-guard](https://github.com/multipliedtwice/prisma-guard) to enforce input validation, query shape restrictions, and tenant isolation on generated routes. Configure either `shape` for the existing guard API or `variants` to co-locate named shapes with per-variant hooks. The handler passes the extracted guard shape map to `prisma.model.guard(shape, caller).method(args)` instead of calling Prisma directly.
 
-Guard shapes work identically across all three targets. The only difference is the type of the `resolveVariant` callback parameter (`Request` for Express, `FastifyRequest` for Fastify, `Context` for Hono).
+Guard routing works identically across Express, Fastify, and Hono. The only target-specific differences are hook types and the type of the `resolveVariant` callback parameter (`Request` for Express, `FastifyRequest` for Fastify, `Context` for Hono).
 
 ### Guard setup
 
@@ -579,71 +593,81 @@ If prisma-guard is not installed or the client is not extended with the guard ex
 
 ### How guard integration works
 
-Each operation config accepts an optional `shape` property. When present, the generated handler:
+Each operation accepts either the existing `shape` property or the new `variants` property:
 
-1. Stores the shape on the request context via middleware (Express: `res.locals.guardShape = shape`, Fastify: `request.guardShape = shape`, Hono: `c.set('guardShape', shape)`)
-2. Resolves the caller from `config.guard.resolveVariant(req)`, then from the configured header (default `x-api-variant`), falling back to `undefined`
-3. Calls `prisma.model.guard(shape, caller).method(args)` instead of `prisma.model.method(args)`
+- `shape` accepts one direct shape, one context-dependent shape function, or a named shape map.
+- `variants` is a named map whose entries contain one shape plus optional per-variant hooks.
+- `shape` and `variants` cannot both be defined on the same operation.
+- Both may be absent when the operation only needs operation-wide hooks or pagination.
 
-The downstream handler reads these values (`res.locals.guardShape`, `request.guardShape`, `c.get('guardShape')`) when constructing the Prisma call.
+At router construction, the generated router validates and normalizes the descriptor. Variant descriptors are removed before anything reaches prisma-guard, dropped-guard projection logic, progressive planning, or OpenAPI extraction.
 
-When `shape` is absent, the handler calls Prisma directly with no guard enforcement.
+For each request, the generated router:
 
-For Express auto-include SSE on supported single-record reads, the router can also resolve the guard shape before planning the stream. It still executes the root query and every relation-stage query through prisma-guard. See [Guarded auto-include mode](#guarded-auto-include-mode).
+1. Resolves the raw caller from `config.guard.resolveVariant(request)`, then from the configured header (default `x-api-variant`), falling back to `undefined`.
+2. Resolves the declared guard variant key using the same exact/default/parameterized precedence as prisma-guard.
+3. Applies dropped-guard projection defaults immediately for successful routing when guard is globally dropped, preserving what operation before-hooks observe.
+4. Runs operation before-hooks.
+5. Converts a stored routing failure into HTTP 400 before any variant hook or generated handler runs.
+6. Runs hooks for the matched declared key, calls the generated handler, then runs after-hooks in reverse scope order.
 
-Generated route config types treat `shape` as a named shape map. Use `default` for the normal single-shape case, and add other keys only when you need caller-based variants. The runtime still passes the map to `prisma-guard`; the `default` variant is selected when no caller is provided or no variant matches.
+The normalized guard shape is stored on request context (`res.locals.guardShape`, `request.guardShape`, or `c.get('guardShape')`). The declared matched key is stored separately from the raw caller. For example, caller `customer/123` matching `customer/:id` stores `customer/:id` as the variant key.
 
-### Default shape per operation
+When neither `shape` nor `variants` is configured, the generated handler calls Prisma directly with no guard enforcement.
 
-In generated route configs, `shape` is always a named shape map. Use the `default` key when an operation has one normal shape and no caller-specific variants.
+### Default shape per operation
 
-`default` is used when no caller is provided or when the caller does not match a named variant. If you do not want fallback behavior, omit `default` and define only explicit variants.
+For one normal shape, use a direct shape object:
 
 ```ts
 const userConfig = {
   findMany: {
     shape: {
-      default: {
-        where: { email: { contains: true }, role: { equals: true } },
-        orderBy: { createdAt: true },
-        take: { max: 100, default: 25 },
-        skip: true,
-      },
+      where: { email: { contains: true }, role: { equals: true } },
+      orderBy: { createdAt: true },
+      take: { max: 100, default: 25 },
+      skip: true,
     },
   },
-  create: {
-    shape: {
-      default: {
-        data: { email: true, name: true, role: 'user' },
+}
+```
+
+A context-dependent shape function is also valid:
+
+```ts
+const userConfig = {
+  findMany: {
+    shape: (ctx) => ({
+      where: {
+        companyId: { equals: ctx.companyId },
+        name: { contains: true },
       },
-    },
+      take: { max: 50 },
+    }),
   },
-  update: {
+}
+```
+
+Use a named shape map when only shape routing differs and no per-variant route hooks are needed:
+
+```ts
+const userConfig = {
+  findMany: {
     shape: {
-      default: {
-        data: { name: true },
-        where: { id: { equals: true } },
+      admin: {
+        where: { email: { contains: true }, role: { equals: true } },
+        take: { max: 100 },
       },
-    },
-  },
-  delete: {
-    shape: {
       default: {
-        where: { id: { equals: true } },
+        where: { name: { contains: true } },
+        take: { max: 20, default: 10 },
       },
     },
   },
 }
-
-app.use('/', UserRouter(userConfig))
 ```
 
-In this example:
-
-- `findMany` allows filtering by `email` (contains) and `role` (equals), sorting by `createdAt`, pagination via `take`/`skip`. All other where fields, orderBy fields, and include/select are rejected.
-- `create` accepts `email` and `name` from the client. `role` is forced to `'user'` regardless of what the client sends.
-- `update` only allows changing `name`, and requires a unique `id` in `where`.
-- `delete` requires a unique `id` in `where`.
+`default` is selected when the caller is missing, blank, or unmatched. Without `default`, the request returns 400. Use `variants` instead when hooks must differ by the matched shape.
 
 ### Shape value types in data
 
@@ -728,6 +752,62 @@ fetch('/user', {
 
 If the caller is missing or doesn't match any key, the request is rejected with 400 (`CallerError`).
 
+### Variant-specific hooks
+
+Use `variants` to keep each named shape beside the hooks that belong to it:
+
+```ts
+const orderConfig = {
+  create: {
+    before: [authenticate],
+    after: [auditOrderCreation],
+
+    variants: {
+      customer: {
+        shape: customerCreateShape,
+        before: [bindCustomer],
+        after: [sendCustomerConfirmation],
+      },
+
+      seller: {
+        shape: sellerCreateShape,
+        before: [bindSeller],
+      },
+
+      default: {
+        shape: internalCreateShape,
+      },
+    },
+  },
+
+  guard: {
+    resolveVariant: (req) => req.user?.role,
+  },
+}
+```
+
+The execution order for `customer` is:
+
+```text
+authenticate
+bindCustomer
+generated create handler
+sendCustomerConfirmation
+auditOrderCreation
+```
+
+Important rules:
+
+- Operation-level `before` and `after` hooks run for every successfully resolved variant.
+- Variant hooks run only for the selected declared key.
+- `variants[key].shape` is one direct operation shape or one context-dependent shape function. It cannot contain another named map.
+- `shape` and `variants` are mutually exclusive on one operation, but both may be absent.
+- `default` is allowed as a variant key and receives its own hooks when fallback selects it.
+- Reserved guard shape keys such as `where`, `data`, `include`, and `select` cannot be variant names.
+- OpenAPI generation extracts only the shapes; hook descriptors are never exposed as guard configuration.
+
+`updateEach` does not support `variants`; it keeps operation-wide hooks only.
+
 ### Custom caller resolution
 
 Use `resolveVariant` for caller logic beyond a simple header. The callback parameter type depends on the target.
@@ -798,14 +878,20 @@ Caller keys support parameterized path patterns:
 ```ts
 const projectConfig = {
   update: {
-    shape: {
+    variants: {
       '/admin/projects/:id': {
-        data: { title: true, status: true, priority: true },
-        where: { id: { equals: true } },
+        shape: {
+          data: { title: true, status: true, priority: true },
+          where: { id: true },
+        },
+        before: [requireAdmin],
       },
       '/editor/projects/:id': {
-        data: { title: true },
-        where: { id: { equals: true } },
+        shape: {
+          data: { title: true },
+          where: { id: true },
+        },
+        before: [requireEditor],
       },
     },
   },
@@ -815,7 +901,7 @@ const projectConfig = {
 }
 ```
 
-The client sends the full path:
+The client sends the concrete caller:
 
 ```ts
 fetch('/project', {
@@ -825,13 +911,39 @@ fetch('/project', {
     'Content-Type': 'application/json',
   },
   body: JSON.stringify({
-    where: { id: { equals: 'abc123' } },
+    where: { id: 'abc123' },
     data: { title: 'Updated', status: 'active' },
   }),
 })
 ```
 
-Exact matches are checked first. Parameters (`:id`) are routing-only and are not extracted.
+Exact non-blank keys are checked first. Parameter segments match one path segment and are not extracted. Blank and whitespace-only callers do not exact-match or pattern-match; they use `default` or return 400.
+
+The router stores the declared matched key, not the concrete caller. In this example:
+
+```text
+raw caller:       /admin/projects/abc123
+matched key:      /admin/projects/:id
+selected hooks:   variants['/admin/projects/:id']
+```
+
+Express progressive configuration should also use the declared matched key:
+
+```ts
+update: {
+  variants: {
+    '/admin/projects/:id': { shape: adminShape },
+  },
+  progressive: {
+    '/admin/projects/:id': {
+      enabled: true,
+      mode: 'autoInclude',
+    },
+  },
+}
+```
+
+For backward compatibility, a concrete raw-caller progressive key may be used only when no declared-key entry exists. That fallback emits a deduplicated deprecation warning identifying the declared key to use. Declared-key configuration always takes precedence.
 
 ### Forced where conditions
 
@@ -1181,7 +1293,11 @@ Guard errors are mapped to HTTP status codes by the generated error handler:
 | `CallerError` | 400         | Missing/unknown/ambiguous caller, caller in body                  |
 | `PolicyError` | 403         | Scope denied, missing tenant context, rejected findUnique         |
 
-All errors return `{ "message": "..." }` in the response body.
+Generated caller routing preserves the same 400 messages for existing named `shape` maps. Missing, unknown, ambiguous, and reserved-key routing failures are stored during shape preparation, operation before-hooks run, and the failure is then surfaced before variant hooks and the handler.
+
+The new `variants` descriptor is validated when the router is constructed. Invalid configuration such as an empty variants map, a missing entry shape, a reserved variant name, or defining both `shape` and `variants` throws immediately instead of registering the route.
+
+All request errors return `{ "message": "..." }` in the response body.
 
 ### Complete guard example
 
@@ -2343,17 +2459,26 @@ Auto-include does not require `resolveContext` or `progressiveStages`.
 
 ### Hooks and guard behavior
 
-For SSE requests:
+For SSE requests, routing and before-hooks run in the same order as JSON requests:
+
+```text
+operation before-hooks
+variant before-hooks
+progressive SSE middleware
+```
+
+If the progressive middleware starts or completes an SSE response, it does not continue to the normal generated handler. Consequently, variant after-hooks and operation after-hooks do not run for that request. They are not cleanup handlers.
+
+Additional behavior:
 
-- `before` hooks run before streaming starts
-- `after` hooks do not run, because the SSE middleware handles the response and does not continue to the normal handler
 - manual progressive stages receive `req.prisma` directly
 - manual progressive stages do not automatically use guard shapes
-- auto-include mode does not run when an operation has a guard `shape`; it falls back to single-result SSE or emits an SSE error depending on `fallback`
+- auto-include mode does not run when an operation has a guard shape; it falls back to single-result SSE or emits an SSE error depending on `fallback`
+- variants without progressive config use the single-result SSE fallback through the normal generated core read handler, so guard shape behavior matches the JSON endpoint
 
-Manual stage authors are responsible for using the resolved context and enforcing ownership or tenant constraints in their stage queries.
+Progressive lookup uses the declared matched variant key. A caller such as `/user/123` matched by `/user/:id` should configure `progressive['/user/:id']`. If only a legacy concrete raw-caller key exists, the router may use it as a compatibility fallback and emits a deduplicated deprecation warning.
 
-For variants without progressive config, the single-result SSE fallback uses the normal generated core read handler, so guard shape behavior matches the JSON endpoint.
+Manual stage authors are responsible for using the resolved context and enforcing ownership or tenant constraints in their stage queries.
 
 ### Client-side usage
 
@@ -2523,7 +2648,7 @@ app.use('/', UserRouter({
 }))
 ```
 
-Only `before` and `after` hooks are configurable. It has no `shape`, `pagination`, or progressive config. In development, enabling `updateEach` without a `before` hook may print a warning because this route bypasses guard shapes and should be protected explicitly.
+Only operation-wide `before` and `after` hooks are configurable. It has no `shape`, `variants`, pagination, or progressive config. In development, enabling `updateEach` without a `before` hook may print a warning because this route bypasses guard shapes and should be protected explicitly.
 
 When enabled, `updateEach` is included in generated OpenAPI output as `POST /{modelname}/each`. It remains excluded from `enableAll: true`.
 
@@ -2531,7 +2656,7 @@ When enabled, `updateEach` is included in generated OpenAPI output as `POST /{mo
 
 `updateEach` does **not** apply prisma-guard shapes on any target, by design. It is intended as a trusted internal batch path, for example worker-to-backend bulk updates, not a public endpoint. Because it bypasses guard, it can write any field the underlying `update` allows.
 
-Caller resolution still runs before hooks on all three targets, so a `before` hook can read the resolved caller for its own authorization logic. This is separate from guard shapes and does not enable guard enforcement for `updateEach`.
+Raw caller resolution still runs before hooks on all three targets, so a `before` hook can read the caller for its own authorization logic. No variant key is selected and no variant hook gate runs for `updateEach`. This is separate from guard shapes and does not enable guard enforcement.
 
 Protect it yourself with route middleware (`before`) enforcing authentication or network-level restrictions. A guard `variantHeader` such as `x-api-variant` is **not** a security boundary — it only selects a caller value for hooks to read and is trivially spoofable. Do not expose `/each` to untrusted callers.
 
@@ -3055,14 +3180,39 @@ interface RouteConfig<TCtx = unknown> {
   updateEach?: UpdateEachConfig
 }
 
-interface OperationConfig {
+type ShapeOrFn<TShape, TCtx> = TShape | ((ctx: TCtx) => TShape)
+
+type VariantEntry<TShape, TCtx, TBefore, TAfter = TBefore> = {
+  shape: ShapeOrFn<TShape, TCtx>
+  before?: TBefore[]
+  after?: TAfter[]
+}
+
+type OperationConfig<
+  TShape = Record<string, any>,
+  TCtx = unknown,
+> = {
   before?: RequestHandler[]
   after?: RequestHandler[]
-  shape?: Record<string, any>
   pagination?: Partial<PaginationConfig>
-}
+} & (
+  | {
+      shape?: ShapeOrFn<TShape, TCtx> | Record<string, ShapeOrFn<TShape, TCtx>>
+      variants?: never
+    }
+  | {
+      shape?: never
+      variants: Record<
+        string,
+        VariantEntry<TShape, TCtx, RequestHandler>
+      >
+    }
+)
 
-interface ReadOperationConfig<TCtx = unknown> extends OperationConfig {
+type ReadOperationConfig<
+  TCtx = unknown,
+  TShape = Record<string, any>,
+> = OperationConfig<TShape, TCtx> & {
   progressive?: Record<string, ProgressiveVariantConfig>
   progressiveStages?: Record<string, ProgressiveStage<TCtx>>
 }
@@ -3132,12 +3282,14 @@ interface QueryBuilderConfig {
 The Fastify config is identical except for hook and resolver types:
 
 ```ts
-interface OperationConfig {
+type OperationConfig<TShape = Record<string, any>> = {
   before?: FastifyHookHandler[]
   after?: FastifyHookHandler[]
-  shape?: Record<string, any>
   pagination?: Partial<PaginationConfig>
-}
+} & (
+  | { shape?: TShape | ((ctx: unknown) => TShape) | Record<string, TShape | ((ctx: unknown) => TShape)>; variants?: never }
+  | { shape?: never; variants: Record<string, { shape: TShape | ((ctx: unknown) => TShape); before?: FastifyHookHandler[]; after?: FastifyHookHandler[] }> }
+)
 
 type FastifyHookHandler = (
   request: FastifyRequest,
@@ -3152,12 +3304,14 @@ The `guard.resolveVariant` callback receives `FastifyRequest` instead of `Reques
 The Hono config is identical except for hook and resolver types:
 
 ```ts
-interface OperationConfig {
+type OperationConfig<TShape = Record<string, any>> = {
   before?: HonoBeforeHook[]
   after?: HonoAfterHook[]
-  shape?: Record<string, any>
   pagination?: Partial<PaginationConfig>
-}
+} & (
+  | { shape?: TShape | ((ctx: unknown) => TShape) | Record<string, TShape | ((ctx: unknown) => TShape)>; variants?: never }
+  | { shape?: never; variants: Record<string, { shape: TShape | ((ctx: unknown) => TShape); before?: HonoBeforeHook[]; after?: HonoAfterHook[] }> }
+)
 
 type HonoBeforeHook<Env extends { Variables: any } = any> = (
   c: Context<Env>,
@@ -3233,19 +3387,11 @@ Generated routers use this effective guard-drop flag:
 const DROP_GUARD = GENERATOR_DROP_GUARD || process.env.E2E === 'true'
 ```
 
-When `DROP_GUARD` is true:
-
-```ts
-delegate.findMany(args)
-```
+When `DROP_GUARD` is true, the generated router calls Prisma directly instead of calling `delegate.guard(...)`. Before doing so, it still applies forced values and default projection behavior using vendored, dependency-free generated runtime helpers.
 
-is used instead of:
+Caller routing is not dropped. Active and dropped modes use the same exact/default/parameterized resolver and the same declared matched key. Missing, unknown, ambiguous, and reserved-key routing failures return 400 after operation before-hooks in both modes.
 
-```ts
-delegate.guard(shape, caller).findMany(args)
-```
-
-This is global for generated routers. No per-router config is required.
+Generated dropped/E2E router output has no runtime import from `prisma-guard`, the configured guard runtime import path, or a generated guard bridge. Type-only imports of generated guard shape declarations are allowed because they are erased at build time.
 
 ### Production safety
 
@@ -3362,27 +3508,20 @@ SQL extension receives normal id filters
 
 ### Required implementation notes
 
-Generated router code should compute:
+Generated router code computes:
 
 ```ts
-const DROP_GUARD = ${dropGuard} || process.env.E2E === 'true'
+const DROP_GUARD = GENERATOR_DROP_GUARD || process.env.E2E === 'true'
 ```
 
-Then only assign guard shape when guard is not dropped:
+The router always resolves caller routing first. On a successful match:
 
-```ts
-if (opConfig.shape && !DROP_GUARD) {
-  locals.guardShape = opConfig.shape
-}
-```
+- active mode stores the normalized guard shape for `delegate.guard(...)`
+- dropped mode applies the same matched shape locally before operation before-hooks
 
-The same behavior should apply to all generated targets:
+On a routing failure, the router stores the failure, runs operation before-hooks, then returns HTTP 400 before variant hooks or the handler. This ordering is identical across Express, Fastify, and Hono.
 
-```text
-Express
-Fastify
-Hono
-```
+The dropped runtime must remain self-contained. Generated code must not require `prisma-guard` to be installed or resolvable when `dropGuard=true` or `E2E=true`.
 
 ## Environment variables
 
@@ -3394,4 +3533,4 @@ Hono
 
 ## License
 
-MIT
+MIT

package/dist/generators/generateRouteConfigType.js

@@ -59,26 +59,46 @@ function generateRouteConfigType(modelName, hookHandlerType, guardShapesImport,
     }
     const shapeOps = Array.from(new Set(ROUTER_OPERATIONS));
     const opShapeImports = shapeOps
-        .map((op) => `${m}${capitalize(op)}ShapeInput`)
+        .flatMap((op) => {
+        const prefix = `${m}${capitalize(op)}Shape`;
+        return [prefix, `${prefix}Input`];
+    })
         .join(',\n  ');
+    const shapeOrFnAliases = shapeOps
+        .map((op) => {
+        const prefix = `${m}${capitalize(op)}Shape`;
+        return (`type ${prefix}OrFn<TCtx = unknown> =\n` +
+            `  | ${prefix}\n` +
+            `  | ((ctx: TCtx) => ${prefix})`);
+    })
+        .join('\n\n');
     const overrides = ROUTER_OPERATIONS.map((routerOp) => {
         const c = capitalize(routerOp);
         const isRead = operationDefinitions_1.READ_OPERATION_NAMES.has(routerOp);
-        const lines = [
+        const commonLines = [
             `    before?: ${beforeRef}[]`,
             `    after?: ${afterRef}[]`,
-            `    shape?: ${m}${c}ShapeInput<TCtx>`,
             `    pagination?: Partial<PaginationConfig>`,
         ];
         if (isRead && supportsProgressive) {
-            lines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`);
-            lines.push(`    progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>`);
+            commonLines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`);
+            commonLines.push(`    progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>`);
         }
-        return `  ${routerOp}?: {\n${lines.join('\n')}\n  } | false`;
+        const commonConfig = `{\n${commonLines.join('\n')}\n  }`;
+        const variantsConfig = `Record<string, {\n` +
+            `      shape: ${m}${c}ShapeOrFn<TCtx>\n` +
+            `      before?: ${beforeRef}[]\n` +
+            `      after?: ${afterRef}[]\n` +
+            `    }>`;
+        return (`  ${routerOp}?: (${commonConfig} & (\n` +
+            `    | { shape?: ${m}${c}ShapeInput<TCtx>; variants?: never }\n` +
+            `    | { shape?: never; variants: ${variantsConfig} }\n` +
+            `  )) | false`);
     }).join('\n');
     const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ');
     return (progressiveTypeImport +
         `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
+        `${shapeOrFnAliases}\n\n` +
         `export type ${m}RouteConfig${generics} = Omit<\n` +
         `  ${baseConfig},\n` +
         `  | ${omitKeys}\n` +

package/dist/generators/generateRouteConfigType.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateRouteConfigType.js","sourceRoot":"","sources":["../../src/generators/generateRouteConfigType.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generateRouteConfigType.js","sourceRoot":"","sources":["../../src/generators/generateRouteConfigType.ts"],"names":[],"mappings":"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"}