🎩 You're Invited:Meet the Socket team at Black Hat in Las Vegas, August 3-6.RSVP →
@prisma-next/sql-relational-core
Advanced tools
@prisma-next/sql-relational-core - npm Package Compare versions
| import { Codec, CodecCallContext, CodecCallContext as CodecCallContext$1, CodecDescriptor, CodecDescriptor as CodecDescriptor$1, CodecInstanceContext, CodecRef, CodecRef as CodecRef$1, CodecTrait, CodecTrait as CodecTrait$1 } from "@prisma-next/framework-components/codec"; | ||
| //#region src/ast/codec-types.d.ts | ||
| declare function frozenCodecRef(codec: CodecRef): CodecRef; | ||
| /** | ||
| * SQL-family addressing of a single column. The decode site populates a `SqlColumnRef` whenever it can resolve the cell to a single underlying `(table, column)` (the typical case for projected columns from a single-table source); cells the runtime cannot resolve (aggregate aliases, include aggregate fields, computed projections without a simple ref) get `column = undefined`. | ||
| * | ||
| * The shape is a structural projection of the runtime's `ColumnRef` so the SQL decode site can reuse the resolution it already performs for `RUNTIME.DECODE_FAILED` envelope construction without allocating twice per cell. | ||
| */ | ||
| interface SqlColumnRef { | ||
| readonly table: string; | ||
| readonly name: string; | ||
| } | ||
| /** | ||
| * SQL-family per-call context. Extends the framework {@link CodecCallContext} (which carries `signal` only) with `column?: SqlColumnRef`, populated on **decode** call sites that can resolve a single underlying column ref. Encode call sites currently leave `column` undefined (encode-time column context is the middleware's domain). | ||
| * | ||
| * SQL codec authors writing codec methods observe this type via {@link SqlCodec}. The framework codec dispatch surface (and Mongo) sees only the base `CodecCallContext`. | ||
| */ | ||
| interface SqlCodecCallContext extends CodecCallContext { | ||
| readonly column?: SqlColumnRef; | ||
| } | ||
| /** | ||
| * SQL-family per-instance context. Extends the framework {@link CodecInstanceContext} (`name` only) with `usedAt`, the set of `(table, column)` pairs the resolved codec serves. | ||
| * | ||
| * - For `typeRef` columns sharing one named `storage.types` instance, the array lists every referencing column — a column-scoped stateful codec (e.g. encryption) can derive aggregated per-instance state across all the columns sharing the named instance. | ||
| * - For inline-`typeParams` columns, the array has exactly one entry — the column that owns the inline params. | ||
| * - For shared non-parameterized codecs, the array carries one representative entry (the column that triggered materialization); the codec is shared across every column with that codec id, so the `usedAt` is informational only. | ||
| * | ||
| * SQL extensions consuming `usedAt` (e.g. column-scoped state derivation) type their factory parameter as `SqlCodecInstanceContext`. Extensions that don't read `usedAt` type their factory parameter as the family-agnostic {@link CodecInstanceContext} — a `SqlCodecInstanceContext` is structurally assignable to the base. | ||
| */ | ||
| interface SqlCodecInstanceContext extends CodecInstanceContext { | ||
| readonly usedAt: ReadonlyArray<{ | ||
| readonly table: string; | ||
| readonly column: string; | ||
| }>; | ||
| } | ||
| /** | ||
| * Codec metadata for database-specific type information. Used for schema introspection and verification. | ||
| */ | ||
| interface CodecMeta { | ||
| readonly db?: { | ||
| readonly sql?: { | ||
| readonly postgres?: { | ||
| readonly nativeType: string; | ||
| }; | ||
| }; | ||
| }; | ||
| } | ||
| /** | ||
| * SQL codec — extends the framework codec base by narrowing the per-call context to the SQL-family {@link SqlCodecCallContext} (adds `column?: SqlColumnRef`). TypeScript treats method-syntax declarations bivariantly, so the SQL narrowing is structurally compatible with the framework {@link BaseCodec} super-interface. | ||
| * | ||
| * Codec-id-keyed static metadata (`traits`, `targetTypes`, `meta`, `paramsSchema`, `renderOutputType`) lives on the unified {@link import('@prisma-next/framework-components/codec').CodecDescriptor} — the codec instance itself only carries `id` plus the four conversion methods. | ||
| * | ||
| * See `Codec` in `@prisma-next/framework-components/codec` for the codec contract that this interface extends. | ||
| */ | ||
| interface Codec$1<Id extends string = string, TTraits extends readonly CodecTrait[] = readonly CodecTrait[], TWire = unknown, TInput = unknown> extends Codec<Id, TTraits, TWire, TInput> { | ||
| encode(value: TInput, ctx: SqlCodecCallContext): Promise<TWire>; | ||
| decode(wire: TWire, ctx: SqlCodecCallContext): Promise<TInput>; | ||
| } | ||
| /** | ||
| * Contract-bound codec registry. | ||
| * | ||
| * Built once at `ExecutionContext` construction time by walking the contract's `storage.tables[].columns[]` and resolving each column through its descriptor's factory. Runtime encode/decode dispatch resolves codecs via `forCodecRef(ref)` — the single dispatch shape for AST-bound codec resolution. | ||
| * | ||
| * `forColumn(namespace, table, column)` is retained for build-time helpers that need column-keyed lookup (e.g. projection stamping); runtime dispatch routes through `forCodecRef`. | ||
| */ | ||
| interface ContractCodecRegistry { | ||
| /** | ||
| * Resolve the codec for `(namespace, table, column)`. Returns the per-instance parameterized codec for parameterized columns, the shared codec for non-parameterized columns, or `undefined` if the column is unknown or the codec isn't registered. | ||
| * | ||
| * The `namespaceId` coordinate leads and is always supplied — the column is resolved strictly within that namespace, so two same-bare-named tables across namespaces resolve to their own per-namespace codecs. | ||
| */ | ||
| forColumn(namespaceId: string, table: string, column: string): Codec$1 | undefined; | ||
| /** | ||
| * Resolve a codec by {@link CodecRef}. The single dispatch shape for AST-bound codec resolution — every codec-bearing AST node carries a `CodecRef` that resolves through this method via the per-`ExecutionContext` `AstCodecResolver`. Two refs with the same `codecId` and structurally equal `typeParams` (regardless of object key order) return the same memoised codec instance. Throws `RUNTIME.CODEC_DESCRIPTOR_MISSING` for unknown `codecId`s and `RUNTIME.TYPE_PARAMS_INVALID` on `paramsSchema` rejection. | ||
| * | ||
| * Pre-populated from the contract walk at registry construction time (so contract-declared codecs hit on first call); grows lazily for AST-supplied refs not seen at contract-load time (deserialised migration ops, refs-less raw SQL with an explicit codec). | ||
| */ | ||
| forCodecRef(ref: CodecRef): Codec$1; | ||
| } | ||
| /** | ||
| * Variance-erased descriptor type used for heterogeneous storage in collection containers and on the unified contributor `codecs:` slot. The descriptor's `factory` and `renderOutputType` are contravariant in `P`, so descriptors with different params shapes are not in a subtype relationship; collecting them into one container needs an explicit variance erasure rather than `CodecDescriptor<unknown>` (which is the | ||
| * narrowest, not the widest, of the family). | ||
| */ | ||
| type AnyCodecDescriptor = CodecDescriptor<any>; | ||
| type DescriptorResolvedCodec<D> = D extends CodecDescriptor<infer _P> ? ReturnType<ReturnType<D['factory']>> : never; | ||
| type DescriptorCodecId<D> = D extends AnyCodecDescriptor ? D['codecId'] : never; | ||
| type DescriptorCodecInput<D> = DescriptorResolvedCodec<D> extends Codec<string, readonly CodecTrait[], unknown, infer In> ? In : never; | ||
| /** | ||
| * Resolve the trait union for a descriptor `D`. | ||
| * | ||
| * Reads `traits` directly off the descriptor — concrete descriptor classes declare `override readonly traits = [...] as const`, which preserves the literal trait tuple at the descriptor type. Reading from the resolved codec instance (`CodecImpl<…, TTraits, …>`) would lose the literal because `Codec` carries `TTraits` only on its optional phantom slot (`readonly __codecTraits?: TTraits`); codecs extending `CodecImpl` | ||
| * have no required structural site that pins `TTraits`, so a descriptor-keyed extractor reading from the codec instance would widen to the broad `CodecTrait` union. | ||
| */ | ||
| type DescriptorCodecTraits<D> = D extends { | ||
| readonly traits: infer TTraits extends readonly CodecTrait[]; | ||
| } ? TTraits[number] & CodecTrait : never; | ||
| /** | ||
| * Project a record of {@link AnyCodecDescriptor}s keyed by scalar name onto the codec-id-keyed `CodecTypes` shape consumed by emit and no-emit type pipelines (`{ readonly [codecId]: { input; output; traits } }`). | ||
| * | ||
| * Canonical extractor for the descriptor-keyed type pipeline; the legacy instance-keyed extractor and its `mkCodec`-bound builder retired alongside the carrier deletion. | ||
| */ | ||
| type ExtractCodecTypes<ScalarNames extends { readonly [K in keyof ScalarNames]: AnyCodecDescriptor; } = Record<never, never>> = { readonly [K in keyof ScalarNames as DescriptorCodecId<ScalarNames[K]>]: { | ||
| readonly input: DescriptorCodecInput<ScalarNames[K]>; | ||
| readonly output: DescriptorCodecInput<ScalarNames[K]>; | ||
| readonly traits: DescriptorCodecTraits<ScalarNames[K]>; | ||
| }; }; | ||
| //#endregion | ||
| export { CodecMeta as a, ContractCodecRegistry as c, DescriptorCodecTraits as d, ExtractCodecTypes as f, frozenCodecRef as g, SqlColumnRef as h, CodecDescriptor$1 as i, DescriptorCodecId as l, SqlCodecInstanceContext as m, Codec$1 as n, CodecRef$1 as o, SqlCodecCallContext as p, CodecCallContext$1 as r, CodecTrait$1 as s, AnyCodecDescriptor as t, DescriptorCodecInput as u }; | ||
| //# sourceMappingURL=codec-types-Bayoa4PI.d.mts.map |
| {"version":3,"file":"codec-types-Bayoa4PI.d.mts","names":[],"sources":["../src/ast/codec-types.ts"],"mappings":";;iBAwCgB,eAAe,OAAO,WAAW;;;;;;UAkBhC;WACN;WACA;;;;;;;UAQM,4BAA4B;WAClC,SAAS;;;;;;;;;;;UAYH,gCAAgC;WACtC,QAAQ;aAAyB;aAAwB;;;;;;UAMnD;WACN;aACE;eACE;iBACE;;;;;;;;;;;;UAaA,QACf,4BACA,yBAAyB,wBAAwB,cACjD,iBACA,0BACQ,MAAU,IAAI,SAAS,OAAO;EACtC,OAAO,OAAO,QAAQ,KAAK,sBAAsB,QAAQ;EACzD,OAAO,MAAM,OAAO,KAAK,sBAAsB,QAAQ;;;;;;;;;UAUxC;;;;;;EAMf,UAAU,qBAAqB,eAAe,iBAAiB;;;;;;EAO/D,YAAY,KAAK,WAAW;;;;;;KAQlB,qBAAqB;KAE5B,wBAAwB,KAC3B,UAAU,sBAAsB,MAAM,WAAW,WAAW;KAElD,kBAAkB,KAAK,UAAU,qBAAqB;KAEtD,qBAAqB,KAC/B,wBAAwB,WAAW,uBAA2B,6BAA6B,MACvF;;;;;;;KASM,sBAAsB,KAAK;WAC5B,cAAc,yBAAyB;IAE9C,kBAAkB;;;;;;KAQV,kBACV,gCACY,WAAW,cAAc,wBACjC,oCAEM,WAAW,eAAe,kBAAkB,YAAY;WACvD,OAAO,qBAAqB,YAAY;WACxC,QAAQ,qBAAqB,YAAY;WACzC,QAAQ,sBAAsB,YAAY"} |
| import { o as CodecRef } from "./codec-types-Bayoa4PI.mjs"; | ||
| import { d as AnyParamRef } from "./types-CWlaErjN.mjs"; | ||
| import { ColumnDefaultLiteralInputValue } from "@prisma-next/contract/types"; | ||
| import { ReferentialAction } from "@prisma-next/sql-contract/types"; | ||
| //#region src/ast/ddl-types.d.ts | ||
| /** | ||
| * Render-time context the column-default visitor needs to make dialect | ||
| * decisions that depend on the parent column. Today only the parent | ||
| * column's native type (`"jsonb"`, `"text"`, …) — the Postgres renderer | ||
| * uses it to decide whether to emit a `::jsonb` / `::json` cast on JSON | ||
| * literal defaults so the emitted DDL matches the column type without | ||
| * relying on Postgres's implicit text → jsonb cast at default-evaluation | ||
| * time. Additional fields can join without re-shaping the interface. | ||
| */ | ||
| interface DdlColumnRenderContext { | ||
| readonly nativeType: string; | ||
| } | ||
| interface DdlColumnDefaultVisitor<R> { | ||
| literal(node: LiteralColumnDefault, ctx: DdlColumnRenderContext): R; | ||
| function(node: FunctionColumnDefault, ctx: DdlColumnRenderContext): R; | ||
| } | ||
| declare abstract class DdlColumnDefault { | ||
| abstract readonly kind: string; | ||
| abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R; | ||
| protected freeze(): void; | ||
| } | ||
| declare class LiteralColumnDefault extends DdlColumnDefault { | ||
| readonly kind: "literal"; | ||
| readonly value: ColumnDefaultLiteralInputValue; | ||
| constructor(value: ColumnDefaultLiteralInputValue); | ||
| accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R; | ||
| } | ||
| declare class FunctionColumnDefault extends DdlColumnDefault { | ||
| readonly kind: "function"; | ||
| readonly expression: string; | ||
| constructor(expression: string); | ||
| accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R; | ||
| } | ||
| type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault; | ||
| declare class DdlColumn { | ||
| readonly name: string; | ||
| readonly type: string; | ||
| readonly notNull?: boolean | undefined; | ||
| readonly primaryKey?: boolean | undefined; | ||
| readonly default?: AnyDdlColumnDefault | undefined; | ||
| /** Codec identity for this column. When present, the DDL walker resolves the codec via `codecLookup.get(codecRef.codecId)` and calls `codec.encode(default.value, {})` to obtain the wire value before inlining the literal default into the DDL string. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */ | ||
| readonly codecRef?: CodecRef | undefined; | ||
| constructor(options: { | ||
| readonly name: string; | ||
| readonly type: string; | ||
| readonly notNull?: boolean; | ||
| readonly primaryKey?: boolean; | ||
| readonly default?: AnyDdlColumnDefault; | ||
| readonly codecRef?: CodecRef; | ||
| }); | ||
| } | ||
| declare abstract class DdlNode { | ||
| abstract readonly kind: string; | ||
| /** | ||
| * Structural brand: every DDL node answers `true`. Lets {@link isDdlNode} | ||
| * recognise any `DdlNode` subclass — including target-contributed kinds — | ||
| * without a central kind registry that subclasses would have to register | ||
| * into. | ||
| */ | ||
| isDdlNode(): true; | ||
| protected freeze(): void; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| } | ||
| declare function isDdlNode(value: unknown): value is DdlNode; | ||
| /** | ||
| * A composite (or single-column) PRIMARY KEY constraint on a `CreateTable` | ||
| * node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY | ||
| * (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class PrimaryKeyConstraint { | ||
| readonly kind: "primary-key"; | ||
| readonly columns: ReadonlyArray<string>; | ||
| readonly name: string | undefined; | ||
| constructor(options: { | ||
| readonly columns: readonly string[]; | ||
| readonly name?: string; | ||
| }); | ||
| } | ||
| /** | ||
| * A FOREIGN KEY constraint on a `CreateTable` node. `onDelete` and `onUpdate` | ||
| * use the same `ReferentialAction` vocabulary already used by the migration | ||
| * planner and the contract IR — no parallel string enum. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class ForeignKeyConstraint { | ||
| readonly kind: "foreign-key"; | ||
| readonly columns: ReadonlyArray<string>; | ||
| readonly refTable: string; | ||
| readonly refColumns: ReadonlyArray<string>; | ||
| readonly onDelete: ReferentialAction | undefined; | ||
| readonly onUpdate: ReferentialAction | undefined; | ||
| readonly name: string | undefined; | ||
| constructor(options: { | ||
| readonly columns: readonly string[]; | ||
| readonly refTable: string; | ||
| readonly refColumns: readonly string[]; | ||
| readonly onDelete?: ReferentialAction; | ||
| readonly onUpdate?: ReferentialAction; | ||
| readonly name?: string; | ||
| }); | ||
| } | ||
| /** | ||
| * A table-level UNIQUE constraint on a `CreateTable` node. When `name` is | ||
| * set, the adapter renders `CONSTRAINT <name> UNIQUE (…)`; otherwise it | ||
| * renders an anonymous `UNIQUE (…)`. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class UniqueConstraint { | ||
| readonly kind: "unique"; | ||
| readonly columns: ReadonlyArray<string>; | ||
| readonly name: string | undefined; | ||
| constructor(options: { | ||
| readonly columns: readonly string[]; | ||
| readonly name?: string; | ||
| }); | ||
| } | ||
| /** | ||
| * A table-level CHECK constraint carrying a raw SQL predicate expression. Used | ||
| * for checks that are not enum value-set restrictions — e.g. the element-non-null | ||
| * constraint on a scalar-array column (`array_position(col, NULL) IS NULL`). | ||
| * The `expression` is emitted verbatim, so callers must supply safe, | ||
| * pre-validated SQL. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class CheckExpressionConstraint { | ||
| readonly kind: "check-expression"; | ||
| readonly name: string; | ||
| readonly expression: string; | ||
| constructor(options: { | ||
| readonly name: string; | ||
| readonly expression: string; | ||
| }); | ||
| } | ||
| type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint | CheckExpressionConstraint; | ||
| //#endregion | ||
| export { DdlColumnDefaultVisitor as a, DdlTableConstraint as c, LiteralColumnDefault as d, PrimaryKeyConstraint as f, DdlColumnDefault as i, ForeignKeyConstraint as l, isDdlNode as m, CheckExpressionConstraint as n, DdlColumnRenderContext as o, UniqueConstraint as p, DdlColumn as r, DdlNode as s, AnyDdlColumnDefault as t, FunctionColumnDefault as u }; | ||
| //# sourceMappingURL=ddl-types-B3SfjPGI.d.mts.map |
| {"version":3,"file":"ddl-types-B3SfjPGI.d.mts","names":[],"sources":["../src/ast/ddl-types.ts"],"mappings":";;;;;;;;;;;;;;UAeiB;WACN;;UAGM,wBAAwB;EACvC,QAAQ,MAAM,sBAAsB,KAAK,yBAAyB;EAClE,SAAS,MAAM,uBAAuB,KAAK,yBAAyB;;uBAGhD;oBACF;WACT,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;YAE5E;;cAKC,6BAA6B;WAC/B;WACA,OAAO;cAEJ,OAAO;EASV,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;cAK3E,8BAA8B;WAChC;WACA;cAEG;EAMH,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;KAK5E,sBAAsB,uBAAuB;cAE5C;WACF;WACA;WACA;WACA;WACA,UAAU;;WAEV,WAAW;cAER;aACD;aACA;aACA;aACA;aACA,UAAU;aACV,WAAW;;;uBAYF;oBACF;;;;;;;EAQlB;YAIU;EAIV,oBAAoB;;iBAKN,UAAU,iBAAiB,SAAS;;;;;;;;cAoBvC;WACF;WACA,SAAS;WACT;cAEG;aAAoB;aAAqC;;;;;;;;;;cAc1D;WACF;WACA,SAAS;WACT;WACA,YAAY;WACZ,UAAU;WACV,UAAU;WACV;cAEG;aACD;aACA;aACA;aACA,WAAW;aACX,WAAW;aACX;;;;;;;;;;cAmBA;WACF;WACA,SAAS;WACT;cAEG;aAAoB;aAAqC;;;;;;;;;;;;cAgB1D;WACF;WACA;WACA;cAEG;aAAoB;aAAuB;;;KAO7C,qBACR,uBACA,uBACA,mBACA"} |
| import { t as SqlExecutionPlan } from "./sql-execution-plan-B-C-6cZN.mjs"; | ||
| import { ParamRefMutator } from "@prisma-next/framework-components/runtime"; | ||
| //#region src/middleware/param-ref-mutator.d.ts | ||
| /** | ||
| * Brand applied to {@link ParamRefHandle} so user-constructed handles | ||
| * are rejected by the type system. The mutator only accepts handles it | ||
| * produced from `entries()`. | ||
| * | ||
| * The brand is a phantom type — there is no runtime token. At runtime | ||
| * the handle is the underlying `ParamRef` instance from the plan's | ||
| * `ast`; the brand only narrows the type-level surface so callers | ||
| * cannot fabricate a handle from a fresh `ParamRef.of(...)`. | ||
| */ | ||
| declare const paramRefHandleBrand: unique symbol; | ||
| /** | ||
| * Opaque token identifying a single `ParamRef` in the plan. Produced by | ||
| * {@link SqlParamRefMutator.entries}; consumed by `replaceValue` / | ||
| * `replaceValues`. | ||
| * | ||
| * The phantom `TCodecId` parameter records the codec id of the | ||
| * referenced `ParamRef` so type-level inference can route replacement | ||
| * values through `TCodecMap` to the codec's declared `TInput`. | ||
| */ | ||
| interface ParamRefHandle<TCodecId extends string | undefined = string | undefined> { | ||
| readonly [paramRefHandleBrand]: TCodecId; | ||
| } | ||
| /** | ||
| * One outbound `ParamRef` slot in the plan exposed to middleware. | ||
| * `value` is the current value (post any prior middleware mutations); | ||
| * `codecId` is the codec id declared on the underlying `ParamRef.codec`. | ||
| */ | ||
| interface ParamRefEntry<TCodecId extends string | undefined = string | undefined> { | ||
| readonly ref: ParamRefHandle<TCodecId>; | ||
| readonly value: unknown; | ||
| readonly codecId: TCodecId; | ||
| } | ||
| /** | ||
| * Discriminated entry union over a codec map. For each `K` in | ||
| * `TCodecMap`, `entries()` may yield a `ParamRefEntry<K>`; ParamRefs | ||
| * with no codec id (or a codec id outside the map) yield a | ||
| * `ParamRefEntry<undefined>`. Pattern-matching on `entry.codecId` | ||
| * narrows `entry.ref` to a `ParamRefHandle<K>`, which routes through | ||
| * the typed `replaceValue` overload. | ||
| */ | ||
| type ParamRefEntryUnion<TCodecMap extends Record<string, unknown>> = { [K in keyof TCodecMap & string]: ParamRefEntry<K>; }[keyof TCodecMap & string] | ParamRefEntry<undefined>; | ||
| /** | ||
| * SQL-family mutator threaded into `SqlMiddleware.beforeExecute` as | ||
| * `params`. Scope is `ParamRef.value` slots only — middleware cannot | ||
| * insert / remove `ParamRef`s, rewrite SQL, or modify projection. The | ||
| * type-level `ParamRefHandle` brand and the `replaceValue(ref, | ||
| * newValue)` shape enforce this at compile time. | ||
| * | ||
| * `entries()` surfaces both literal call-site `ParamRef` slots and | ||
| * `prepare()`-time `PreparedParamRef` bind slots; the handle and codec | ||
| * id work the same for both. | ||
| * | ||
| * Allocation discipline: the mutator is constructed lazily from the | ||
| * plan. `entries()` walks the plan's existing AST without allocating | ||
| * an intermediate array; the working params buffer is only allocated | ||
| * on the first `replaceValue` / `replaceValues` call. If no middleware | ||
| * mutates, `currentParams()` returns the plan's original `params` by | ||
| * reference identity. | ||
| * | ||
| * The `TCodecMap` parameter is a record keyed by codec id; `replaceValue` | ||
| * infers `newValue` from `TCodecMap[H['codecId']]` for handles whose | ||
| * codec id is statically resolvable. For codec ids the type system | ||
| * cannot resolve, `newValue` falls back to `unknown` and the middleware | ||
| * is on the hook for runtime correctness. | ||
| */ | ||
| interface SqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends ParamRefMutator { | ||
| /** Iterate every outbound `ParamRef` the plan currently carries, in canonical order. */ | ||
| entries(): IterableIterator<ParamRefEntryUnion<TCodecMap>>; | ||
| /** | ||
| * Replace one `ParamRef`'s value with the result of bulk processing. | ||
| * `newValue` is constrained to the codec's declared `TInput` for codec | ||
| * ids the type system can resolve via `TCodecMap`; for unresolvable | ||
| * codec ids `newValue` is `unknown` (the second overload). | ||
| */ | ||
| replaceValue<TCodecId extends keyof TCodecMap & string>(ref: ParamRefHandle<TCodecId>, newValue: TCodecMap[TCodecId]): void; | ||
| replaceValue(ref: ParamRefHandle<undefined>, newValue: unknown): void; | ||
| /** Replace many at once (typical for bulk-pattern middleware). */ | ||
| replaceValues(updates: Iterable<{ | ||
| readonly ref: ParamRefHandle<(keyof TCodecMap & string) | undefined>; | ||
| readonly newValue: unknown; | ||
| }>): void; | ||
| } | ||
| /** | ||
| * Internal-only view of the mutator that exposes the post-mutation params | ||
| * array to the SQL runtime. The runtime calls `currentParams()` after the | ||
| * `beforeExecute` chain has run; the result is the plan's original | ||
| * `params` by reference identity if no middleware mutated, otherwise a | ||
| * frozen new array carrying the mutations applied in chain order. | ||
| * | ||
| * Family-internal contract — `SqlMiddleware` consumers never see this | ||
| * shape; they receive the public `SqlParamRefMutator` view above. | ||
| */ | ||
| interface SqlParamRefMutatorInternal<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends SqlParamRefMutator<TCodecMap> { | ||
| currentParams(): readonly unknown[]; | ||
| } | ||
| /** | ||
| * Build a {@link SqlParamRefMutatorInternal} for the given lowered plan. | ||
| * | ||
| * The mutator captures `plan.params` by reference and walks | ||
| * `plan.ast` (via `collectOrderedParamRefs`) on demand to build | ||
| * entries. Mutations write to a lazily-allocated working copy so the | ||
| * fast path (no mutation) preserves bit-for-bit reference identity to | ||
| * the original `plan.params`. | ||
| * | ||
| * Threading: `plan.ast` carries the canonical `ParamRef` ordering used | ||
| * by every consumer (renderer's `$N` index map, encode-side metadata | ||
| * walk, etc.). The mutator's `entries()` yields the same order so | ||
| * middleware that filters by codec id sees ParamRefs in the order the | ||
| * runtime will encode them. | ||
| */ | ||
| declare function createSqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>>(plan: SqlExecutionPlan): SqlParamRefMutatorInternal<TCodecMap>; | ||
| //#endregion | ||
| export { SqlParamRefMutatorInternal as a, SqlParamRefMutator as i, ParamRefEntryUnion as n, createSqlParamRefMutator as o, ParamRefHandle as r, ParamRefEntry as t }; | ||
| //# sourceMappingURL=middleware-_9-4TYKC.d.mts.map |
| {"version":3,"file":"middleware-_9-4TYKC.d.mts","names":[],"sources":["../src/middleware/param-ref-mutator.ts"],"mappings":";;;;;;;;;;;;;cAec;;;;;;;;;;UAWG,eAAe;YACpB,sBAAsB;;;;;;;UAQjB,cAAc;WACpB,KAAK,eAAe;WACpB;WACA,SAAS;;;;;;;;;;KAWR,mBAAmB,kBAAkB,8BAC1C,WAAW,qBAAqB,cAAc,YAAW,sBAC5D;;;;;;;;;;;;;;;;;;;;;;;;;UA0Ba,mBACf,kBAAkB,0BAA0B,iCACpC;;EAER,WAAW,iBAAiB,mBAAmB;;;;;;;EAQ/C,aAAa,uBAAuB,oBAClC,KAAK,eAAe,WACpB,UAAU,UAAU;EAEtB,aAAa,KAAK,2BAA2B;;EAG7C,cACE,SAAS;aACE,KAAK,sBAAsB;aAC3B;;;;;;;;;;;;;UAeE,2BACf,kBAAkB,0BAA0B,iCACpC,mBAAmB;EAC3B;;;;;;;;;;;;;;;;;iBAoBc,yBACd,kBAAkB,0BAA0B,yBAC5C,MAAM,mBAAmB,2BAA2B"} |
| import { f as AnyQueryAst } from "./types-CWlaErjN.mjs"; | ||
| import { Contract } from "@prisma-next/contract/types"; | ||
| import { QueryPlan } from "@prisma-next/framework-components/runtime"; | ||
| import { SqlStorage } from "@prisma-next/sql-contract/types"; | ||
| //#region src/plan.d.ts | ||
| /** | ||
| * SQL query plan produced by lanes before lowering. | ||
| * | ||
| * Lanes build ASTs and metadata but do not perform SQL lowering. The `sql` | ||
| * field is absent — `RuntimeCore` (the runtime base class in | ||
| * `@prisma-next/framework-components/runtime`) drives lowering via the | ||
| * SQL adapter and produces a `SqlExecutionPlan`. | ||
| * | ||
| * Extends the framework-level `QueryPlan<Row>` marker (`meta + _row`) and | ||
| * adds SQL-specific fields (`ast`, `params`). The phantom `_row` property | ||
| * (inherited from `QueryPlan`) is what `ResultType<P>` inspects to recover | ||
| * the row type. | ||
| */ | ||
| interface SqlQueryPlan<Row = unknown> extends QueryPlan<Row> { | ||
| readonly ast: AnyQueryAst; | ||
| readonly params: readonly unknown[]; | ||
| } | ||
| /** | ||
| * Wraps an `AnyQueryAst` (typically a `RawSqlExpr` constructed package-internally | ||
| * by an extension's migration factory) in a fully-populated `SqlQueryPlan` | ||
| * whose `meta` is sourced from the supplied contract. | ||
| * | ||
| * Centralising the envelope here means consumers (cipherstash migration | ||
| * factories today; future raw-sql callers) cannot drift on `storageHash` / | ||
| * `target` / `targetFamily`, which would otherwise surface as a subtle | ||
| * `assertContractMatches` failure inside `dataTransform`. `params` defaults | ||
| * to `[]` because parameters embedded in the AST as `ParamRef`s are resolved | ||
| * at lowering time (`encodeParams` walks `plan.ast.collectParamRefs()`), | ||
| * not at plan-construction time. | ||
| * | ||
| * The default `laneId` of `'raw'` reflects raw-SQL plans' standard lane tag; | ||
| * callers (e.g. a future `sql-raw-factory`) may override to differentiate | ||
| * the plan's provenance. | ||
| */ | ||
| declare function planFromAst<Row = unknown>(ast: AnyQueryAst, contract: Contract<SqlStorage>, laneId?: string): SqlQueryPlan<Row>; | ||
| //#endregion | ||
| export { planFromAst as n, SqlQueryPlan as t }; | ||
| //# sourceMappingURL=plan-Dq94efZJ.d.mts.map |
| {"version":3,"file":"plan-Dq94efZJ.d.mts","names":[],"sources":["../src/plan.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAkBiB,aAAa,uBAAuB,UAAU;WACpD,KAAK;WACL;;;;;;;;;;;;;;;;;;;iBAoBK,YAAY,eAC1B,KAAK,aACL,UAAU,SAAS,aACnB,kBACC,aAAa"} |
| import { c as ContractCodecRegistry } from "./codec-types-Bayoa4PI.mjs"; | ||
| import { Contract } from "@prisma-next/contract/types"; | ||
| import { CodecDescriptor, CodecRef } from "@prisma-next/framework-components/codec"; | ||
| import { SqlStorage } from "@prisma-next/sql-contract/types"; | ||
| import { SqlOperationRegistry } from "@prisma-next/sql-operations"; | ||
| //#region src/query-lane-context.d.ts | ||
| /** | ||
| * Codec-id-keyed accessor for descriptor metadata. The unified read API for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`) — non-branching for parameterized vs. non-parameterized codecs. Every codec ships natively as a `CodecDescriptor` through the unified `codecs:` contributor slot (see ADR 208). | ||
| */ | ||
| interface CodecDescriptorRegistry { | ||
| /** | ||
| * Descriptors carry distinct param shapes per codec id; the registry is heterogeneous and the consumer narrows per codec. | ||
| */ | ||
| descriptorFor(codecId: string): CodecDescriptor<unknown> | undefined; | ||
| /** | ||
| * Derive the canonical {@link CodecRef} for a contract `(table, column)`. The builder side calls this at AST construction time to stamp `codec` onto every column-bound `ParamRef` / `ProjectionItem`; the runtime side uses the result as the cache key into the content-keyed codec resolver. | ||
| * | ||
| * Resolution rules over `storage.namespaces[namespaceId].tables[table].columns[column]`: | ||
| * | ||
| * - `typeRef` column → emit `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef produce the same ref → same memoised codec). | ||
| * - inline `typeParams` column → emit `{codecId, typeParams}` from the column itself. | ||
| * - non-parameterized column → emit `{codecId}` with `typeParams` undefined (keys as `${codecId}:undefined` → one shared codec). | ||
| * | ||
| * The `namespaceId` coordinate leads and is always supplied — the table is resolved strictly within that namespace, so two same-bare-named tables in different namespaces resolve to their own per-namespace columns/codecs without colliding. | ||
| * | ||
| * Returns `undefined` when the registry was built without contract storage (package-scoped registries used purely as descriptor lookups), when the table or column is unknown in the namespace, or when the column declares a `typeRef` that the storage doesn't define. | ||
| */ | ||
| codecRefForColumn(namespaceId: string, table: string, column: string): CodecRef | undefined; | ||
| /** | ||
| * All registered descriptors. Used by `validateCodecRegistryCompleteness` and other startup-time consumers that enumerate descriptors. | ||
| */ | ||
| values(): IterableIterator<CodecDescriptor<unknown>>; | ||
| /** | ||
| * Descriptors indexed by `targetTypes[i]` (each scalar type the codec advertises). Multiple descriptors may map to the same scalar type; ordering reflects registration order. | ||
| */ | ||
| byTargetType(targetType: string): readonly CodecDescriptor<unknown>[]; | ||
| } | ||
| /** | ||
| * Registry of initialized type helpers from storage.types. Each key is a type name from storage.types, and the value is the resolved codec materialized once for that named instance via `descriptor.factory(typeParams)(ctx)` (or the raw `StorageTypeInstance` metadata for codec ids whose descriptor isn't registered). | ||
| */ | ||
| type TypeHelperRegistry = Record<string, unknown>; | ||
| type MutationDefaultsOp = 'create' | 'update'; | ||
| type AppliedMutationDefault = { | ||
| readonly column: string; | ||
| readonly value: unknown; | ||
| }; | ||
| type MutationDefaultsOptions = { | ||
| readonly op: MutationDefaultsOp; | ||
| readonly table: string; | ||
| /** | ||
| * Namespace of the target table. Execution-default refs are namespace-scoped, | ||
| * so only defaults declared for `(namespace, table)` are applied — this is what | ||
| * disambiguates same-named tables across namespaces. Required so the coordinate | ||
| * is always part of the match; a missing namespace is a caller bug, not a | ||
| * silent degrade to table-name-only matching. | ||
| */ | ||
| readonly namespace: string; | ||
| readonly values: Record<string, unknown>; | ||
| /** | ||
| * Per-ORM-operation cache for generators that declare `stability: 'query'`. The caller passes the same `Map` across every `applyMutationDefaults` invocation in one bulk operation; the framework keys by `generatorId` so the same value is reused across all rows and columns. Generators with `stability: 'row'` use a fresh per-call cache the framework manages internally; generators with `stability: 'field'` skip caching | ||
| * entirely. Omit to make every call independent (degrades `'query'` to per-call behavior). | ||
| */ | ||
| readonly defaultValueCache?: Map<string, unknown>; | ||
| }; | ||
| /** | ||
| * Minimal context interface for SQL query lanes. | ||
| * | ||
| * Lanes only need contract, operations, and codecs to build typed ASTs and attach operation builders. This interface explicitly excludes runtime concerns like adapters, connection management, and transaction state. | ||
| */ | ||
| interface ExecutionContext<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> { | ||
| readonly contract: TContract; | ||
| /** | ||
| * Contract-bound codec registry built once at context-construction time by walking the contract's columns and resolving each through its descriptor's factory. Runtime dispatch (`encodeParam` / `decodeRow`) resolves codecs via `forCodecRef(ref)` — the single dispatch shape for AST-bound codec resolution. | ||
| */ | ||
| readonly contractCodecs: ContractCodecRegistry; | ||
| /** | ||
| * Codec-id-keyed descriptor map. Single source of truth for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`) — every codec, parameterized or not, resolves through this map without branching. | ||
| */ | ||
| readonly codecDescriptors: CodecDescriptorRegistry; | ||
| readonly queryOperations: SqlOperationRegistry; | ||
| /** | ||
| * Type helper registry for parameterized types. Schema builders expose these helpers via schema.types. | ||
| */ | ||
| readonly types: TypeHelperRegistry; | ||
| /** | ||
| * Applies execution-time mutation defaults for the given table. Returns the applied defaults (caller-provided values always win). | ||
| */ | ||
| applyMutationDefaults(options: MutationDefaultsOptions): ReadonlyArray<AppliedMutationDefault>; | ||
| } | ||
| //#endregion | ||
| export { MutationDefaultsOptions as a, MutationDefaultsOp as i, CodecDescriptorRegistry as n, TypeHelperRegistry as o, ExecutionContext as r, AppliedMutationDefault as t }; | ||
| //# sourceMappingURL=query-lane-context-DTCOHMXn.d.mts.map |
| {"version":3,"file":"query-lane-context-DTCOHMXn.d.mts","names":[],"sources":["../src/query-lane-context.ts"],"mappings":";;;;;;;;;UASiB;;;;EAIf,cAAc,kBAAkB;;;;;;;;;;;;;;EAchC,kBAAkB,qBAAqB,eAAe,iBAAiB;;;;EAIvE,UAAU,iBAAiB;;;;EAI3B,aAAa,8BAA8B;;;;;KAMjC,qBAAqB;KAErB;KAEA;WACD;WACA;;KAGC;WACD,IAAI;WACJ;;;;;;;;WAQA;WACA,QAAQ;;;;;WAKR,oBAAoB;;;;;;;UAQd,iBAAiB,kBAAkB,SAAS,cAAc,SAAS;WACzE,UAAU;;;;WAIV,gBAAgB;;;;WAIhB,kBAAkB;WAClB,iBAAiB;;;;WAIjB,OAAO;;;;EAIhB,sBAAsB,SAAS,0BAA0B,cAAc"} |
| import { f as AnyQueryAst } from "./types-CWlaErjN.mjs"; | ||
| import { ExecutionPlan } from "@prisma-next/framework-components/runtime"; | ||
| //#region src/sql-execution-plan.d.ts | ||
| /** | ||
| * SQL-domain execution plan: a query lowered to the wire-level shape that a | ||
| * SQL driver can run. | ||
| * | ||
| * The plan carries: | ||
| * - `sql` — the rendered SQL text | ||
| * - `params` — the bound parameter list | ||
| * - `ast` — the pre-lowering AST, retained for decoding / telemetry / middleware | ||
| * - `meta` — family-agnostic plan metadata (target, lane, hashes, ...) | ||
| * - `_row` — phantom row type, propagated from the originating `SqlQueryPlan` | ||
| * | ||
| * Extends the framework-level `ExecutionPlan<Row>` marker so generic SPIs | ||
| * (`RuntimeExecutor<SqlExecutionPlan>`, `RuntimeMiddleware<SqlExecutionPlan>`) | ||
| * can be parameterized over it. | ||
| * | ||
| * Co-located with `SqlQueryPlan` (its pre-lowering counterpart) in the lanes | ||
| * layer because lane-level utilities (`RawTemplateFactory`, `RawFactory`, | ||
| * `SqlPlan`) compose against the executable shape and the lanes layer cannot | ||
| * depend on the runtime layer. | ||
| */ | ||
| interface SqlExecutionPlan<Row = unknown> extends ExecutionPlan<Row> { | ||
| readonly sql: string; | ||
| readonly params: readonly unknown[]; | ||
| readonly ast: AnyQueryAst; | ||
| } | ||
| //#endregion | ||
| export { SqlExecutionPlan as t }; | ||
| //# sourceMappingURL=sql-execution-plan-B-C-6cZN.d.mts.map |
| {"version":3,"file":"sql-execution-plan-B-C-6cZN.d.mts","names":[],"sources":["../src/sql-execution-plan.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAuBiB,iBAAiB,uBAAuB,cAAc;WAC5D;WACA;WACA,KAAK"} |
| import { et as ParamRef, y as ColumnRef } from "./types-CWlaErjN.mjs"; | ||
| import { r as ExecutionContext } from "./query-lane-context-DTCOHMXn.mjs"; | ||
| import { t as SqlExecutionPlan } from "./sql-execution-plan-B-C-6cZN.mjs"; | ||
| import { t as SqlQueryPlan } from "./plan-Dq94efZJ.mjs"; | ||
| import { Contract } from "@prisma-next/contract/types"; | ||
| import { RuntimeExecutor } from "@prisma-next/framework-components/runtime"; | ||
| import { ExtractFieldOutputTypes, SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types"; | ||
| import { ParamSpec } from "@prisma-next/operations"; | ||
| import { SqlLoweringSpec } from "@prisma-next/sql-operations"; | ||
| //#region src/runtime-scope.d.ts | ||
| /** | ||
| * The plan shape accepted by the SQL ORM client and SQL runtime: either a | ||
| * pre-lowering `SqlQueryPlan` (AST + meta) or a post-lowering | ||
| * `SqlExecutionPlan` (sql + params + meta). | ||
| */ | ||
| type SqlOrmPlan = SqlExecutionPlan | SqlQueryPlan; | ||
| /** | ||
| * The minimal SQL-runtime surface that the ORM client and SQL runtime both | ||
| * depend on: the `execute` method of `RuntimeExecutor<SqlOrmPlan>`. | ||
| * | ||
| * Owned by `sql-relational-core` (lanes layer) so both | ||
| * `@prisma-next/sql-runtime` and `@prisma-next/sql-orm-client` consume the | ||
| * same source of truth without a layering inversion. | ||
| */ | ||
| type RuntimeScope = Pick<RuntimeExecutor<SqlOrmPlan>, 'execute'>; | ||
| //#endregion | ||
| //#region src/types.d.ts | ||
| type Expr = ColumnRef | ParamRef; | ||
| /** | ||
| * The minimal contract shape the per-namespace column resolver needs: the | ||
| * application-domain models and the storage tables, both keyed by namespace | ||
| * coordinate, plus (via the optional TypeMaps phantom key, read structurally by | ||
| * {@link ExtractFieldOutputTypes}) the refined field-output map. Every emitted | ||
| * `Contract<SqlStorage>` satisfies it, as does `sql-builder`'s `TableProxyContract` | ||
| * — so the resolver indexes the coordinate directly without forcing callers to | ||
| * carry the full `Contract`. | ||
| */ | ||
| type ColumnResolutionContract = { | ||
| readonly domain: { | ||
| readonly namespaces: Readonly<Record<string, { | ||
| readonly models: Readonly<Record<string, unknown>>; | ||
| }>>; | ||
| }; | ||
| readonly storage: { | ||
| readonly namespaces: Readonly<Record<string, { | ||
| readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>; | ||
| }>>; | ||
| }; | ||
| }; | ||
| type NamespaceModels<TContract extends ColumnResolutionContract, NsId extends string> = TContract['domain']['namespaces'][NsId] extends { | ||
| readonly models: infer Models extends Record<string, unknown>; | ||
| } ? Models : never; | ||
| type ExtractTableToModel<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string> = NamespaceModels<TContract, NsId> extends (infer Models extends Record<string, unknown>) ? { [M in keyof Models & string]: Models[M] extends { | ||
| readonly storage: { | ||
| readonly table: TableName; | ||
| }; | ||
| } ? M : never; }[keyof Models & string] : never; | ||
| type ExtractColumnToField<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string> = ExtractTableToModel<TContract, NsId, TableName> extends (infer ModelName extends string) ? NamespaceModels<TContract, NsId> extends (infer Models extends Record<string, unknown>) ? ModelName & keyof Models extends (infer MKey extends string) ? Models[MKey] extends { | ||
| readonly storage: { | ||
| readonly fields: infer Fields extends Record<string, unknown>; | ||
| }; | ||
| } ? { [F in keyof Fields & string]: Fields[F] extends { | ||
| readonly column: ColumnName; | ||
| } ? F : never; }[keyof Fields & string] : never : never : never : never; | ||
| /** Resolves to `never` when the table or column is absent in the namespace. */ | ||
| type NamespaceStorageColumn<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string> = TContract['storage']['namespaces'][NsId] extends { | ||
| readonly entries: { | ||
| readonly table: infer Tables extends Record<string, unknown>; | ||
| }; | ||
| } ? TableName extends keyof Tables ? Tables[TableName] extends { | ||
| readonly columns: infer Columns extends Record<string, unknown>; | ||
| } ? ColumnName extends keyof Columns ? Columns[ColumnName] extends StorageColumn ? Columns[ColumnName] : never : never : never : never : never; | ||
| type FallbackCodecLookup<ColumnMeta extends StorageColumn, CodecTypes extends Record<string, { | ||
| readonly output: unknown; | ||
| }>> = ColumnMeta extends { | ||
| codecId: infer CodecId extends string; | ||
| } ? CodecId extends keyof CodecTypes ? CodecTypes[CodecId] extends { | ||
| readonly output: infer O; | ||
| } ? ColumnMeta extends { | ||
| nullable: true; | ||
| } ? O | null : O : unknown : unknown : unknown; | ||
| /** | ||
| * The refined (typeParam-applied) JS output type for a field within a namespace | ||
| * coordinate, read from the emitter's namespace-nested `FieldOutputTypes` map at | ||
| * `FieldOutputTypes[NsId][Model][Field]`. This preserves parameterized codec | ||
| * refinements (e.g. `Vector<N>`, `Char<N>`) that a bare codec-output lookup | ||
| * would drop. Resolves to `never` when the coordinate is absent from the map. | ||
| */ | ||
| type NamespaceFieldOutput<TContract extends ColumnResolutionContract, NsId extends string, ModelName extends string, FieldName extends string> = ExtractFieldOutputTypes<TContract> extends (infer Outputs) ? NsId extends keyof Outputs ? Outputs[NsId] extends (infer NamespaceOutputs) ? ModelName extends keyof NamespaceOutputs ? NamespaceOutputs[ModelName] extends (infer ModelOutputs) ? FieldName extends keyof ModelOutputs ? ModelOutputs[FieldName] : never : never : never : never : never : never; | ||
| /** | ||
| * The secondary resolution path, taken for a storage column not backed by a | ||
| * domain model field in the namespace (e.g. a column with no corresponding | ||
| * field); refined model fields resolve via {@link NamespaceFieldOutput}. | ||
| */ | ||
| type ColumnCodecFallback<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string, CodecTypes extends Record<string, { | ||
| readonly output: unknown; | ||
| }>> = NamespaceStorageColumn<TContract, NsId, TableName, ColumnName> extends (infer ColumnMeta) ? [ColumnMeta] extends [never] ? never : ColumnMeta extends StorageColumn ? FallbackCodecLookup<ColumnMeta, CodecTypes> : never : never; | ||
| /** | ||
| * Type-level operation signature. | ||
| * Represents an operation at the type level for use in contract type maps. | ||
| */ | ||
| type OperationTypeSignature = { | ||
| readonly args: ReadonlyArray<ParamSpec>; | ||
| readonly returns: ParamSpec; | ||
| readonly lowering: SqlLoweringSpec; | ||
| readonly capabilities?: ReadonlyArray<string>; | ||
| }; | ||
| /** | ||
| * Type-level operation registry. | ||
| * Maps typeId → operations, where operations is a record of method name → operation signature. | ||
| * | ||
| * Example: | ||
| * ```typescript | ||
| * type MyOperations: OperationTypes = { | ||
| * 'pg/vector@1': { | ||
| * cosineDistance: { | ||
| * args: [{ codecId: 'pg/vector@1'; nullable: false }]; | ||
| * returns: { codecId: 'core/float8'; nullable: false }; | ||
| * lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' }; | ||
| * }; | ||
| * }; | ||
| * }; | ||
| * ``` | ||
| */ | ||
| type OperationTypes = Record<string, Record<string, OperationTypeSignature>>; | ||
| /** | ||
| * CodecTypes represents a map of typeId to codec definitions. | ||
| * Each codec definition must have an `output` property indicating the JavaScript type. | ||
| * | ||
| * Example: | ||
| * ```typescript | ||
| * type MyCodecTypes: CodecTypes = { | ||
| * 'pg/int4@1': { output: number }; | ||
| * 'pg/text@1': { output: string }; | ||
| * }; | ||
| * ``` | ||
| */ | ||
| type CodecTypes = Record<string, { | ||
| readonly output: unknown; | ||
| }>; | ||
| /** | ||
| * Extracts operations for a given typeId from the operation registry. | ||
| * Returns an empty record if the typeId is not found. | ||
| * | ||
| * @example | ||
| * ```typescript | ||
| * type Ops = OperationsForTypeId<'pg/vector@1', MyOperations>; | ||
| * // Ops = { cosineDistance: { ... }, l2Distance: { ... } } | ||
| * ``` | ||
| */ | ||
| type OperationsForTypeId<TypeId extends string, Operations extends OperationTypes> = Operations extends Record<string, never> ? Record<string, never> : TypeId extends keyof Operations ? Operations[TypeId] : Record<string, never>; | ||
| /** | ||
| * Resolves the JavaScript output type of a column addressed by an explicit | ||
| * namespace coordinate. | ||
| * | ||
| * The table→model and column→field mapping is resolved per-namespace from | ||
| * `domain.namespaces[NsId]['models']`, and the refined output type from the | ||
| * emitter's namespace-nested `FieldOutputTypes[NsId][Model][Field]` — so a bare | ||
| * table name shared across namespaces resolves to each namespace's own field, | ||
| * and parameterized codec refinements (e.g. `Vector<N>`) are preserved. A | ||
| * storage column not backed by a model field in the namespace falls back to a | ||
| * codec-output lookup; a column absent in the namespace resolves to `never`. | ||
| */ | ||
| type ComputeColumnJsType<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string, CodecTypes extends Record<string, { | ||
| readonly output: unknown; | ||
| }>> = ExtractTableToModel<TContract, NsId, TableName> extends (infer ModelName) ? [ModelName] extends [never] ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes> : ModelName extends string ? ExtractColumnToField<TContract, NsId, TableName, ColumnName> extends (infer FieldName) ? [FieldName] extends [never] ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes> : FieldName extends string ? NamespaceFieldOutput<TContract, NsId, ModelName, FieldName> extends (infer Out) ? [Out] extends [never] ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes> : Out : never : never : never : never : never; | ||
| /** | ||
| * Alias for the SQL-domain executable plan, exposed under the legacy | ||
| * `SqlPlan` name for compatibility with SQL builder/utility call sites. | ||
| * The canonical name is `SqlExecutionPlan` (`./sql-execution-plan`). | ||
| */ | ||
| type SqlPlan<Row = unknown> = SqlExecutionPlan<Row>; | ||
| /** | ||
| * Helper types for extracting contract structure. | ||
| */ | ||
| type TablesOf<TContract> = TContract extends { | ||
| storage: { | ||
| tables: infer U; | ||
| }; | ||
| } ? U : never; | ||
| type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>; | ||
| /** | ||
| * Unique symbol for metadata property to avoid collisions with user-defined properties | ||
| */ | ||
| declare const META: unique symbol; | ||
| /** | ||
| * Extracts metadata from a type that has a META property | ||
| */ | ||
| type Meta<T extends { | ||
| [META]: unknown; | ||
| }> = T[typeof META]; | ||
| /** | ||
| * Metadata interface for table definitions | ||
| */ | ||
| interface TableMetadata<Name extends string> { | ||
| name: Name; | ||
| } | ||
| /** | ||
| * Metadata interface for model definitions | ||
| */ | ||
| interface ModelMetadata<Name extends string> { | ||
| name: Name; | ||
| } | ||
| /** | ||
| * Base interface for table definitions with metadata | ||
| * Used in contract.d.ts to define storage-level table types | ||
| */ | ||
| interface TableDef<Name extends string> { | ||
| readonly [META]: TableMetadata<Name>; | ||
| } | ||
| /** | ||
| * Base interface for model definitions with metadata | ||
| * Used in contract.d.ts to define application-level model types | ||
| */ | ||
| interface ModelDef<Name extends string> { | ||
| readonly [META]: ModelMetadata<Name>; | ||
| } | ||
| type ColumnsOf<TContract, K extends TableKey<TContract>> = K extends keyof TablesOf<TContract> ? TablesOf<TContract>[K] extends { | ||
| columns: infer C; | ||
| } ? C : never : never; | ||
| interface RawTemplateOptions { | ||
| readonly annotations?: Record<string, unknown>; | ||
| } | ||
| interface RawFunctionOptions extends RawTemplateOptions { | ||
| readonly params: ReadonlyArray<unknown>; | ||
| } | ||
| type RawTemplateFactory = (strings: TemplateStringsArray, ...values: readonly unknown[]) => SqlExecutionPlan; | ||
| interface RawFactory extends RawTemplateFactory { | ||
| (text: string, options: RawFunctionOptions): SqlExecutionPlan; | ||
| with(options: RawTemplateOptions): RawTemplateFactory; | ||
| } | ||
| interface BuildParamsMap { | ||
| readonly [name: string]: unknown; | ||
| } | ||
| interface BuildOptions { | ||
| readonly params?: BuildParamsMap; | ||
| } | ||
| interface SqlBuilderOptions<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> { | ||
| readonly context: ExecutionContext<TContract>; | ||
| } | ||
| //#endregion | ||
| export { TableMetadata as C, SqlOrmPlan as E, TableKey as S, RuntimeScope as T, RawTemplateFactory as _, ColumnsOf as a, SqlPlan as b, META as c, ModelMetadata as d, OperationTypeSignature as f, RawFunctionOptions as g, RawFactory as h, ColumnResolutionContract as i, Meta as l, OperationsForTypeId as m, BuildParamsMap as n, ComputeColumnJsType as o, OperationTypes as p, CodecTypes as r, Expr as s, BuildOptions as t, ModelDef as u, RawTemplateOptions as v, TablesOf as w, TableDef as x, SqlBuilderOptions as y }; | ||
| //# sourceMappingURL=types-CRV7uuOC.d.mts.map |
| {"version":3,"file":"types-CRV7uuOC.d.mts","names":[],"sources":["../src/runtime-scope.ts","../src/types.ts"],"mappings":"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"} |
| import { o as CodecRef } from "./codec-types-Bayoa4PI.mjs"; | ||
| import { ParamSpec } from "@prisma-next/operations"; | ||
| import { SqlLoweringSpec } from "@prisma-next/sql-operations"; | ||
| //#region src/ast/json-value-projection.d.ts | ||
| declare abstract class JsonValueProjection { | ||
| abstract readonly kind: string; | ||
| readonly value: ProjectionExpr; | ||
| protected constructor(value: ProjectionExpr); | ||
| abstract accept<R>(visitor: JsonValueProjectionVisitor<R>): R; | ||
| abstract rewrite(rewriter: ExpressionRewriter): AnyJsonValueProjection; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| collectColumnRefs(): ColumnRef[]; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| protected freeze(): void; | ||
| } | ||
| interface JsonValueProjectionVisitor<R> { | ||
| codec(projection: CodecJsonValueProjection): R; | ||
| native(projection: NativeJsonValueProjection): R; | ||
| document(projection: JsonDocumentProjection): R; | ||
| } | ||
| declare class CodecJsonValueProjection extends JsonValueProjection { | ||
| readonly kind: "codec"; | ||
| readonly codec: CodecRef; | ||
| constructor(value: ProjectionExpr, codec: CodecRef); | ||
| accept<R>(visitor: JsonValueProjectionVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): CodecJsonValueProjection; | ||
| } | ||
| declare class NativeJsonValueProjection extends JsonValueProjection { | ||
| readonly kind: "native"; | ||
| constructor(value: ProjectionExpr); | ||
| accept<R>(visitor: JsonValueProjectionVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): NativeJsonValueProjection; | ||
| } | ||
| declare class JsonDocumentProjection extends JsonValueProjection { | ||
| readonly kind: "document"; | ||
| constructor(value: ProjectionExpr); | ||
| accept<R>(visitor: JsonValueProjectionVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): JsonDocumentProjection; | ||
| } | ||
| type AnyJsonValueProjection = CodecJsonValueProjection | NativeJsonValueProjection | JsonDocumentProjection; | ||
| //#endregion | ||
| //#region src/ast/types.d.ts | ||
| type Direction = 'asc' | 'desc'; | ||
| type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'like' | 'in' | 'notIn'; | ||
| type AggregateCountFn = 'count'; | ||
| type AggregateOpFn = 'sum' | 'avg' | 'min' | 'max'; | ||
| type AggregateFn = AggregateCountFn | AggregateOpFn; | ||
| /** | ||
| * Window function names. Currently only `row_number` is wired up — added | ||
| * to support `ROW_NUMBER() OVER (PARTITION BY ... ORDER BY ...) = 1` | ||
| * lowering for `.distinct(cols)` semantics in the SQL ORM client. `rank` | ||
| * and `dense_rank` are reserved here so future additions don't churn the | ||
| * type; renderers only need to dispatch on the function name string. | ||
| */ | ||
| type WindowFn = 'row_number' | 'rank' | 'dense_rank'; | ||
| /** Scalar JS values that map directly to a SQL wire type. Values outside this set must be routed through `param(value, { codecId })` to declare the target codec explicitly. */ | ||
| type RawSqlLiteral = number | bigint | string | boolean | Uint8Array; | ||
| interface ExpressionSource { | ||
| toExpr(): AnyExpression; | ||
| } | ||
| interface ExpressionRewriter { | ||
| columnRef?(expr: ColumnRef): AnyExpression; | ||
| identifierRef?(expr: IdentifierRef): AnyExpression; | ||
| paramRef?(expr: ParamRef): ParamRef | LiteralExpr; | ||
| preparedParamRef?(expr: PreparedParamRef): PreparedParamRef; | ||
| literal?(expr: LiteralExpr): LiteralExpr; | ||
| list?(expr: ListExpression): ListExpression | LiteralExpr; | ||
| select?(ast: SelectAst): SelectAst; | ||
| rawExpr?(expr: RawExpr): AnyExpression; | ||
| } | ||
| interface AstRewriter extends ExpressionRewriter { | ||
| tableSource?(source: TableSource): TableSource; | ||
| eqColJoinOn?(on: EqColJoinOn): EqColJoinOn | AnyExpression; | ||
| } | ||
| interface ExprVisitor<R> { | ||
| columnRef(expr: ColumnRef): R; | ||
| identifierRef(expr: IdentifierRef): R; | ||
| subquery(expr: SubqueryExpr): R; | ||
| operation(expr: OperationExpr): R; | ||
| aggregate(expr: AggregateExpr): R; | ||
| windowFunc(expr: WindowFuncExpr): R; | ||
| functionCall(expr: FunctionCallExpr): R; | ||
| cast(expr: CastExpr): R; | ||
| case(expr: CaseExpr): R; | ||
| jsonObject(expr: JsonObjectExpr): R; | ||
| jsonArrayAgg(expr: JsonArrayAggExpr): R; | ||
| binary(expr: BinaryExpr): R; | ||
| and(expr: AndExpr): R; | ||
| or(expr: OrExpr): R; | ||
| exists(expr: ExistsExpr): R; | ||
| nullCheck(expr: NullCheckExpr): R; | ||
| not(expr: NotExpr): R; | ||
| literal(expr: LiteralExpr): R; | ||
| param(expr: ParamRef): R; | ||
| preparedParam(expr: PreparedParamRef): R; | ||
| list(expr: ListExpression): R; | ||
| rawExpr(expr: RawExpr): R; | ||
| } | ||
| interface ExpressionFolder<T> { | ||
| empty: T; | ||
| combine(a: T, b: T): T; | ||
| isAbsorbing?(value: T): boolean; | ||
| columnRef?(expr: ColumnRef): T; | ||
| identifierRef?(expr: IdentifierRef): T; | ||
| paramRef?(expr: ParamRef): T; | ||
| preparedParamRef?(expr: PreparedParamRef): T; | ||
| literal?(expr: LiteralExpr): T; | ||
| list?(expr: ListExpression): T; | ||
| select?(ast: SelectAst): T; | ||
| rawExpr?(expr: RawExpr): T; | ||
| } | ||
| type ProjectionExpr = AnyExpression; | ||
| type InsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr; | ||
| type JoinOnExpr = EqColJoinOn | AnyExpression; | ||
| type WhereArg = AnyExpression | ToWhereExpr; | ||
| type JsonObjectEntry = { | ||
| readonly key: string; | ||
| readonly value: AnyJsonValueProjection; | ||
| }; | ||
| declare abstract class AstNode { | ||
| abstract readonly kind: string; | ||
| protected freeze(): void; | ||
| } | ||
| declare abstract class QueryAst extends AstNode { | ||
| abstract collectParamRefs(): AnyParamRef[]; | ||
| abstract toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare abstract class FromSource extends AstNode { | ||
| abstract rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| abstract toFromSource(): AnyFromSource; | ||
| } | ||
| declare abstract class Expression extends AstNode implements ExpressionSource { | ||
| #private; | ||
| abstract accept<R>(visitor: ExprVisitor<R>): R; | ||
| abstract rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| abstract fold<T>(folder: ExpressionFolder<T>): T; | ||
| collectColumnRefs(): ColumnRef[]; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| baseColumnRef(): ColumnRef; | ||
| toExpr(): AnyExpression; | ||
| not(): NotExpr; | ||
| } | ||
| declare class TableSource extends FromSource { | ||
| readonly kind: "table-source"; | ||
| readonly name: string; | ||
| readonly alias: string | undefined; | ||
| /** | ||
| * Resolved storage namespace coordinate for this table, stamped when the | ||
| * table proxy constructs the AST. Renderers qualify via the namespace | ||
| * concretion's `qualifyTable()` using this id — never by re-resolving the | ||
| * bare table name at render time. | ||
| */ | ||
| readonly namespaceId: string | undefined; | ||
| protected constructor(name: string, alias?: string, namespaceId?: string); | ||
| static named(name: string, alias?: string, namespaceId?: string): TableSource; | ||
| rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| toFromSource(): AnyFromSource; | ||
| } | ||
| interface TableRef { | ||
| readonly name: string; | ||
| readonly alias?: string; | ||
| } | ||
| declare class DerivedTableSource extends FromSource { | ||
| readonly kind: "derived-table-source"; | ||
| readonly alias: string; | ||
| readonly query: SelectAst; | ||
| constructor(alias: string, query: SelectAst); | ||
| static as(alias: string, query: SelectAst): DerivedTableSource; | ||
| rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| toFromSource(): AnyFromSource; | ||
| } | ||
| interface FunctionSourceAlias { | ||
| readonly alias: string; | ||
| readonly columnAliases?: ReadonlyArray<string>; | ||
| } | ||
| declare class FunctionSource extends FromSource { | ||
| #private; | ||
| readonly kind: "function-source"; | ||
| readonly fn: string; | ||
| readonly args: ReadonlyArray<AnyExpression>; | ||
| readonly alias: string | undefined; | ||
| readonly columnAliases: ReadonlyArray<string> | undefined; | ||
| readonly ordinality: boolean; | ||
| protected constructor(fn: string, args: ReadonlyArray<AnyExpression>, alias?: FunctionSourceAlias, ordinality?: boolean); | ||
| static of(fn: string, args: ReadonlyArray<AnyExpression>, alias?: FunctionSourceAlias): FunctionSource; | ||
| withOrdinality(): FunctionSource; | ||
| rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| toFromSource(): AnyFromSource; | ||
| } | ||
| declare class ColumnRef extends Expression { | ||
| readonly kind: "column-ref"; | ||
| readonly table: string; | ||
| readonly column: string; | ||
| constructor(table: string, column: string); | ||
| static of(table: string, column: string): ColumnRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| baseColumnRef(): ColumnRef; | ||
| } | ||
| declare class IdentifierRef extends Expression { | ||
| readonly kind: "identifier-ref"; | ||
| readonly name: string; | ||
| constructor(name: string); | ||
| static of(name: string): IdentifierRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class ParamRef extends Expression { | ||
| readonly kind: "param-ref"; | ||
| readonly value: unknown; | ||
| readonly name: string | undefined; | ||
| /** | ||
| * Codec identity carried by every column-bound `ParamRef`. The encode-side dispatch path materialises the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation on `(codecId, canonicalize(typeParams))` keeps repeated lookups for the same logical column on one shared {@link Codec}. | ||
| * | ||
| * `codec` may be `undefined` for `ParamRef`s constructed without a column-bound site (literals, transient builder state); the runtime treats those as untyped passthroughs. | ||
| */ | ||
| readonly codec: CodecRef | undefined; | ||
| constructor(value: unknown, options?: { | ||
| name?: string; | ||
| codec?: CodecRef; | ||
| }); | ||
| static of(value: unknown, options?: { | ||
| name?: string; | ||
| codec?: CodecRef; | ||
| }): ParamRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| /** | ||
| * Bind-site placeholder: occupies the same positions as `ParamRef` in the | ||
| * AST, but carries no value — the value is supplied per-execute by the | ||
| * `PreparedStatement.execute(params)` caller and matched to this node by | ||
| * `name`. | ||
| */ | ||
| declare class PreparedParamRef extends Expression { | ||
| readonly kind: "prepared-param-ref"; | ||
| readonly name: string; | ||
| readonly codec: CodecRef; | ||
| constructor(name: string, codec: CodecRef); | ||
| static of(name: string, codec: CodecRef): PreparedParamRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class DefaultValueExpr extends AstNode { | ||
| readonly kind: "default-value"; | ||
| constructor(); | ||
| } | ||
| declare class LiteralExpr extends Expression { | ||
| readonly kind: "literal"; | ||
| readonly value: unknown; | ||
| constructor(value: unknown); | ||
| static of(value: unknown): LiteralExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class SubqueryExpr extends Expression { | ||
| readonly kind: "subquery"; | ||
| readonly query: SelectAst; | ||
| constructor(query: SelectAst); | ||
| static of(query: SelectAst): SubqueryExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class OperationExpr extends Expression { | ||
| readonly kind: "operation"; | ||
| readonly method: string; | ||
| readonly self: AnyExpression; | ||
| readonly args: ReadonlyArray<AnyExpression | ParamRef | LiteralExpr>; | ||
| readonly returns: ParamSpec; | ||
| readonly lowering: SqlLoweringSpec; | ||
| constructor(options: { | ||
| readonly method: string; | ||
| readonly self: AnyExpression; | ||
| readonly args: ReadonlyArray<AnyExpression | ParamRef | LiteralExpr> | undefined; | ||
| readonly returns: ParamSpec; | ||
| readonly lowering: SqlLoweringSpec; | ||
| }); | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| baseColumnRef(): ColumnRef; | ||
| } | ||
| declare class RawExpr extends Expression { | ||
| readonly kind: "raw-expr"; | ||
| readonly parts: ReadonlyArray<string | AnyExpression>; | ||
| readonly returns: ParamSpec; | ||
| constructor(options: { | ||
| readonly parts: ReadonlyArray<string | AnyExpression>; | ||
| readonly returns: ParamSpec; | ||
| }); | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class AggregateExpr extends Expression { | ||
| readonly kind: "aggregate"; | ||
| readonly fn: AggregateFn; | ||
| readonly expr: AnyExpression | undefined; | ||
| constructor(fn: AggregateFn, expr?: AnyExpression); | ||
| static count(expr?: AnyExpression): AggregateExpr; | ||
| static sum(expr: AnyExpression): AggregateExpr; | ||
| static avg(expr: AnyExpression): AggregateExpr; | ||
| static min(expr: AnyExpression): AggregateExpr; | ||
| static max(expr: AnyExpression): AggregateExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| /** | ||
| * Window function call: `fn(args) OVER (PARTITION BY ... ORDER BY ...)`. | ||
| * | ||
| * Both `partitionBy` and `orderBy` are optional; an empty `OVER ()` | ||
| * clause is legal SQL but rarely useful. For `ROW_NUMBER`, `RANK`, and | ||
| * `DENSE_RANK` the standard mandates an `ORDER BY` for deterministic | ||
| * results — callers are expected to provide one, but the AST does not | ||
| * enforce it. | ||
| * | ||
| * The `args` slot exists for future window function additions that take | ||
| * arguments (e.g. `COUNT(*) OVER`, `SUM(x) OVER`); `ROW_NUMBER` and the | ||
| * other ranking functions take no arguments. | ||
| */ | ||
| declare class WindowFuncExpr extends Expression { | ||
| readonly kind: "window-func"; | ||
| readonly fn: WindowFn; | ||
| readonly args: ReadonlyArray<AnyExpression>; | ||
| readonly partitionBy: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| constructor(options: { | ||
| readonly fn: WindowFn; | ||
| readonly args?: ReadonlyArray<AnyExpression>; | ||
| readonly partitionBy?: ReadonlyArray<AnyExpression>; | ||
| readonly orderBy?: ReadonlyArray<OrderByItem>; | ||
| }); | ||
| static rowNumber(options: { | ||
| readonly partitionBy?: ReadonlyArray<AnyExpression>; | ||
| readonly orderBy?: ReadonlyArray<OrderByItem>; | ||
| }): WindowFuncExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class FunctionCallExpr extends Expression { | ||
| readonly kind: "function-call"; | ||
| readonly fn: string; | ||
| readonly args: ReadonlyArray<AnyExpression>; | ||
| constructor(fn: string, args: ReadonlyArray<AnyExpression>); | ||
| static of(fn: string, args: ReadonlyArray<AnyExpression>): FunctionCallExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class CastExpr extends Expression { | ||
| readonly kind: "cast"; | ||
| readonly expr: AnyExpression; | ||
| readonly targetType: string; | ||
| constructor(expr: AnyExpression, targetType: string); | ||
| static as(expr: AnyExpression, targetType: string): CastExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| interface CaseBranch { | ||
| readonly condition: AnyExpression; | ||
| readonly value: AnyExpression; | ||
| } | ||
| declare class CaseExpr extends Expression { | ||
| readonly kind: "case"; | ||
| readonly branches: ReadonlyArray<Readonly<CaseBranch>>; | ||
| readonly elseExpr: AnyExpression | undefined; | ||
| constructor(branches: ReadonlyArray<CaseBranch>, elseExpr?: AnyExpression); | ||
| static of(branches: ReadonlyArray<CaseBranch>, elseExpr?: AnyExpression): CaseExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class JsonObjectExpr extends Expression { | ||
| readonly kind: "json-object"; | ||
| readonly entries: ReadonlyArray<JsonObjectEntry>; | ||
| constructor(entries: ReadonlyArray<JsonObjectEntry>); | ||
| static entry(key: string, value: AnyJsonValueProjection): JsonObjectEntry; | ||
| static fromEntries(entries: ReadonlyArray<JsonObjectEntry>): JsonObjectExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class OrderByItem extends AstNode { | ||
| readonly kind: "order-by-item"; | ||
| readonly expr: AnyExpression; | ||
| readonly dir: Direction; | ||
| constructor(expr: AnyExpression, dir: Direction); | ||
| static asc(expr: AnyExpression): OrderByItem; | ||
| static desc(expr: AnyExpression): OrderByItem; | ||
| rewrite(rewriter: ExpressionRewriter): OrderByItem; | ||
| /** | ||
| * A new frozen item with the sort direction flipped and `expr` unchanged. | ||
| * Integrations that own pagination (e.g. backward cursor pagination) use | ||
| * this to reverse a user's sort order without reaching into the AST. | ||
| */ | ||
| reverse(): OrderByItem; | ||
| } | ||
| declare class JsonArrayAggExpr extends Expression { | ||
| readonly kind: "json-array-agg"; | ||
| readonly expr: AnyJsonValueProjection; | ||
| readonly onEmpty: 'null' | 'emptyArray'; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| constructor(expr: AnyJsonValueProjection, onEmpty?: 'null' | 'emptyArray', orderBy?: ReadonlyArray<OrderByItem>); | ||
| static of(expr: AnyJsonValueProjection, onEmpty?: 'null' | 'emptyArray', orderBy?: ReadonlyArray<OrderByItem>): JsonArrayAggExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class ListExpression extends Expression { | ||
| readonly kind: "list"; | ||
| readonly values: ReadonlyArray<AnyExpression>; | ||
| constructor(values: ReadonlyArray<AnyExpression>); | ||
| static of(values: ReadonlyArray<AnyExpression>): ListExpression; | ||
| static fromValues(values: ReadonlyArray<unknown>): ListExpression; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class BinaryExpr extends Expression { | ||
| readonly kind: "binary"; | ||
| readonly op: BinaryOp; | ||
| readonly left: AnyExpression; | ||
| readonly right: AnyExpression; | ||
| constructor(op: BinaryOp, left: AnyExpression, right: AnyExpression); | ||
| static eq(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static neq(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static gt(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static lt(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static gte(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static lte(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static like(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static in(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static notIn(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class AndExpr extends Expression { | ||
| readonly kind: "and"; | ||
| readonly exprs: ReadonlyArray<AnyExpression>; | ||
| constructor(exprs: ReadonlyArray<AnyExpression>); | ||
| static of(exprs: ReadonlyArray<AnyExpression>): AndExpr; | ||
| static true(): AndExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class OrExpr extends Expression { | ||
| readonly kind: "or"; | ||
| readonly exprs: ReadonlyArray<AnyExpression>; | ||
| constructor(exprs: ReadonlyArray<AnyExpression>); | ||
| static of(exprs: ReadonlyArray<AnyExpression>): OrExpr; | ||
| static false(): OrExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class ExistsExpr extends Expression { | ||
| readonly kind: "exists"; | ||
| readonly notExists: boolean; | ||
| readonly subquery: SelectAst; | ||
| constructor(subquery: SelectAst, notExists?: boolean); | ||
| static exists(subquery: SelectAst): ExistsExpr; | ||
| static notExists(subquery: SelectAst): ExistsExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class NullCheckExpr extends Expression { | ||
| readonly kind: "null-check"; | ||
| readonly expr: AnyExpression; | ||
| readonly isNull: boolean; | ||
| constructor(expr: AnyExpression, isNull: boolean); | ||
| static isNull(expr: AnyExpression): NullCheckExpr; | ||
| static isNotNull(expr: AnyExpression): NullCheckExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class NotExpr extends Expression { | ||
| readonly kind: "not"; | ||
| readonly expr: AnyExpression; | ||
| constructor(expr: AnyExpression); | ||
| toWhereExpr(): AnyExpression; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class EqColJoinOn extends AstNode { | ||
| readonly kind: "eq-col-join-on"; | ||
| readonly left: ColumnRef; | ||
| readonly right: ColumnRef; | ||
| constructor(left: ColumnRef, right: ColumnRef); | ||
| static of(left: ColumnRef, right: ColumnRef): EqColJoinOn; | ||
| rewrite(rewriter: AstRewriter): EqColJoinOn | AnyExpression; | ||
| } | ||
| declare class JoinAst extends AstNode { | ||
| readonly kind: "join"; | ||
| readonly joinType: 'inner' | 'left' | 'right' | 'full'; | ||
| readonly source: AnyFromSource; | ||
| readonly lateral: boolean; | ||
| readonly on: JoinOnExpr; | ||
| constructor(joinType: 'inner' | 'left' | 'right' | 'full', source: AnyFromSource, on: JoinOnExpr, lateral?: boolean); | ||
| static inner(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| static left(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| static right(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| static full(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| rewrite(rewriter: AstRewriter): JoinAst; | ||
| } | ||
| declare class ProjectionItem extends AstNode { | ||
| readonly kind: "projection-item"; | ||
| readonly alias: string; | ||
| readonly expr: ProjectionExpr; | ||
| /** | ||
| * Codec identity for any known projected result, whether read directly from a contract column or forwarded through a query wrapper. Decode-side dispatch resolves the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation collapses repeated lookups for the same logical result onto one shared {@link Codec}. | ||
| * | ||
| * Stays `undefined` only when the projected result's codec is unknown, such as computed expressions, subqueries, or raw aliases whose decoded type the runtime cannot infer. | ||
| */ | ||
| readonly codec: CodecRef | undefined; | ||
| constructor(alias: string, expr: ProjectionExpr, codec?: CodecRef); | ||
| static of(alias: string, expr: ProjectionExpr, codec?: CodecRef): ProjectionItem; | ||
| withCodec(codec: CodecRef | undefined): ProjectionItem; | ||
| } | ||
| type LimitOffsetValue = number | AnyExpression; | ||
| interface SelectAstOptions { | ||
| readonly from?: AnyFromSource; | ||
| readonly joins: ReadonlyArray<JoinAst> | undefined; | ||
| readonly projection: ReadonlyArray<ProjectionItem>; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| readonly distinct: true | undefined; | ||
| readonly distinctOn: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly groupBy: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly having: AnyExpression | undefined; | ||
| readonly limit: LimitOffsetValue | undefined; | ||
| readonly offset: LimitOffsetValue | undefined; | ||
| readonly selectAllIntent: { | ||
| readonly table?: string; | ||
| } | undefined; | ||
| } | ||
| declare class SelectAst extends QueryAst { | ||
| readonly kind: "select"; | ||
| readonly from: AnyFromSource | undefined; | ||
| readonly joins: ReadonlyArray<JoinAst> | undefined; | ||
| readonly projection: ReadonlyArray<ProjectionItem>; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| readonly distinct: true | undefined; | ||
| readonly distinctOn: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly groupBy: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly having: AnyExpression | undefined; | ||
| readonly limit: LimitOffsetValue | undefined; | ||
| readonly offset: LimitOffsetValue | undefined; | ||
| readonly selectAllIntent: { | ||
| readonly table?: string; | ||
| } | undefined; | ||
| constructor(options: SelectAstOptions); | ||
| static from(from: AnyFromSource): SelectAst; | ||
| static noFrom(): SelectAst; | ||
| private toOptions; | ||
| withFrom(from: AnyFromSource): SelectAst; | ||
| withJoins(joins: ReadonlyArray<JoinAst>): SelectAst; | ||
| withProjection(projection: ReadonlyArray<ProjectionItem>): SelectAst; | ||
| addProjection(alias: string, expr: ProjectionExpr): SelectAst; | ||
| withWhere(where: AnyExpression | undefined): SelectAst; | ||
| withOrderBy(orderBy: ReadonlyArray<OrderByItem>): SelectAst; | ||
| withDistinct(enabled?: boolean): SelectAst; | ||
| withDistinctOn(distinctOn: ReadonlyArray<AnyExpression>): SelectAst; | ||
| withGroupBy(groupBy: ReadonlyArray<AnyExpression>): SelectAst; | ||
| withHaving(having: AnyExpression | undefined): SelectAst; | ||
| withLimit(limit: LimitOffsetValue | undefined): SelectAst; | ||
| withOffset(offset: LimitOffsetValue | undefined): SelectAst; | ||
| withSelectAllIntent(selectAllIntent: { | ||
| readonly table?: string; | ||
| } | undefined): SelectAst; | ||
| rewrite(rewriter: AstRewriter): SelectAst; | ||
| collectColumnRefs(): ColumnRef[]; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare abstract class InsertOnConflictAction extends AstNode { | ||
| abstract toInsertOnConflictAction(): AnyInsertOnConflictAction; | ||
| } | ||
| declare class DoNothingConflictAction extends InsertOnConflictAction { | ||
| readonly kind: "do-nothing"; | ||
| constructor(); | ||
| toInsertOnConflictAction(): AnyInsertOnConflictAction; | ||
| } | ||
| declare class DoUpdateSetConflictAction extends InsertOnConflictAction { | ||
| readonly kind: "do-update-set"; | ||
| readonly set: Readonly<Record<string, AnyExpression>>; | ||
| constructor(set: Readonly<Record<string, AnyExpression>>); | ||
| toInsertOnConflictAction(): AnyInsertOnConflictAction; | ||
| } | ||
| declare class InsertOnConflict extends AstNode { | ||
| readonly kind: "insert-on-conflict"; | ||
| readonly columns: ReadonlyArray<ColumnRef>; | ||
| readonly action: AnyInsertOnConflictAction; | ||
| constructor(columns: ReadonlyArray<ColumnRef>, action: AnyInsertOnConflictAction); | ||
| static on(columns: ReadonlyArray<ColumnRef>): InsertOnConflict; | ||
| doNothing(): InsertOnConflict; | ||
| doUpdateSet(set: Readonly<Record<string, AnyExpression>>): InsertOnConflict; | ||
| } | ||
| declare class InsertAst extends QueryAst { | ||
| readonly kind: "insert"; | ||
| readonly table: TableSource; | ||
| readonly rows: ReadonlyArray<Readonly<Record<string, InsertValue>>>; | ||
| readonly onConflict: InsertOnConflict | undefined; | ||
| readonly returning: ReadonlyArray<ProjectionItem> | undefined; | ||
| constructor(table: TableSource, rows?: ReadonlyArray<Record<string, InsertValue>>, onConflict?: InsertOnConflict, returning?: ReadonlyArray<ProjectionItem>); | ||
| static into(table: TableSource): InsertAst; | ||
| withRows(rows: ReadonlyArray<Record<string, InsertValue>>): InsertAst; | ||
| withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): InsertAst; | ||
| withOnConflict(onConflict: InsertOnConflict | undefined): InsertAst; | ||
| rewrite(rewriter: AstRewriter): InsertAst; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare class UpdateAst extends QueryAst { | ||
| readonly kind: "update"; | ||
| readonly table: TableSource; | ||
| readonly set: Readonly<Record<string, AnyExpression>>; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly returning: ReadonlyArray<ProjectionItem> | undefined; | ||
| constructor(table: TableSource, set?: Readonly<Record<string, AnyExpression>>, where?: AnyExpression, returning?: ReadonlyArray<ProjectionItem>); | ||
| static table(table: TableSource): UpdateAst; | ||
| withSet(set: Readonly<Record<string, AnyExpression>>): UpdateAst; | ||
| withWhere(where: AnyExpression | undefined): UpdateAst; | ||
| withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): UpdateAst; | ||
| rewrite(rewriter: AstRewriter): UpdateAst; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare class DeleteAst extends QueryAst { | ||
| readonly kind: "delete"; | ||
| readonly table: TableSource; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly returning: ReadonlyArray<ProjectionItem> | undefined; | ||
| constructor(table: TableSource, where?: AnyExpression, returning?: ReadonlyArray<ProjectionItem>); | ||
| static from(table: TableSource): DeleteAst; | ||
| withWhere(where: AnyExpression | undefined): DeleteAst; | ||
| withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): DeleteAst; | ||
| rewrite(rewriter: AstRewriter): DeleteAst; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| /** | ||
| * Raw-SQL query AST node carrying interpolated parameter / expression nodes | ||
| * embedded inside literal SQL fragments. | ||
| * | ||
| * `fragments` and `args` are interleaved during lowering: | ||
| * `fragments[0] + lower(args[0]) + fragments[1] + ... + fragments[n]`. | ||
| * Construction enforces `fragments.length === args.length + 1`. | ||
| * | ||
| * Extends {@link QueryAst} (whole-query AST, not a sub-expression). | ||
| * Construction does not validate that each arg is a `ParamRef` / | ||
| * `AnyExpression`: the type system already rejects bare values because | ||
| * `args` is typed `readonly AnyExpression[]`. The user-facing `raw\`...\`` | ||
| * factory (separate `sql-raw-factory` component) layers stricter | ||
| * type-level rejection on top of this AST node. | ||
| */ | ||
| declare class RawSqlExpr extends QueryAst { | ||
| readonly kind: "raw-sql"; | ||
| readonly fragments: readonly string[]; | ||
| readonly args: readonly AnyExpression[]; | ||
| constructor(fragments: readonly string[], args: readonly AnyExpression[]); | ||
| static of(fragments: readonly string[], args: readonly AnyExpression[]): RawSqlExpr; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| type AnyQueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst | RawSqlExpr; | ||
| type AnyFromSource = TableSource | DerivedTableSource | FunctionSource; | ||
| type AnyExpression = ColumnRef | IdentifierRef | ParamRef | PreparedParamRef | LiteralExpr | SubqueryExpr | OperationExpr | AggregateExpr | WindowFuncExpr | FunctionCallExpr | CastExpr | CaseExpr | JsonObjectExpr | JsonArrayAggExpr | ListExpression | BinaryExpr | AndExpr | OrExpr | ExistsExpr | NullCheckExpr | NotExpr | RawExpr; | ||
| type AnyParamRef = ParamRef | PreparedParamRef; | ||
| type AnyInsertOnConflictAction = DoNothingConflictAction | DoUpdateSetConflictAction; | ||
| type AnyInsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr; | ||
| type AnyOperationArg = AnyExpression | ParamRef | PreparedParamRef | LiteralExpr; | ||
| declare const queryAstKinds: ReadonlySet<string>; | ||
| declare const whereExprKinds: ReadonlySet<string>; | ||
| declare function isQueryAst(value: unknown): value is AnyQueryAst; | ||
| declare function isWhereExpr(value: unknown): value is AnyExpression; | ||
| interface ToWhereExpr { | ||
| toWhereExpr(): AnyExpression; | ||
| } | ||
| /** | ||
| * One positional slot of a lowered SQL statement. | ||
| * | ||
| * - `literal` — a value baked into the AST; passes through to the driver. | ||
| * - `bind` — a `PreparedParamRef` placeholder; the runtime resolves the | ||
| * value from the per-execute `userParams[name]` before calling the driver. | ||
| * | ||
| * The same `name` may legitimately appear in multiple `bind` slots when a | ||
| * renderer does not dedupe `PreparedParamRef` occurrences (e.g. SQLite's | ||
| * positional `?` walker calls `ast.collectParamRefs()` directly rather than | ||
| * `collectOrderedParamRefs`); resolution-by-name handles that case | ||
| * correctly. See `collectOrderedParamRefs` in `./util` for the dedupe | ||
| * contract used by Postgres' `$N` renderer. | ||
| */ | ||
| type LoweredParam = { | ||
| readonly kind: 'literal'; | ||
| readonly value: unknown; | ||
| } | { | ||
| readonly kind: 'bind'; | ||
| readonly name: string; | ||
| }; | ||
| interface LoweredStatement { | ||
| readonly sql: string; | ||
| readonly params: readonly LoweredParam[]; | ||
| readonly annotations?: Record<string, unknown>; | ||
| } | ||
| //#endregion | ||
| export { OrderByItem as $, ExpressionRewriter as A, JoinOnExpr as B, Direction as C, JsonDocumentProjection as Ct, ExistsExpr as D, EqColJoinOn as E, IdentifierRef as F, ListExpression as G, JsonObjectEntry as H, InsertAst as I, LoweredStatement as J, LiteralExpr as K, InsertOnConflict as L, FunctionCallExpr as M, FunctionSource as N, ExprVisitor as O, FunctionSourceAlias as P, OrExpr as Q, InsertValue as R, DerivedTableSource as S, CodecJsonValueProjection as St, DoUpdateSetConflictAction as T, NativeJsonValueProjection as Tt, JsonObjectExpr as U, JsonArrayAggExpr as V, LimitOffsetValue as W, NullCheckExpr as X, NotExpr as Y, OperationExpr as Z, CaseExpr as _, isQueryAst as _t, AndExpr as a, RawSqlExpr as at, DefaultValueExpr as b, whereExprKinds as bt, AnyInsertOnConflictAction as c, SelectAstOptions as ct, AnyParamRef as d, TableSource as dt, ParamRef as et, AnyQueryAst as f, ToWhereExpr as ft, CaseBranch as g, WindowFuncExpr as gt, BinaryOp as h, WindowFn as ht, AggregateOpFn as i, RawExpr as it, ExpressionSource as j, ExpressionFolder as k, AnyInsertValue as l, SubqueryExpr as lt, BinaryExpr as m, WhereArg as mt, AggregateExpr as n, ProjectionExpr as nt, AnyExpression as o, RawSqlLiteral as ot, AstRewriter as p, UpdateAst as pt, LoweredParam as q, AggregateFn as r, ProjectionItem as rt, AnyFromSource as s, SelectAst as st, AggregateCountFn as t, PreparedParamRef as tt, AnyOperationArg as u, TableRef as ut, CastExpr as v, isWhereExpr as vt, DoNothingConflictAction as w, JsonValueProjectionVisitor as wt, DeleteAst as x, AnyJsonValueProjection as xt, ColumnRef as y, queryAstKinds as yt, JoinAst as z }; | ||
| //# sourceMappingURL=types-CWlaErjN.d.mts.map |
| {"version":3,"file":"types-CWlaErjN.d.mts","names":[],"sources":["../src/ast/json-value-projection.ts","../src/ast/types.ts"],"mappings":"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"} |
| import { ifDefined } from "@prisma-next/utils/defined"; | ||
| import { structuredError } from "@prisma-next/utils/structured-error"; | ||
| //#region src/ast/codec-types.ts | ||
| function isJsonArray(value) { | ||
| return Array.isArray(value); | ||
| } | ||
| function freezeJsonValue(value) { | ||
| if (value === null || typeof value !== "object") return; | ||
| if (isJsonArray(value)) for (const item of value) freezeJsonValue(item); | ||
| else for (const item of Object.values(value)) freezeJsonValue(item); | ||
| Object.freeze(value); | ||
| } | ||
| function frozenCodecRef(codec) { | ||
| const typeParams = codec.typeParams === void 0 ? void 0 : structuredClone(codec.typeParams); | ||
| if (typeParams !== void 0) freezeJsonValue(typeParams); | ||
| return Object.freeze({ | ||
| codecId: codec.codecId, | ||
| ...ifDefined("typeParams", typeParams), | ||
| ...ifDefined("many", codec.many) | ||
| }); | ||
| } | ||
| //#endregion | ||
| //#region src/ast/types.ts | ||
| const toAnyExpressionVisitor = { | ||
| columnRef: (expr) => expr, | ||
| identifierRef: (expr) => expr, | ||
| subquery: (expr) => expr, | ||
| operation: (expr) => expr, | ||
| aggregate: (expr) => expr, | ||
| windowFunc: (expr) => expr, | ||
| functionCall: (expr) => expr, | ||
| cast: (expr) => expr, | ||
| case: (expr) => expr, | ||
| jsonObject: (expr) => expr, | ||
| jsonArrayAgg: (expr) => expr, | ||
| binary: (expr) => expr, | ||
| and: (expr) => expr, | ||
| or: (expr) => expr, | ||
| exists: (expr) => expr, | ||
| nullCheck: (expr) => expr, | ||
| not: (expr) => expr, | ||
| literal: (expr) => expr, | ||
| param: (expr) => expr, | ||
| preparedParam: (expr) => expr, | ||
| list: (expr) => expr, | ||
| rawExpr: (expr) => expr | ||
| }; | ||
| function frozenArrayCopy(values) { | ||
| return Object.freeze([...values]); | ||
| } | ||
| function frozenOptionalRecordCopy(value) { | ||
| return value === void 0 ? void 0 : Object.freeze({ ...value }); | ||
| } | ||
| function frozenRecordCopy(record) { | ||
| return Object.freeze({ ...record }); | ||
| } | ||
| function freezeRows(rows) { | ||
| return Object.freeze(rows.map((row) => Object.freeze({ ...row }))); | ||
| } | ||
| function combineAll(folder, thunks) { | ||
| let result = folder.empty; | ||
| for (const thunk of thunks) { | ||
| if (folder.isAbsorbing?.(result)) return result; | ||
| result = folder.combine(result, thunk()); | ||
| } | ||
| return result; | ||
| } | ||
| function rewriteComparable(value, rewriter) { | ||
| switch (value.kind) { | ||
| case "param-ref": return rewriter.paramRef ? rewriter.paramRef(value) : value; | ||
| case "prepared-param-ref": return rewriter.preparedParamRef ? rewriter.preparedParamRef(value) : value; | ||
| case "literal": return rewriter.literal ? rewriter.literal(value) : value; | ||
| case "list": | ||
| if (rewriter.list) return rewriter.list(value); | ||
| return value.rewrite(rewriter); | ||
| default: return value.rewrite(rewriter); | ||
| } | ||
| } | ||
| function foldComparable(value, folder) { | ||
| switch (value.kind) { | ||
| case "param-ref": return folder.paramRef ? folder.paramRef(value) : folder.empty; | ||
| case "prepared-param-ref": return folder.preparedParamRef ? folder.preparedParamRef(value) : folder.empty; | ||
| case "literal": return folder.literal ? folder.literal(value) : folder.empty; | ||
| case "list": return value.fold(folder); | ||
| default: return value.fold(folder); | ||
| } | ||
| } | ||
| function collectColumnRefsWith(node) { | ||
| return node.fold({ | ||
| empty: [], | ||
| combine: (a, b) => [...a, ...b], | ||
| columnRef: (columnRef) => [columnRef], | ||
| select: (ast) => ast.collectColumnRefs() | ||
| }); | ||
| } | ||
| function collectParamRefsWith(node) { | ||
| return node.fold({ | ||
| empty: [], | ||
| combine: (a, b) => [...a, ...b], | ||
| paramRef: (paramRef) => [paramRef], | ||
| preparedParamRef: (paramRef) => [paramRef], | ||
| select: (ast) => ast.collectParamRefs() | ||
| }); | ||
| } | ||
| function rewriteTableSource(table, rewriter) { | ||
| return rewriter.tableSource ? rewriter.tableSource(table) : table; | ||
| } | ||
| function rewriteProjectionItem(item, rewriter) { | ||
| const rewrittenExpr = item.expr.kind === "literal" ? rewriter.literal ? rewriter.literal(item.expr) : item.expr : item.expr.rewrite(rewriter); | ||
| return new ProjectionItem(item.alias, rewrittenExpr, item.codec); | ||
| } | ||
| function rewriteInsertValue(value, rewriter) { | ||
| switch (value.kind) { | ||
| case "param-ref": return rewriter.paramRef ? rewriteParamRefForInsert(value, rewriter) : value; | ||
| case "prepared-param-ref": return rewriter.preparedParamRef ? rewriter.preparedParamRef(value) : value; | ||
| case "column-ref": return rewriter.columnRef ? rewriteColumnRefForInsert(value, rewriter) : value; | ||
| case "default-value": return value; | ||
| case "raw-expr": return value; | ||
| } | ||
| } | ||
| function rewriteParamRefForInsert(value, rewriter) { | ||
| const rewritten = rewriter.paramRef ? rewriter.paramRef(value) : value; | ||
| return rewritten.kind === "param-ref" ? rewritten : value; | ||
| } | ||
| function rewriteColumnRefForInsert(value, rewriter) { | ||
| const rewritten = rewriter.columnRef ? rewriter.columnRef(value) : value; | ||
| return rewritten.kind === "column-ref" ? rewritten : value; | ||
| } | ||
| function rewriteInsertRow(row, rewriter) { | ||
| const result = {}; | ||
| for (const [key, value] of Object.entries(row)) result[key] = rewriteInsertValue(value, rewriter); | ||
| return result; | ||
| } | ||
| function rewriteUpdateSet(set, rewriter) { | ||
| const result = {}; | ||
| for (const [key, value] of Object.entries(set)) result[key] = value.rewrite(rewriter); | ||
| return result; | ||
| } | ||
| function rewriteLimitOffset(value, rewriter) { | ||
| if (value === void 0 || typeof value === "number") return value; | ||
| return value.rewrite(rewriter); | ||
| } | ||
| function rewriteOnConflict(onConflict, rewriter) { | ||
| const columns = onConflict.columns.map((columnRef) => { | ||
| const rewritten = rewriter.columnRef ? rewriter.columnRef(columnRef) : columnRef; | ||
| return rewritten.kind === "column-ref" ? rewritten : columnRef; | ||
| }); | ||
| if (onConflict.action.kind === "do-nothing") return new InsertOnConflict(columns, new DoNothingConflictAction()); | ||
| return new InsertOnConflict(columns, new DoUpdateSetConflictAction(rewriteUpdateSet(onConflict.action.set, rewriter))); | ||
| } | ||
| var AstNode = class { | ||
| freeze() { | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| var QueryAst = class extends AstNode {}; | ||
| var FromSource = class extends AstNode {}; | ||
| var Expression = class extends AstNode { | ||
| collectColumnRefs() { | ||
| return collectColumnRefsWith(this); | ||
| } | ||
| collectParamRefs() { | ||
| return collectParamRefsWith(this); | ||
| } | ||
| baseColumnRef() { | ||
| throw new Error(`${this.constructor.name} does not expose a base column reference`); | ||
| } | ||
| #asAnyExpression() { | ||
| return this.accept(toAnyExpressionVisitor); | ||
| } | ||
| toExpr() { | ||
| return this.#asAnyExpression(); | ||
| } | ||
| not() { | ||
| return new NotExpr(this.#asAnyExpression()); | ||
| } | ||
| }; | ||
| var TableSource = class TableSource extends FromSource { | ||
| kind = "table-source"; | ||
| name; | ||
| alias; | ||
| /** | ||
| * Resolved storage namespace coordinate for this table, stamped when the | ||
| * table proxy constructs the AST. Renderers qualify via the namespace | ||
| * concretion's `qualifyTable()` using this id — never by re-resolving the | ||
| * bare table name at render time. | ||
| */ | ||
| namespaceId; | ||
| constructor(name, alias, namespaceId) { | ||
| super(); | ||
| this.name = name; | ||
| this.alias = alias; | ||
| this.namespaceId = namespaceId; | ||
| } | ||
| static named(name, alias, namespaceId) { | ||
| const source = new TableSource(name, alias, namespaceId); | ||
| source.freeze(); | ||
| return source; | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.tableSource ? rewriter.tableSource(this) : this; | ||
| } | ||
| toFromSource() { | ||
| return this; | ||
| } | ||
| }; | ||
| var DerivedTableSource = class DerivedTableSource extends FromSource { | ||
| kind = "derived-table-source"; | ||
| alias; | ||
| query; | ||
| constructor(alias, query) { | ||
| super(); | ||
| this.alias = alias; | ||
| this.query = query; | ||
| this.freeze(); | ||
| } | ||
| static as(alias, query) { | ||
| return new DerivedTableSource(alias, query); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new DerivedTableSource(this.alias, this.query.rewrite(rewriter)); | ||
| } | ||
| toFromSource() { | ||
| return this; | ||
| } | ||
| }; | ||
| var FunctionSource = class FunctionSource extends FromSource { | ||
| kind = "function-source"; | ||
| fn; | ||
| args; | ||
| alias; | ||
| columnAliases; | ||
| ordinality; | ||
| constructor(fn, args, alias, ordinality = false) { | ||
| super(); | ||
| if (alias?.columnAliases?.length === 0) throw structuredError("SQL.AST_INVALID", "FunctionSource column aliases must not be empty", { meta: { | ||
| kind: "function-source", | ||
| field: "columnAliases" | ||
| } }); | ||
| this.fn = fn; | ||
| this.args = frozenArrayCopy(args); | ||
| this.alias = alias?.alias; | ||
| this.columnAliases = alias?.columnAliases === void 0 ? void 0 : frozenArrayCopy(alias.columnAliases); | ||
| this.ordinality = ordinality; | ||
| this.freeze(); | ||
| } | ||
| static of(fn, args, alias) { | ||
| return new FunctionSource(fn, args, alias); | ||
| } | ||
| #aliasOptions() { | ||
| if (this.alias === void 0) return void 0; | ||
| return { | ||
| alias: this.alias, | ||
| ...ifDefined("columnAliases", this.columnAliases) | ||
| }; | ||
| } | ||
| withOrdinality() { | ||
| if (this.ordinality) return this; | ||
| return new FunctionSource(this.fn, this.args, this.#aliasOptions(), true); | ||
| } | ||
| rewrite(rewriter) { | ||
| const rewrittenArgs = this.args.map((arg) => rewriteComparable(arg, rewriter)); | ||
| if (rewrittenArgs.every((arg, i) => arg === this.args[i])) return this; | ||
| return new FunctionSource(this.fn, rewrittenArgs, this.#aliasOptions(), this.ordinality); | ||
| } | ||
| toFromSource() { | ||
| return this; | ||
| } | ||
| }; | ||
| var ColumnRef = class ColumnRef extends Expression { | ||
| kind = "column-ref"; | ||
| table; | ||
| column; | ||
| constructor(table, column) { | ||
| super(); | ||
| this.table = table; | ||
| this.column = column; | ||
| this.freeze(); | ||
| } | ||
| static of(table, column) { | ||
| return new ColumnRef(table, column); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.columnRef(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.columnRef ? rewriter.columnRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.columnRef ? folder.columnRef(this) : folder.empty; | ||
| } | ||
| baseColumnRef() { | ||
| return this; | ||
| } | ||
| }; | ||
| var IdentifierRef = class IdentifierRef extends Expression { | ||
| kind = "identifier-ref"; | ||
| name; | ||
| constructor(name) { | ||
| super(); | ||
| this.name = name; | ||
| this.freeze(); | ||
| } | ||
| static of(name) { | ||
| return new IdentifierRef(name); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.identifierRef(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.identifierRef ? rewriter.identifierRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.identifierRef ? folder.identifierRef(this) : folder.empty; | ||
| } | ||
| }; | ||
| var ParamRef = class ParamRef extends Expression { | ||
| kind = "param-ref"; | ||
| value; | ||
| name; | ||
| /** | ||
| * Codec identity carried by every column-bound `ParamRef`. The encode-side dispatch path materialises the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation on `(codecId, canonicalize(typeParams))` keeps repeated lookups for the same logical column on one shared {@link Codec}. | ||
| * | ||
| * `codec` may be `undefined` for `ParamRef`s constructed without a column-bound site (literals, transient builder state); the runtime treats those as untyped passthroughs. | ||
| */ | ||
| codec; | ||
| constructor(value, options) { | ||
| super(); | ||
| this.value = value; | ||
| this.name = options?.name; | ||
| this.codec = options?.codec ? frozenCodecRef(options.codec) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static of(value, options) { | ||
| return new ParamRef(value, options); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.param(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.paramRef ? rewriter.paramRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.paramRef ? folder.paramRef(this) : folder.empty; | ||
| } | ||
| }; | ||
| /** | ||
| * Bind-site placeholder: occupies the same positions as `ParamRef` in the | ||
| * AST, but carries no value — the value is supplied per-execute by the | ||
| * `PreparedStatement.execute(params)` caller and matched to this node by | ||
| * `name`. | ||
| */ | ||
| var PreparedParamRef = class PreparedParamRef extends Expression { | ||
| kind = "prepared-param-ref"; | ||
| name; | ||
| codec; | ||
| constructor(name, codec) { | ||
| super(); | ||
| this.name = name; | ||
| this.codec = frozenCodecRef(codec); | ||
| this.freeze(); | ||
| } | ||
| static of(name, codec) { | ||
| return new PreparedParamRef(name, codec); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.preparedParam(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.preparedParamRef ? rewriter.preparedParamRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.preparedParamRef ? folder.preparedParamRef(this) : folder.empty; | ||
| } | ||
| }; | ||
| var DefaultValueExpr = class extends AstNode { | ||
| kind = "default-value"; | ||
| constructor() { | ||
| super(); | ||
| this.freeze(); | ||
| } | ||
| }; | ||
| var LiteralExpr = class LiteralExpr extends Expression { | ||
| kind = "literal"; | ||
| value; | ||
| constructor(value) { | ||
| super(); | ||
| this.value = value; | ||
| this.freeze(); | ||
| } | ||
| static of(value) { | ||
| return new LiteralExpr(value); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.literal(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.literal ? rewriter.literal(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.literal ? folder.literal(this) : folder.empty; | ||
| } | ||
| }; | ||
| var SubqueryExpr = class SubqueryExpr extends Expression { | ||
| kind = "subquery"; | ||
| query; | ||
| constructor(query) { | ||
| super(); | ||
| this.query = query; | ||
| this.freeze(); | ||
| } | ||
| static of(query) { | ||
| return new SubqueryExpr(query); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.subquery(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| const query = this.query.rewrite(rewriter); | ||
| return new SubqueryExpr(query); | ||
| } | ||
| fold(folder) { | ||
| return folder.select ? folder.select(this.query) : folder.empty; | ||
| } | ||
| }; | ||
| var OperationExpr = class OperationExpr extends Expression { | ||
| kind = "operation"; | ||
| method; | ||
| self; | ||
| args; | ||
| returns; | ||
| lowering; | ||
| constructor(options) { | ||
| super(); | ||
| this.method = options.method; | ||
| this.self = options.self; | ||
| this.args = frozenArrayCopy(options.args ?? []); | ||
| this.returns = options.returns; | ||
| this.lowering = options.lowering; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.operation(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new OperationExpr({ | ||
| method: this.method, | ||
| self: this.self.rewrite(rewriter), | ||
| args: this.args.map((arg) => rewriteComparable(arg, rewriter)), | ||
| returns: this.returns, | ||
| lowering: this.lowering | ||
| }); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [() => this.self.fold(folder), ...this.args.map((arg) => () => foldComparable(arg, folder))]); | ||
| } | ||
| baseColumnRef() { | ||
| return this.self.baseColumnRef(); | ||
| } | ||
| }; | ||
| var RawExpr = class extends Expression { | ||
| kind = "raw-expr"; | ||
| parts; | ||
| returns; | ||
| constructor(options) { | ||
| super(); | ||
| this.parts = frozenArrayCopy(options.parts); | ||
| this.returns = options.returns; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.rawExpr(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.rawExpr ? rewriter.rawExpr(this) : this; | ||
| } | ||
| fold(folder) { | ||
| if (folder.rawExpr) return folder.rawExpr(this); | ||
| return combineAll(folder, this.parts.filter((p) => typeof p !== "string").map((p) => () => p.fold(folder))); | ||
| } | ||
| }; | ||
| var AggregateExpr = class AggregateExpr extends Expression { | ||
| kind = "aggregate"; | ||
| fn; | ||
| expr; | ||
| constructor(fn, expr) { | ||
| super(); | ||
| if (fn !== "count" && expr === void 0) throw new Error(`Aggregate function "${fn}" requires an expression`); | ||
| this.fn = fn; | ||
| this.expr = expr; | ||
| this.freeze(); | ||
| } | ||
| static count(expr) { | ||
| return new AggregateExpr("count", expr); | ||
| } | ||
| static sum(expr) { | ||
| return new AggregateExpr("sum", expr); | ||
| } | ||
| static avg(expr) { | ||
| return new AggregateExpr("avg", expr); | ||
| } | ||
| static min(expr) { | ||
| return new AggregateExpr("min", expr); | ||
| } | ||
| static max(expr) { | ||
| return new AggregateExpr("max", expr); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.aggregate(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return this.expr === void 0 ? this : new AggregateExpr(this.fn, this.expr.rewrite(rewriter)); | ||
| } | ||
| fold(folder) { | ||
| return this.expr ? this.expr.fold(folder) : folder.empty; | ||
| } | ||
| }; | ||
| /** | ||
| * Window function call: `fn(args) OVER (PARTITION BY ... ORDER BY ...)`. | ||
| * | ||
| * Both `partitionBy` and `orderBy` are optional; an empty `OVER ()` | ||
| * clause is legal SQL but rarely useful. For `ROW_NUMBER`, `RANK`, and | ||
| * `DENSE_RANK` the standard mandates an `ORDER BY` for deterministic | ||
| * results — callers are expected to provide one, but the AST does not | ||
| * enforce it. | ||
| * | ||
| * The `args` slot exists for future window function additions that take | ||
| * arguments (e.g. `COUNT(*) OVER`, `SUM(x) OVER`); `ROW_NUMBER` and the | ||
| * other ranking functions take no arguments. | ||
| */ | ||
| var WindowFuncExpr = class WindowFuncExpr extends Expression { | ||
| kind = "window-func"; | ||
| fn; | ||
| args; | ||
| partitionBy; | ||
| orderBy; | ||
| constructor(options) { | ||
| super(); | ||
| this.fn = options.fn; | ||
| this.args = options.args && options.args.length > 0 ? frozenArrayCopy(options.args) : []; | ||
| this.partitionBy = options.partitionBy && options.partitionBy.length > 0 ? frozenArrayCopy(options.partitionBy) : void 0; | ||
| this.orderBy = options.orderBy && options.orderBy.length > 0 ? frozenArrayCopy(options.orderBy) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static rowNumber(options) { | ||
| return new WindowFuncExpr({ | ||
| fn: "row_number", | ||
| ...options | ||
| }); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.windowFunc(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new WindowFuncExpr({ | ||
| fn: this.fn, | ||
| args: this.args.map((arg) => arg.rewrite(rewriter)), | ||
| ...ifDefined("partitionBy", this.partitionBy?.map((expr) => expr.rewrite(rewriter))), | ||
| ...ifDefined("orderBy", this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter))) | ||
| }); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [ | ||
| ...this.args.map((arg) => () => arg.fold(folder)), | ||
| ...(this.partitionBy ?? []).map((expr) => () => expr.fold(folder)), | ||
| ...(this.orderBy ?? []).map((orderItem) => () => orderItem.expr.fold(folder)) | ||
| ]); | ||
| } | ||
| }; | ||
| var FunctionCallExpr = class FunctionCallExpr extends Expression { | ||
| kind = "function-call"; | ||
| fn; | ||
| args; | ||
| constructor(fn, args) { | ||
| super(); | ||
| this.fn = fn; | ||
| this.args = frozenArrayCopy(args); | ||
| this.freeze(); | ||
| } | ||
| static of(fn, args) { | ||
| return new FunctionCallExpr(fn, args); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.functionCall(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new FunctionCallExpr(this.fn, this.args.map((arg) => arg.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, this.args.map((arg) => () => arg.fold(folder))); | ||
| } | ||
| }; | ||
| var CastExpr = class CastExpr extends Expression { | ||
| kind = "cast"; | ||
| expr; | ||
| targetType; | ||
| constructor(expr, targetType) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.targetType = targetType; | ||
| this.freeze(); | ||
| } | ||
| static as(expr, targetType) { | ||
| return new CastExpr(expr, targetType); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.cast(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new CastExpr(this.expr.rewrite(rewriter), this.targetType); | ||
| } | ||
| fold(folder) { | ||
| return this.expr.fold(folder); | ||
| } | ||
| }; | ||
| var CaseExpr = class CaseExpr extends Expression { | ||
| kind = "case"; | ||
| branches; | ||
| elseExpr; | ||
| constructor(branches, elseExpr) { | ||
| super(); | ||
| if (branches.length === 0) throw structuredError("SQL.AST_INVALID", "CaseExpr requires at least one branch", { meta: { | ||
| kind: "case", | ||
| field: "branches" | ||
| } }); | ||
| this.branches = Object.freeze(branches.map((branch) => Object.freeze({ | ||
| condition: branch.condition, | ||
| value: branch.value | ||
| }))); | ||
| this.elseExpr = elseExpr; | ||
| this.freeze(); | ||
| } | ||
| static of(branches, elseExpr) { | ||
| return new CaseExpr(branches, elseExpr); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.case(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new CaseExpr(this.branches.map((branch) => ({ | ||
| condition: branch.condition.rewrite(rewriter), | ||
| value: branch.value.rewrite(rewriter) | ||
| })), this.elseExpr?.rewrite(rewriter)); | ||
| } | ||
| fold(folder) { | ||
| const elseExpr = this.elseExpr; | ||
| return combineAll(folder, [...this.branches.flatMap((branch) => [() => branch.condition.fold(folder), () => branch.value.fold(folder)]), ...elseExpr === void 0 ? [] : [() => elseExpr.fold(folder)]]); | ||
| } | ||
| }; | ||
| var JsonObjectExpr = class JsonObjectExpr extends Expression { | ||
| kind = "json-object"; | ||
| entries; | ||
| constructor(entries) { | ||
| super(); | ||
| this.entries = frozenArrayCopy(entries.map((entry) => Object.freeze({ ...entry }))); | ||
| this.freeze(); | ||
| } | ||
| static entry(key, value) { | ||
| return { | ||
| key, | ||
| value | ||
| }; | ||
| } | ||
| static fromEntries(entries) { | ||
| return new JsonObjectExpr(entries); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.jsonObject(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new JsonObjectExpr(this.entries.map((entry) => ({ | ||
| key: entry.key, | ||
| value: entry.value.rewrite(rewriter) | ||
| }))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, this.entries.map((entry) => () => entry.value.fold(folder))); | ||
| } | ||
| }; | ||
| var OrderByItem = class OrderByItem extends AstNode { | ||
| kind = "order-by-item"; | ||
| expr; | ||
| dir; | ||
| constructor(expr, dir) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.dir = dir; | ||
| this.freeze(); | ||
| } | ||
| static asc(expr) { | ||
| return new OrderByItem(expr, "asc"); | ||
| } | ||
| static desc(expr) { | ||
| return new OrderByItem(expr, "desc"); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new OrderByItem(this.expr.rewrite(rewriter), this.dir); | ||
| } | ||
| /** | ||
| * A new frozen item with the sort direction flipped and `expr` unchanged. | ||
| * Integrations that own pagination (e.g. backward cursor pagination) use | ||
| * this to reverse a user's sort order without reaching into the AST. | ||
| */ | ||
| reverse() { | ||
| return new OrderByItem(this.expr, this.dir === "asc" ? "desc" : "asc"); | ||
| } | ||
| }; | ||
| var JsonArrayAggExpr = class JsonArrayAggExpr extends Expression { | ||
| kind = "json-array-agg"; | ||
| expr; | ||
| onEmpty; | ||
| orderBy; | ||
| constructor(expr, onEmpty = "null", orderBy) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.onEmpty = onEmpty; | ||
| this.orderBy = orderBy && orderBy.length > 0 ? frozenArrayCopy(orderBy) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static of(expr, onEmpty = "null", orderBy) { | ||
| return new JsonArrayAggExpr(expr, onEmpty, orderBy); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.jsonArrayAgg(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new JsonArrayAggExpr(this.expr.rewrite(rewriter), this.onEmpty, this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [() => this.expr.fold(folder), ...(this.orderBy ?? []).map((orderItem) => () => orderItem.expr.fold(folder))]); | ||
| } | ||
| }; | ||
| var ListExpression = class ListExpression extends Expression { | ||
| kind = "list"; | ||
| values; | ||
| constructor(values) { | ||
| super(); | ||
| this.values = frozenArrayCopy(values); | ||
| this.freeze(); | ||
| } | ||
| static of(values) { | ||
| return new ListExpression(values); | ||
| } | ||
| static fromValues(values) { | ||
| return new ListExpression(values.map((value) => new LiteralExpr(value))); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.list(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| if (rewriter.list) return rewriter.list(this); | ||
| return new ListExpression(this.values.map((value) => value.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| if (folder.list) return folder.list(this); | ||
| return combineAll(folder, this.values.map((value) => () => value.fold(folder))); | ||
| } | ||
| }; | ||
| var BinaryExpr = class BinaryExpr extends Expression { | ||
| kind = "binary"; | ||
| op; | ||
| left; | ||
| right; | ||
| constructor(op, left, right) { | ||
| super(); | ||
| this.op = op; | ||
| this.left = left; | ||
| this.right = right; | ||
| this.freeze(); | ||
| } | ||
| static eq(left, right) { | ||
| return new BinaryExpr("eq", left, right); | ||
| } | ||
| static neq(left, right) { | ||
| return new BinaryExpr("neq", left, right); | ||
| } | ||
| static gt(left, right) { | ||
| return new BinaryExpr("gt", left, right); | ||
| } | ||
| static lt(left, right) { | ||
| return new BinaryExpr("lt", left, right); | ||
| } | ||
| static gte(left, right) { | ||
| return new BinaryExpr("gte", left, right); | ||
| } | ||
| static lte(left, right) { | ||
| return new BinaryExpr("lte", left, right); | ||
| } | ||
| static like(left, right) { | ||
| return new BinaryExpr("like", left, right); | ||
| } | ||
| static in(left, right) { | ||
| return new BinaryExpr("in", left, right); | ||
| } | ||
| static notIn(left, right) { | ||
| return new BinaryExpr("notIn", left, right); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.binary(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new BinaryExpr(this.op, rewriteComparable(this.left, rewriter), rewriteComparable(this.right, rewriter)); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [() => foldComparable(this.left, folder), () => foldComparable(this.right, folder)]); | ||
| } | ||
| }; | ||
| var AndExpr = class AndExpr extends Expression { | ||
| kind = "and"; | ||
| exprs; | ||
| constructor(exprs) { | ||
| super(); | ||
| this.exprs = frozenArrayCopy(exprs); | ||
| this.freeze(); | ||
| } | ||
| static of(exprs) { | ||
| return new AndExpr(exprs); | ||
| } | ||
| static true() { | ||
| return new AndExpr([]); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.and(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new AndExpr(this.exprs.map((expr) => expr.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder))); | ||
| } | ||
| }; | ||
| var OrExpr = class OrExpr extends Expression { | ||
| kind = "or"; | ||
| exprs; | ||
| constructor(exprs) { | ||
| super(); | ||
| this.exprs = frozenArrayCopy(exprs); | ||
| this.freeze(); | ||
| } | ||
| static of(exprs) { | ||
| return new OrExpr(exprs); | ||
| } | ||
| static false() { | ||
| return new OrExpr([]); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.or(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new OrExpr(this.exprs.map((expr) => expr.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder))); | ||
| } | ||
| }; | ||
| var ExistsExpr = class ExistsExpr extends Expression { | ||
| kind = "exists"; | ||
| notExists; | ||
| subquery; | ||
| constructor(subquery, notExists = false) { | ||
| super(); | ||
| this.notExists = notExists; | ||
| this.subquery = subquery; | ||
| this.freeze(); | ||
| } | ||
| static exists(subquery) { | ||
| return new ExistsExpr(subquery, false); | ||
| } | ||
| static notExists(subquery) { | ||
| return new ExistsExpr(subquery, true); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.exists(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new ExistsExpr(this.subquery.rewrite(rewriter), this.notExists); | ||
| } | ||
| fold(folder) { | ||
| return folder.select ? folder.select(this.subquery) : folder.empty; | ||
| } | ||
| }; | ||
| var NullCheckExpr = class NullCheckExpr extends Expression { | ||
| kind = "null-check"; | ||
| expr; | ||
| isNull; | ||
| constructor(expr, isNull) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.isNull = isNull; | ||
| this.freeze(); | ||
| } | ||
| static isNull(expr) { | ||
| return new NullCheckExpr(expr, true); | ||
| } | ||
| static isNotNull(expr) { | ||
| return new NullCheckExpr(expr, false); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.nullCheck(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new NullCheckExpr(this.expr.rewrite(rewriter), this.isNull); | ||
| } | ||
| fold(folder) { | ||
| return this.expr.fold(folder); | ||
| } | ||
| }; | ||
| var NotExpr = class NotExpr extends Expression { | ||
| kind = "not"; | ||
| expr; | ||
| constructor(expr) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.freeze(); | ||
| } | ||
| toWhereExpr() { | ||
| return this; | ||
| } | ||
| accept(visitor) { | ||
| return visitor.not(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new NotExpr(this.expr.rewrite(rewriter)); | ||
| } | ||
| fold(folder) { | ||
| return this.expr.fold(folder); | ||
| } | ||
| }; | ||
| var EqColJoinOn = class EqColJoinOn extends AstNode { | ||
| kind = "eq-col-join-on"; | ||
| left; | ||
| right; | ||
| constructor(left, right) { | ||
| super(); | ||
| this.left = left; | ||
| this.right = right; | ||
| this.freeze(); | ||
| } | ||
| static of(left, right) { | ||
| return new EqColJoinOn(left, right); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.eqColJoinOn ? rewriter.eqColJoinOn(this) : this; | ||
| } | ||
| }; | ||
| var JoinAst = class JoinAst extends AstNode { | ||
| kind = "join"; | ||
| joinType; | ||
| source; | ||
| lateral; | ||
| on; | ||
| constructor(joinType, source, on, lateral = false) { | ||
| super(); | ||
| this.joinType = joinType; | ||
| this.source = source; | ||
| this.lateral = lateral; | ||
| this.on = on; | ||
| this.freeze(); | ||
| } | ||
| static inner(source, on, lateral = false) { | ||
| return new JoinAst("inner", source, on, lateral); | ||
| } | ||
| static left(source, on, lateral = false) { | ||
| return new JoinAst("left", source, on, lateral); | ||
| } | ||
| static right(source, on, lateral = false) { | ||
| return new JoinAst("right", source, on, lateral); | ||
| } | ||
| static full(source, on, lateral = false) { | ||
| return new JoinAst("full", source, on, lateral); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new JoinAst(this.joinType, this.source.rewrite(rewriter), this.on.kind === "eq-col-join-on" ? this.on.rewrite(rewriter) : this.on.rewrite(rewriter), this.lateral); | ||
| } | ||
| }; | ||
| var ProjectionItem = class ProjectionItem extends AstNode { | ||
| kind = "projection-item"; | ||
| alias; | ||
| expr; | ||
| /** | ||
| * Codec identity for any known projected result, whether read directly from a contract column or forwarded through a query wrapper. Decode-side dispatch resolves the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation collapses repeated lookups for the same logical result onto one shared {@link Codec}. | ||
| * | ||
| * Stays `undefined` only when the projected result's codec is unknown, such as computed expressions, subqueries, or raw aliases whose decoded type the runtime cannot infer. | ||
| */ | ||
| codec; | ||
| constructor(alias, expr, codec) { | ||
| super(); | ||
| this.alias = alias; | ||
| this.expr = expr; | ||
| this.codec = codec ? frozenCodecRef(codec) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static of(alias, expr, codec) { | ||
| return new ProjectionItem(alias, expr, codec); | ||
| } | ||
| withCodec(codec) { | ||
| return new ProjectionItem(this.alias, this.expr, codec); | ||
| } | ||
| }; | ||
| var SelectAst = class SelectAst extends QueryAst { | ||
| kind = "select"; | ||
| from; | ||
| joins; | ||
| projection; | ||
| where; | ||
| orderBy; | ||
| distinct; | ||
| distinctOn; | ||
| groupBy; | ||
| having; | ||
| limit; | ||
| offset; | ||
| selectAllIntent; | ||
| constructor(options) { | ||
| super(); | ||
| this.from = options.from; | ||
| this.joins = options.joins && options.joins.length > 0 ? frozenArrayCopy(options.joins) : void 0; | ||
| this.projection = frozenArrayCopy(options.projection); | ||
| this.where = options.where; | ||
| this.orderBy = options.orderBy && options.orderBy.length > 0 ? frozenArrayCopy(options.orderBy) : void 0; | ||
| this.distinct = options.distinct; | ||
| this.distinctOn = options.distinctOn && options.distinctOn.length > 0 ? frozenArrayCopy(options.distinctOn) : void 0; | ||
| this.groupBy = options.groupBy && options.groupBy.length > 0 ? frozenArrayCopy(options.groupBy) : void 0; | ||
| this.having = options.having; | ||
| this.limit = options.limit; | ||
| this.offset = options.offset; | ||
| this.selectAllIntent = frozenOptionalRecordCopy(options.selectAllIntent); | ||
| this.freeze(); | ||
| } | ||
| static from(from) { | ||
| return new SelectAst({ | ||
| from, | ||
| joins: void 0, | ||
| projection: [], | ||
| where: void 0, | ||
| orderBy: void 0, | ||
| distinct: void 0, | ||
| distinctOn: void 0, | ||
| groupBy: void 0, | ||
| having: void 0, | ||
| limit: void 0, | ||
| offset: void 0, | ||
| selectAllIntent: void 0 | ||
| }); | ||
| } | ||
| static noFrom() { | ||
| return new SelectAst({ | ||
| joins: void 0, | ||
| projection: [], | ||
| where: void 0, | ||
| orderBy: void 0, | ||
| distinct: void 0, | ||
| distinctOn: void 0, | ||
| groupBy: void 0, | ||
| having: void 0, | ||
| limit: void 0, | ||
| offset: void 0, | ||
| selectAllIntent: void 0 | ||
| }); | ||
| } | ||
| toOptions() { | ||
| return { | ||
| ...this.from !== void 0 ? { from: this.from } : {}, | ||
| joins: this.joins, | ||
| projection: this.projection, | ||
| where: this.where, | ||
| orderBy: this.orderBy, | ||
| distinct: this.distinct, | ||
| distinctOn: this.distinctOn, | ||
| groupBy: this.groupBy, | ||
| having: this.having, | ||
| limit: this.limit, | ||
| offset: this.offset, | ||
| selectAllIntent: this.selectAllIntent | ||
| }; | ||
| } | ||
| withFrom(from) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| from | ||
| }); | ||
| } | ||
| withJoins(joins) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| joins: joins.length > 0 ? joins : void 0 | ||
| }); | ||
| } | ||
| withProjection(projection) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| projection | ||
| }); | ||
| } | ||
| addProjection(alias, expr) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| projection: [...this.projection, new ProjectionItem(alias, expr)] | ||
| }); | ||
| } | ||
| withWhere(where) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| where | ||
| }); | ||
| } | ||
| withOrderBy(orderBy) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| orderBy: orderBy.length > 0 ? orderBy : void 0 | ||
| }); | ||
| } | ||
| withDistinct(enabled = true) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| distinct: enabled ? true : void 0 | ||
| }); | ||
| } | ||
| withDistinctOn(distinctOn) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| distinctOn: distinctOn.length > 0 ? distinctOn : void 0 | ||
| }); | ||
| } | ||
| withGroupBy(groupBy) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| groupBy: groupBy.length > 0 ? groupBy : void 0 | ||
| }); | ||
| } | ||
| withHaving(having) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| having | ||
| }); | ||
| } | ||
| withLimit(limit) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| limit | ||
| }); | ||
| } | ||
| withOffset(offset) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| offset | ||
| }); | ||
| } | ||
| withSelectAllIntent(selectAllIntent) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| selectAllIntent | ||
| }); | ||
| } | ||
| rewrite(rewriter) { | ||
| const rewrittenFrom = this.from?.rewrite(rewriter); | ||
| const rewritten = new SelectAst({ | ||
| ...rewrittenFrom !== void 0 ? { from: rewrittenFrom } : {}, | ||
| joins: this.joins?.map((join) => join.rewrite(rewriter)), | ||
| projection: this.projection.map((projection) => new ProjectionItem(projection.alias, projection.expr.kind === "literal" ? rewriter.literal ? rewriter.literal(projection.expr) : projection.expr : projection.expr.rewrite(rewriter), projection.codec)), | ||
| where: this.where?.rewrite(rewriter), | ||
| orderBy: this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter)), | ||
| distinct: this.distinct, | ||
| distinctOn: this.distinctOn?.map((expr) => expr.rewrite(rewriter)), | ||
| groupBy: this.groupBy?.map((expr) => expr.rewrite(rewriter)), | ||
| having: this.having?.rewrite(rewriter), | ||
| limit: rewriteLimitOffset(this.limit, rewriter), | ||
| offset: rewriteLimitOffset(this.offset, rewriter), | ||
| selectAllIntent: this.selectAllIntent | ||
| }); | ||
| return rewriter.select ? rewriter.select(rewritten) : rewritten; | ||
| } | ||
| collectColumnRefs() { | ||
| const refs = []; | ||
| const pushRefs = (columns) => { | ||
| refs.push(...columns); | ||
| }; | ||
| if (this.from?.kind === "derived-table-source") pushRefs(this.from.query.collectColumnRefs()); | ||
| else if (this.from?.kind === "function-source") for (const arg of this.from.args) pushRefs(arg.collectColumnRefs()); | ||
| for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectColumnRefs()); | ||
| if (this.where) pushRefs(this.where.collectColumnRefs()); | ||
| if (this.having) pushRefs(this.having.collectColumnRefs()); | ||
| for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectColumnRefs()); | ||
| for (const expr of this.distinctOn ?? []) pushRefs(expr.collectColumnRefs()); | ||
| for (const expr of this.groupBy ?? []) pushRefs(expr.collectColumnRefs()); | ||
| for (const join of this.joins ?? []) { | ||
| if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectColumnRefs()); | ||
| else if (join.source.kind === "function-source") for (const arg of join.source.args) pushRefs(arg.collectColumnRefs()); | ||
| if (join.on.kind === "eq-col-join-on") refs.push(join.on.left, join.on.right); | ||
| else pushRefs(join.on.collectColumnRefs()); | ||
| } | ||
| if (typeof this.limit === "object") pushRefs(this.limit.collectColumnRefs()); | ||
| if (typeof this.offset === "object") pushRefs(this.offset.collectColumnRefs()); | ||
| return refs; | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| const pushRefs = (params) => { | ||
| refs.push(...params); | ||
| }; | ||
| if (this.from?.kind === "derived-table-source") pushRefs(this.from.query.collectParamRefs()); | ||
| else if (this.from?.kind === "function-source") for (const arg of this.from.args) pushRefs(arg.collectParamRefs()); | ||
| for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectParamRefs()); | ||
| if (this.where) pushRefs(this.where.collectParamRefs()); | ||
| if (this.having) pushRefs(this.having.collectParamRefs()); | ||
| for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectParamRefs()); | ||
| for (const expr of this.distinctOn ?? []) pushRefs(expr.collectParamRefs()); | ||
| for (const expr of this.groupBy ?? []) pushRefs(expr.collectParamRefs()); | ||
| for (const join of this.joins ?? []) { | ||
| if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectParamRefs()); | ||
| else if (join.source.kind === "function-source") for (const arg of join.source.args) pushRefs(arg.collectParamRefs()); | ||
| if (!(join.on.kind === "eq-col-join-on")) pushRefs(join.on.collectParamRefs()); | ||
| } | ||
| if (typeof this.limit === "object") pushRefs(this.limit.collectParamRefs()); | ||
| if (typeof this.offset === "object") pushRefs(this.offset.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| var InsertOnConflictAction = class extends AstNode {}; | ||
| var DoNothingConflictAction = class extends InsertOnConflictAction { | ||
| kind = "do-nothing"; | ||
| constructor() { | ||
| super(); | ||
| this.freeze(); | ||
| } | ||
| toInsertOnConflictAction() { | ||
| return this; | ||
| } | ||
| }; | ||
| var DoUpdateSetConflictAction = class extends InsertOnConflictAction { | ||
| kind = "do-update-set"; | ||
| set; | ||
| constructor(set) { | ||
| super(); | ||
| this.set = frozenRecordCopy(set); | ||
| this.freeze(); | ||
| } | ||
| toInsertOnConflictAction() { | ||
| return this; | ||
| } | ||
| }; | ||
| var InsertOnConflict = class InsertOnConflict extends AstNode { | ||
| kind = "insert-on-conflict"; | ||
| columns; | ||
| action; | ||
| constructor(columns, action) { | ||
| super(); | ||
| this.columns = frozenArrayCopy(columns); | ||
| this.action = action; | ||
| this.freeze(); | ||
| } | ||
| static on(columns) { | ||
| return new InsertOnConflict(columns, new DoNothingConflictAction()); | ||
| } | ||
| doNothing() { | ||
| return new InsertOnConflict(this.columns, new DoNothingConflictAction()); | ||
| } | ||
| doUpdateSet(set) { | ||
| return new InsertOnConflict(this.columns, new DoUpdateSetConflictAction(set)); | ||
| } | ||
| }; | ||
| var InsertAst = class InsertAst extends QueryAst { | ||
| kind = "insert"; | ||
| table; | ||
| rows; | ||
| onConflict; | ||
| returning; | ||
| constructor(table, rows = [{}], onConflict, returning) { | ||
| super(); | ||
| this.table = table; | ||
| this.rows = freezeRows(rows); | ||
| this.onConflict = onConflict; | ||
| this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static into(table) { | ||
| return new InsertAst(table); | ||
| } | ||
| withRows(rows) { | ||
| return new InsertAst(this.table, rows.map((row) => ({ ...row })), this.onConflict, this.returning); | ||
| } | ||
| withReturning(returning) { | ||
| return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), this.onConflict, returning); | ||
| } | ||
| withOnConflict(onConflict) { | ||
| return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), onConflict, this.returning); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new InsertAst(rewriteTableSource(this.table, rewriter), this.rows.map((row) => rewriteInsertRow(row, rewriter)), this.onConflict ? rewriteOnConflict(this.onConflict, rewriter) : void 0, this.returning?.map((item) => rewriteProjectionItem(item, rewriter))); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| for (const row of this.rows) for (const value of Object.values(row)) if (value.kind === "param-ref" || value.kind === "prepared-param-ref") refs.push(value); | ||
| else if (value.kind === "raw-expr") refs.push(...value.collectParamRefs()); | ||
| if (this.onConflict?.action.kind === "do-update-set") { | ||
| for (const value of Object.values(this.onConflict.action.set)) if (value.kind === "param-ref" || value.kind === "prepared-param-ref") refs.push(value); | ||
| } | ||
| for (const item of this.returning ?? []) if (item.expr.kind !== "literal") refs.push(...item.expr.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| var UpdateAst = class UpdateAst extends QueryAst { | ||
| kind = "update"; | ||
| table; | ||
| set; | ||
| where; | ||
| returning; | ||
| constructor(table, set = {}, where, returning) { | ||
| super(); | ||
| this.table = table; | ||
| this.set = frozenRecordCopy(set); | ||
| this.where = where; | ||
| this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static table(table) { | ||
| return new UpdateAst(table); | ||
| } | ||
| withSet(set) { | ||
| return new UpdateAst(this.table, set, this.where, this.returning); | ||
| } | ||
| withWhere(where) { | ||
| return new UpdateAst(this.table, this.set, where, this.returning); | ||
| } | ||
| withReturning(returning) { | ||
| return new UpdateAst(this.table, this.set, this.where, returning); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new UpdateAst(rewriteTableSource(this.table, rewriter), rewriteUpdateSet(this.set, rewriter), this.where?.rewrite(rewriter), this.returning?.map((item) => rewriteProjectionItem(item, rewriter))); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| for (const value of Object.values(this.set)) refs.push(...value.collectParamRefs()); | ||
| if (this.where) refs.push(...this.where.collectParamRefs()); | ||
| for (const item of this.returning ?? []) if (item.expr.kind !== "literal") refs.push(...item.expr.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| var DeleteAst = class DeleteAst extends QueryAst { | ||
| kind = "delete"; | ||
| table; | ||
| where; | ||
| returning; | ||
| constructor(table, where, returning) { | ||
| super(); | ||
| this.table = table; | ||
| this.where = where; | ||
| this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static from(table) { | ||
| return new DeleteAst(table); | ||
| } | ||
| withWhere(where) { | ||
| return new DeleteAst(this.table, where, this.returning); | ||
| } | ||
| withReturning(returning) { | ||
| return new DeleteAst(this.table, this.where, returning); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new DeleteAst(rewriteTableSource(this.table, rewriter), this.where?.rewrite(rewriter), this.returning?.map((item) => rewriteProjectionItem(item, rewriter))); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| if (this.where) refs.push(...this.where.collectParamRefs()); | ||
| for (const item of this.returning ?? []) if (item.expr.kind !== "literal") refs.push(...item.expr.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| /** | ||
| * Raw-SQL query AST node carrying interpolated parameter / expression nodes | ||
| * embedded inside literal SQL fragments. | ||
| * | ||
| * `fragments` and `args` are interleaved during lowering: | ||
| * `fragments[0] + lower(args[0]) + fragments[1] + ... + fragments[n]`. | ||
| * Construction enforces `fragments.length === args.length + 1`. | ||
| * | ||
| * Extends {@link QueryAst} (whole-query AST, not a sub-expression). | ||
| * Construction does not validate that each arg is a `ParamRef` / | ||
| * `AnyExpression`: the type system already rejects bare values because | ||
| * `args` is typed `readonly AnyExpression[]`. The user-facing `raw\`...\`` | ||
| * factory (separate `sql-raw-factory` component) layers stricter | ||
| * type-level rejection on top of this AST node. | ||
| */ | ||
| var RawSqlExpr = class RawSqlExpr extends QueryAst { | ||
| kind = "raw-sql"; | ||
| fragments; | ||
| args; | ||
| constructor(fragments, args) { | ||
| super(); | ||
| if (fragments.length !== args.length + 1) throw new Error(`RawSqlExpr: fragments.length must equal args.length + 1 (got fragments=${fragments.length}, args=${args.length})`); | ||
| this.fragments = Object.freeze([...fragments]); | ||
| this.args = Object.freeze([...args]); | ||
| this.freeze(); | ||
| } | ||
| static of(fragments, args) { | ||
| return new RawSqlExpr(fragments, args); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| for (const arg of this.args) if (arg.kind === "param-ref") refs.push(arg); | ||
| else refs.push(...arg.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| const queryAstKinds = /* @__PURE__ */ new Set([ | ||
| "select", | ||
| "insert", | ||
| "update", | ||
| "delete", | ||
| "raw-sql" | ||
| ]); | ||
| const whereExprKinds = /* @__PURE__ */ new Set([ | ||
| "binary", | ||
| "and", | ||
| "or", | ||
| "exists", | ||
| "null-check", | ||
| "not" | ||
| ]); | ||
| function isQueryAst(value) { | ||
| return typeof value === "object" && value !== null && "kind" in value && typeof value.kind === "string" && queryAstKinds.has(value.kind); | ||
| } | ||
| function isWhereExpr(value) { | ||
| return typeof value === "object" && value !== null && "kind" in value && typeof value.kind === "string" && whereExprKinds.has(value.kind); | ||
| } | ||
| //#endregion | ||
| export { PreparedParamRef as A, isWhereExpr as B, LiteralExpr as C, OrExpr as D, OperationExpr as E, SubqueryExpr as F, whereExprKinds as H, TableSource as I, UpdateAst as L, RawExpr as M, RawSqlExpr as N, OrderByItem as O, SelectAst as P, WindowFuncExpr as R, ListExpression as S, NullCheckExpr as T, frozenCodecRef as U, queryAstKinds as V, InsertAst as _, CastExpr as a, JsonArrayAggExpr as b, DeleteAst as c, DoUpdateSetConflictAction as d, EqColJoinOn as f, IdentifierRef as g, FunctionSource as h, CaseExpr as i, ProjectionItem as j, ParamRef as k, DerivedTableSource as l, FunctionCallExpr as m, AndExpr as n, ColumnRef as o, ExistsExpr as p, BinaryExpr as r, DefaultValueExpr as s, AggregateExpr as t, DoNothingConflictAction as u, InsertOnConflict as v, NotExpr as w, JsonObjectExpr as x, JoinAst as y, isQueryAst as z }; | ||
| //# sourceMappingURL=types-DpAvAX8u.mjs.map |
Sorry, the diff of this file is too big to display
| import { type CodecRef, frozenCodecRef } from './codec-types'; | ||
| import type { | ||
| AnyParamRef, | ||
| ColumnRef, | ||
| ExpressionFolder, | ||
| ExpressionRewriter, | ||
| ProjectionExpr, | ||
| } from './types'; | ||
| abstract class JsonValueProjection { | ||
| abstract readonly kind: string; | ||
| readonly value: ProjectionExpr; | ||
| protected constructor(value: ProjectionExpr) { | ||
| this.value = value; | ||
| } | ||
| abstract accept<R>(visitor: JsonValueProjectionVisitor<R>): R; | ||
| abstract rewrite(rewriter: ExpressionRewriter): AnyJsonValueProjection; | ||
| fold<T>(folder: ExpressionFolder<T>): T { | ||
| return this.value.fold(folder); | ||
| } | ||
| collectColumnRefs(): ColumnRef[] { | ||
| return this.value.collectColumnRefs(); | ||
| } | ||
| collectParamRefs(): AnyParamRef[] { | ||
| return this.value.collectParamRefs(); | ||
| } | ||
| protected freeze(): void { | ||
| Object.freeze(this); | ||
| } | ||
| } | ||
| export interface JsonValueProjectionVisitor<R> { | ||
| codec(projection: CodecJsonValueProjection): R; | ||
| native(projection: NativeJsonValueProjection): R; | ||
| document(projection: JsonDocumentProjection): R; | ||
| } | ||
| export class CodecJsonValueProjection extends JsonValueProjection { | ||
| readonly kind = 'codec' as const; | ||
| readonly codec: CodecRef; | ||
| constructor(value: ProjectionExpr, codec: CodecRef) { | ||
| super(value); | ||
| this.codec = frozenCodecRef(codec); | ||
| this.freeze(); | ||
| } | ||
| override accept<R>(visitor: JsonValueProjectionVisitor<R>): R { | ||
| return visitor.codec(this); | ||
| } | ||
| override rewrite(rewriter: ExpressionRewriter): CodecJsonValueProjection { | ||
| return new CodecJsonValueProjection(this.value.rewrite(rewriter), this.codec); | ||
| } | ||
| } | ||
| export class NativeJsonValueProjection extends JsonValueProjection { | ||
| readonly kind = 'native' as const; | ||
| constructor(value: ProjectionExpr) { | ||
| super(value); | ||
| this.freeze(); | ||
| } | ||
| override accept<R>(visitor: JsonValueProjectionVisitor<R>): R { | ||
| return visitor.native(this); | ||
| } | ||
| override rewrite(rewriter: ExpressionRewriter): NativeJsonValueProjection { | ||
| return new NativeJsonValueProjection(this.value.rewrite(rewriter)); | ||
| } | ||
| } | ||
| export class JsonDocumentProjection extends JsonValueProjection { | ||
| readonly kind = 'document' as const; | ||
| constructor(value: ProjectionExpr) { | ||
| super(value); | ||
| this.freeze(); | ||
| } | ||
| override accept<R>(visitor: JsonValueProjectionVisitor<R>): R { | ||
| return visitor.document(this); | ||
| } | ||
| override rewrite(rewriter: ExpressionRewriter): JsonDocumentProjection { | ||
| return new JsonDocumentProjection(this.value.rewrite(rewriter)); | ||
| } | ||
| } | ||
| export type AnyJsonValueProjection = | ||
| | CodecJsonValueProjection | ||
| | NativeJsonValueProjection | ||
| | JsonDocumentProjection; |
@@ -1,4 +0,4 @@ | ||
| import { a as CodecMeta, c as ContractCodecRegistry, d as DescriptorCodecTraits, f as ExtractCodecTypes, h as SqlColumnRef, i as CodecDescriptor, l as DescriptorCodecId, m as SqlCodecInstanceContext, n as Codec, o as CodecRef, p as SqlCodecCallContext, r as CodecCallContext, s as CodecTrait, t as AnyCodecDescriptor, u as DescriptorCodecInput } from "../codec-types-C8vFGWij.mjs"; | ||
| import { $ as RawExpr, A as IdentifierRef, B as ListExpression, C as EqColJoinOn, D as ExpressionRewriter, E as ExpressionFolder, F as JoinOnExpr, G as NullCheckExpr, H as LoweredParam, I as JsonArrayAggExpr, J as OrderByItem, K as OperationExpr, L as JsonObjectEntry, M as InsertOnConflict, N as InsertValue, O as ExpressionSource, P as JoinAst, Q as ProjectionItem, R as JsonObjectExpr, S as DoUpdateSetConflictAction, T as ExprVisitor, U as LoweredStatement, V as LiteralExpr, W as NotExpr, X as PreparedParamRef, Y as ParamRef, Z as ProjectionExpr, _ as DefaultValueExpr, a as AndExpr, at as TableRef, b as Direction, c as AnyInsertOnConflictAction, ct as UpdateAst, d as AnyParamRef, dt as WindowFuncExpr, et as RawSqlExpr, f as AnyQueryAst, ft as isQueryAst, g as ColumnRef, h as BinaryOp, ht as whereExprKinds, i as AggregateOpFn, it as SubqueryExpr, j as InsertAst, k as FunctionSource, l as AnyInsertValue, lt as WhereArg, m as BinaryExpr, mt as queryAstKinds, n as AggregateExpr, nt as SelectAst, o as AnyExpression, ot as TableSource, p as AstRewriter, pt as isWhereExpr, q as OrExpr, r as AggregateFn, rt as SelectAstOptions, s as AnyFromSource, st as ToWhereExpr, t as AggregateCountFn, tt as RawSqlLiteral, u as AnyOperationArg, ut as WindowFn, v as DeleteAst, w as ExistsExpr, x as DoNothingConflictAction, y as DerivedTableSource, z as LimitOffsetValue } from "../types-Dr3jep6j.mjs"; | ||
| import { a as DdlColumnDefaultVisitor, c as DdlTableConstraint, d as LiteralColumnDefault, f as PrimaryKeyConstraint, i as DdlColumnDefault, l as ForeignKeyConstraint, m as isDdlNode, n as CheckExpressionConstraint, o as DdlColumnRenderContext, p as UniqueConstraint, r as DdlColumn, s as DdlNode, t as AnyDdlColumnDefault, u as FunctionColumnDefault } from "../ddl-types-DzaZCtFT.mjs"; | ||
| import { a as CodecMeta, c as ContractCodecRegistry, d as DescriptorCodecTraits, f as ExtractCodecTypes, g as frozenCodecRef, h as SqlColumnRef, i as CodecDescriptor, l as DescriptorCodecId, m as SqlCodecInstanceContext, n as Codec, o as CodecRef, p as SqlCodecCallContext, r as CodecCallContext, s as CodecTrait, t as AnyCodecDescriptor, u as DescriptorCodecInput } from "../codec-types-Bayoa4PI.mjs"; | ||
| import { $ as OrderByItem, A as ExpressionRewriter, B as JoinOnExpr, C as Direction, Ct as JsonDocumentProjection, D as ExistsExpr, E as EqColJoinOn, F as IdentifierRef, G as ListExpression, H as JsonObjectEntry, I as InsertAst, J as LoweredStatement, K as LiteralExpr, L as InsertOnConflict, M as FunctionCallExpr, N as FunctionSource, O as ExprVisitor, P as FunctionSourceAlias, Q as OrExpr, R as InsertValue, S as DerivedTableSource, St as CodecJsonValueProjection, T as DoUpdateSetConflictAction, Tt as NativeJsonValueProjection, U as JsonObjectExpr, V as JsonArrayAggExpr, W as LimitOffsetValue, X as NullCheckExpr, Y as NotExpr, Z as OperationExpr, _ as CaseExpr, _t as isQueryAst, a as AndExpr, at as RawSqlExpr, b as DefaultValueExpr, bt as whereExprKinds, c as AnyInsertOnConflictAction, ct as SelectAstOptions, d as AnyParamRef, dt as TableSource, et as ParamRef, f as AnyQueryAst, ft as ToWhereExpr, g as CaseBranch, gt as WindowFuncExpr, h as BinaryOp, ht as WindowFn, i as AggregateOpFn, it as RawExpr, j as ExpressionSource, k as ExpressionFolder, l as AnyInsertValue, lt as SubqueryExpr, m as BinaryExpr, mt as WhereArg, n as AggregateExpr, nt as ProjectionExpr, o as AnyExpression, ot as RawSqlLiteral, p as AstRewriter, pt as UpdateAst, q as LoweredParam, r as AggregateFn, rt as ProjectionItem, s as AnyFromSource, st as SelectAst, t as AggregateCountFn, tt as PreparedParamRef, u as AnyOperationArg, ut as TableRef, v as CastExpr, vt as isWhereExpr, w as DoNothingConflictAction, wt as JsonValueProjectionVisitor, x as DeleteAst, xt as AnyJsonValueProjection, y as ColumnRef, yt as queryAstKinds, z as JoinAst } from "../types-CWlaErjN.mjs"; | ||
| import { a as DdlColumnDefaultVisitor, c as DdlTableConstraint, d as LiteralColumnDefault, f as PrimaryKeyConstraint, i as DdlColumnDefault, l as ForeignKeyConstraint, m as isDdlNode, n as CheckExpressionConstraint, o as DdlColumnRenderContext, p as UniqueConstraint, r as DdlColumn, s as DdlNode, t as AnyDdlColumnDefault, u as FunctionColumnDefault } from "../ddl-types-B3SfjPGI.mjs"; | ||
| import { ContractMarkerRecord, JsonValue } from "@prisma-next/contract/types"; | ||
@@ -272,3 +272,3 @@ import { CodecCallContext as CodecCallContext$1, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec"; | ||
| //#endregion | ||
| export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyDdlColumnDefault, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyOperationArg, AnyParamRef, AnyQueryAst, AstRewriter, BinaryExpr, BinaryOp, CheckExpressionConstraint, Codec, type CodecCallContext, type CodecDescriptor, CodecMeta, type CodecRef, type CodecTrait, ColumnRef, ContractCodecRegistry, DdlColumn, DdlColumnDefault, DdlColumnDefaultVisitor, DdlColumnRenderContext, DdlNode, DdlTableConstraint, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ExprVisitor, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ForeignKeyConstraint, FunctionColumnDefault, FunctionSource, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonObjectEntry, JsonObjectExpr, LimitOffsetValue, ListExpression, LiteralColumnDefault, LiteralExpr, LoweredParam, LoweredStatement, Lowerer, LowererContext, MarkerReadResult, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, PreparedExecuteRequest, PreparedParamRef, PrimaryKeyConstraint, ProjectionExpr, ProjectionItem, RawExpr, RawSqlExpr, RawSqlLiteral, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SelectAstOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableRef, TableSource, ToWhereExpr, UniqueConstraint, UpdateAst, WhereArg, WindowFn, WindowFuncExpr, collectOrderedParamRefs, compact, isDdlNode, isQueryAst, isWhereExpr, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, whereExprKinds }; | ||
| export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyDdlColumnDefault, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyJsonValueProjection, AnyOperationArg, AnyParamRef, AnyQueryAst, AstRewriter, BinaryExpr, BinaryOp, CaseBranch, CaseExpr, CastExpr, CheckExpressionConstraint, Codec, type CodecCallContext, type CodecDescriptor, CodecJsonValueProjection, CodecMeta, type CodecRef, type CodecTrait, ColumnRef, ContractCodecRegistry, DdlColumn, DdlColumnDefault, DdlColumnDefaultVisitor, DdlColumnRenderContext, DdlNode, DdlTableConstraint, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ExprVisitor, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ForeignKeyConstraint, FunctionCallExpr, FunctionColumnDefault, FunctionSource, FunctionSourceAlias, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonDocumentProjection, JsonObjectEntry, JsonObjectExpr, JsonValueProjectionVisitor, LimitOffsetValue, ListExpression, LiteralColumnDefault, LiteralExpr, LoweredParam, LoweredStatement, Lowerer, LowererContext, MarkerReadResult, NativeJsonValueProjection, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, PreparedExecuteRequest, PreparedParamRef, PrimaryKeyConstraint, ProjectionExpr, ProjectionItem, RawExpr, RawSqlExpr, RawSqlLiteral, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SelectAstOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableRef, TableSource, ToWhereExpr, UniqueConstraint, UpdateAst, WhereArg, WindowFn, WindowFuncExpr, collectOrderedParamRefs, compact, frozenCodecRef, isDdlNode, isQueryAst, isWhereExpr, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, whereExprKinds }; | ||
| //# sourceMappingURL=ast.d.mts.map |
+63
-2
@@ -0,6 +1,67 @@ | ||
| import { A as PreparedParamRef, B as isWhereExpr, C as LiteralExpr, D as OrExpr, E as OperationExpr, F as SubqueryExpr, H as whereExprKinds, I as TableSource, L as UpdateAst, M as RawExpr, N as RawSqlExpr, O as OrderByItem, P as SelectAst, R as WindowFuncExpr, S as ListExpression, T as NullCheckExpr, U as frozenCodecRef, V as queryAstKinds, _ as InsertAst, a as CastExpr, b as JsonArrayAggExpr, c as DeleteAst, d as DoUpdateSetConflictAction, f as EqColJoinOn, g as IdentifierRef, h as FunctionSource, i as CaseExpr, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, m as FunctionCallExpr, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, u as DoNothingConflictAction, v as InsertOnConflict, w as NotExpr, x as JsonObjectExpr, y as JoinAst, z as isQueryAst } from "../types-DpAvAX8u.mjs"; | ||
| import { a as ForeignKeyConstraint, c as PrimaryKeyConstraint, i as DdlNode, l as UniqueConstraint, n as DdlColumn, o as FunctionColumnDefault, r as DdlColumnDefault, s as LiteralColumnDefault, t as CheckExpressionConstraint, u as isDdlNode } from "../ddl-types-DFKQr_qQ.mjs"; | ||
| import { A as RawSqlExpr, C as OperationExpr, D as PreparedParamRef, E as ParamRef, F as WindowFuncExpr, I as isQueryAst, L as isWhereExpr, M as SubqueryExpr, N as TableSource, O as ProjectionItem, P as UpdateAst, R as queryAstKinds, S as NullCheckExpr, T as OrderByItem, _ as JsonArrayAggExpr, a as DefaultValueExpr, b as LiteralExpr, c as DoNothingConflictAction, d as ExistsExpr, f as FunctionSource, g as JoinAst, h as InsertOnConflict, i as ColumnRef, j as SelectAst, k as RawExpr, l as DoUpdateSetConflictAction, m as InsertAst, n as AndExpr, o as DeleteAst, p as IdentifierRef, r as BinaryExpr, s as DerivedTableSource, t as AggregateExpr, u as EqColJoinOn, v as JsonObjectExpr, w as OrExpr, x as NotExpr, y as ListExpression, z as whereExprKinds } from "../types-DtzFztRV.mjs"; | ||
| import { n as compact, t as collectOrderedParamRefs } from "../util-DQQgv2j1.mjs"; | ||
| import { CodecDescriptorImpl, CodecImpl, column, voidParamsSchema } from "@prisma-next/framework-components/codec"; | ||
| import { type } from "arktype"; | ||
| //#region src/ast/json-value-projection.ts | ||
| var JsonValueProjection = class { | ||
| value; | ||
| constructor(value) { | ||
| this.value = value; | ||
| } | ||
| fold(folder) { | ||
| return this.value.fold(folder); | ||
| } | ||
| collectColumnRefs() { | ||
| return this.value.collectColumnRefs(); | ||
| } | ||
| collectParamRefs() { | ||
| return this.value.collectParamRefs(); | ||
| } | ||
| freeze() { | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| var CodecJsonValueProjection = class CodecJsonValueProjection extends JsonValueProjection { | ||
| kind = "codec"; | ||
| codec; | ||
| constructor(value, codec) { | ||
| super(value); | ||
| this.codec = frozenCodecRef(codec); | ||
| this.freeze(); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.codec(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new CodecJsonValueProjection(this.value.rewrite(rewriter), this.codec); | ||
| } | ||
| }; | ||
| var NativeJsonValueProjection = class NativeJsonValueProjection extends JsonValueProjection { | ||
| kind = "native"; | ||
| constructor(value) { | ||
| super(value); | ||
| this.freeze(); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.native(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new NativeJsonValueProjection(this.value.rewrite(rewriter)); | ||
| } | ||
| }; | ||
| var JsonDocumentProjection = class JsonDocumentProjection extends JsonValueProjection { | ||
| kind = "document"; | ||
| constructor(value) { | ||
| super(value); | ||
| this.freeze(); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.document(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new JsonDocumentProjection(this.value.rewrite(rewriter)); | ||
| } | ||
| }; | ||
| //#endregion | ||
| //#region src/ast/sql-codec-helpers.ts | ||
@@ -234,4 +295,4 @@ const SQL_CHAR_CODEC_ID = "sql/char@1"; | ||
| //#endregion | ||
| export { AggregateExpr, AndExpr, BinaryExpr, CheckExpressionConstraint, ColumnRef, DdlColumn, DdlColumnDefault, DdlNode, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ForeignKeyConstraint, FunctionColumnDefault, FunctionSource, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralColumnDefault, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, PreparedParamRef, PrimaryKeyConstraint, ProjectionItem, RawExpr, RawSqlExpr, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableSource, UniqueConstraint, UpdateAst, WindowFuncExpr, collectOrderedParamRefs, compact, isDdlNode, isQueryAst, isWhereExpr, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, whereExprKinds }; | ||
| export { AggregateExpr, AndExpr, BinaryExpr, CaseExpr, CastExpr, CheckExpressionConstraint, CodecJsonValueProjection, ColumnRef, DdlColumn, DdlColumnDefault, DdlNode, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ForeignKeyConstraint, FunctionCallExpr, FunctionColumnDefault, FunctionSource, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonDocumentProjection, JsonObjectExpr, ListExpression, LiteralColumnDefault, LiteralExpr, NativeJsonValueProjection, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, PreparedParamRef, PrimaryKeyConstraint, ProjectionItem, RawExpr, RawSqlExpr, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableSource, UniqueConstraint, UpdateAst, WindowFuncExpr, collectOrderedParamRefs, compact, frozenCodecRef, isDdlNode, isQueryAst, isWhereExpr, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, whereExprKinds }; | ||
| //# sourceMappingURL=ast.mjs.map |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"ast.mjs","names":["arktype"],"sources":["../../src/ast/sql-codec-helpers.ts","../../src/ast/sql-codecs.ts"],"sourcesContent":["/**\n * Shared encode/decode/render constants and codec id literals for the six SQL base codecs (`sql/char@1`, `sql/varchar@1`, `sql/int@1`, `sql/float@1`, `sql/text@1`, `sql/timestamp@1`).\n *\n * The codec implementations live in `sql-codecs.ts` (TML-2357). This module retains only the conversion helpers + emit-path renderers the codec methods compose with — keeping a single source of truth for non-trivial conversions while the codec methods provide the framework-required `Promise<…>` boundary.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\n\nexport const SQL_CHAR_CODEC_ID = 'sql/char@1' as const;\nexport const SQL_VARCHAR_CODEC_ID = 'sql/varchar@1' as const;\nexport const SQL_INT_CODEC_ID = 'sql/int@1' as const;\nexport const SQL_FLOAT_CODEC_ID = 'sql/float@1' as const;\nexport const SQL_TEXT_CODEC_ID = 'sql/text@1' as const;\nexport const SQL_TIMESTAMP_CODEC_ID = 'sql/timestamp@1' as const;\n\nexport const sqlCharEncode = (value: string): string => value;\nexport const sqlCharDecode = (wire: string): string => wire.trimEnd();\nexport const sqlCharRenderOutputType = (typeParams: { readonly length?: number }) => {\n const length = typeParams.length;\n if (length === undefined) return undefined;\n if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {\n throw new Error(\n `renderOutputType: expected integer \"length\" in typeParams for Char, got ${String(length)}`,\n );\n }\n return `Char<${length}>`;\n};\n\nexport const sqlVarcharEncode = (value: string): string => value;\nexport const sqlVarcharDecode = (wire: string): string => wire;\nexport const sqlVarcharRenderOutputType = (typeParams: { readonly length?: number }) => {\n const length = typeParams.length;\n if (length === undefined) return undefined;\n if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {\n throw new Error(\n `renderOutputType: expected integer \"length\" in typeParams for Varchar, got ${String(length)}`,\n );\n }\n return `Varchar<${length}>`;\n};\n\nexport const sqlIntEncode = (value: number): number => value;\nexport const sqlIntDecode = (wire: number): number => wire;\n\nexport const sqlFloatEncode = (value: number): number => value;\nexport const sqlFloatDecode = (wire: number): number => wire;\n\nexport const sqlTextEncode = (value: string): string => value;\nexport const sqlTextDecode = (wire: string): string => wire;\n\nexport const sqlTimestampEncode = (value: Date): Date => value;\nexport const sqlTimestampDecode = (wire: Date): Date => wire;\nexport const sqlTimestampEncodeJson = (value: Date): JsonValue => value.toISOString();\nexport const sqlTimestampDecodeJson = (json: JsonValue): Date => {\n if (typeof json !== 'string') {\n throw new Error(`Expected ISO date string for sql/timestamp@1, got ${typeof json}`);\n }\n const date = new Date(json);\n if (Number.isNaN(date.getTime())) {\n throw new Error(`Invalid ISO date string for sql/timestamp@1: ${json}`);\n }\n return date;\n};\nexport const sqlTimestampRenderOutputType = (typeParams: { readonly precision?: number }) => {\n const precision = typeParams.precision;\n if (precision === undefined) {\n return 'Timestamp';\n }\n if (\n typeof precision !== 'number' ||\n !Number.isFinite(precision) ||\n !Number.isInteger(precision)\n ) {\n throw new Error(\n `renderOutputType: expected integer \"precision\" in typeParams for Timestamp, got ${String(precision)}`,\n );\n }\n return `Timestamp<${precision}>`;\n};\n","/**\n * The six SQL base codecs (TML-2357).\n *\n * Each codec ships as three artifacts:\n *\n * 1. A `SqlXCodec` class extending {@link CodecImpl} that wraps the module-level encode/decode constants exported from `sql-codec-helpers.ts` (the single source of truth for runtime behaviour). 2. A `SqlXDescriptor` class extending {@link CodecDescriptorImpl} declaring the codec id, traits, target types, params schema, and (where applicable) the emit-path `renderOutputType`. 3. A per-codec column helper (`sqlXColumn`)\n * that calls `descriptor.factory(...)` directly and packages the result into a {@link ColumnSpec} via the framework {@link column} packager. The helper is tied to its descriptor with `satisfies ColumnHelperFor`.\n *\n * After TML-2357 this file is the canonical source of SQL base codec metadata and runtime behaviour — the legacy `mkCodec` / `defineCodec` carriers retired with the deletion sweep.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport {\n type CodecCallContext,\n CodecDescriptorImpl,\n CodecImpl,\n type CodecInstanceContext,\n type ColumnHelperFor,\n type ColumnHelperForStrict,\n column,\n voidParamsSchema,\n} from '@prisma-next/framework-components/codec';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { type as arktype } from 'arktype';\nimport {\n SQL_CHAR_CODEC_ID,\n SQL_FLOAT_CODEC_ID,\n SQL_INT_CODEC_ID,\n SQL_TEXT_CODEC_ID,\n SQL_TIMESTAMP_CODEC_ID,\n SQL_VARCHAR_CODEC_ID,\n sqlCharDecode,\n sqlCharEncode,\n sqlCharRenderOutputType,\n sqlFloatDecode,\n sqlFloatEncode,\n sqlIntDecode,\n sqlIntEncode,\n sqlTextDecode,\n sqlTextEncode,\n sqlTimestampDecode,\n sqlTimestampDecodeJson,\n sqlTimestampEncode,\n sqlTimestampEncodeJson,\n sqlTimestampRenderOutputType,\n sqlVarcharDecode,\n sqlVarcharEncode,\n sqlVarcharRenderOutputType,\n} from './sql-codec-helpers';\n\ntype LengthParams = { readonly length?: number };\ntype PrecisionParams = { readonly precision?: number };\n\nconst lengthParamsSchema = arktype({\n 'length?': 'number.integer > 0',\n}) satisfies StandardSchemaV1<LengthParams>;\n\nconst precisionParamsSchema = arktype({\n 'precision?': 'number.integer >= 0 & number.integer <= 6',\n}) satisfies StandardSchemaV1<PrecisionParams>;\n\nexport class SqlTextCodec extends CodecImpl<\n typeof SQL_TEXT_CODEC_ID,\n readonly ['equality', 'order', 'textual'],\n string,\n string\n> {\n async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n return sqlTextEncode(value);\n }\n async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n return sqlTextDecode(wire);\n }\n encodeJson(value: string): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): string {\n return json as string;\n }\n}\n\nexport class SqlTextDescriptor extends CodecDescriptorImpl<void> {\n override readonly codecId = SQL_TEXT_CODEC_ID;\n override readonly traits = ['equality', 'order', 'textual'] as const;\n override readonly targetTypes = ['text'] as const;\n override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n override factory(): (ctx: CodecInstanceContext) => SqlTextCodec {\n return () => new SqlTextCodec(this);\n }\n}\n\nexport const sqlTextDescriptor = new SqlTextDescriptor();\n\nexport const sqlTextColumn = () =>\n column(sqlTextDescriptor.factory(), sqlTextDescriptor.codecId, undefined, 'text');\n\nsqlTextColumn satisfies ColumnHelperFor<SqlTextDescriptor>;\nsqlTextColumn satisfies ColumnHelperForStrict<SqlTextDescriptor>;\n\nexport class SqlIntCodec extends CodecImpl<\n typeof SQL_INT_CODEC_ID,\n readonly ['equality', 'order', 'numeric'],\n number,\n number\n> {\n async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n return sqlIntEncode(value);\n }\n async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n return sqlIntDecode(wire);\n }\n encodeJson(value: number): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): number {\n return json as number;\n }\n}\n\nexport class SqlIntDescriptor extends CodecDescriptorImpl<void> {\n override readonly codecId = SQL_INT_CODEC_ID;\n override readonly traits = ['equality', 'order', 'numeric'] as const;\n override readonly targetTypes = ['int'] as const;\n override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n override factory(): (ctx: CodecInstanceContext) => SqlIntCodec {\n return () => new SqlIntCodec(this);\n }\n}\n\nexport const sqlIntDescriptor = new SqlIntDescriptor();\n\nexport const sqlIntColumn = () =>\n column(sqlIntDescriptor.factory(), sqlIntDescriptor.codecId, undefined, 'int');\n\nsqlIntColumn satisfies ColumnHelperFor<SqlIntDescriptor>;\nsqlIntColumn satisfies ColumnHelperForStrict<SqlIntDescriptor>;\n\nexport class SqlFloatCodec extends CodecImpl<\n typeof SQL_FLOAT_CODEC_ID,\n readonly ['equality', 'order', 'numeric'],\n number,\n number\n> {\n async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n return sqlFloatEncode(value);\n }\n async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n return sqlFloatDecode(wire);\n }\n encodeJson(value: number): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): number {\n return json as number;\n }\n}\n\nexport class SqlFloatDescriptor extends CodecDescriptorImpl<void> {\n override readonly codecId = SQL_FLOAT_CODEC_ID;\n override readonly traits = ['equality', 'order', 'numeric'] as const;\n override readonly targetTypes = ['float'] as const;\n override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n override factory(): (ctx: CodecInstanceContext) => SqlFloatCodec {\n return () => new SqlFloatCodec(this);\n }\n}\n\nexport const sqlFloatDescriptor = new SqlFloatDescriptor();\n\nexport const sqlFloatColumn = () =>\n column(sqlFloatDescriptor.factory(), sqlFloatDescriptor.codecId, undefined, 'float');\n\nsqlFloatColumn satisfies ColumnHelperFor<SqlFloatDescriptor>;\nsqlFloatColumn satisfies ColumnHelperForStrict<SqlFloatDescriptor>;\n\nexport class SqlCharCodec extends CodecImpl<\n typeof SQL_CHAR_CODEC_ID,\n readonly ['equality', 'order', 'textual'],\n string,\n string\n> {\n async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n return sqlCharEncode(value);\n }\n async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n return sqlCharDecode(wire);\n }\n encodeJson(value: string): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): string {\n return json as string;\n }\n}\n\nexport class SqlCharDescriptor extends CodecDescriptorImpl<LengthParams> {\n override readonly codecId = SQL_CHAR_CODEC_ID;\n override readonly traits = ['equality', 'order', 'textual'] as const;\n override readonly targetTypes = ['char'] as const;\n override readonly paramsSchema: StandardSchemaV1<LengthParams> = lengthParamsSchema;\n override renderOutputType(params: LengthParams): string | undefined {\n return sqlCharRenderOutputType(params);\n }\n override factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlCharCodec {\n return () => new SqlCharCodec(this);\n }\n}\n\nexport const sqlCharDescriptor = new SqlCharDescriptor();\n\nexport const sqlCharColumn = (params: LengthParams = {}) =>\n column(sqlCharDescriptor.factory(params), sqlCharDescriptor.codecId, params, 'char');\n\nsqlCharColumn satisfies ColumnHelperFor<SqlCharDescriptor>;\nsqlCharColumn satisfies ColumnHelperForStrict<SqlCharDescriptor>;\n\nexport class SqlVarcharCodec extends CodecImpl<\n typeof SQL_VARCHAR_CODEC_ID,\n readonly ['equality', 'order', 'textual'],\n string,\n string\n> {\n async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n return sqlVarcharEncode(value);\n }\n async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n return sqlVarcharDecode(wire);\n }\n encodeJson(value: string): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): string {\n return json as string;\n }\n}\n\nexport class SqlVarcharDescriptor extends CodecDescriptorImpl<LengthParams> {\n override readonly codecId = SQL_VARCHAR_CODEC_ID;\n override readonly traits = ['equality', 'order', 'textual'] as const;\n override readonly targetTypes = ['varchar'] as const;\n override readonly paramsSchema: StandardSchemaV1<LengthParams> = lengthParamsSchema;\n override renderOutputType(params: LengthParams): string | undefined {\n return sqlVarcharRenderOutputType(params);\n }\n override factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlVarcharCodec {\n return () => new SqlVarcharCodec(this);\n }\n}\n\nexport const sqlVarcharDescriptor = new SqlVarcharDescriptor();\n\nexport const sqlVarcharColumn = (params: LengthParams = {}) =>\n column(sqlVarcharDescriptor.factory(params), sqlVarcharDescriptor.codecId, params, 'varchar');\n\nsqlVarcharColumn satisfies ColumnHelperFor<SqlVarcharDescriptor>;\nsqlVarcharColumn satisfies ColumnHelperForStrict<SqlVarcharDescriptor>;\n\nexport class SqlTimestampCodec extends CodecImpl<\n typeof SQL_TIMESTAMP_CODEC_ID,\n readonly ['equality', 'order'],\n Date,\n Date\n> {\n async encode(value: Date, _ctx: CodecCallContext): Promise<Date> {\n return sqlTimestampEncode(value);\n }\n async decode(wire: Date, _ctx: CodecCallContext): Promise<Date> {\n return sqlTimestampDecode(wire);\n }\n encodeJson(value: Date): JsonValue {\n return sqlTimestampEncodeJson(value);\n }\n decodeJson(json: JsonValue): Date {\n return sqlTimestampDecodeJson(json);\n }\n}\n\nexport class SqlTimestampDescriptor extends CodecDescriptorImpl<PrecisionParams> {\n override readonly codecId = SQL_TIMESTAMP_CODEC_ID;\n override readonly traits = ['equality', 'order'] as const;\n override readonly targetTypes = ['timestamp'] as const;\n override readonly paramsSchema: StandardSchemaV1<PrecisionParams> = precisionParamsSchema;\n override renderOutputType(params: PrecisionParams): string | undefined {\n return sqlTimestampRenderOutputType(params);\n }\n override factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => SqlTimestampCodec {\n return () => new SqlTimestampCodec(this);\n }\n}\n\nexport const sqlTimestampDescriptor = new SqlTimestampDescriptor();\n\nexport const sqlTimestampColumn = (params: PrecisionParams = {}) =>\n column(\n sqlTimestampDescriptor.factory(params),\n sqlTimestampDescriptor.codecId,\n params,\n 'timestamp',\n );\n\nsqlTimestampColumn satisfies ColumnHelperFor<SqlTimestampDescriptor>;\nsqlTimestampColumn satisfies ColumnHelperForStrict<SqlTimestampDescriptor>;\n"],"mappings":"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"} | ||
| {"version":3,"file":"ast.mjs","names":["arktype"],"sources":["../../src/ast/json-value-projection.ts","../../src/ast/sql-codec-helpers.ts","../../src/ast/sql-codecs.ts"],"sourcesContent":["import { type CodecRef, frozenCodecRef } from './codec-types';\nimport type {\n AnyParamRef,\n ColumnRef,\n ExpressionFolder,\n ExpressionRewriter,\n ProjectionExpr,\n} from './types';\n\nabstract class JsonValueProjection {\n abstract readonly kind: string;\n readonly value: ProjectionExpr;\n\n protected constructor(value: ProjectionExpr) {\n this.value = value;\n }\n\n abstract accept<R>(visitor: JsonValueProjectionVisitor<R>): R;\n abstract rewrite(rewriter: ExpressionRewriter): AnyJsonValueProjection;\n\n fold<T>(folder: ExpressionFolder<T>): T {\n return this.value.fold(folder);\n }\n\n collectColumnRefs(): ColumnRef[] {\n return this.value.collectColumnRefs();\n }\n\n collectParamRefs(): AnyParamRef[] {\n return this.value.collectParamRefs();\n }\n\n protected freeze(): void {\n Object.freeze(this);\n }\n}\n\nexport interface JsonValueProjectionVisitor<R> {\n codec(projection: CodecJsonValueProjection): R;\n native(projection: NativeJsonValueProjection): R;\n document(projection: JsonDocumentProjection): R;\n}\n\nexport class CodecJsonValueProjection extends JsonValueProjection {\n readonly kind = 'codec' as const;\n readonly codec: CodecRef;\n\n constructor(value: ProjectionExpr, codec: CodecRef) {\n super(value);\n this.codec = frozenCodecRef(codec);\n this.freeze();\n }\n\n override accept<R>(visitor: JsonValueProjectionVisitor<R>): R {\n return visitor.codec(this);\n }\n\n override rewrite(rewriter: ExpressionRewriter): CodecJsonValueProjection {\n return new CodecJsonValueProjection(this.value.rewrite(rewriter), this.codec);\n }\n}\n\nexport class NativeJsonValueProjection extends JsonValueProjection {\n readonly kind = 'native' as const;\n\n constructor(value: ProjectionExpr) {\n super(value);\n this.freeze();\n }\n\n override accept<R>(visitor: JsonValueProjectionVisitor<R>): R {\n return visitor.native(this);\n }\n\n override rewrite(rewriter: ExpressionRewriter): NativeJsonValueProjection {\n return new NativeJsonValueProjection(this.value.rewrite(rewriter));\n }\n}\n\nexport class JsonDocumentProjection extends JsonValueProjection {\n readonly kind = 'document' as const;\n\n constructor(value: ProjectionExpr) {\n super(value);\n this.freeze();\n }\n\n override accept<R>(visitor: JsonValueProjectionVisitor<R>): R {\n return visitor.document(this);\n }\n\n override rewrite(rewriter: ExpressionRewriter): JsonDocumentProjection {\n return new JsonDocumentProjection(this.value.rewrite(rewriter));\n }\n}\n\nexport type AnyJsonValueProjection =\n | CodecJsonValueProjection\n | NativeJsonValueProjection\n | JsonDocumentProjection;\n","/**\n * Shared encode/decode/render constants and codec id literals for the six SQL base codecs (`sql/char@1`, `sql/varchar@1`, `sql/int@1`, `sql/float@1`, `sql/text@1`, `sql/timestamp@1`).\n *\n * The codec implementations live in `sql-codecs.ts` (TML-2357). This module retains only the conversion helpers + emit-path renderers the codec methods compose with — keeping a single source of truth for non-trivial conversions while the codec methods provide the framework-required `Promise<…>` boundary.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\n\nexport const SQL_CHAR_CODEC_ID = 'sql/char@1' as const;\nexport const SQL_VARCHAR_CODEC_ID = 'sql/varchar@1' as const;\nexport const SQL_INT_CODEC_ID = 'sql/int@1' as const;\nexport const SQL_FLOAT_CODEC_ID = 'sql/float@1' as const;\nexport const SQL_TEXT_CODEC_ID = 'sql/text@1' as const;\nexport const SQL_TIMESTAMP_CODEC_ID = 'sql/timestamp@1' as const;\n\nexport const sqlCharEncode = (value: string): string => value;\nexport const sqlCharDecode = (wire: string): string => wire.trimEnd();\nexport const sqlCharRenderOutputType = (typeParams: { readonly length?: number }) => {\n const length = typeParams.length;\n if (length === undefined) return undefined;\n if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {\n throw new Error(\n `renderOutputType: expected integer \"length\" in typeParams for Char, got ${String(length)}`,\n );\n }\n return `Char<${length}>`;\n};\n\nexport const sqlVarcharEncode = (value: string): string => value;\nexport const sqlVarcharDecode = (wire: string): string => wire;\nexport const sqlVarcharRenderOutputType = (typeParams: { readonly length?: number }) => {\n const length = typeParams.length;\n if (length === undefined) return undefined;\n if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {\n throw new Error(\n `renderOutputType: expected integer \"length\" in typeParams for Varchar, got ${String(length)}`,\n );\n }\n return `Varchar<${length}>`;\n};\n\nexport const sqlIntEncode = (value: number): number => value;\nexport const sqlIntDecode = (wire: number): number => wire;\n\nexport const sqlFloatEncode = (value: number): number => value;\nexport const sqlFloatDecode = (wire: number): number => wire;\n\nexport const sqlTextEncode = (value: string): string => value;\nexport const sqlTextDecode = (wire: string): string => wire;\n\nexport const sqlTimestampEncode = (value: Date): Date => value;\nexport const sqlTimestampDecode = (wire: Date): Date => wire;\nexport const sqlTimestampEncodeJson = (value: Date): JsonValue => value.toISOString();\nexport const sqlTimestampDecodeJson = (json: JsonValue): Date => {\n if (typeof json !== 'string') {\n throw new Error(`Expected ISO date string for sql/timestamp@1, got ${typeof json}`);\n }\n const date = new Date(json);\n if (Number.isNaN(date.getTime())) {\n throw new Error(`Invalid ISO date string for sql/timestamp@1: ${json}`);\n }\n return date;\n};\nexport const sqlTimestampRenderOutputType = (typeParams: { readonly precision?: number }) => {\n const precision = typeParams.precision;\n if (precision === undefined) {\n return 'Timestamp';\n }\n if (\n typeof precision !== 'number' ||\n !Number.isFinite(precision) ||\n !Number.isInteger(precision)\n ) {\n throw new Error(\n `renderOutputType: expected integer \"precision\" in typeParams for Timestamp, got ${String(precision)}`,\n );\n }\n return `Timestamp<${precision}>`;\n};\n","/**\n * The six SQL base codecs (TML-2357).\n *\n * Each codec ships as three artifacts:\n *\n * 1. A `SqlXCodec` class extending {@link CodecImpl} that wraps the module-level encode/decode constants exported from `sql-codec-helpers.ts` (the single source of truth for runtime behaviour). 2. A `SqlXDescriptor` class extending {@link CodecDescriptorImpl} declaring the codec id, traits, target types, params schema, and (where applicable) the emit-path `renderOutputType`. 3. A per-codec column helper (`sqlXColumn`)\n * that calls `descriptor.factory(...)` directly and packages the result into a {@link ColumnSpec} via the framework {@link column} packager. The helper is tied to its descriptor with `satisfies ColumnHelperFor`.\n *\n * After TML-2357 this file is the canonical source of SQL base codec metadata and runtime behaviour — the legacy `mkCodec` / `defineCodec` carriers retired with the deletion sweep.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport {\n type CodecCallContext,\n CodecDescriptorImpl,\n CodecImpl,\n type CodecInstanceContext,\n type ColumnHelperFor,\n type ColumnHelperForStrict,\n column,\n voidParamsSchema,\n} from '@prisma-next/framework-components/codec';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { type as arktype } from 'arktype';\nimport {\n SQL_CHAR_CODEC_ID,\n SQL_FLOAT_CODEC_ID,\n SQL_INT_CODEC_ID,\n SQL_TEXT_CODEC_ID,\n SQL_TIMESTAMP_CODEC_ID,\n SQL_VARCHAR_CODEC_ID,\n sqlCharDecode,\n sqlCharEncode,\n sqlCharRenderOutputType,\n sqlFloatDecode,\n sqlFloatEncode,\n sqlIntDecode,\n sqlIntEncode,\n sqlTextDecode,\n sqlTextEncode,\n sqlTimestampDecode,\n sqlTimestampDecodeJson,\n sqlTimestampEncode,\n sqlTimestampEncodeJson,\n sqlTimestampRenderOutputType,\n sqlVarcharDecode,\n sqlVarcharEncode,\n sqlVarcharRenderOutputType,\n} from './sql-codec-helpers';\n\ntype LengthParams = { readonly length?: number };\ntype PrecisionParams = { readonly precision?: number };\n\nconst lengthParamsSchema = arktype({\n 'length?': 'number.integer > 0',\n}) satisfies StandardSchemaV1<LengthParams>;\n\nconst precisionParamsSchema = arktype({\n 'precision?': 'number.integer >= 0 & number.integer <= 6',\n}) satisfies StandardSchemaV1<PrecisionParams>;\n\nexport class SqlTextCodec extends CodecImpl<\n typeof SQL_TEXT_CODEC_ID,\n readonly ['equality', 'order', 'textual'],\n string,\n string\n> {\n async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n return sqlTextEncode(value);\n }\n async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n return sqlTextDecode(wire);\n }\n encodeJson(value: string): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): string {\n return json as string;\n }\n}\n\nexport class SqlTextDescriptor extends CodecDescriptorImpl<void> {\n override readonly codecId = SQL_TEXT_CODEC_ID;\n override readonly traits = ['equality', 'order', 'textual'] as const;\n override readonly targetTypes = ['text'] as const;\n override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n override factory(): (ctx: CodecInstanceContext) => SqlTextCodec {\n return () => new SqlTextCodec(this);\n }\n}\n\nexport const sqlTextDescriptor = new SqlTextDescriptor();\n\nexport const sqlTextColumn = () =>\n column(sqlTextDescriptor.factory(), sqlTextDescriptor.codecId, undefined, 'text');\n\nsqlTextColumn satisfies ColumnHelperFor<SqlTextDescriptor>;\nsqlTextColumn satisfies ColumnHelperForStrict<SqlTextDescriptor>;\n\nexport class SqlIntCodec extends CodecImpl<\n typeof SQL_INT_CODEC_ID,\n readonly ['equality', 'order', 'numeric'],\n number,\n number\n> {\n async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n return sqlIntEncode(value);\n }\n async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n return sqlIntDecode(wire);\n }\n encodeJson(value: number): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): number {\n return json as number;\n }\n}\n\nexport class SqlIntDescriptor extends CodecDescriptorImpl<void> {\n override readonly codecId = SQL_INT_CODEC_ID;\n override readonly traits = ['equality', 'order', 'numeric'] as const;\n override readonly targetTypes = ['int'] as const;\n override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n override factory(): (ctx: CodecInstanceContext) => SqlIntCodec {\n return () => new SqlIntCodec(this);\n }\n}\n\nexport const sqlIntDescriptor = new SqlIntDescriptor();\n\nexport const sqlIntColumn = () =>\n column(sqlIntDescriptor.factory(), sqlIntDescriptor.codecId, undefined, 'int');\n\nsqlIntColumn satisfies ColumnHelperFor<SqlIntDescriptor>;\nsqlIntColumn satisfies ColumnHelperForStrict<SqlIntDescriptor>;\n\nexport class SqlFloatCodec extends CodecImpl<\n typeof SQL_FLOAT_CODEC_ID,\n readonly ['equality', 'order', 'numeric'],\n number,\n number\n> {\n async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n return sqlFloatEncode(value);\n }\n async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n return sqlFloatDecode(wire);\n }\n encodeJson(value: number): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): number {\n return json as number;\n }\n}\n\nexport class SqlFloatDescriptor extends CodecDescriptorImpl<void> {\n override readonly codecId = SQL_FLOAT_CODEC_ID;\n override readonly traits = ['equality', 'order', 'numeric'] as const;\n override readonly targetTypes = ['float'] as const;\n override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n override factory(): (ctx: CodecInstanceContext) => SqlFloatCodec {\n return () => new SqlFloatCodec(this);\n }\n}\n\nexport const sqlFloatDescriptor = new SqlFloatDescriptor();\n\nexport const sqlFloatColumn = () =>\n column(sqlFloatDescriptor.factory(), sqlFloatDescriptor.codecId, undefined, 'float');\n\nsqlFloatColumn satisfies ColumnHelperFor<SqlFloatDescriptor>;\nsqlFloatColumn satisfies ColumnHelperForStrict<SqlFloatDescriptor>;\n\nexport class SqlCharCodec extends CodecImpl<\n typeof SQL_CHAR_CODEC_ID,\n readonly ['equality', 'order', 'textual'],\n string,\n string\n> {\n async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n return sqlCharEncode(value);\n }\n async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n return sqlCharDecode(wire);\n }\n encodeJson(value: string): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): string {\n return json as string;\n }\n}\n\nexport class SqlCharDescriptor extends CodecDescriptorImpl<LengthParams> {\n override readonly codecId = SQL_CHAR_CODEC_ID;\n override readonly traits = ['equality', 'order', 'textual'] as const;\n override readonly targetTypes = ['char'] as const;\n override readonly paramsSchema: StandardSchemaV1<LengthParams> = lengthParamsSchema;\n override renderOutputType(params: LengthParams): string | undefined {\n return sqlCharRenderOutputType(params);\n }\n override factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlCharCodec {\n return () => new SqlCharCodec(this);\n }\n}\n\nexport const sqlCharDescriptor = new SqlCharDescriptor();\n\nexport const sqlCharColumn = (params: LengthParams = {}) =>\n column(sqlCharDescriptor.factory(params), sqlCharDescriptor.codecId, params, 'char');\n\nsqlCharColumn satisfies ColumnHelperFor<SqlCharDescriptor>;\nsqlCharColumn satisfies ColumnHelperForStrict<SqlCharDescriptor>;\n\nexport class SqlVarcharCodec extends CodecImpl<\n typeof SQL_VARCHAR_CODEC_ID,\n readonly ['equality', 'order', 'textual'],\n string,\n string\n> {\n async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n return sqlVarcharEncode(value);\n }\n async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n return sqlVarcharDecode(wire);\n }\n encodeJson(value: string): JsonValue {\n return value;\n }\n decodeJson(json: JsonValue): string {\n return json as string;\n }\n}\n\nexport class SqlVarcharDescriptor extends CodecDescriptorImpl<LengthParams> {\n override readonly codecId = SQL_VARCHAR_CODEC_ID;\n override readonly traits = ['equality', 'order', 'textual'] as const;\n override readonly targetTypes = ['varchar'] as const;\n override readonly paramsSchema: StandardSchemaV1<LengthParams> = lengthParamsSchema;\n override renderOutputType(params: LengthParams): string | undefined {\n return sqlVarcharRenderOutputType(params);\n }\n override factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlVarcharCodec {\n return () => new SqlVarcharCodec(this);\n }\n}\n\nexport const sqlVarcharDescriptor = new SqlVarcharDescriptor();\n\nexport const sqlVarcharColumn = (params: LengthParams = {}) =>\n column(sqlVarcharDescriptor.factory(params), sqlVarcharDescriptor.codecId, params, 'varchar');\n\nsqlVarcharColumn satisfies ColumnHelperFor<SqlVarcharDescriptor>;\nsqlVarcharColumn satisfies ColumnHelperForStrict<SqlVarcharDescriptor>;\n\nexport class SqlTimestampCodec extends CodecImpl<\n typeof SQL_TIMESTAMP_CODEC_ID,\n readonly ['equality', 'order'],\n Date,\n Date\n> {\n async encode(value: Date, _ctx: CodecCallContext): Promise<Date> {\n return sqlTimestampEncode(value);\n }\n async decode(wire: Date, _ctx: CodecCallContext): Promise<Date> {\n return sqlTimestampDecode(wire);\n }\n encodeJson(value: Date): JsonValue {\n return sqlTimestampEncodeJson(value);\n }\n decodeJson(json: JsonValue): Date {\n return sqlTimestampDecodeJson(json);\n }\n}\n\nexport class SqlTimestampDescriptor extends CodecDescriptorImpl<PrecisionParams> {\n override readonly codecId = SQL_TIMESTAMP_CODEC_ID;\n override readonly traits = ['equality', 'order'] as const;\n override readonly targetTypes = ['timestamp'] as const;\n override readonly paramsSchema: StandardSchemaV1<PrecisionParams> = precisionParamsSchema;\n override renderOutputType(params: PrecisionParams): string | undefined {\n return sqlTimestampRenderOutputType(params);\n }\n override factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => SqlTimestampCodec {\n return () => new SqlTimestampCodec(this);\n }\n}\n\nexport const sqlTimestampDescriptor = new SqlTimestampDescriptor();\n\nexport const sqlTimestampColumn = (params: PrecisionParams = {}) =>\n column(\n sqlTimestampDescriptor.factory(params),\n sqlTimestampDescriptor.codecId,\n params,\n 'timestamp',\n );\n\nsqlTimestampColumn satisfies ColumnHelperFor<SqlTimestampDescriptor>;\nsqlTimestampColumn satisfies ColumnHelperForStrict<SqlTimestampDescriptor>;\n"],"mappings":"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"} |
@@ -1,3 +0,3 @@ | ||
| import { t as AnyCodecDescriptor } from "../codec-types-C8vFGWij.mjs"; | ||
| import { n as CodecDescriptorRegistry } from "../query-lane-context-BNbbusGn.mjs"; | ||
| import { t as AnyCodecDescriptor } from "../codec-types-Bayoa4PI.mjs"; | ||
| import { n as CodecDescriptorRegistry } from "../query-lane-context-DTCOHMXn.mjs"; | ||
| import { CodecRef } from "@prisma-next/framework-components/codec"; | ||
@@ -4,0 +4,0 @@ import { SqlStorage } from "@prisma-next/sql-contract/types"; |
@@ -1,4 +0,4 @@ | ||
| import { o as CodecRef } from "../codec-types-C8vFGWij.mjs"; | ||
| import { J as OrderByItem, P as JoinAst, Q as ProjectionItem, ct as UpdateAst, g as ColumnRef, j as InsertAst, nt as SelectAst, o as AnyExpression, ot as TableSource, s as AnyFromSource } from "../types-Dr3jep6j.mjs"; | ||
| import { d as LiteralColumnDefault, f as PrimaryKeyConstraint, l as ForeignKeyConstraint, n as CheckExpressionConstraint, p as UniqueConstraint, r as DdlColumn, t as AnyDdlColumnDefault, u as FunctionColumnDefault } from "../ddl-types-DzaZCtFT.mjs"; | ||
| import { o as CodecRef } from "../codec-types-Bayoa4PI.mjs"; | ||
| import { $ as OrderByItem, I as InsertAst, dt as TableSource, o as AnyExpression, pt as UpdateAst, rt as ProjectionItem, s as AnyFromSource, st as SelectAst, y as ColumnRef, z as JoinAst } from "../types-CWlaErjN.mjs"; | ||
| import { d as LiteralColumnDefault, f as PrimaryKeyConstraint, l as ForeignKeyConstraint, n as CheckExpressionConstraint, p as UniqueConstraint, r as DdlColumn, t as AnyDdlColumnDefault, u as FunctionColumnDefault } from "../ddl-types-B3SfjPGI.mjs"; | ||
| import { ColumnDefaultLiteralInputValue } from "@prisma-next/contract/types"; | ||
@@ -5,0 +5,0 @@ import { ReferentialAction } from "@prisma-next/sql-contract/types"; |
@@ -0,3 +1,3 @@ | ||
| import { C as LiteralExpr, D as OrExpr, E as OperationExpr, I as TableSource, L as UpdateAst, M as RawExpr, O as OrderByItem, P as SelectAst, T as NullCheckExpr, _ as InsertAst, g as IdentifierRef, j as ProjectionItem, k as ParamRef, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, t as AggregateExpr, v as InsertOnConflict, y as JoinAst } from "../types-DpAvAX8u.mjs"; | ||
| import { a as ForeignKeyConstraint, c as PrimaryKeyConstraint, l as UniqueConstraint, n as DdlColumn, o as FunctionColumnDefault, s as LiteralColumnDefault, t as CheckExpressionConstraint } from "../ddl-types-DFKQr_qQ.mjs"; | ||
| import { C as OperationExpr, E as ParamRef, N as TableSource, O as ProjectionItem, P as UpdateAst, S as NullCheckExpr, T as OrderByItem, b as LiteralExpr, d as ExistsExpr, g as JoinAst, h as InsertOnConflict, i as ColumnRef, j as SelectAst, k as RawExpr, m as InsertAst, n as AndExpr, p as IdentifierRef, r as BinaryExpr, t as AggregateExpr, w as OrExpr } from "../types-DtzFztRV.mjs"; | ||
| import { blindCast } from "@prisma-next/utils/casts"; | ||
@@ -4,0 +4,0 @@ //#region src/contract-free/column.ts |
@@ -1,3 +0,3 @@ | ||
| import { o as CodecRef } from "../codec-types-C8vFGWij.mjs"; | ||
| import { Y as ParamRef, o as AnyExpression, tt as RawSqlLiteral } from "../types-Dr3jep6j.mjs"; | ||
| import { o as CodecRef } from "../codec-types-Bayoa4PI.mjs"; | ||
| import { et as ParamRef, o as AnyExpression, ot as RawSqlLiteral } from "../types-CWlaErjN.mjs"; | ||
| import { QueryOperationReturn } from "@prisma-next/sql-contract/types"; | ||
@@ -4,0 +4,0 @@ import { ParamSpec } from "@prisma-next/operations"; |
@@ -1,2 +0,2 @@ | ||
| import { C as OperationExpr, E as ParamRef, k as RawExpr } from "../types-DtzFztRV.mjs"; | ||
| import { E as OperationExpr, M as RawExpr, k as ParamRef } from "../types-DpAvAX8u.mjs"; | ||
| import { runtimeError } from "@prisma-next/framework-components/runtime"; | ||
@@ -3,0 +3,0 @@ //#region src/expression.ts |
@@ -1,2 +0,2 @@ | ||
| import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "../middleware-CFDg6XOc.mjs"; | ||
| import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "../middleware-_9-4TYKC.mjs"; | ||
| export { type ParamRefEntry, type ParamRefEntryUnion, type ParamRefHandle, type SqlParamRefMutator, type SqlParamRefMutatorInternal, createSqlParamRefMutator }; |
@@ -1,3 +0,3 @@ | ||
| import { t as SqlExecutionPlan } from "../sql-execution-plan-CPw3uKrJ.mjs"; | ||
| import { n as planFromAst, t as SqlQueryPlan } from "../plan-CBT55zev.mjs"; | ||
| import { t as SqlExecutionPlan } from "../sql-execution-plan-B-C-6cZN.mjs"; | ||
| import { n as planFromAst, t as SqlQueryPlan } from "../plan-Dq94efZJ.mjs"; | ||
| export { type SqlExecutionPlan, SqlQueryPlan, planFromAst }; |
@@ -1,2 +0,2 @@ | ||
| import { a as MutationDefaultsOptions, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as TypeHelperRegistry, r as ExecutionContext, t as AppliedMutationDefault } from "../query-lane-context-BNbbusGn.mjs"; | ||
| import { a as MutationDefaultsOptions, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as TypeHelperRegistry, r as ExecutionContext, t as AppliedMutationDefault } from "../query-lane-context-DTCOHMXn.mjs"; | ||
| export { AppliedMutationDefault, CodecDescriptorRegistry, ExecutionContext, MutationDefaultsOp, MutationDefaultsOptions, TypeHelperRegistry }; |
@@ -1,2 +0,2 @@ | ||
| import { C as TableMetadata, E as SqlOrmPlan, S as TableKey, T as RuntimeScope, _ as RawTemplateFactory, a as ColumnsOf, b as SqlPlan, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TablesOf, x as TableDef, y as SqlBuilderOptions } from "../types-BR266jxM.mjs"; | ||
| import { C as TableMetadata, E as SqlOrmPlan, S as TableKey, T as RuntimeScope, _ as RawTemplateFactory, a as ColumnsOf, b as SqlPlan, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TablesOf, x as TableDef, y as SqlBuilderOptions } from "../types-CRV7uuOC.mjs"; | ||
| export { BuildOptions, BuildParamsMap, CodecTypes, ColumnResolutionContract, ColumnsOf, ComputeColumnJsType, Expr, META, Meta, ModelDef, ModelMetadata, OperationTypeSignature, OperationTypes, OperationsForTypeId, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, type RuntimeScope, SqlBuilderOptions, type SqlOrmPlan, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf }; |
+9
-9
@@ -1,13 +0,13 @@ | ||
| import { a as CodecMeta, c as ContractCodecRegistry, d as DescriptorCodecTraits, f as ExtractCodecTypes, h as SqlColumnRef, i as CodecDescriptor, l as DescriptorCodecId, m as SqlCodecInstanceContext, n as Codec, o as CodecRef, p as SqlCodecCallContext, r as CodecCallContext, s as CodecTrait, t as AnyCodecDescriptor, u as DescriptorCodecInput } from "./codec-types-C8vFGWij.mjs"; | ||
| import { $ as RawExpr, A as IdentifierRef, B as ListExpression, C as EqColJoinOn, D as ExpressionRewriter, E as ExpressionFolder, F as JoinOnExpr, G as NullCheckExpr, H as LoweredParam, I as JsonArrayAggExpr, J as OrderByItem, K as OperationExpr, L as JsonObjectEntry, M as InsertOnConflict, N as InsertValue, O as ExpressionSource, P as JoinAst, Q as ProjectionItem, R as JsonObjectExpr, S as DoUpdateSetConflictAction, T as ExprVisitor, U as LoweredStatement, V as LiteralExpr, W as NotExpr, X as PreparedParamRef, Y as ParamRef, Z as ProjectionExpr, _ as DefaultValueExpr, a as AndExpr, at as TableRef, b as Direction, c as AnyInsertOnConflictAction, ct as UpdateAst, d as AnyParamRef, dt as WindowFuncExpr, et as RawSqlExpr, f as AnyQueryAst, ft as isQueryAst, g as ColumnRef, h as BinaryOp, ht as whereExprKinds, i as AggregateOpFn, it as SubqueryExpr, j as InsertAst, k as FunctionSource, l as AnyInsertValue, lt as WhereArg, m as BinaryExpr, mt as queryAstKinds, n as AggregateExpr, nt as SelectAst, o as AnyExpression, ot as TableSource, p as AstRewriter, pt as isWhereExpr, q as OrExpr, r as AggregateFn, rt as SelectAstOptions, s as AnyFromSource, st as ToWhereExpr, t as AggregateCountFn, tt as RawSqlLiteral, u as AnyOperationArg, ut as WindowFn, v as DeleteAst, w as ExistsExpr, x as DoNothingConflictAction, y as DerivedTableSource, z as LimitOffsetValue } from "./types-Dr3jep6j.mjs"; | ||
| import { a as DdlColumnDefaultVisitor, c as DdlTableConstraint, d as LiteralColumnDefault, f as PrimaryKeyConstraint, i as DdlColumnDefault, l as ForeignKeyConstraint, m as isDdlNode, n as CheckExpressionConstraint, o as DdlColumnRenderContext, p as UniqueConstraint, r as DdlColumn, s as DdlNode, t as AnyDdlColumnDefault, u as FunctionColumnDefault } from "./ddl-types-DzaZCtFT.mjs"; | ||
| import { a as CodecMeta, c as ContractCodecRegistry, d as DescriptorCodecTraits, f as ExtractCodecTypes, g as frozenCodecRef, h as SqlColumnRef, i as CodecDescriptor, l as DescriptorCodecId, m as SqlCodecInstanceContext, n as Codec, o as CodecRef, p as SqlCodecCallContext, r as CodecCallContext, s as CodecTrait, t as AnyCodecDescriptor, u as DescriptorCodecInput } from "./codec-types-Bayoa4PI.mjs"; | ||
| import { $ as OrderByItem, A as ExpressionRewriter, B as JoinOnExpr, C as Direction, Ct as JsonDocumentProjection, D as ExistsExpr, E as EqColJoinOn, F as IdentifierRef, G as ListExpression, H as JsonObjectEntry, I as InsertAst, J as LoweredStatement, K as LiteralExpr, L as InsertOnConflict, M as FunctionCallExpr, N as FunctionSource, O as ExprVisitor, P as FunctionSourceAlias, Q as OrExpr, R as InsertValue, S as DerivedTableSource, St as CodecJsonValueProjection, T as DoUpdateSetConflictAction, Tt as NativeJsonValueProjection, U as JsonObjectExpr, V as JsonArrayAggExpr, W as LimitOffsetValue, X as NullCheckExpr, Y as NotExpr, Z as OperationExpr, _ as CaseExpr, _t as isQueryAst, a as AndExpr, at as RawSqlExpr, b as DefaultValueExpr, bt as whereExprKinds, c as AnyInsertOnConflictAction, ct as SelectAstOptions, d as AnyParamRef, dt as TableSource, et as ParamRef, f as AnyQueryAst, ft as ToWhereExpr, g as CaseBranch, gt as WindowFuncExpr, h as BinaryOp, ht as WindowFn, i as AggregateOpFn, it as RawExpr, j as ExpressionSource, k as ExpressionFolder, l as AnyInsertValue, lt as SubqueryExpr, m as BinaryExpr, mt as WhereArg, n as AggregateExpr, nt as ProjectionExpr, o as AnyExpression, ot as RawSqlLiteral, p as AstRewriter, pt as UpdateAst, q as LoweredParam, r as AggregateFn, rt as ProjectionItem, s as AnyFromSource, st as SelectAst, t as AggregateCountFn, tt as PreparedParamRef, u as AnyOperationArg, ut as TableRef, v as CastExpr, vt as isWhereExpr, w as DoNothingConflictAction, wt as JsonValueProjectionVisitor, x as DeleteAst, xt as AnyJsonValueProjection, y as ColumnRef, yt as queryAstKinds, z as JoinAst } from "./types-CWlaErjN.mjs"; | ||
| import { a as DdlColumnDefaultVisitor, c as DdlTableConstraint, d as LiteralColumnDefault, f as PrimaryKeyConstraint, i as DdlColumnDefault, l as ForeignKeyConstraint, m as isDdlNode, n as CheckExpressionConstraint, o as DdlColumnRenderContext, p as UniqueConstraint, r as DdlColumn, s as DdlNode, t as AnyDdlColumnDefault, u as FunctionColumnDefault } from "./ddl-types-B3SfjPGI.mjs"; | ||
| import { Adapter, AdapterProfile, AdapterTarget, Lowerer, LowererContext, MarkerReadResult, PreparedExecuteRequest, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SqlCharCodec, SqlCharDescriptor, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, collectOrderedParamRefs, compact, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType } from "./exports/ast.mjs"; | ||
| import { a as MutationDefaultsOptions, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as TypeHelperRegistry, r as ExecutionContext, t as AppliedMutationDefault } from "./query-lane-context-BNbbusGn.mjs"; | ||
| import { a as MutationDefaultsOptions, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as TypeHelperRegistry, r as ExecutionContext, t as AppliedMutationDefault } from "./query-lane-context-DTCOHMXn.mjs"; | ||
| import { BuildOperationSpec, CodecExpression, CodecTypesBase, CodecValue, Expression, RawCodecInferer, RawSqlBuilder, RawSqlTag, ScalarListExpression, ScopeField, TraitExpression, buildOperation, codecOf, createRawSql, param, toExpr } from "./exports/expression.mjs"; | ||
| import { t as SqlExecutionPlan } from "./sql-execution-plan-CPw3uKrJ.mjs"; | ||
| import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-CFDg6XOc.mjs"; | ||
| import { n as planFromAst, t as SqlQueryPlan } from "./plan-CBT55zev.mjs"; | ||
| import { t as SqlExecutionPlan } from "./sql-execution-plan-B-C-6cZN.mjs"; | ||
| import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-_9-4TYKC.mjs"; | ||
| import { n as planFromAst, t as SqlQueryPlan } from "./plan-Dq94efZJ.mjs"; | ||
| import "./exports/plan.mjs"; | ||
| import "./exports/query-lane-context.mjs"; | ||
| import { C as TableMetadata, E as SqlOrmPlan, S as TableKey, T as RuntimeScope, _ as RawTemplateFactory, a as ColumnsOf, b as SqlPlan, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TablesOf, x as TableDef, y as SqlBuilderOptions } from "./types-BR266jxM.mjs"; | ||
| export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyDdlColumnDefault, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyOperationArg, AnyParamRef, AnyQueryAst, AppliedMutationDefault, AstRewriter, BinaryExpr, BinaryOp, BuildOperationSpec, BuildOptions, BuildParamsMap, CheckExpressionConstraint, Codec, type CodecCallContext, type CodecDescriptor, CodecDescriptorRegistry, CodecExpression, CodecMeta, type CodecRef, type CodecTrait, CodecTypes, CodecTypesBase, CodecValue, ColumnRef, ColumnResolutionContract, ColumnsOf, ComputeColumnJsType, ContractCodecRegistry, DdlColumn, DdlColumnDefault, DdlColumnDefaultVisitor, DdlColumnRenderContext, DdlNode, DdlTableConstraint, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExecutionContext, ExistsExpr, Expr, ExprVisitor, Expression, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ForeignKeyConstraint, FunctionColumnDefault, FunctionSource, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonObjectEntry, JsonObjectExpr, LimitOffsetValue, ListExpression, LiteralColumnDefault, LiteralExpr, LoweredParam, LoweredStatement, Lowerer, LowererContext, META, MarkerReadResult, Meta, ModelDef, ModelMetadata, MutationDefaultsOp, MutationDefaultsOptions, NotExpr, NullCheckExpr, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrExpr, OrderByItem, ParamRef, type ParamRefEntry, type ParamRefEntryUnion, type ParamRefHandle, PreparedExecuteRequest, PreparedParamRef, PrimaryKeyConstraint, ProjectionExpr, ProjectionItem, RawCodecInferer, RawExpr, RawFactory, RawFunctionOptions, RawSqlBuilder, RawSqlExpr, RawSqlLiteral, RawSqlTag, RawTemplateFactory, RawTemplateOptions, type RuntimeScope, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, ScalarListExpression, ScopeField, SelectAst, SelectAstOptions, SqlBuilderOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, type SqlExecutionPlan, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, type SqlOrmPlan, type SqlParamRefMutator, type SqlParamRefMutatorInternal, SqlPlan, SqlQueryPlan, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableDef, TableKey, TableMetadata, TableRef, TableSource, TablesOf, ToWhereExpr, TraitExpression, TypeHelperRegistry, UniqueConstraint, UpdateAst, WhereArg, WindowFn, WindowFuncExpr, buildOperation, codecOf, collectOrderedParamRefs, compact, createRawSql, createSqlParamRefMutator, isDdlNode, isQueryAst, isWhereExpr, param, planFromAst, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, whereExprKinds }; | ||
| import { C as TableMetadata, E as SqlOrmPlan, S as TableKey, T as RuntimeScope, _ as RawTemplateFactory, a as ColumnsOf, b as SqlPlan, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TablesOf, x as TableDef, y as SqlBuilderOptions } from "./types-CRV7uuOC.mjs"; | ||
| export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyDdlColumnDefault, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyJsonValueProjection, AnyOperationArg, AnyParamRef, AnyQueryAst, AppliedMutationDefault, AstRewriter, BinaryExpr, BinaryOp, BuildOperationSpec, BuildOptions, BuildParamsMap, CaseBranch, CaseExpr, CastExpr, CheckExpressionConstraint, Codec, type CodecCallContext, type CodecDescriptor, CodecDescriptorRegistry, CodecExpression, CodecJsonValueProjection, CodecMeta, type CodecRef, type CodecTrait, CodecTypes, CodecTypesBase, CodecValue, ColumnRef, ColumnResolutionContract, ColumnsOf, ComputeColumnJsType, ContractCodecRegistry, DdlColumn, DdlColumnDefault, DdlColumnDefaultVisitor, DdlColumnRenderContext, DdlNode, DdlTableConstraint, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExecutionContext, ExistsExpr, Expr, ExprVisitor, Expression, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ForeignKeyConstraint, FunctionCallExpr, FunctionColumnDefault, FunctionSource, FunctionSourceAlias, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonDocumentProjection, JsonObjectEntry, JsonObjectExpr, JsonValueProjectionVisitor, LimitOffsetValue, ListExpression, LiteralColumnDefault, LiteralExpr, LoweredParam, LoweredStatement, Lowerer, LowererContext, META, MarkerReadResult, Meta, ModelDef, ModelMetadata, MutationDefaultsOp, MutationDefaultsOptions, NativeJsonValueProjection, NotExpr, NullCheckExpr, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrExpr, OrderByItem, ParamRef, type ParamRefEntry, type ParamRefEntryUnion, type ParamRefHandle, PreparedExecuteRequest, PreparedParamRef, PrimaryKeyConstraint, ProjectionExpr, ProjectionItem, RawCodecInferer, RawExpr, RawFactory, RawFunctionOptions, RawSqlBuilder, RawSqlExpr, RawSqlLiteral, RawSqlTag, RawTemplateFactory, RawTemplateOptions, type RuntimeScope, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, ScalarListExpression, ScopeField, SelectAst, SelectAstOptions, SqlBuilderOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, type SqlExecutionPlan, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, type SqlOrmPlan, type SqlParamRefMutator, type SqlParamRefMutatorInternal, SqlPlan, SqlQueryPlan, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableDef, TableKey, TableMetadata, TableRef, TableSource, TablesOf, ToWhereExpr, TraitExpression, TypeHelperRegistry, UniqueConstraint, UpdateAst, WhereArg, WindowFn, WindowFuncExpr, buildOperation, codecOf, collectOrderedParamRefs, compact, createRawSql, createSqlParamRefMutator, frozenCodecRef, isDdlNode, isQueryAst, isWhereExpr, param, planFromAst, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, whereExprKinds }; |
+3
-3
@@ -0,5 +1,5 @@ | ||
| import { A as PreparedParamRef, B as isWhereExpr, C as LiteralExpr, D as OrExpr, E as OperationExpr, F as SubqueryExpr, H as whereExprKinds, I as TableSource, L as UpdateAst, M as RawExpr, N as RawSqlExpr, O as OrderByItem, P as SelectAst, R as WindowFuncExpr, S as ListExpression, T as NullCheckExpr, U as frozenCodecRef, V as queryAstKinds, _ as InsertAst, a as CastExpr, b as JsonArrayAggExpr, c as DeleteAst, d as DoUpdateSetConflictAction, f as EqColJoinOn, g as IdentifierRef, h as FunctionSource, i as CaseExpr, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, m as FunctionCallExpr, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, u as DoNothingConflictAction, v as InsertOnConflict, w as NotExpr, x as JsonObjectExpr, y as JoinAst, z as isQueryAst } from "./types-DpAvAX8u.mjs"; | ||
| import { a as ForeignKeyConstraint, c as PrimaryKeyConstraint, i as DdlNode, l as UniqueConstraint, n as DdlColumn, o as FunctionColumnDefault, r as DdlColumnDefault, s as LiteralColumnDefault, t as CheckExpressionConstraint, u as isDdlNode } from "./ddl-types-DFKQr_qQ.mjs"; | ||
| import { A as RawSqlExpr, C as OperationExpr, D as PreparedParamRef, E as ParamRef, F as WindowFuncExpr, I as isQueryAst, L as isWhereExpr, M as SubqueryExpr, N as TableSource, O as ProjectionItem, P as UpdateAst, R as queryAstKinds, S as NullCheckExpr, T as OrderByItem, _ as JsonArrayAggExpr, a as DefaultValueExpr, b as LiteralExpr, c as DoNothingConflictAction, d as ExistsExpr, f as FunctionSource, g as JoinAst, h as InsertOnConflict, i as ColumnRef, j as SelectAst, k as RawExpr, l as DoUpdateSetConflictAction, m as InsertAst, n as AndExpr, o as DeleteAst, p as IdentifierRef, r as BinaryExpr, s as DerivedTableSource, t as AggregateExpr, u as EqColJoinOn, v as JsonObjectExpr, w as OrExpr, x as NotExpr, y as ListExpression, z as whereExprKinds } from "./types-DtzFztRV.mjs"; | ||
| import { n as compact, t as collectOrderedParamRefs } from "./util-DQQgv2j1.mjs"; | ||
| import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType } from "./exports/ast.mjs"; | ||
| import { CodecJsonValueProjection, JsonDocumentProjection, NativeJsonValueProjection, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType } from "./exports/ast.mjs"; | ||
| import { buildOperation, codecOf, createRawSql, param, toExpr } from "./exports/expression.mjs"; | ||
@@ -10,2 +10,2 @@ import { t as createSqlParamRefMutator } from "./middleware-CMr4CHNz.mjs"; | ||
| import "./exports/types.mjs"; | ||
| export { AggregateExpr, AndExpr, BinaryExpr, CheckExpressionConstraint, ColumnRef, DdlColumn, DdlColumnDefault, DdlNode, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ForeignKeyConstraint, FunctionColumnDefault, FunctionSource, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralColumnDefault, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, PreparedParamRef, PrimaryKeyConstraint, ProjectionItem, RawExpr, RawSqlExpr, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableSource, UniqueConstraint, UpdateAst, WindowFuncExpr, buildOperation, codecOf, collectOrderedParamRefs, compact, createRawSql, createSqlParamRefMutator, isDdlNode, isQueryAst, isWhereExpr, param, planFromAst, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, whereExprKinds }; | ||
| export { AggregateExpr, AndExpr, BinaryExpr, CaseExpr, CastExpr, CheckExpressionConstraint, CodecJsonValueProjection, ColumnRef, DdlColumn, DdlColumnDefault, DdlNode, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ForeignKeyConstraint, FunctionCallExpr, FunctionColumnDefault, FunctionSource, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonDocumentProjection, JsonObjectExpr, ListExpression, LiteralColumnDefault, LiteralExpr, NativeJsonValueProjection, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, PreparedParamRef, PrimaryKeyConstraint, ProjectionItem, RawExpr, RawSqlExpr, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableSource, UniqueConstraint, UpdateAst, WindowFuncExpr, buildOperation, codecOf, collectOrderedParamRefs, compact, createRawSql, createSqlParamRefMutator, frozenCodecRef, isDdlNode, isQueryAst, isWhereExpr, param, planFromAst, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, whereExprKinds }; |
+11
-11
| { | ||
| "name": "@prisma-next/sql-relational-core", | ||
| "version": "0.16.0-dev.7", | ||
| "version": "0.16.0-dev.10", | ||
| "license": "Apache-2.0", | ||
@@ -9,8 +9,8 @@ "type": "module", | ||
| "dependencies": { | ||
| "@prisma-next/contract": "0.16.0-dev.7", | ||
| "@prisma-next/framework-components": "0.16.0-dev.7", | ||
| "@prisma-next/operations": "0.16.0-dev.7", | ||
| "@prisma-next/sql-contract": "0.16.0-dev.7", | ||
| "@prisma-next/sql-operations": "0.16.0-dev.7", | ||
| "@prisma-next/utils": "0.16.0-dev.7", | ||
| "@prisma-next/contract": "0.16.0-dev.10", | ||
| "@prisma-next/framework-components": "0.16.0-dev.10", | ||
| "@prisma-next/operations": "0.16.0-dev.10", | ||
| "@prisma-next/sql-contract": "0.16.0-dev.10", | ||
| "@prisma-next/sql-operations": "0.16.0-dev.10", | ||
| "@prisma-next/utils": "0.16.0-dev.10", | ||
| "@standard-schema/spec": "^1.1.0", | ||
@@ -21,6 +21,6 @@ "arktype": "^2.2.2", | ||
| "devDependencies": { | ||
| "@prisma-next/sql-contract-ts": "0.16.0-dev.7", | ||
| "@prisma-next/test-utils": "0.16.0-dev.7", | ||
| "@prisma-next/tsconfig": "0.16.0-dev.7", | ||
| "@prisma-next/tsdown": "0.16.0-dev.7", | ||
| "@prisma-next/sql-contract-ts": "0.16.0-dev.10", | ||
| "@prisma-next/test-utils": "0.16.0-dev.10", | ||
| "@prisma-next/tsconfig": "0.16.0-dev.10", | ||
| "@prisma-next/tsdown": "0.16.0-dev.10", | ||
| "tsdown": "0.22.8", | ||
@@ -27,0 +27,0 @@ "typescript": "5.9.3", |
@@ -0,1 +1,2 @@ | ||
| import type { JsonValue } from '@prisma-next/contract/types'; | ||
| import type { | ||
@@ -9,2 +10,3 @@ Codec as BaseCodec, | ||
| } from '@prisma-next/framework-components/codec'; | ||
| import { ifDefined } from '@prisma-next/utils/defined'; | ||
@@ -18,2 +20,37 @@ export type { | ||
| function isJsonArray(value: JsonValue): value is readonly JsonValue[] { | ||
| return Array.isArray(value); | ||
| } | ||
| function freezeJsonValue(value: JsonValue): void { | ||
| if (value === null || typeof value !== 'object') { | ||
| return; | ||
| } | ||
| if (isJsonArray(value)) { | ||
| for (const item of value) { | ||
| freezeJsonValue(item); | ||
| } | ||
| } else { | ||
| for (const item of Object.values(value)) { | ||
| freezeJsonValue(item); | ||
| } | ||
| } | ||
| Object.freeze(value); | ||
| } | ||
| export function frozenCodecRef(codec: CodecRef): CodecRef { | ||
| const typeParams = codec.typeParams === undefined ? undefined : structuredClone(codec.typeParams); | ||
| if (typeParams !== undefined) { | ||
| freezeJsonValue(typeParams); | ||
| } | ||
| return Object.freeze({ | ||
| codecId: codec.codecId, | ||
| ...ifDefined('typeParams', typeParams), | ||
| ...ifDefined('many', codec.many), | ||
| }); | ||
| } | ||
| /** | ||
@@ -20,0 +57,0 @@ * SQL-family addressing of a single column. The decode site populates a `SqlColumnRef` whenever it can resolve the cell to a single underlying `(table, column)` (the typical case for projected columns from a single-table source); cells the runtime cannot resolve (aggregate aliases, include aggregate fields, computed projections without a simple ref) get `column = undefined`. |
@@ -5,2 +5,3 @@ export * from '../ast/adapter-types'; | ||
| export * from '../ast/driver-types'; | ||
| export * from '../ast/json-value-projection'; | ||
| export * from '../ast/sql-codec-helpers'; | ||
@@ -7,0 +8,0 @@ export * from '../ast/sql-codecs'; |
| import { Codec, CodecCallContext, CodecCallContext as CodecCallContext$1, CodecDescriptor, CodecDescriptor as CodecDescriptor$1, CodecInstanceContext, CodecRef, CodecRef as CodecRef$1, CodecTrait, CodecTrait as CodecTrait$1 } from "@prisma-next/framework-components/codec"; | ||
| //#region src/ast/codec-types.d.ts | ||
| /** | ||
| * SQL-family addressing of a single column. The decode site populates a `SqlColumnRef` whenever it can resolve the cell to a single underlying `(table, column)` (the typical case for projected columns from a single-table source); cells the runtime cannot resolve (aggregate aliases, include aggregate fields, computed projections without a simple ref) get `column = undefined`. | ||
| * | ||
| * The shape is a structural projection of the runtime's `ColumnRef` so the SQL decode site can reuse the resolution it already performs for `RUNTIME.DECODE_FAILED` envelope construction without allocating twice per cell. | ||
| */ | ||
| interface SqlColumnRef { | ||
| readonly table: string; | ||
| readonly name: string; | ||
| } | ||
| /** | ||
| * SQL-family per-call context. Extends the framework {@link CodecCallContext} (which carries `signal` only) with `column?: SqlColumnRef`, populated on **decode** call sites that can resolve a single underlying column ref. Encode call sites currently leave `column` undefined (encode-time column context is the middleware's domain). | ||
| * | ||
| * SQL codec authors writing codec methods observe this type via {@link SqlCodec}. The framework codec dispatch surface (and Mongo) sees only the base `CodecCallContext`. | ||
| */ | ||
| interface SqlCodecCallContext extends CodecCallContext { | ||
| readonly column?: SqlColumnRef; | ||
| } | ||
| /** | ||
| * SQL-family per-instance context. Extends the framework {@link CodecInstanceContext} (`name` only) with `usedAt`, the set of `(table, column)` pairs the resolved codec serves. | ||
| * | ||
| * - For `typeRef` columns sharing one named `storage.types` instance, the array lists every referencing column — a column-scoped stateful codec (e.g. encryption) can derive aggregated per-instance state across all the columns sharing the named instance. | ||
| * - For inline-`typeParams` columns, the array has exactly one entry — the column that owns the inline params. | ||
| * - For shared non-parameterized codecs, the array carries one representative entry (the column that triggered materialization); the codec is shared across every column with that codec id, so the `usedAt` is informational only. | ||
| * | ||
| * SQL extensions consuming `usedAt` (e.g. column-scoped state derivation) type their factory parameter as `SqlCodecInstanceContext`. Extensions that don't read `usedAt` type their factory parameter as the family-agnostic {@link CodecInstanceContext} — a `SqlCodecInstanceContext` is structurally assignable to the base. | ||
| */ | ||
| interface SqlCodecInstanceContext extends CodecInstanceContext { | ||
| readonly usedAt: ReadonlyArray<{ | ||
| readonly table: string; | ||
| readonly column: string; | ||
| }>; | ||
| } | ||
| /** | ||
| * Codec metadata for database-specific type information. Used for schema introspection and verification. | ||
| */ | ||
| interface CodecMeta { | ||
| readonly db?: { | ||
| readonly sql?: { | ||
| readonly postgres?: { | ||
| readonly nativeType: string; | ||
| }; | ||
| }; | ||
| }; | ||
| } | ||
| /** | ||
| * SQL codec — extends the framework codec base by narrowing the per-call context to the SQL-family {@link SqlCodecCallContext} (adds `column?: SqlColumnRef`). TypeScript treats method-syntax declarations bivariantly, so the SQL narrowing is structurally compatible with the framework {@link BaseCodec} super-interface. | ||
| * | ||
| * Codec-id-keyed static metadata (`traits`, `targetTypes`, `meta`, `paramsSchema`, `renderOutputType`) lives on the unified {@link import('@prisma-next/framework-components/codec').CodecDescriptor} — the codec instance itself only carries `id` plus the four conversion methods. | ||
| * | ||
| * See `Codec` in `@prisma-next/framework-components/codec` for the codec contract that this interface extends. | ||
| */ | ||
| interface Codec$1<Id extends string = string, TTraits extends readonly CodecTrait[] = readonly CodecTrait[], TWire = unknown, TInput = unknown> extends Codec<Id, TTraits, TWire, TInput> { | ||
| encode(value: TInput, ctx: SqlCodecCallContext): Promise<TWire>; | ||
| decode(wire: TWire, ctx: SqlCodecCallContext): Promise<TInput>; | ||
| } | ||
| /** | ||
| * Contract-bound codec registry. | ||
| * | ||
| * Built once at `ExecutionContext` construction time by walking the contract's `storage.tables[].columns[]` and resolving each column through its descriptor's factory. Runtime encode/decode dispatch resolves codecs via `forCodecRef(ref)` — the single dispatch shape for AST-bound codec resolution. | ||
| * | ||
| * `forColumn(namespace, table, column)` is retained for build-time helpers that need column-keyed lookup (e.g. projection stamping); runtime dispatch routes through `forCodecRef`. | ||
| */ | ||
| interface ContractCodecRegistry { | ||
| /** | ||
| * Resolve the codec for `(namespace, table, column)`. Returns the per-instance parameterized codec for parameterized columns, the shared codec for non-parameterized columns, or `undefined` if the column is unknown or the codec isn't registered. | ||
| * | ||
| * The `namespaceId` coordinate leads and is always supplied — the column is resolved strictly within that namespace, so two same-bare-named tables across namespaces resolve to their own per-namespace codecs. | ||
| */ | ||
| forColumn(namespaceId: string, table: string, column: string): Codec$1 | undefined; | ||
| /** | ||
| * Resolve a codec by {@link CodecRef}. The single dispatch shape for AST-bound codec resolution — every codec-bearing AST node carries a `CodecRef` that resolves through this method via the per-`ExecutionContext` `AstCodecResolver`. Two refs with the same `codecId` and structurally equal `typeParams` (regardless of object key order) return the same memoised codec instance. Throws `RUNTIME.CODEC_DESCRIPTOR_MISSING` for unknown `codecId`s and `RUNTIME.TYPE_PARAMS_INVALID` on `paramsSchema` rejection. | ||
| * | ||
| * Pre-populated from the contract walk at registry construction time (so contract-declared codecs hit on first call); grows lazily for AST-supplied refs not seen at contract-load time (deserialised migration ops, refs-less raw SQL with an explicit codec). | ||
| */ | ||
| forCodecRef(ref: CodecRef): Codec$1; | ||
| } | ||
| /** | ||
| * Variance-erased descriptor type used for heterogeneous storage in collection containers and on the unified contributor `codecs:` slot. The descriptor's `factory` and `renderOutputType` are contravariant in `P`, so descriptors with different params shapes are not in a subtype relationship; collecting them into one container needs an explicit variance erasure rather than `CodecDescriptor<unknown>` (which is the | ||
| * narrowest, not the widest, of the family). | ||
| */ | ||
| type AnyCodecDescriptor = CodecDescriptor<any>; | ||
| type DescriptorResolvedCodec<D> = D extends CodecDescriptor<infer _P> ? ReturnType<ReturnType<D['factory']>> : never; | ||
| type DescriptorCodecId<D> = D extends AnyCodecDescriptor ? D['codecId'] : never; | ||
| type DescriptorCodecInput<D> = DescriptorResolvedCodec<D> extends Codec<string, readonly CodecTrait[], unknown, infer In> ? In : never; | ||
| /** | ||
| * Resolve the trait union for a descriptor `D`. | ||
| * | ||
| * Reads `traits` directly off the descriptor — concrete descriptor classes declare `override readonly traits = [...] as const`, which preserves the literal trait tuple at the descriptor type. Reading from the resolved codec instance (`CodecImpl<…, TTraits, …>`) would lose the literal because `Codec` carries `TTraits` only on its optional phantom slot (`readonly __codecTraits?: TTraits`); codecs extending `CodecImpl` | ||
| * have no required structural site that pins `TTraits`, so a descriptor-keyed extractor reading from the codec instance would widen to the broad `CodecTrait` union. | ||
| */ | ||
| type DescriptorCodecTraits<D> = D extends { | ||
| readonly traits: infer TTraits extends readonly CodecTrait[]; | ||
| } ? TTraits[number] & CodecTrait : never; | ||
| /** | ||
| * Project a record of {@link AnyCodecDescriptor}s keyed by scalar name onto the codec-id-keyed `CodecTypes` shape consumed by emit and no-emit type pipelines (`{ readonly [codecId]: { input; output; traits } }`). | ||
| * | ||
| * Canonical extractor for the descriptor-keyed type pipeline; the legacy instance-keyed extractor and its `mkCodec`-bound builder retired alongside the carrier deletion. | ||
| */ | ||
| type ExtractCodecTypes<ScalarNames extends { readonly [K in keyof ScalarNames]: AnyCodecDescriptor; } = Record<never, never>> = { readonly [K in keyof ScalarNames as DescriptorCodecId<ScalarNames[K]>]: { | ||
| readonly input: DescriptorCodecInput<ScalarNames[K]>; | ||
| readonly output: DescriptorCodecInput<ScalarNames[K]>; | ||
| readonly traits: DescriptorCodecTraits<ScalarNames[K]>; | ||
| }; }; | ||
| //#endregion | ||
| export { CodecMeta as a, ContractCodecRegistry as c, DescriptorCodecTraits as d, ExtractCodecTypes as f, SqlColumnRef as h, CodecDescriptor$1 as i, DescriptorCodecId as l, SqlCodecInstanceContext as m, Codec$1 as n, CodecRef$1 as o, SqlCodecCallContext as p, CodecCallContext$1 as r, CodecTrait$1 as s, AnyCodecDescriptor as t, DescriptorCodecInput as u }; | ||
| //# sourceMappingURL=codec-types-C8vFGWij.d.mts.map |
| {"version":3,"file":"codec-types-C8vFGWij.d.mts","names":[],"sources":["../src/ast/codec-types.ts"],"mappings":";;;;;;;UAqBiB;WACN;WACA;;;;;;;UAQM,4BAA4B;WAClC,SAAS;;;;;;;;;;;UAYH,gCAAgC;WACtC,QAAQ;aAAyB;aAAwB;;;;;;UAMnD;WACN;aACE;eACE;iBACE;;;;;;;;;;;;UAaA,QACf,4BACA,yBAAyB,wBAAwB,cACjD,iBACA,0BACQ,MAAU,IAAI,SAAS,OAAO;EACtC,OAAO,OAAO,QAAQ,KAAK,sBAAsB,QAAQ;EACzD,OAAO,MAAM,OAAO,KAAK,sBAAsB,QAAQ;;;;;;;;;UAUxC;;;;;;EAMf,UAAU,qBAAqB,eAAe,iBAAiB;;;;;;EAO/D,YAAY,KAAK,WAAW;;;;;;KAQlB,qBAAqB;KAE5B,wBAAwB,KAC3B,UAAU,sBAAsB,MAAM,WAAW,WAAW;KAElD,kBAAkB,KAAK,UAAU,qBAAqB;KAEtD,qBAAqB,KAC/B,wBAAwB,WAAW,uBAA2B,6BAA6B,MACvF;;;;;;;KASM,sBAAsB,KAAK;WAC5B,cAAc,yBAAyB;IAE9C,kBAAkB;;;;;;KAQV,kBACV,gCACY,WAAW,cAAc,wBACjC,oCAEM,WAAW,eAAe,kBAAkB,YAAY;WACvD,OAAO,qBAAqB,YAAY;WACxC,QAAQ,qBAAqB,YAAY;WACzC,QAAQ,sBAAsB,YAAY"} |
| import { o as CodecRef } from "./codec-types-C8vFGWij.mjs"; | ||
| import { d as AnyParamRef } from "./types-Dr3jep6j.mjs"; | ||
| import { ColumnDefaultLiteralInputValue } from "@prisma-next/contract/types"; | ||
| import { ReferentialAction } from "@prisma-next/sql-contract/types"; | ||
| //#region src/ast/ddl-types.d.ts | ||
| /** | ||
| * Render-time context the column-default visitor needs to make dialect | ||
| * decisions that depend on the parent column. Today only the parent | ||
| * column's native type (`"jsonb"`, `"text"`, …) — the Postgres renderer | ||
| * uses it to decide whether to emit a `::jsonb` / `::json` cast on JSON | ||
| * literal defaults so the emitted DDL matches the column type without | ||
| * relying on Postgres's implicit text → jsonb cast at default-evaluation | ||
| * time. Additional fields can join without re-shaping the interface. | ||
| */ | ||
| interface DdlColumnRenderContext { | ||
| readonly nativeType: string; | ||
| } | ||
| interface DdlColumnDefaultVisitor<R> { | ||
| literal(node: LiteralColumnDefault, ctx: DdlColumnRenderContext): R; | ||
| function(node: FunctionColumnDefault, ctx: DdlColumnRenderContext): R; | ||
| } | ||
| declare abstract class DdlColumnDefault { | ||
| abstract readonly kind: string; | ||
| abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R; | ||
| protected freeze(): void; | ||
| } | ||
| declare class LiteralColumnDefault extends DdlColumnDefault { | ||
| readonly kind: "literal"; | ||
| readonly value: ColumnDefaultLiteralInputValue; | ||
| constructor(value: ColumnDefaultLiteralInputValue); | ||
| accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R; | ||
| } | ||
| declare class FunctionColumnDefault extends DdlColumnDefault { | ||
| readonly kind: "function"; | ||
| readonly expression: string; | ||
| constructor(expression: string); | ||
| accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R; | ||
| } | ||
| type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault; | ||
| declare class DdlColumn { | ||
| readonly name: string; | ||
| readonly type: string; | ||
| readonly notNull?: boolean | undefined; | ||
| readonly primaryKey?: boolean | undefined; | ||
| readonly default?: AnyDdlColumnDefault | undefined; | ||
| /** Codec identity for this column. When present, the DDL walker resolves the codec via `codecLookup.get(codecRef.codecId)` and calls `codec.encode(default.value, {})` to obtain the wire value before inlining the literal default into the DDL string. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */ | ||
| readonly codecRef?: CodecRef | undefined; | ||
| constructor(options: { | ||
| readonly name: string; | ||
| readonly type: string; | ||
| readonly notNull?: boolean; | ||
| readonly primaryKey?: boolean; | ||
| readonly default?: AnyDdlColumnDefault; | ||
| readonly codecRef?: CodecRef; | ||
| }); | ||
| } | ||
| declare abstract class DdlNode { | ||
| abstract readonly kind: string; | ||
| /** | ||
| * Structural brand: every DDL node answers `true`. Lets {@link isDdlNode} | ||
| * recognise any `DdlNode` subclass — including target-contributed kinds — | ||
| * without a central kind registry that subclasses would have to register | ||
| * into. | ||
| */ | ||
| isDdlNode(): true; | ||
| protected freeze(): void; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| } | ||
| declare function isDdlNode(value: unknown): value is DdlNode; | ||
| /** | ||
| * A composite (or single-column) PRIMARY KEY constraint on a `CreateTable` | ||
| * node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY | ||
| * (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class PrimaryKeyConstraint { | ||
| readonly kind: "primary-key"; | ||
| readonly columns: ReadonlyArray<string>; | ||
| readonly name: string | undefined; | ||
| constructor(options: { | ||
| readonly columns: readonly string[]; | ||
| readonly name?: string; | ||
| }); | ||
| } | ||
| /** | ||
| * A FOREIGN KEY constraint on a `CreateTable` node. `onDelete` and `onUpdate` | ||
| * use the same `ReferentialAction` vocabulary already used by the migration | ||
| * planner and the contract IR — no parallel string enum. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class ForeignKeyConstraint { | ||
| readonly kind: "foreign-key"; | ||
| readonly columns: ReadonlyArray<string>; | ||
| readonly refTable: string; | ||
| readonly refColumns: ReadonlyArray<string>; | ||
| readonly onDelete: ReferentialAction | undefined; | ||
| readonly onUpdate: ReferentialAction | undefined; | ||
| readonly name: string | undefined; | ||
| constructor(options: { | ||
| readonly columns: readonly string[]; | ||
| readonly refTable: string; | ||
| readonly refColumns: readonly string[]; | ||
| readonly onDelete?: ReferentialAction; | ||
| readonly onUpdate?: ReferentialAction; | ||
| readonly name?: string; | ||
| }); | ||
| } | ||
| /** | ||
| * A table-level UNIQUE constraint on a `CreateTable` node. When `name` is | ||
| * set, the adapter renders `CONSTRAINT <name> UNIQUE (…)`; otherwise it | ||
| * renders an anonymous `UNIQUE (…)`. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class UniqueConstraint { | ||
| readonly kind: "unique"; | ||
| readonly columns: ReadonlyArray<string>; | ||
| readonly name: string | undefined; | ||
| constructor(options: { | ||
| readonly columns: readonly string[]; | ||
| readonly name?: string; | ||
| }); | ||
| } | ||
| /** | ||
| * A table-level CHECK constraint carrying a raw SQL predicate expression. Used | ||
| * for checks that are not enum value-set restrictions — e.g. the element-non-null | ||
| * constraint on a scalar-array column (`array_position(col, NULL) IS NULL`). | ||
| * The `expression` is emitted verbatim, so callers must supply safe, | ||
| * pre-validated SQL. | ||
| * | ||
| * Frozen on construction — immutable after creation. | ||
| */ | ||
| declare class CheckExpressionConstraint { | ||
| readonly kind: "check-expression"; | ||
| readonly name: string; | ||
| readonly expression: string; | ||
| constructor(options: { | ||
| readonly name: string; | ||
| readonly expression: string; | ||
| }); | ||
| } | ||
| type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint | CheckExpressionConstraint; | ||
| //#endregion | ||
| export { DdlColumnDefaultVisitor as a, DdlTableConstraint as c, LiteralColumnDefault as d, PrimaryKeyConstraint as f, DdlColumnDefault as i, ForeignKeyConstraint as l, isDdlNode as m, CheckExpressionConstraint as n, DdlColumnRenderContext as o, UniqueConstraint as p, DdlColumn as r, DdlNode as s, AnyDdlColumnDefault as t, FunctionColumnDefault as u }; | ||
| //# sourceMappingURL=ddl-types-DzaZCtFT.d.mts.map |
| {"version":3,"file":"ddl-types-DzaZCtFT.d.mts","names":[],"sources":["../src/ast/ddl-types.ts"],"mappings":";;;;;;;;;;;;;;UAeiB;WACN;;UAGM,wBAAwB;EACvC,QAAQ,MAAM,sBAAsB,KAAK,yBAAyB;EAClE,SAAS,MAAM,uBAAuB,KAAK,yBAAyB;;uBAGhD;oBACF;WACT,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;YAE5E;;cAKC,6BAA6B;WAC/B;WACA,OAAO;cAEJ,OAAO;EASV,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;cAK3E,8BAA8B;WAChC;WACA;cAEG;EAMH,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;KAK5E,sBAAsB,uBAAuB;cAE5C;WACF;WACA;WACA;WACA;WACA,UAAU;;WAEV,WAAW;cAER;aACD;aACA;aACA;aACA;aACA,UAAU;aACV,WAAW;;;uBAYF;oBACF;;;;;;;EAQlB;YAIU;EAIV,oBAAoB;;iBAKN,UAAU,iBAAiB,SAAS;;;;;;;;cAoBvC;WACF;WACA,SAAS;WACT;cAEG;aAAoB;aAAqC;;;;;;;;;;cAc1D;WACF;WACA,SAAS;WACT;WACA,YAAY;WACZ,UAAU;WACV,UAAU;WACV;cAEG;aACD;aACA;aACA;aACA,WAAW;aACX,WAAW;aACX;;;;;;;;;;cAmBA;WACF;WACA,SAAS;WACT;cAEG;aAAoB;aAAqC;;;;;;;;;;;;cAgB1D;WACF;WACA;WACA;cAEG;aAAoB;aAAuB;;;KAO7C,qBACR,uBACA,uBACA,mBACA"} |
| import { t as SqlExecutionPlan } from "./sql-execution-plan-CPw3uKrJ.mjs"; | ||
| import { ParamRefMutator } from "@prisma-next/framework-components/runtime"; | ||
| //#region src/middleware/param-ref-mutator.d.ts | ||
| /** | ||
| * Brand applied to {@link ParamRefHandle} so user-constructed handles | ||
| * are rejected by the type system. The mutator only accepts handles it | ||
| * produced from `entries()`. | ||
| * | ||
| * The brand is a phantom type — there is no runtime token. At runtime | ||
| * the handle is the underlying `ParamRef` instance from the plan's | ||
| * `ast`; the brand only narrows the type-level surface so callers | ||
| * cannot fabricate a handle from a fresh `ParamRef.of(...)`. | ||
| */ | ||
| declare const paramRefHandleBrand: unique symbol; | ||
| /** | ||
| * Opaque token identifying a single `ParamRef` in the plan. Produced by | ||
| * {@link SqlParamRefMutator.entries}; consumed by `replaceValue` / | ||
| * `replaceValues`. | ||
| * | ||
| * The phantom `TCodecId` parameter records the codec id of the | ||
| * referenced `ParamRef` so type-level inference can route replacement | ||
| * values through `TCodecMap` to the codec's declared `TInput`. | ||
| */ | ||
| interface ParamRefHandle<TCodecId extends string | undefined = string | undefined> { | ||
| readonly [paramRefHandleBrand]: TCodecId; | ||
| } | ||
| /** | ||
| * One outbound `ParamRef` slot in the plan exposed to middleware. | ||
| * `value` is the current value (post any prior middleware mutations); | ||
| * `codecId` is the codec id declared on the underlying `ParamRef.codec`. | ||
| */ | ||
| interface ParamRefEntry<TCodecId extends string | undefined = string | undefined> { | ||
| readonly ref: ParamRefHandle<TCodecId>; | ||
| readonly value: unknown; | ||
| readonly codecId: TCodecId; | ||
| } | ||
| /** | ||
| * Discriminated entry union over a codec map. For each `K` in | ||
| * `TCodecMap`, `entries()` may yield a `ParamRefEntry<K>`; ParamRefs | ||
| * with no codec id (or a codec id outside the map) yield a | ||
| * `ParamRefEntry<undefined>`. Pattern-matching on `entry.codecId` | ||
| * narrows `entry.ref` to a `ParamRefHandle<K>`, which routes through | ||
| * the typed `replaceValue` overload. | ||
| */ | ||
| type ParamRefEntryUnion<TCodecMap extends Record<string, unknown>> = { [K in keyof TCodecMap & string]: ParamRefEntry<K>; }[keyof TCodecMap & string] | ParamRefEntry<undefined>; | ||
| /** | ||
| * SQL-family mutator threaded into `SqlMiddleware.beforeExecute` as | ||
| * `params`. Scope is `ParamRef.value` slots only — middleware cannot | ||
| * insert / remove `ParamRef`s, rewrite SQL, or modify projection. The | ||
| * type-level `ParamRefHandle` brand and the `replaceValue(ref, | ||
| * newValue)` shape enforce this at compile time. | ||
| * | ||
| * `entries()` surfaces both literal call-site `ParamRef` slots and | ||
| * `prepare()`-time `PreparedParamRef` bind slots; the handle and codec | ||
| * id work the same for both. | ||
| * | ||
| * Allocation discipline: the mutator is constructed lazily from the | ||
| * plan. `entries()` walks the plan's existing AST without allocating | ||
| * an intermediate array; the working params buffer is only allocated | ||
| * on the first `replaceValue` / `replaceValues` call. If no middleware | ||
| * mutates, `currentParams()` returns the plan's original `params` by | ||
| * reference identity. | ||
| * | ||
| * The `TCodecMap` parameter is a record keyed by codec id; `replaceValue` | ||
| * infers `newValue` from `TCodecMap[H['codecId']]` for handles whose | ||
| * codec id is statically resolvable. For codec ids the type system | ||
| * cannot resolve, `newValue` falls back to `unknown` and the middleware | ||
| * is on the hook for runtime correctness. | ||
| */ | ||
| interface SqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends ParamRefMutator { | ||
| /** Iterate every outbound `ParamRef` the plan currently carries, in canonical order. */ | ||
| entries(): IterableIterator<ParamRefEntryUnion<TCodecMap>>; | ||
| /** | ||
| * Replace one `ParamRef`'s value with the result of bulk processing. | ||
| * `newValue` is constrained to the codec's declared `TInput` for codec | ||
| * ids the type system can resolve via `TCodecMap`; for unresolvable | ||
| * codec ids `newValue` is `unknown` (the second overload). | ||
| */ | ||
| replaceValue<TCodecId extends keyof TCodecMap & string>(ref: ParamRefHandle<TCodecId>, newValue: TCodecMap[TCodecId]): void; | ||
| replaceValue(ref: ParamRefHandle<undefined>, newValue: unknown): void; | ||
| /** Replace many at once (typical for bulk-pattern middleware). */ | ||
| replaceValues(updates: Iterable<{ | ||
| readonly ref: ParamRefHandle<(keyof TCodecMap & string) | undefined>; | ||
| readonly newValue: unknown; | ||
| }>): void; | ||
| } | ||
| /** | ||
| * Internal-only view of the mutator that exposes the post-mutation params | ||
| * array to the SQL runtime. The runtime calls `currentParams()` after the | ||
| * `beforeExecute` chain has run; the result is the plan's original | ||
| * `params` by reference identity if no middleware mutated, otherwise a | ||
| * frozen new array carrying the mutations applied in chain order. | ||
| * | ||
| * Family-internal contract — `SqlMiddleware` consumers never see this | ||
| * shape; they receive the public `SqlParamRefMutator` view above. | ||
| */ | ||
| interface SqlParamRefMutatorInternal<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends SqlParamRefMutator<TCodecMap> { | ||
| currentParams(): readonly unknown[]; | ||
| } | ||
| /** | ||
| * Build a {@link SqlParamRefMutatorInternal} for the given lowered plan. | ||
| * | ||
| * The mutator captures `plan.params` by reference and walks | ||
| * `plan.ast` (via `collectOrderedParamRefs`) on demand to build | ||
| * entries. Mutations write to a lazily-allocated working copy so the | ||
| * fast path (no mutation) preserves bit-for-bit reference identity to | ||
| * the original `plan.params`. | ||
| * | ||
| * Threading: `plan.ast` carries the canonical `ParamRef` ordering used | ||
| * by every consumer (renderer's `$N` index map, encode-side metadata | ||
| * walk, etc.). The mutator's `entries()` yields the same order so | ||
| * middleware that filters by codec id sees ParamRefs in the order the | ||
| * runtime will encode them. | ||
| */ | ||
| declare function createSqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>>(plan: SqlExecutionPlan): SqlParamRefMutatorInternal<TCodecMap>; | ||
| //#endregion | ||
| export { SqlParamRefMutatorInternal as a, SqlParamRefMutator as i, ParamRefEntryUnion as n, createSqlParamRefMutator as o, ParamRefHandle as r, ParamRefEntry as t }; | ||
| //# sourceMappingURL=middleware-CFDg6XOc.d.mts.map |
| {"version":3,"file":"middleware-CFDg6XOc.d.mts","names":[],"sources":["../src/middleware/param-ref-mutator.ts"],"mappings":";;;;;;;;;;;;;cAec;;;;;;;;;;UAWG,eAAe;YACpB,sBAAsB;;;;;;;UAQjB,cAAc;WACpB,KAAK,eAAe;WACpB;WACA,SAAS;;;;;;;;;;KAWR,mBAAmB,kBAAkB,8BAC1C,WAAW,qBAAqB,cAAc,YAAW,sBAC5D;;;;;;;;;;;;;;;;;;;;;;;;;UA0Ba,mBACf,kBAAkB,0BAA0B,iCACpC;;EAER,WAAW,iBAAiB,mBAAmB;;;;;;;EAQ/C,aAAa,uBAAuB,oBAClC,KAAK,eAAe,WACpB,UAAU,UAAU;EAEtB,aAAa,KAAK,2BAA2B;;EAG7C,cACE,SAAS;aACE,KAAK,sBAAsB;aAC3B;;;;;;;;;;;;;UAeE,2BACf,kBAAkB,0BAA0B,iCACpC,mBAAmB;EAC3B;;;;;;;;;;;;;;;;;iBAoBc,yBACd,kBAAkB,0BAA0B,yBAC5C,MAAM,mBAAmB,2BAA2B"} |
| import { f as AnyQueryAst } from "./types-Dr3jep6j.mjs"; | ||
| import { Contract } from "@prisma-next/contract/types"; | ||
| import { QueryPlan } from "@prisma-next/framework-components/runtime"; | ||
| import { SqlStorage } from "@prisma-next/sql-contract/types"; | ||
| //#region src/plan.d.ts | ||
| /** | ||
| * SQL query plan produced by lanes before lowering. | ||
| * | ||
| * Lanes build ASTs and metadata but do not perform SQL lowering. The `sql` | ||
| * field is absent — `RuntimeCore` (the runtime base class in | ||
| * `@prisma-next/framework-components/runtime`) drives lowering via the | ||
| * SQL adapter and produces a `SqlExecutionPlan`. | ||
| * | ||
| * Extends the framework-level `QueryPlan<Row>` marker (`meta + _row`) and | ||
| * adds SQL-specific fields (`ast`, `params`). The phantom `_row` property | ||
| * (inherited from `QueryPlan`) is what `ResultType<P>` inspects to recover | ||
| * the row type. | ||
| */ | ||
| interface SqlQueryPlan<Row = unknown> extends QueryPlan<Row> { | ||
| readonly ast: AnyQueryAst; | ||
| readonly params: readonly unknown[]; | ||
| } | ||
| /** | ||
| * Wraps an `AnyQueryAst` (typically a `RawSqlExpr` constructed package-internally | ||
| * by an extension's migration factory) in a fully-populated `SqlQueryPlan` | ||
| * whose `meta` is sourced from the supplied contract. | ||
| * | ||
| * Centralising the envelope here means consumers (cipherstash migration | ||
| * factories today; future raw-sql callers) cannot drift on `storageHash` / | ||
| * `target` / `targetFamily`, which would otherwise surface as a subtle | ||
| * `assertContractMatches` failure inside `dataTransform`. `params` defaults | ||
| * to `[]` because parameters embedded in the AST as `ParamRef`s are resolved | ||
| * at lowering time (`encodeParams` walks `plan.ast.collectParamRefs()`), | ||
| * not at plan-construction time. | ||
| * | ||
| * The default `laneId` of `'raw'` reflects raw-SQL plans' standard lane tag; | ||
| * callers (e.g. a future `sql-raw-factory`) may override to differentiate | ||
| * the plan's provenance. | ||
| */ | ||
| declare function planFromAst<Row = unknown>(ast: AnyQueryAst, contract: Contract<SqlStorage>, laneId?: string): SqlQueryPlan<Row>; | ||
| //#endregion | ||
| export { planFromAst as n, SqlQueryPlan as t }; | ||
| //# sourceMappingURL=plan-CBT55zev.d.mts.map |
| {"version":3,"file":"plan-CBT55zev.d.mts","names":[],"sources":["../src/plan.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAkBiB,aAAa,uBAAuB,UAAU;WACpD,KAAK;WACL;;;;;;;;;;;;;;;;;;;iBAoBK,YAAY,eAC1B,KAAK,aACL,UAAU,SAAS,aACnB,kBACC,aAAa"} |
| import { c as ContractCodecRegistry } from "./codec-types-C8vFGWij.mjs"; | ||
| import { Contract } from "@prisma-next/contract/types"; | ||
| import { CodecDescriptor, CodecRef } from "@prisma-next/framework-components/codec"; | ||
| import { SqlStorage } from "@prisma-next/sql-contract/types"; | ||
| import { SqlOperationRegistry } from "@prisma-next/sql-operations"; | ||
| //#region src/query-lane-context.d.ts | ||
| /** | ||
| * Codec-id-keyed accessor for descriptor metadata. The unified read API for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`) — non-branching for parameterized vs. non-parameterized codecs. Every codec ships natively as a `CodecDescriptor` through the unified `codecs:` contributor slot (see ADR 208). | ||
| */ | ||
| interface CodecDescriptorRegistry { | ||
| /** | ||
| * Descriptors carry distinct param shapes per codec id; the registry is heterogeneous and the consumer narrows per codec. | ||
| */ | ||
| descriptorFor(codecId: string): CodecDescriptor<unknown> | undefined; | ||
| /** | ||
| * Derive the canonical {@link CodecRef} for a contract `(table, column)`. The builder side calls this at AST construction time to stamp `codec` onto every column-bound `ParamRef` / `ProjectionItem`; the runtime side uses the result as the cache key into the content-keyed codec resolver. | ||
| * | ||
| * Resolution rules over `storage.namespaces[namespaceId].tables[table].columns[column]`: | ||
| * | ||
| * - `typeRef` column → emit `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef produce the same ref → same memoised codec). | ||
| * - inline `typeParams` column → emit `{codecId, typeParams}` from the column itself. | ||
| * - non-parameterized column → emit `{codecId}` with `typeParams` undefined (keys as `${codecId}:undefined` → one shared codec). | ||
| * | ||
| * The `namespaceId` coordinate leads and is always supplied — the table is resolved strictly within that namespace, so two same-bare-named tables in different namespaces resolve to their own per-namespace columns/codecs without colliding. | ||
| * | ||
| * Returns `undefined` when the registry was built without contract storage (package-scoped registries used purely as descriptor lookups), when the table or column is unknown in the namespace, or when the column declares a `typeRef` that the storage doesn't define. | ||
| */ | ||
| codecRefForColumn(namespaceId: string, table: string, column: string): CodecRef | undefined; | ||
| /** | ||
| * All registered descriptors. Used by `validateCodecRegistryCompleteness` and other startup-time consumers that enumerate descriptors. | ||
| */ | ||
| values(): IterableIterator<CodecDescriptor<unknown>>; | ||
| /** | ||
| * Descriptors indexed by `targetTypes[i]` (each scalar type the codec advertises). Multiple descriptors may map to the same scalar type; ordering reflects registration order. | ||
| */ | ||
| byTargetType(targetType: string): readonly CodecDescriptor<unknown>[]; | ||
| } | ||
| /** | ||
| * Registry of initialized type helpers from storage.types. Each key is a type name from storage.types, and the value is the resolved codec materialized once for that named instance via `descriptor.factory(typeParams)(ctx)` (or the raw `StorageTypeInstance` metadata for codec ids whose descriptor isn't registered). | ||
| */ | ||
| type TypeHelperRegistry = Record<string, unknown>; | ||
| type MutationDefaultsOp = 'create' | 'update'; | ||
| type AppliedMutationDefault = { | ||
| readonly column: string; | ||
| readonly value: unknown; | ||
| }; | ||
| type MutationDefaultsOptions = { | ||
| readonly op: MutationDefaultsOp; | ||
| readonly table: string; | ||
| /** | ||
| * Namespace of the target table. Execution-default refs are namespace-scoped, | ||
| * so only defaults declared for `(namespace, table)` are applied — this is what | ||
| * disambiguates same-named tables across namespaces. Required so the coordinate | ||
| * is always part of the match; a missing namespace is a caller bug, not a | ||
| * silent degrade to table-name-only matching. | ||
| */ | ||
| readonly namespace: string; | ||
| readonly values: Record<string, unknown>; | ||
| /** | ||
| * Per-ORM-operation cache for generators that declare `stability: 'query'`. The caller passes the same `Map` across every `applyMutationDefaults` invocation in one bulk operation; the framework keys by `generatorId` so the same value is reused across all rows and columns. Generators with `stability: 'row'` use a fresh per-call cache the framework manages internally; generators with `stability: 'field'` skip caching | ||
| * entirely. Omit to make every call independent (degrades `'query'` to per-call behavior). | ||
| */ | ||
| readonly defaultValueCache?: Map<string, unknown>; | ||
| }; | ||
| /** | ||
| * Minimal context interface for SQL query lanes. | ||
| * | ||
| * Lanes only need contract, operations, and codecs to build typed ASTs and attach operation builders. This interface explicitly excludes runtime concerns like adapters, connection management, and transaction state. | ||
| */ | ||
| interface ExecutionContext<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> { | ||
| readonly contract: TContract; | ||
| /** | ||
| * Contract-bound codec registry built once at context-construction time by walking the contract's columns and resolving each through its descriptor's factory. Runtime dispatch (`encodeParam` / `decodeRow`) resolves codecs via `forCodecRef(ref)` — the single dispatch shape for AST-bound codec resolution. | ||
| */ | ||
| readonly contractCodecs: ContractCodecRegistry; | ||
| /** | ||
| * Codec-id-keyed descriptor map. Single source of truth for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`) — every codec, parameterized or not, resolves through this map without branching. | ||
| */ | ||
| readonly codecDescriptors: CodecDescriptorRegistry; | ||
| readonly queryOperations: SqlOperationRegistry; | ||
| /** | ||
| * Type helper registry for parameterized types. Schema builders expose these helpers via schema.types. | ||
| */ | ||
| readonly types: TypeHelperRegistry; | ||
| /** | ||
| * Applies execution-time mutation defaults for the given table. Returns the applied defaults (caller-provided values always win). | ||
| */ | ||
| applyMutationDefaults(options: MutationDefaultsOptions): ReadonlyArray<AppliedMutationDefault>; | ||
| } | ||
| //#endregion | ||
| export { MutationDefaultsOptions as a, MutationDefaultsOp as i, CodecDescriptorRegistry as n, TypeHelperRegistry as o, ExecutionContext as r, AppliedMutationDefault as t }; | ||
| //# sourceMappingURL=query-lane-context-BNbbusGn.d.mts.map |
| {"version":3,"file":"query-lane-context-BNbbusGn.d.mts","names":[],"sources":["../src/query-lane-context.ts"],"mappings":";;;;;;;;;UASiB;;;;EAIf,cAAc,kBAAkB;;;;;;;;;;;;;;EAchC,kBAAkB,qBAAqB,eAAe,iBAAiB;;;;EAIvE,UAAU,iBAAiB;;;;EAI3B,aAAa,8BAA8B;;;;;KAMjC,qBAAqB;KAErB;KAEA;WACD;WACA;;KAGC;WACD,IAAI;WACJ;;;;;;;;WAQA;WACA,QAAQ;;;;;WAKR,oBAAoB;;;;;;;UAQd,iBAAiB,kBAAkB,SAAS,cAAc,SAAS;WACzE,UAAU;;;;WAIV,gBAAgB;;;;WAIhB,kBAAkB;WAClB,iBAAiB;;;;WAIjB,OAAO;;;;EAIhB,sBAAsB,SAAS,0BAA0B,cAAc"} |
| import { f as AnyQueryAst } from "./types-Dr3jep6j.mjs"; | ||
| import { ExecutionPlan } from "@prisma-next/framework-components/runtime"; | ||
| //#region src/sql-execution-plan.d.ts | ||
| /** | ||
| * SQL-domain execution plan: a query lowered to the wire-level shape that a | ||
| * SQL driver can run. | ||
| * | ||
| * The plan carries: | ||
| * - `sql` — the rendered SQL text | ||
| * - `params` — the bound parameter list | ||
| * - `ast` — the pre-lowering AST, retained for decoding / telemetry / middleware | ||
| * - `meta` — family-agnostic plan metadata (target, lane, hashes, ...) | ||
| * - `_row` — phantom row type, propagated from the originating `SqlQueryPlan` | ||
| * | ||
| * Extends the framework-level `ExecutionPlan<Row>` marker so generic SPIs | ||
| * (`RuntimeExecutor<SqlExecutionPlan>`, `RuntimeMiddleware<SqlExecutionPlan>`) | ||
| * can be parameterized over it. | ||
| * | ||
| * Co-located with `SqlQueryPlan` (its pre-lowering counterpart) in the lanes | ||
| * layer because lane-level utilities (`RawTemplateFactory`, `RawFactory`, | ||
| * `SqlPlan`) compose against the executable shape and the lanes layer cannot | ||
| * depend on the runtime layer. | ||
| */ | ||
| interface SqlExecutionPlan<Row = unknown> extends ExecutionPlan<Row> { | ||
| readonly sql: string; | ||
| readonly params: readonly unknown[]; | ||
| readonly ast: AnyQueryAst; | ||
| } | ||
| //#endregion | ||
| export { SqlExecutionPlan as t }; | ||
| //# sourceMappingURL=sql-execution-plan-CPw3uKrJ.d.mts.map |
| {"version":3,"file":"sql-execution-plan-CPw3uKrJ.d.mts","names":[],"sources":["../src/sql-execution-plan.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAuBiB,iBAAiB,uBAAuB,cAAc;WAC5D;WACA;WACA,KAAK"} |
| import { Y as ParamRef, g as ColumnRef } from "./types-Dr3jep6j.mjs"; | ||
| import { r as ExecutionContext } from "./query-lane-context-BNbbusGn.mjs"; | ||
| import { t as SqlExecutionPlan } from "./sql-execution-plan-CPw3uKrJ.mjs"; | ||
| import { t as SqlQueryPlan } from "./plan-CBT55zev.mjs"; | ||
| import { Contract } from "@prisma-next/contract/types"; | ||
| import { RuntimeExecutor } from "@prisma-next/framework-components/runtime"; | ||
| import { ExtractFieldOutputTypes, SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types"; | ||
| import { ParamSpec } from "@prisma-next/operations"; | ||
| import { SqlLoweringSpec } from "@prisma-next/sql-operations"; | ||
| //#region src/runtime-scope.d.ts | ||
| /** | ||
| * The plan shape accepted by the SQL ORM client and SQL runtime: either a | ||
| * pre-lowering `SqlQueryPlan` (AST + meta) or a post-lowering | ||
| * `SqlExecutionPlan` (sql + params + meta). | ||
| */ | ||
| type SqlOrmPlan = SqlExecutionPlan | SqlQueryPlan; | ||
| /** | ||
| * The minimal SQL-runtime surface that the ORM client and SQL runtime both | ||
| * depend on: the `execute` method of `RuntimeExecutor<SqlOrmPlan>`. | ||
| * | ||
| * Owned by `sql-relational-core` (lanes layer) so both | ||
| * `@prisma-next/sql-runtime` and `@prisma-next/sql-orm-client` consume the | ||
| * same source of truth without a layering inversion. | ||
| */ | ||
| type RuntimeScope = Pick<RuntimeExecutor<SqlOrmPlan>, 'execute'>; | ||
| //#endregion | ||
| //#region src/types.d.ts | ||
| type Expr = ColumnRef | ParamRef; | ||
| /** | ||
| * The minimal contract shape the per-namespace column resolver needs: the | ||
| * application-domain models and the storage tables, both keyed by namespace | ||
| * coordinate, plus (via the optional TypeMaps phantom key, read structurally by | ||
| * {@link ExtractFieldOutputTypes}) the refined field-output map. Every emitted | ||
| * `Contract<SqlStorage>` satisfies it, as does `sql-builder`'s `TableProxyContract` | ||
| * — so the resolver indexes the coordinate directly without forcing callers to | ||
| * carry the full `Contract`. | ||
| */ | ||
| type ColumnResolutionContract = { | ||
| readonly domain: { | ||
| readonly namespaces: Readonly<Record<string, { | ||
| readonly models: Readonly<Record<string, unknown>>; | ||
| }>>; | ||
| }; | ||
| readonly storage: { | ||
| readonly namespaces: Readonly<Record<string, { | ||
| readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>; | ||
| }>>; | ||
| }; | ||
| }; | ||
| type NamespaceModels<TContract extends ColumnResolutionContract, NsId extends string> = TContract['domain']['namespaces'][NsId] extends { | ||
| readonly models: infer Models extends Record<string, unknown>; | ||
| } ? Models : never; | ||
| type ExtractTableToModel<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string> = NamespaceModels<TContract, NsId> extends (infer Models extends Record<string, unknown>) ? { [M in keyof Models & string]: Models[M] extends { | ||
| readonly storage: { | ||
| readonly table: TableName; | ||
| }; | ||
| } ? M : never; }[keyof Models & string] : never; | ||
| type ExtractColumnToField<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string> = ExtractTableToModel<TContract, NsId, TableName> extends (infer ModelName extends string) ? NamespaceModels<TContract, NsId> extends (infer Models extends Record<string, unknown>) ? ModelName & keyof Models extends (infer MKey extends string) ? Models[MKey] extends { | ||
| readonly storage: { | ||
| readonly fields: infer Fields extends Record<string, unknown>; | ||
| }; | ||
| } ? { [F in keyof Fields & string]: Fields[F] extends { | ||
| readonly column: ColumnName; | ||
| } ? F : never; }[keyof Fields & string] : never : never : never : never; | ||
| /** Resolves to `never` when the table or column is absent in the namespace. */ | ||
| type NamespaceStorageColumn<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string> = TContract['storage']['namespaces'][NsId] extends { | ||
| readonly entries: { | ||
| readonly table: infer Tables extends Record<string, unknown>; | ||
| }; | ||
| } ? TableName extends keyof Tables ? Tables[TableName] extends { | ||
| readonly columns: infer Columns extends Record<string, unknown>; | ||
| } ? ColumnName extends keyof Columns ? Columns[ColumnName] extends StorageColumn ? Columns[ColumnName] : never : never : never : never : never; | ||
| type FallbackCodecLookup<ColumnMeta extends StorageColumn, CodecTypes extends Record<string, { | ||
| readonly output: unknown; | ||
| }>> = ColumnMeta extends { | ||
| codecId: infer CodecId extends string; | ||
| } ? CodecId extends keyof CodecTypes ? CodecTypes[CodecId] extends { | ||
| readonly output: infer O; | ||
| } ? ColumnMeta extends { | ||
| nullable: true; | ||
| } ? O | null : O : unknown : unknown : unknown; | ||
| /** | ||
| * The refined (typeParam-applied) JS output type for a field within a namespace | ||
| * coordinate, read from the emitter's namespace-nested `FieldOutputTypes` map at | ||
| * `FieldOutputTypes[NsId][Model][Field]`. This preserves parameterized codec | ||
| * refinements (e.g. `Vector<N>`, `Char<N>`) that a bare codec-output lookup | ||
| * would drop. Resolves to `never` when the coordinate is absent from the map. | ||
| */ | ||
| type NamespaceFieldOutput<TContract extends ColumnResolutionContract, NsId extends string, ModelName extends string, FieldName extends string> = ExtractFieldOutputTypes<TContract> extends (infer Outputs) ? NsId extends keyof Outputs ? Outputs[NsId] extends (infer NamespaceOutputs) ? ModelName extends keyof NamespaceOutputs ? NamespaceOutputs[ModelName] extends (infer ModelOutputs) ? FieldName extends keyof ModelOutputs ? ModelOutputs[FieldName] : never : never : never : never : never : never; | ||
| /** | ||
| * The secondary resolution path, taken for a storage column not backed by a | ||
| * domain model field in the namespace (e.g. a column with no corresponding | ||
| * field); refined model fields resolve via {@link NamespaceFieldOutput}. | ||
| */ | ||
| type ColumnCodecFallback<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string, CodecTypes extends Record<string, { | ||
| readonly output: unknown; | ||
| }>> = NamespaceStorageColumn<TContract, NsId, TableName, ColumnName> extends (infer ColumnMeta) ? [ColumnMeta] extends [never] ? never : ColumnMeta extends StorageColumn ? FallbackCodecLookup<ColumnMeta, CodecTypes> : never : never; | ||
| /** | ||
| * Type-level operation signature. | ||
| * Represents an operation at the type level for use in contract type maps. | ||
| */ | ||
| type OperationTypeSignature = { | ||
| readonly args: ReadonlyArray<ParamSpec>; | ||
| readonly returns: ParamSpec; | ||
| readonly lowering: SqlLoweringSpec; | ||
| readonly capabilities?: ReadonlyArray<string>; | ||
| }; | ||
| /** | ||
| * Type-level operation registry. | ||
| * Maps typeId → operations, where operations is a record of method name → operation signature. | ||
| * | ||
| * Example: | ||
| * ```typescript | ||
| * type MyOperations: OperationTypes = { | ||
| * 'pg/vector@1': { | ||
| * cosineDistance: { | ||
| * args: [{ codecId: 'pg/vector@1'; nullable: false }]; | ||
| * returns: { codecId: 'core/float8'; nullable: false }; | ||
| * lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' }; | ||
| * }; | ||
| * }; | ||
| * }; | ||
| * ``` | ||
| */ | ||
| type OperationTypes = Record<string, Record<string, OperationTypeSignature>>; | ||
| /** | ||
| * CodecTypes represents a map of typeId to codec definitions. | ||
| * Each codec definition must have an `output` property indicating the JavaScript type. | ||
| * | ||
| * Example: | ||
| * ```typescript | ||
| * type MyCodecTypes: CodecTypes = { | ||
| * 'pg/int4@1': { output: number }; | ||
| * 'pg/text@1': { output: string }; | ||
| * }; | ||
| * ``` | ||
| */ | ||
| type CodecTypes = Record<string, { | ||
| readonly output: unknown; | ||
| }>; | ||
| /** | ||
| * Extracts operations for a given typeId from the operation registry. | ||
| * Returns an empty record if the typeId is not found. | ||
| * | ||
| * @example | ||
| * ```typescript | ||
| * type Ops = OperationsForTypeId<'pg/vector@1', MyOperations>; | ||
| * // Ops = { cosineDistance: { ... }, l2Distance: { ... } } | ||
| * ``` | ||
| */ | ||
| type OperationsForTypeId<TypeId extends string, Operations extends OperationTypes> = Operations extends Record<string, never> ? Record<string, never> : TypeId extends keyof Operations ? Operations[TypeId] : Record<string, never>; | ||
| /** | ||
| * Resolves the JavaScript output type of a column addressed by an explicit | ||
| * namespace coordinate. | ||
| * | ||
| * The table→model and column→field mapping is resolved per-namespace from | ||
| * `domain.namespaces[NsId]['models']`, and the refined output type from the | ||
| * emitter's namespace-nested `FieldOutputTypes[NsId][Model][Field]` — so a bare | ||
| * table name shared across namespaces resolves to each namespace's own field, | ||
| * and parameterized codec refinements (e.g. `Vector<N>`) are preserved. A | ||
| * storage column not backed by a model field in the namespace falls back to a | ||
| * codec-output lookup; a column absent in the namespace resolves to `never`. | ||
| */ | ||
| type ComputeColumnJsType<TContract extends ColumnResolutionContract, NsId extends string, TableName extends string, ColumnName extends string, CodecTypes extends Record<string, { | ||
| readonly output: unknown; | ||
| }>> = ExtractTableToModel<TContract, NsId, TableName> extends (infer ModelName) ? [ModelName] extends [never] ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes> : ModelName extends string ? ExtractColumnToField<TContract, NsId, TableName, ColumnName> extends (infer FieldName) ? [FieldName] extends [never] ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes> : FieldName extends string ? NamespaceFieldOutput<TContract, NsId, ModelName, FieldName> extends (infer Out) ? [Out] extends [never] ? ColumnCodecFallback<TContract, NsId, TableName, ColumnName, CodecTypes> : Out : never : never : never : never : never; | ||
| /** | ||
| * Alias for the SQL-domain executable plan, exposed under the legacy | ||
| * `SqlPlan` name for compatibility with SQL builder/utility call sites. | ||
| * The canonical name is `SqlExecutionPlan` (`./sql-execution-plan`). | ||
| */ | ||
| type SqlPlan<Row = unknown> = SqlExecutionPlan<Row>; | ||
| /** | ||
| * Helper types for extracting contract structure. | ||
| */ | ||
| type TablesOf<TContract> = TContract extends { | ||
| storage: { | ||
| tables: infer U; | ||
| }; | ||
| } ? U : never; | ||
| type TableKey<TContract> = Extract<keyof TablesOf<TContract>, string>; | ||
| /** | ||
| * Unique symbol for metadata property to avoid collisions with user-defined properties | ||
| */ | ||
| declare const META: unique symbol; | ||
| /** | ||
| * Extracts metadata from a type that has a META property | ||
| */ | ||
| type Meta<T extends { | ||
| [META]: unknown; | ||
| }> = T[typeof META]; | ||
| /** | ||
| * Metadata interface for table definitions | ||
| */ | ||
| interface TableMetadata<Name extends string> { | ||
| name: Name; | ||
| } | ||
| /** | ||
| * Metadata interface for model definitions | ||
| */ | ||
| interface ModelMetadata<Name extends string> { | ||
| name: Name; | ||
| } | ||
| /** | ||
| * Base interface for table definitions with metadata | ||
| * Used in contract.d.ts to define storage-level table types | ||
| */ | ||
| interface TableDef<Name extends string> { | ||
| readonly [META]: TableMetadata<Name>; | ||
| } | ||
| /** | ||
| * Base interface for model definitions with metadata | ||
| * Used in contract.d.ts to define application-level model types | ||
| */ | ||
| interface ModelDef<Name extends string> { | ||
| readonly [META]: ModelMetadata<Name>; | ||
| } | ||
| type ColumnsOf<TContract, K extends TableKey<TContract>> = K extends keyof TablesOf<TContract> ? TablesOf<TContract>[K] extends { | ||
| columns: infer C; | ||
| } ? C : never : never; | ||
| interface RawTemplateOptions { | ||
| readonly annotations?: Record<string, unknown>; | ||
| } | ||
| interface RawFunctionOptions extends RawTemplateOptions { | ||
| readonly params: ReadonlyArray<unknown>; | ||
| } | ||
| type RawTemplateFactory = (strings: TemplateStringsArray, ...values: readonly unknown[]) => SqlExecutionPlan; | ||
| interface RawFactory extends RawTemplateFactory { | ||
| (text: string, options: RawFunctionOptions): SqlExecutionPlan; | ||
| with(options: RawTemplateOptions): RawTemplateFactory; | ||
| } | ||
| interface BuildParamsMap { | ||
| readonly [name: string]: unknown; | ||
| } | ||
| interface BuildOptions { | ||
| readonly params?: BuildParamsMap; | ||
| } | ||
| interface SqlBuilderOptions<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> { | ||
| readonly context: ExecutionContext<TContract>; | ||
| } | ||
| //#endregion | ||
| export { TableMetadata as C, SqlOrmPlan as E, TableKey as S, RuntimeScope as T, RawTemplateFactory as _, ColumnsOf as a, SqlPlan as b, META as c, ModelMetadata as d, OperationTypeSignature as f, RawFunctionOptions as g, RawFactory as h, ColumnResolutionContract as i, Meta as l, OperationsForTypeId as m, BuildParamsMap as n, ComputeColumnJsType as o, OperationTypes as p, CodecTypes as r, Expr as s, BuildOptions as t, ModelDef as u, RawTemplateOptions as v, TablesOf as w, TableDef as x, SqlBuilderOptions as y }; | ||
| //# sourceMappingURL=types-BR266jxM.d.mts.map |
| {"version":3,"file":"types-BR266jxM.d.mts","names":[],"sources":["../src/runtime-scope.ts","../src/types.ts"],"mappings":"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"} |
| import { o as CodecRef } from "./codec-types-C8vFGWij.mjs"; | ||
| import { ParamSpec } from "@prisma-next/operations"; | ||
| import { SqlLoweringSpec } from "@prisma-next/sql-operations"; | ||
| //#region src/ast/types.d.ts | ||
| type Direction = 'asc' | 'desc'; | ||
| type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'like' | 'in' | 'notIn'; | ||
| type AggregateCountFn = 'count'; | ||
| type AggregateOpFn = 'sum' | 'avg' | 'min' | 'max'; | ||
| type AggregateFn = AggregateCountFn | AggregateOpFn; | ||
| /** | ||
| * Window function names. Currently only `row_number` is wired up — added | ||
| * to support `ROW_NUMBER() OVER (PARTITION BY ... ORDER BY ...) = 1` | ||
| * lowering for `.distinct(cols)` semantics in the SQL ORM client. `rank` | ||
| * and `dense_rank` are reserved here so future additions don't churn the | ||
| * type; renderers only need to dispatch on the function name string. | ||
| */ | ||
| type WindowFn = 'row_number' | 'rank' | 'dense_rank'; | ||
| /** Scalar JS values that map directly to a SQL wire type. Values outside this set must be routed through `param(value, { codecId })` to declare the target codec explicitly. */ | ||
| type RawSqlLiteral = number | bigint | string | boolean | Uint8Array; | ||
| interface ExpressionSource { | ||
| toExpr(): AnyExpression; | ||
| } | ||
| interface ExpressionRewriter { | ||
| columnRef?(expr: ColumnRef): AnyExpression; | ||
| identifierRef?(expr: IdentifierRef): AnyExpression; | ||
| paramRef?(expr: ParamRef): ParamRef | LiteralExpr; | ||
| preparedParamRef?(expr: PreparedParamRef): PreparedParamRef; | ||
| literal?(expr: LiteralExpr): LiteralExpr; | ||
| list?(expr: ListExpression): ListExpression | LiteralExpr; | ||
| select?(ast: SelectAst): SelectAst; | ||
| rawExpr?(expr: RawExpr): AnyExpression; | ||
| } | ||
| interface AstRewriter extends ExpressionRewriter { | ||
| tableSource?(source: TableSource): TableSource; | ||
| eqColJoinOn?(on: EqColJoinOn): EqColJoinOn | AnyExpression; | ||
| } | ||
| interface ExprVisitor<R> { | ||
| columnRef(expr: ColumnRef): R; | ||
| identifierRef(expr: IdentifierRef): R; | ||
| subquery(expr: SubqueryExpr): R; | ||
| operation(expr: OperationExpr): R; | ||
| aggregate(expr: AggregateExpr): R; | ||
| windowFunc(expr: WindowFuncExpr): R; | ||
| jsonObject(expr: JsonObjectExpr): R; | ||
| jsonArrayAgg(expr: JsonArrayAggExpr): R; | ||
| binary(expr: BinaryExpr): R; | ||
| and(expr: AndExpr): R; | ||
| or(expr: OrExpr): R; | ||
| exists(expr: ExistsExpr): R; | ||
| nullCheck(expr: NullCheckExpr): R; | ||
| not(expr: NotExpr): R; | ||
| literal(expr: LiteralExpr): R; | ||
| param(expr: ParamRef): R; | ||
| preparedParam(expr: PreparedParamRef): R; | ||
| list(expr: ListExpression): R; | ||
| rawExpr(expr: RawExpr): R; | ||
| } | ||
| interface ExpressionFolder<T> { | ||
| empty: T; | ||
| combine(a: T, b: T): T; | ||
| isAbsorbing?(value: T): boolean; | ||
| columnRef?(expr: ColumnRef): T; | ||
| identifierRef?(expr: IdentifierRef): T; | ||
| paramRef?(expr: ParamRef): T; | ||
| preparedParamRef?(expr: PreparedParamRef): T; | ||
| literal?(expr: LiteralExpr): T; | ||
| list?(expr: ListExpression): T; | ||
| select?(ast: SelectAst): T; | ||
| rawExpr?(expr: RawExpr): T; | ||
| } | ||
| type ProjectionExpr = AnyExpression; | ||
| type InsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr; | ||
| type JoinOnExpr = EqColJoinOn | AnyExpression; | ||
| type WhereArg = AnyExpression | ToWhereExpr; | ||
| type JsonObjectEntry = { | ||
| readonly key: string; | ||
| readonly value: ProjectionExpr; | ||
| }; | ||
| declare abstract class AstNode { | ||
| abstract readonly kind: string; | ||
| protected freeze(): void; | ||
| } | ||
| declare abstract class QueryAst extends AstNode { | ||
| abstract collectParamRefs(): AnyParamRef[]; | ||
| abstract toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare abstract class FromSource extends AstNode { | ||
| abstract rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| abstract toFromSource(): AnyFromSource; | ||
| } | ||
| declare abstract class Expression extends AstNode implements ExpressionSource { | ||
| abstract accept<R>(visitor: ExprVisitor<R>): R; | ||
| abstract rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| abstract fold<T>(folder: ExpressionFolder<T>): T; | ||
| collectColumnRefs(): ColumnRef[]; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| baseColumnRef(): ColumnRef; | ||
| toExpr(): AnyExpression; | ||
| not(): NotExpr; | ||
| } | ||
| declare class TableSource extends FromSource { | ||
| readonly kind: "table-source"; | ||
| readonly name: string; | ||
| readonly alias: string | undefined; | ||
| /** | ||
| * Resolved storage namespace coordinate for this table, stamped when the | ||
| * table proxy constructs the AST. Renderers qualify via the namespace | ||
| * concretion's `qualifyTable()` using this id — never by re-resolving the | ||
| * bare table name at render time. | ||
| */ | ||
| readonly namespaceId: string | undefined; | ||
| protected constructor(name: string, alias?: string, namespaceId?: string); | ||
| static named(name: string, alias?: string, namespaceId?: string): TableSource; | ||
| rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| toFromSource(): AnyFromSource; | ||
| } | ||
| interface TableRef { | ||
| readonly name: string; | ||
| readonly alias?: string; | ||
| } | ||
| declare class DerivedTableSource extends FromSource { | ||
| readonly kind: "derived-table-source"; | ||
| readonly alias: string; | ||
| readonly query: SelectAst; | ||
| constructor(alias: string, query: SelectAst); | ||
| static as(alias: string, query: SelectAst): DerivedTableSource; | ||
| rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| toFromSource(): AnyFromSource; | ||
| } | ||
| declare class FunctionSource extends FromSource { | ||
| readonly kind: "function-source"; | ||
| readonly fn: string; | ||
| readonly args: ReadonlyArray<AnyExpression>; | ||
| readonly alias: string | undefined; | ||
| protected constructor(fn: string, args: ReadonlyArray<AnyExpression>, alias?: string); | ||
| static of(fn: string, args: ReadonlyArray<AnyExpression>, alias?: string): FunctionSource; | ||
| rewrite(rewriter: AstRewriter): AnyFromSource; | ||
| toFromSource(): AnyFromSource; | ||
| } | ||
| declare class ColumnRef extends Expression { | ||
| readonly kind: "column-ref"; | ||
| readonly table: string; | ||
| readonly column: string; | ||
| constructor(table: string, column: string); | ||
| static of(table: string, column: string): ColumnRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| baseColumnRef(): ColumnRef; | ||
| } | ||
| declare class IdentifierRef extends Expression { | ||
| readonly kind: "identifier-ref"; | ||
| readonly name: string; | ||
| constructor(name: string); | ||
| static of(name: string): IdentifierRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class ParamRef extends Expression { | ||
| readonly kind: "param-ref"; | ||
| readonly value: unknown; | ||
| readonly name: string | undefined; | ||
| /** | ||
| * Codec identity carried by every column-bound `ParamRef`. The encode-side dispatch path materialises the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation on `(codecId, canonicalize(typeParams))` keeps repeated lookups for the same logical column on one shared {@link Codec}. | ||
| * | ||
| * `codec` may be `undefined` for `ParamRef`s constructed without a column-bound site (literals, transient builder state); the runtime treats those as untyped passthroughs. | ||
| */ | ||
| readonly codec: CodecRef | undefined; | ||
| constructor(value: unknown, options?: { | ||
| name?: string; | ||
| codec?: CodecRef; | ||
| }); | ||
| static of(value: unknown, options?: { | ||
| name?: string; | ||
| codec?: CodecRef; | ||
| }): ParamRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| /** | ||
| * Bind-site placeholder: occupies the same positions as `ParamRef` in the | ||
| * AST, but carries no value — the value is supplied per-execute by the | ||
| * `PreparedStatement.execute(params)` caller and matched to this node by | ||
| * `name`. | ||
| */ | ||
| declare class PreparedParamRef extends Expression { | ||
| readonly kind: "prepared-param-ref"; | ||
| readonly name: string; | ||
| readonly codec: CodecRef; | ||
| constructor(name: string, codec: CodecRef); | ||
| static of(name: string, codec: CodecRef): PreparedParamRef; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class DefaultValueExpr extends AstNode { | ||
| readonly kind: "default-value"; | ||
| constructor(); | ||
| } | ||
| declare class LiteralExpr extends Expression { | ||
| readonly kind: "literal"; | ||
| readonly value: unknown; | ||
| constructor(value: unknown); | ||
| static of(value: unknown): LiteralExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class SubqueryExpr extends Expression { | ||
| readonly kind: "subquery"; | ||
| readonly query: SelectAst; | ||
| constructor(query: SelectAst); | ||
| static of(query: SelectAst): SubqueryExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class OperationExpr extends Expression { | ||
| readonly kind: "operation"; | ||
| readonly method: string; | ||
| readonly self: AnyExpression; | ||
| readonly args: ReadonlyArray<AnyExpression | ParamRef | LiteralExpr>; | ||
| readonly returns: ParamSpec; | ||
| readonly lowering: SqlLoweringSpec; | ||
| constructor(options: { | ||
| readonly method: string; | ||
| readonly self: AnyExpression; | ||
| readonly args: ReadonlyArray<AnyExpression | ParamRef | LiteralExpr> | undefined; | ||
| readonly returns: ParamSpec; | ||
| readonly lowering: SqlLoweringSpec; | ||
| }); | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| baseColumnRef(): ColumnRef; | ||
| } | ||
| declare class RawExpr extends Expression { | ||
| readonly kind: "raw-expr"; | ||
| readonly parts: ReadonlyArray<string | AnyExpression>; | ||
| readonly returns: ParamSpec; | ||
| constructor(options: { | ||
| readonly parts: ReadonlyArray<string | AnyExpression>; | ||
| readonly returns: ParamSpec; | ||
| }); | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class AggregateExpr extends Expression { | ||
| readonly kind: "aggregate"; | ||
| readonly fn: AggregateFn; | ||
| readonly expr: AnyExpression | undefined; | ||
| constructor(fn: AggregateFn, expr?: AnyExpression); | ||
| static count(expr?: AnyExpression): AggregateExpr; | ||
| static sum(expr: AnyExpression): AggregateExpr; | ||
| static avg(expr: AnyExpression): AggregateExpr; | ||
| static min(expr: AnyExpression): AggregateExpr; | ||
| static max(expr: AnyExpression): AggregateExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| /** | ||
| * Window function call: `fn(args) OVER (PARTITION BY ... ORDER BY ...)`. | ||
| * | ||
| * Both `partitionBy` and `orderBy` are optional; an empty `OVER ()` | ||
| * clause is legal SQL but rarely useful. For `ROW_NUMBER`, `RANK`, and | ||
| * `DENSE_RANK` the standard mandates an `ORDER BY` for deterministic | ||
| * results — callers are expected to provide one, but the AST does not | ||
| * enforce it. | ||
| * | ||
| * The `args` slot exists for future window function additions that take | ||
| * arguments (e.g. `COUNT(*) OVER`, `SUM(x) OVER`); `ROW_NUMBER` and the | ||
| * other ranking functions take no arguments. | ||
| */ | ||
| declare class WindowFuncExpr extends Expression { | ||
| readonly kind: "window-func"; | ||
| readonly fn: WindowFn; | ||
| readonly args: ReadonlyArray<AnyExpression>; | ||
| readonly partitionBy: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| constructor(options: { | ||
| readonly fn: WindowFn; | ||
| readonly args?: ReadonlyArray<AnyExpression>; | ||
| readonly partitionBy?: ReadonlyArray<AnyExpression>; | ||
| readonly orderBy?: ReadonlyArray<OrderByItem>; | ||
| }); | ||
| static rowNumber(options: { | ||
| readonly partitionBy?: ReadonlyArray<AnyExpression>; | ||
| readonly orderBy?: ReadonlyArray<OrderByItem>; | ||
| }): WindowFuncExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class JsonObjectExpr extends Expression { | ||
| readonly kind: "json-object"; | ||
| readonly entries: ReadonlyArray<JsonObjectEntry>; | ||
| constructor(entries: ReadonlyArray<JsonObjectEntry>); | ||
| static entry(key: string, value: ProjectionExpr): JsonObjectEntry; | ||
| static fromEntries(entries: ReadonlyArray<JsonObjectEntry>): JsonObjectExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class OrderByItem extends AstNode { | ||
| readonly kind: "order-by-item"; | ||
| readonly expr: AnyExpression; | ||
| readonly dir: Direction; | ||
| constructor(expr: AnyExpression, dir: Direction); | ||
| static asc(expr: AnyExpression): OrderByItem; | ||
| static desc(expr: AnyExpression): OrderByItem; | ||
| rewrite(rewriter: ExpressionRewriter): OrderByItem; | ||
| /** | ||
| * A new frozen item with the sort direction flipped and `expr` unchanged. | ||
| * Integrations that own pagination (e.g. backward cursor pagination) use | ||
| * this to reverse a user's sort order without reaching into the AST. | ||
| */ | ||
| reverse(): OrderByItem; | ||
| } | ||
| declare class JsonArrayAggExpr extends Expression { | ||
| readonly kind: "json-array-agg"; | ||
| readonly expr: AnyExpression; | ||
| readonly onEmpty: 'null' | 'emptyArray'; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| constructor(expr: AnyExpression, onEmpty?: 'null' | 'emptyArray', orderBy?: ReadonlyArray<OrderByItem>); | ||
| static of(expr: AnyExpression, onEmpty?: 'null' | 'emptyArray', orderBy?: ReadonlyArray<OrderByItem>): JsonArrayAggExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class ListExpression extends Expression { | ||
| readonly kind: "list"; | ||
| readonly values: ReadonlyArray<AnyExpression>; | ||
| constructor(values: ReadonlyArray<AnyExpression>); | ||
| static of(values: ReadonlyArray<AnyExpression>): ListExpression; | ||
| static fromValues(values: ReadonlyArray<unknown>): ListExpression; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class BinaryExpr extends Expression { | ||
| readonly kind: "binary"; | ||
| readonly op: BinaryOp; | ||
| readonly left: AnyExpression; | ||
| readonly right: AnyExpression; | ||
| constructor(op: BinaryOp, left: AnyExpression, right: AnyExpression); | ||
| static eq(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static neq(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static gt(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static lt(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static gte(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static lte(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static like(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static in(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| static notIn(left: AnyExpression, right: AnyExpression): BinaryExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class AndExpr extends Expression { | ||
| readonly kind: "and"; | ||
| readonly exprs: ReadonlyArray<AnyExpression>; | ||
| constructor(exprs: ReadonlyArray<AnyExpression>); | ||
| static of(exprs: ReadonlyArray<AnyExpression>): AndExpr; | ||
| static true(): AndExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class OrExpr extends Expression { | ||
| readonly kind: "or"; | ||
| readonly exprs: ReadonlyArray<AnyExpression>; | ||
| constructor(exprs: ReadonlyArray<AnyExpression>); | ||
| static of(exprs: ReadonlyArray<AnyExpression>): OrExpr; | ||
| static false(): OrExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class ExistsExpr extends Expression { | ||
| readonly kind: "exists"; | ||
| readonly notExists: boolean; | ||
| readonly subquery: SelectAst; | ||
| constructor(subquery: SelectAst, notExists?: boolean); | ||
| static exists(subquery: SelectAst): ExistsExpr; | ||
| static notExists(subquery: SelectAst): ExistsExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class NullCheckExpr extends Expression { | ||
| readonly kind: "null-check"; | ||
| readonly expr: AnyExpression; | ||
| readonly isNull: boolean; | ||
| constructor(expr: AnyExpression, isNull: boolean); | ||
| static isNull(expr: AnyExpression): NullCheckExpr; | ||
| static isNotNull(expr: AnyExpression): NullCheckExpr; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class NotExpr extends Expression { | ||
| readonly kind: "not"; | ||
| readonly expr: AnyExpression; | ||
| constructor(expr: AnyExpression); | ||
| toWhereExpr(): AnyExpression; | ||
| accept<R>(visitor: ExprVisitor<R>): R; | ||
| rewrite(rewriter: ExpressionRewriter): AnyExpression; | ||
| fold<T>(folder: ExpressionFolder<T>): T; | ||
| } | ||
| declare class EqColJoinOn extends AstNode { | ||
| readonly kind: "eq-col-join-on"; | ||
| readonly left: ColumnRef; | ||
| readonly right: ColumnRef; | ||
| constructor(left: ColumnRef, right: ColumnRef); | ||
| static of(left: ColumnRef, right: ColumnRef): EqColJoinOn; | ||
| rewrite(rewriter: AstRewriter): EqColJoinOn | AnyExpression; | ||
| } | ||
| declare class JoinAst extends AstNode { | ||
| readonly kind: "join"; | ||
| readonly joinType: 'inner' | 'left' | 'right' | 'full'; | ||
| readonly source: AnyFromSource; | ||
| readonly lateral: boolean; | ||
| readonly on: JoinOnExpr; | ||
| constructor(joinType: 'inner' | 'left' | 'right' | 'full', source: AnyFromSource, on: JoinOnExpr, lateral?: boolean); | ||
| static inner(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| static left(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| static right(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| static full(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst; | ||
| rewrite(rewriter: AstRewriter): JoinAst; | ||
| } | ||
| declare class ProjectionItem extends AstNode { | ||
| readonly kind: "projection-item"; | ||
| readonly alias: string; | ||
| readonly expr: ProjectionExpr; | ||
| /** | ||
| * Codec identity for the projected cell. Decode-side dispatch resolves the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation collapses repeated lookups for the same logical column onto one shared {@link Codec}. | ||
| * | ||
| * Stays `undefined` for non-column-bound projections (computed expressions, subqueries, raw aliases) whose decoded type the runtime cannot infer from a single contract column. | ||
| */ | ||
| readonly codec: CodecRef | undefined; | ||
| constructor(alias: string, expr: ProjectionExpr, codec?: CodecRef); | ||
| static of(alias: string, expr: ProjectionExpr, codec?: CodecRef): ProjectionItem; | ||
| withCodec(codec: CodecRef | undefined): ProjectionItem; | ||
| } | ||
| type LimitOffsetValue = number | AnyExpression; | ||
| interface SelectAstOptions { | ||
| readonly from?: AnyFromSource; | ||
| readonly joins: ReadonlyArray<JoinAst> | undefined; | ||
| readonly projection: ReadonlyArray<ProjectionItem>; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| readonly distinct: true | undefined; | ||
| readonly distinctOn: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly groupBy: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly having: AnyExpression | undefined; | ||
| readonly limit: LimitOffsetValue | undefined; | ||
| readonly offset: LimitOffsetValue | undefined; | ||
| readonly selectAllIntent: { | ||
| readonly table?: string; | ||
| } | undefined; | ||
| } | ||
| declare class SelectAst extends QueryAst { | ||
| readonly kind: "select"; | ||
| readonly from: AnyFromSource | undefined; | ||
| readonly joins: ReadonlyArray<JoinAst> | undefined; | ||
| readonly projection: ReadonlyArray<ProjectionItem>; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly orderBy: ReadonlyArray<OrderByItem> | undefined; | ||
| readonly distinct: true | undefined; | ||
| readonly distinctOn: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly groupBy: ReadonlyArray<AnyExpression> | undefined; | ||
| readonly having: AnyExpression | undefined; | ||
| readonly limit: LimitOffsetValue | undefined; | ||
| readonly offset: LimitOffsetValue | undefined; | ||
| readonly selectAllIntent: { | ||
| readonly table?: string; | ||
| } | undefined; | ||
| constructor(options: SelectAstOptions); | ||
| static from(from: AnyFromSource): SelectAst; | ||
| static noFrom(): SelectAst; | ||
| private toOptions; | ||
| withFrom(from: AnyFromSource): SelectAst; | ||
| withJoins(joins: ReadonlyArray<JoinAst>): SelectAst; | ||
| withProjection(projection: ReadonlyArray<ProjectionItem>): SelectAst; | ||
| addProjection(alias: string, expr: ProjectionExpr): SelectAst; | ||
| withWhere(where: AnyExpression | undefined): SelectAst; | ||
| withOrderBy(orderBy: ReadonlyArray<OrderByItem>): SelectAst; | ||
| withDistinct(enabled?: boolean): SelectAst; | ||
| withDistinctOn(distinctOn: ReadonlyArray<AnyExpression>): SelectAst; | ||
| withGroupBy(groupBy: ReadonlyArray<AnyExpression>): SelectAst; | ||
| withHaving(having: AnyExpression | undefined): SelectAst; | ||
| withLimit(limit: LimitOffsetValue | undefined): SelectAst; | ||
| withOffset(offset: LimitOffsetValue | undefined): SelectAst; | ||
| withSelectAllIntent(selectAllIntent: { | ||
| readonly table?: string; | ||
| } | undefined): SelectAst; | ||
| rewrite(rewriter: AstRewriter): SelectAst; | ||
| collectColumnRefs(): ColumnRef[]; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare abstract class InsertOnConflictAction extends AstNode { | ||
| abstract toInsertOnConflictAction(): AnyInsertOnConflictAction; | ||
| } | ||
| declare class DoNothingConflictAction extends InsertOnConflictAction { | ||
| readonly kind: "do-nothing"; | ||
| constructor(); | ||
| toInsertOnConflictAction(): AnyInsertOnConflictAction; | ||
| } | ||
| declare class DoUpdateSetConflictAction extends InsertOnConflictAction { | ||
| readonly kind: "do-update-set"; | ||
| readonly set: Readonly<Record<string, AnyExpression>>; | ||
| constructor(set: Readonly<Record<string, AnyExpression>>); | ||
| toInsertOnConflictAction(): AnyInsertOnConflictAction; | ||
| } | ||
| declare class InsertOnConflict extends AstNode { | ||
| readonly kind: "insert-on-conflict"; | ||
| readonly columns: ReadonlyArray<ColumnRef>; | ||
| readonly action: AnyInsertOnConflictAction; | ||
| constructor(columns: ReadonlyArray<ColumnRef>, action: AnyInsertOnConflictAction); | ||
| static on(columns: ReadonlyArray<ColumnRef>): InsertOnConflict; | ||
| doNothing(): InsertOnConflict; | ||
| doUpdateSet(set: Readonly<Record<string, AnyExpression>>): InsertOnConflict; | ||
| } | ||
| declare class InsertAst extends QueryAst { | ||
| readonly kind: "insert"; | ||
| readonly table: TableSource; | ||
| readonly rows: ReadonlyArray<Readonly<Record<string, InsertValue>>>; | ||
| readonly onConflict: InsertOnConflict | undefined; | ||
| readonly returning: ReadonlyArray<ProjectionItem> | undefined; | ||
| constructor(table: TableSource, rows?: ReadonlyArray<Record<string, InsertValue>>, onConflict?: InsertOnConflict, returning?: ReadonlyArray<ProjectionItem>); | ||
| static into(table: TableSource): InsertAst; | ||
| withRows(rows: ReadonlyArray<Record<string, InsertValue>>): InsertAst; | ||
| withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): InsertAst; | ||
| withOnConflict(onConflict: InsertOnConflict | undefined): InsertAst; | ||
| rewrite(rewriter: AstRewriter): InsertAst; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare class UpdateAst extends QueryAst { | ||
| readonly kind: "update"; | ||
| readonly table: TableSource; | ||
| readonly set: Readonly<Record<string, AnyExpression>>; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly returning: ReadonlyArray<ProjectionItem> | undefined; | ||
| constructor(table: TableSource, set?: Readonly<Record<string, AnyExpression>>, where?: AnyExpression, returning?: ReadonlyArray<ProjectionItem>); | ||
| static table(table: TableSource): UpdateAst; | ||
| withSet(set: Readonly<Record<string, AnyExpression>>): UpdateAst; | ||
| withWhere(where: AnyExpression | undefined): UpdateAst; | ||
| withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): UpdateAst; | ||
| rewrite(rewriter: AstRewriter): UpdateAst; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| declare class DeleteAst extends QueryAst { | ||
| readonly kind: "delete"; | ||
| readonly table: TableSource; | ||
| readonly where: AnyExpression | undefined; | ||
| readonly returning: ReadonlyArray<ProjectionItem> | undefined; | ||
| constructor(table: TableSource, where?: AnyExpression, returning?: ReadonlyArray<ProjectionItem>); | ||
| static from(table: TableSource): DeleteAst; | ||
| withWhere(where: AnyExpression | undefined): DeleteAst; | ||
| withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): DeleteAst; | ||
| rewrite(rewriter: AstRewriter): DeleteAst; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| /** | ||
| * Raw-SQL query AST node carrying interpolated parameter / expression nodes | ||
| * embedded inside literal SQL fragments. | ||
| * | ||
| * `fragments` and `args` are interleaved during lowering: | ||
| * `fragments[0] + lower(args[0]) + fragments[1] + ... + fragments[n]`. | ||
| * Construction enforces `fragments.length === args.length + 1`. | ||
| * | ||
| * Extends {@link QueryAst} (whole-query AST, not a sub-expression). | ||
| * Construction does not validate that each arg is a `ParamRef` / | ||
| * `AnyExpression`: the type system already rejects bare values because | ||
| * `args` is typed `readonly AnyExpression[]`. The user-facing `raw\`...\`` | ||
| * factory (separate `sql-raw-factory` component) layers stricter | ||
| * type-level rejection on top of this AST node. | ||
| */ | ||
| declare class RawSqlExpr extends QueryAst { | ||
| readonly kind: "raw-sql"; | ||
| readonly fragments: readonly string[]; | ||
| readonly args: readonly AnyExpression[]; | ||
| constructor(fragments: readonly string[], args: readonly AnyExpression[]); | ||
| static of(fragments: readonly string[], args: readonly AnyExpression[]): RawSqlExpr; | ||
| collectParamRefs(): AnyParamRef[]; | ||
| toQueryAst(): AnyQueryAst; | ||
| } | ||
| type AnyQueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst | RawSqlExpr; | ||
| type AnyFromSource = TableSource | DerivedTableSource | FunctionSource; | ||
| type AnyExpression = ColumnRef | IdentifierRef | ParamRef | PreparedParamRef | LiteralExpr | SubqueryExpr | OperationExpr | AggregateExpr | WindowFuncExpr | JsonObjectExpr | JsonArrayAggExpr | ListExpression | BinaryExpr | AndExpr | OrExpr | ExistsExpr | NullCheckExpr | NotExpr | RawExpr; | ||
| type AnyParamRef = ParamRef | PreparedParamRef; | ||
| type AnyInsertOnConflictAction = DoNothingConflictAction | DoUpdateSetConflictAction; | ||
| type AnyInsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr; | ||
| type AnyOperationArg = AnyExpression | ParamRef | PreparedParamRef | LiteralExpr; | ||
| declare const queryAstKinds: ReadonlySet<string>; | ||
| declare const whereExprKinds: ReadonlySet<string>; | ||
| declare function isQueryAst(value: unknown): value is AnyQueryAst; | ||
| declare function isWhereExpr(value: unknown): value is AnyExpression; | ||
| interface ToWhereExpr { | ||
| toWhereExpr(): AnyExpression; | ||
| } | ||
| /** | ||
| * One positional slot of a lowered SQL statement. | ||
| * | ||
| * - `literal` — a value baked into the AST; passes through to the driver. | ||
| * - `bind` — a `PreparedParamRef` placeholder; the runtime resolves the | ||
| * value from the per-execute `userParams[name]` before calling the driver. | ||
| * | ||
| * The same `name` may legitimately appear in multiple `bind` slots when a | ||
| * renderer does not dedupe `PreparedParamRef` occurrences (e.g. SQLite's | ||
| * positional `?` walker calls `ast.collectParamRefs()` directly rather than | ||
| * `collectOrderedParamRefs`); resolution-by-name handles that case | ||
| * correctly. See `collectOrderedParamRefs` in `./util` for the dedupe | ||
| * contract used by Postgres' `$N` renderer. | ||
| */ | ||
| type LoweredParam = { | ||
| readonly kind: 'literal'; | ||
| readonly value: unknown; | ||
| } | { | ||
| readonly kind: 'bind'; | ||
| readonly name: string; | ||
| }; | ||
| interface LoweredStatement { | ||
| readonly sql: string; | ||
| readonly params: readonly LoweredParam[]; | ||
| readonly annotations?: Record<string, unknown>; | ||
| } | ||
| //#endregion | ||
| export { RawExpr as $, IdentifierRef as A, ListExpression as B, EqColJoinOn as C, ExpressionRewriter as D, ExpressionFolder as E, JoinOnExpr as F, NullCheckExpr as G, LoweredParam as H, JsonArrayAggExpr as I, OrderByItem as J, OperationExpr as K, JsonObjectEntry as L, InsertOnConflict as M, InsertValue as N, ExpressionSource as O, JoinAst as P, ProjectionItem as Q, JsonObjectExpr as R, DoUpdateSetConflictAction as S, ExprVisitor as T, LoweredStatement as U, LiteralExpr as V, NotExpr as W, PreparedParamRef as X, ParamRef as Y, ProjectionExpr as Z, DefaultValueExpr as _, AndExpr as a, TableRef as at, Direction as b, AnyInsertOnConflictAction as c, UpdateAst as ct, AnyParamRef as d, WindowFuncExpr as dt, RawSqlExpr as et, AnyQueryAst as f, isQueryAst as ft, ColumnRef as g, BinaryOp as h, whereExprKinds as ht, AggregateOpFn as i, SubqueryExpr as it, InsertAst as j, FunctionSource as k, AnyInsertValue as l, WhereArg as lt, BinaryExpr as m, queryAstKinds as mt, AggregateExpr as n, SelectAst as nt, AnyExpression as o, TableSource as ot, AstRewriter as p, isWhereExpr as pt, OrExpr as q, AggregateFn as r, SelectAstOptions as rt, AnyFromSource as s, ToWhereExpr as st, AggregateCountFn as t, RawSqlLiteral as tt, AnyOperationArg as u, WindowFn as ut, DeleteAst as v, ExistsExpr as w, DoNothingConflictAction as x, DerivedTableSource as y, LimitOffsetValue as z }; | ||
| //# sourceMappingURL=types-Dr3jep6j.d.mts.map |
| {"version":3,"file":"types-Dr3jep6j.d.mts","names":[],"sources":["../src/ast/types.ts"],"mappings":"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"} |
| import { ifDefined } from "@prisma-next/utils/defined"; | ||
| //#region src/ast/types.ts | ||
| function frozenArrayCopy(values) { | ||
| return Object.freeze([...values]); | ||
| } | ||
| function frozenOptionalRecordCopy(value) { | ||
| return value === void 0 ? void 0 : Object.freeze({ ...value }); | ||
| } | ||
| function frozenRecordCopy(record) { | ||
| return Object.freeze({ ...record }); | ||
| } | ||
| function frozenCodecRef(codec) { | ||
| const typeParams = codec.typeParams === void 0 ? void 0 : structuredClone(codec.typeParams); | ||
| const base = { | ||
| codecId: codec.codecId, | ||
| ...ifDefined("typeParams", typeParams) | ||
| }; | ||
| return Object.freeze(codec.many ? { | ||
| ...base, | ||
| many: true | ||
| } : base); | ||
| } | ||
| function freezeRows(rows) { | ||
| return Object.freeze(rows.map((row) => Object.freeze({ ...row }))); | ||
| } | ||
| function combineAll(folder, thunks) { | ||
| let result = folder.empty; | ||
| for (const thunk of thunks) { | ||
| if (folder.isAbsorbing?.(result)) return result; | ||
| result = folder.combine(result, thunk()); | ||
| } | ||
| return result; | ||
| } | ||
| function rewriteComparable(value, rewriter) { | ||
| switch (value.kind) { | ||
| case "param-ref": return rewriter.paramRef ? rewriter.paramRef(value) : value; | ||
| case "prepared-param-ref": return rewriter.preparedParamRef ? rewriter.preparedParamRef(value) : value; | ||
| case "literal": return rewriter.literal ? rewriter.literal(value) : value; | ||
| case "list": | ||
| if (rewriter.list) return rewriter.list(value); | ||
| return value.rewrite(rewriter); | ||
| default: return value.rewrite(rewriter); | ||
| } | ||
| } | ||
| function foldComparable(value, folder) { | ||
| switch (value.kind) { | ||
| case "param-ref": return folder.paramRef ? folder.paramRef(value) : folder.empty; | ||
| case "prepared-param-ref": return folder.preparedParamRef ? folder.preparedParamRef(value) : folder.empty; | ||
| case "literal": return folder.literal ? folder.literal(value) : folder.empty; | ||
| case "list": return value.fold(folder); | ||
| default: return value.fold(folder); | ||
| } | ||
| } | ||
| function collectColumnRefsWith(node) { | ||
| return node.fold({ | ||
| empty: [], | ||
| combine: (a, b) => [...a, ...b], | ||
| columnRef: (columnRef) => [columnRef], | ||
| select: (ast) => ast.collectColumnRefs() | ||
| }); | ||
| } | ||
| function collectParamRefsWith(node) { | ||
| return node.fold({ | ||
| empty: [], | ||
| combine: (a, b) => [...a, ...b], | ||
| paramRef: (paramRef) => [paramRef], | ||
| preparedParamRef: (paramRef) => [paramRef], | ||
| select: (ast) => ast.collectParamRefs() | ||
| }); | ||
| } | ||
| function rewriteTableSource(table, rewriter) { | ||
| return rewriter.tableSource ? rewriter.tableSource(table) : table; | ||
| } | ||
| function rewriteProjectionItem(item, rewriter) { | ||
| const rewrittenExpr = item.expr.kind === "literal" ? rewriter.literal ? rewriter.literal(item.expr) : item.expr : item.expr.rewrite(rewriter); | ||
| return new ProjectionItem(item.alias, rewrittenExpr, item.codec); | ||
| } | ||
| function rewriteInsertValue(value, rewriter) { | ||
| switch (value.kind) { | ||
| case "param-ref": return rewriter.paramRef ? rewriteParamRefForInsert(value, rewriter) : value; | ||
| case "prepared-param-ref": return rewriter.preparedParamRef ? rewriter.preparedParamRef(value) : value; | ||
| case "column-ref": return rewriter.columnRef ? rewriteColumnRefForInsert(value, rewriter) : value; | ||
| case "default-value": return value; | ||
| case "raw-expr": return value; | ||
| } | ||
| } | ||
| function rewriteParamRefForInsert(value, rewriter) { | ||
| const rewritten = rewriter.paramRef ? rewriter.paramRef(value) : value; | ||
| return rewritten.kind === "param-ref" ? rewritten : value; | ||
| } | ||
| function rewriteColumnRefForInsert(value, rewriter) { | ||
| const rewritten = rewriter.columnRef ? rewriter.columnRef(value) : value; | ||
| return rewritten.kind === "column-ref" ? rewritten : value; | ||
| } | ||
| function rewriteInsertRow(row, rewriter) { | ||
| const result = {}; | ||
| for (const [key, value] of Object.entries(row)) result[key] = rewriteInsertValue(value, rewriter); | ||
| return result; | ||
| } | ||
| function rewriteUpdateSet(set, rewriter) { | ||
| const result = {}; | ||
| for (const [key, value] of Object.entries(set)) result[key] = value.rewrite(rewriter); | ||
| return result; | ||
| } | ||
| function rewriteLimitOffset(value, rewriter) { | ||
| if (value === void 0 || typeof value === "number") return value; | ||
| return value.rewrite(rewriter); | ||
| } | ||
| function rewriteOnConflict(onConflict, rewriter) { | ||
| const columns = onConflict.columns.map((columnRef) => { | ||
| const rewritten = rewriter.columnRef ? rewriter.columnRef(columnRef) : columnRef; | ||
| return rewritten.kind === "column-ref" ? rewritten : columnRef; | ||
| }); | ||
| if (onConflict.action.kind === "do-nothing") return new InsertOnConflict(columns, new DoNothingConflictAction()); | ||
| return new InsertOnConflict(columns, new DoUpdateSetConflictAction(rewriteUpdateSet(onConflict.action.set, rewriter))); | ||
| } | ||
| var AstNode = class { | ||
| freeze() { | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| var QueryAst = class extends AstNode {}; | ||
| var FromSource = class extends AstNode {}; | ||
| var Expression = class extends AstNode { | ||
| collectColumnRefs() { | ||
| return collectColumnRefsWith(this); | ||
| } | ||
| collectParamRefs() { | ||
| return collectParamRefsWith(this); | ||
| } | ||
| baseColumnRef() { | ||
| throw new Error(`${this.constructor.name} does not expose a base column reference`); | ||
| } | ||
| toExpr() { | ||
| return this; | ||
| } | ||
| not() { | ||
| return new NotExpr(this); | ||
| } | ||
| }; | ||
| var TableSource = class TableSource extends FromSource { | ||
| kind = "table-source"; | ||
| name; | ||
| alias; | ||
| /** | ||
| * Resolved storage namespace coordinate for this table, stamped when the | ||
| * table proxy constructs the AST. Renderers qualify via the namespace | ||
| * concretion's `qualifyTable()` using this id — never by re-resolving the | ||
| * bare table name at render time. | ||
| */ | ||
| namespaceId; | ||
| constructor(name, alias, namespaceId) { | ||
| super(); | ||
| this.name = name; | ||
| this.alias = alias; | ||
| this.namespaceId = namespaceId; | ||
| } | ||
| static named(name, alias, namespaceId) { | ||
| const source = new TableSource(name, alias, namespaceId); | ||
| source.freeze(); | ||
| return source; | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.tableSource ? rewriter.tableSource(this) : this; | ||
| } | ||
| toFromSource() { | ||
| return this; | ||
| } | ||
| }; | ||
| var DerivedTableSource = class DerivedTableSource extends FromSource { | ||
| kind = "derived-table-source"; | ||
| alias; | ||
| query; | ||
| constructor(alias, query) { | ||
| super(); | ||
| this.alias = alias; | ||
| this.query = query; | ||
| this.freeze(); | ||
| } | ||
| static as(alias, query) { | ||
| return new DerivedTableSource(alias, query); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new DerivedTableSource(this.alias, this.query.rewrite(rewriter)); | ||
| } | ||
| toFromSource() { | ||
| return this; | ||
| } | ||
| }; | ||
| var FunctionSource = class FunctionSource extends FromSource { | ||
| kind = "function-source"; | ||
| fn; | ||
| args; | ||
| alias; | ||
| constructor(fn, args, alias) { | ||
| super(); | ||
| this.fn = fn; | ||
| this.args = frozenArrayCopy(args); | ||
| this.alias = alias; | ||
| this.freeze(); | ||
| } | ||
| static of(fn, args, alias) { | ||
| return new FunctionSource(fn, args, alias); | ||
| } | ||
| rewrite(rewriter) { | ||
| const rewrittenArgs = this.args.map((arg) => rewriteComparable(arg, rewriter)); | ||
| if (rewrittenArgs.every((arg, i) => arg === this.args[i])) return this; | ||
| return new FunctionSource(this.fn, rewrittenArgs, this.alias); | ||
| } | ||
| toFromSource() { | ||
| return this; | ||
| } | ||
| }; | ||
| var ColumnRef = class ColumnRef extends Expression { | ||
| kind = "column-ref"; | ||
| table; | ||
| column; | ||
| constructor(table, column) { | ||
| super(); | ||
| this.table = table; | ||
| this.column = column; | ||
| this.freeze(); | ||
| } | ||
| static of(table, column) { | ||
| return new ColumnRef(table, column); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.columnRef(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.columnRef ? rewriter.columnRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.columnRef ? folder.columnRef(this) : folder.empty; | ||
| } | ||
| baseColumnRef() { | ||
| return this; | ||
| } | ||
| }; | ||
| var IdentifierRef = class IdentifierRef extends Expression { | ||
| kind = "identifier-ref"; | ||
| name; | ||
| constructor(name) { | ||
| super(); | ||
| this.name = name; | ||
| this.freeze(); | ||
| } | ||
| static of(name) { | ||
| return new IdentifierRef(name); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.identifierRef(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.identifierRef ? rewriter.identifierRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.identifierRef ? folder.identifierRef(this) : folder.empty; | ||
| } | ||
| }; | ||
| var ParamRef = class ParamRef extends Expression { | ||
| kind = "param-ref"; | ||
| value; | ||
| name; | ||
| /** | ||
| * Codec identity carried by every column-bound `ParamRef`. The encode-side dispatch path materialises the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation on `(codecId, canonicalize(typeParams))` keeps repeated lookups for the same logical column on one shared {@link Codec}. | ||
| * | ||
| * `codec` may be `undefined` for `ParamRef`s constructed without a column-bound site (literals, transient builder state); the runtime treats those as untyped passthroughs. | ||
| */ | ||
| codec; | ||
| constructor(value, options) { | ||
| super(); | ||
| this.value = value; | ||
| this.name = options?.name; | ||
| this.codec = options?.codec ? frozenCodecRef(options.codec) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static of(value, options) { | ||
| return new ParamRef(value, options); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.param(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.paramRef ? rewriter.paramRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.paramRef ? folder.paramRef(this) : folder.empty; | ||
| } | ||
| }; | ||
| /** | ||
| * Bind-site placeholder: occupies the same positions as `ParamRef` in the | ||
| * AST, but carries no value — the value is supplied per-execute by the | ||
| * `PreparedStatement.execute(params)` caller and matched to this node by | ||
| * `name`. | ||
| */ | ||
| var PreparedParamRef = class PreparedParamRef extends Expression { | ||
| kind = "prepared-param-ref"; | ||
| name; | ||
| codec; | ||
| constructor(name, codec) { | ||
| super(); | ||
| this.name = name; | ||
| this.codec = frozenCodecRef(codec); | ||
| this.freeze(); | ||
| } | ||
| static of(name, codec) { | ||
| return new PreparedParamRef(name, codec); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.preparedParam(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.preparedParamRef ? rewriter.preparedParamRef(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.preparedParamRef ? folder.preparedParamRef(this) : folder.empty; | ||
| } | ||
| }; | ||
| var DefaultValueExpr = class extends AstNode { | ||
| kind = "default-value"; | ||
| constructor() { | ||
| super(); | ||
| this.freeze(); | ||
| } | ||
| }; | ||
| var LiteralExpr = class LiteralExpr extends Expression { | ||
| kind = "literal"; | ||
| value; | ||
| constructor(value) { | ||
| super(); | ||
| this.value = value; | ||
| this.freeze(); | ||
| } | ||
| static of(value) { | ||
| return new LiteralExpr(value); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.literal(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.literal ? rewriter.literal(this) : this; | ||
| } | ||
| fold(folder) { | ||
| return folder.literal ? folder.literal(this) : folder.empty; | ||
| } | ||
| }; | ||
| var SubqueryExpr = class SubqueryExpr extends Expression { | ||
| kind = "subquery"; | ||
| query; | ||
| constructor(query) { | ||
| super(); | ||
| this.query = query; | ||
| this.freeze(); | ||
| } | ||
| static of(query) { | ||
| return new SubqueryExpr(query); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.subquery(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| const query = this.query.rewrite(rewriter); | ||
| return new SubqueryExpr(query); | ||
| } | ||
| fold(folder) { | ||
| return folder.select ? folder.select(this.query) : folder.empty; | ||
| } | ||
| }; | ||
| var OperationExpr = class OperationExpr extends Expression { | ||
| kind = "operation"; | ||
| method; | ||
| self; | ||
| args; | ||
| returns; | ||
| lowering; | ||
| constructor(options) { | ||
| super(); | ||
| this.method = options.method; | ||
| this.self = options.self; | ||
| this.args = frozenArrayCopy(options.args ?? []); | ||
| this.returns = options.returns; | ||
| this.lowering = options.lowering; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.operation(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new OperationExpr({ | ||
| method: this.method, | ||
| self: this.self.rewrite(rewriter), | ||
| args: this.args.map((arg) => rewriteComparable(arg, rewriter)), | ||
| returns: this.returns, | ||
| lowering: this.lowering | ||
| }); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [() => this.self.fold(folder), ...this.args.map((arg) => () => foldComparable(arg, folder))]); | ||
| } | ||
| baseColumnRef() { | ||
| return this.self.baseColumnRef(); | ||
| } | ||
| }; | ||
| var RawExpr = class extends Expression { | ||
| kind = "raw-expr"; | ||
| parts; | ||
| returns; | ||
| constructor(options) { | ||
| super(); | ||
| this.parts = frozenArrayCopy(options.parts); | ||
| this.returns = options.returns; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.rawExpr(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.rawExpr ? rewriter.rawExpr(this) : this; | ||
| } | ||
| fold(folder) { | ||
| if (folder.rawExpr) return folder.rawExpr(this); | ||
| return combineAll(folder, this.parts.filter((p) => typeof p !== "string").map((p) => () => p.fold(folder))); | ||
| } | ||
| }; | ||
| var AggregateExpr = class AggregateExpr extends Expression { | ||
| kind = "aggregate"; | ||
| fn; | ||
| expr; | ||
| constructor(fn, expr) { | ||
| super(); | ||
| if (fn !== "count" && expr === void 0) throw new Error(`Aggregate function "${fn}" requires an expression`); | ||
| this.fn = fn; | ||
| this.expr = expr; | ||
| this.freeze(); | ||
| } | ||
| static count(expr) { | ||
| return new AggregateExpr("count", expr); | ||
| } | ||
| static sum(expr) { | ||
| return new AggregateExpr("sum", expr); | ||
| } | ||
| static avg(expr) { | ||
| return new AggregateExpr("avg", expr); | ||
| } | ||
| static min(expr) { | ||
| return new AggregateExpr("min", expr); | ||
| } | ||
| static max(expr) { | ||
| return new AggregateExpr("max", expr); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.aggregate(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return this.expr === void 0 ? this : new AggregateExpr(this.fn, this.expr.rewrite(rewriter)); | ||
| } | ||
| fold(folder) { | ||
| return this.expr ? this.expr.fold(folder) : folder.empty; | ||
| } | ||
| }; | ||
| /** | ||
| * Window function call: `fn(args) OVER (PARTITION BY ... ORDER BY ...)`. | ||
| * | ||
| * Both `partitionBy` and `orderBy` are optional; an empty `OVER ()` | ||
| * clause is legal SQL but rarely useful. For `ROW_NUMBER`, `RANK`, and | ||
| * `DENSE_RANK` the standard mandates an `ORDER BY` for deterministic | ||
| * results — callers are expected to provide one, but the AST does not | ||
| * enforce it. | ||
| * | ||
| * The `args` slot exists for future window function additions that take | ||
| * arguments (e.g. `COUNT(*) OVER`, `SUM(x) OVER`); `ROW_NUMBER` and the | ||
| * other ranking functions take no arguments. | ||
| */ | ||
| var WindowFuncExpr = class WindowFuncExpr extends Expression { | ||
| kind = "window-func"; | ||
| fn; | ||
| args; | ||
| partitionBy; | ||
| orderBy; | ||
| constructor(options) { | ||
| super(); | ||
| this.fn = options.fn; | ||
| this.args = options.args && options.args.length > 0 ? frozenArrayCopy(options.args) : []; | ||
| this.partitionBy = options.partitionBy && options.partitionBy.length > 0 ? frozenArrayCopy(options.partitionBy) : void 0; | ||
| this.orderBy = options.orderBy && options.orderBy.length > 0 ? frozenArrayCopy(options.orderBy) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static rowNumber(options) { | ||
| return new WindowFuncExpr({ | ||
| fn: "row_number", | ||
| ...options | ||
| }); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.windowFunc(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new WindowFuncExpr({ | ||
| fn: this.fn, | ||
| args: this.args.map((arg) => arg.rewrite(rewriter)), | ||
| ...ifDefined("partitionBy", this.partitionBy?.map((expr) => expr.rewrite(rewriter))), | ||
| ...ifDefined("orderBy", this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter))) | ||
| }); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [ | ||
| ...this.args.map((arg) => () => arg.fold(folder)), | ||
| ...(this.partitionBy ?? []).map((expr) => () => expr.fold(folder)), | ||
| ...(this.orderBy ?? []).map((orderItem) => () => orderItem.expr.fold(folder)) | ||
| ]); | ||
| } | ||
| }; | ||
| var JsonObjectExpr = class JsonObjectExpr extends Expression { | ||
| kind = "json-object"; | ||
| entries; | ||
| constructor(entries) { | ||
| super(); | ||
| this.entries = frozenArrayCopy(entries.map((entry) => Object.freeze({ ...entry }))); | ||
| this.freeze(); | ||
| } | ||
| static entry(key, value) { | ||
| return { | ||
| key, | ||
| value | ||
| }; | ||
| } | ||
| static fromEntries(entries) { | ||
| return new JsonObjectExpr(entries); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.jsonObject(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new JsonObjectExpr(this.entries.map((entry) => ({ | ||
| key: entry.key, | ||
| value: entry.value.kind === "literal" ? rewriter.literal ? rewriter.literal(entry.value) : entry.value : entry.value.rewrite(rewriter) | ||
| }))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, this.entries.map((entry) => () => entry.value.kind === "literal" ? folder.literal ? folder.literal(entry.value) : folder.empty : entry.value.fold(folder))); | ||
| } | ||
| }; | ||
| var OrderByItem = class OrderByItem extends AstNode { | ||
| kind = "order-by-item"; | ||
| expr; | ||
| dir; | ||
| constructor(expr, dir) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.dir = dir; | ||
| this.freeze(); | ||
| } | ||
| static asc(expr) { | ||
| return new OrderByItem(expr, "asc"); | ||
| } | ||
| static desc(expr) { | ||
| return new OrderByItem(expr, "desc"); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new OrderByItem(this.expr.rewrite(rewriter), this.dir); | ||
| } | ||
| /** | ||
| * A new frozen item with the sort direction flipped and `expr` unchanged. | ||
| * Integrations that own pagination (e.g. backward cursor pagination) use | ||
| * this to reverse a user's sort order without reaching into the AST. | ||
| */ | ||
| reverse() { | ||
| return new OrderByItem(this.expr, this.dir === "asc" ? "desc" : "asc"); | ||
| } | ||
| }; | ||
| var JsonArrayAggExpr = class JsonArrayAggExpr extends Expression { | ||
| kind = "json-array-agg"; | ||
| expr; | ||
| onEmpty; | ||
| orderBy; | ||
| constructor(expr, onEmpty = "null", orderBy) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.onEmpty = onEmpty; | ||
| this.orderBy = orderBy && orderBy.length > 0 ? frozenArrayCopy(orderBy) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static of(expr, onEmpty = "null", orderBy) { | ||
| return new JsonArrayAggExpr(expr, onEmpty, orderBy); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.jsonArrayAgg(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new JsonArrayAggExpr(this.expr.rewrite(rewriter), this.onEmpty, this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [() => this.expr.fold(folder), ...(this.orderBy ?? []).map((orderItem) => () => orderItem.expr.fold(folder))]); | ||
| } | ||
| }; | ||
| var ListExpression = class ListExpression extends Expression { | ||
| kind = "list"; | ||
| values; | ||
| constructor(values) { | ||
| super(); | ||
| this.values = frozenArrayCopy(values); | ||
| this.freeze(); | ||
| } | ||
| static of(values) { | ||
| return new ListExpression(values); | ||
| } | ||
| static fromValues(values) { | ||
| return new ListExpression(values.map((value) => new LiteralExpr(value))); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.list(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| if (rewriter.list) return rewriter.list(this); | ||
| return new ListExpression(this.values.map((value) => value.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| if (folder.list) return folder.list(this); | ||
| return combineAll(folder, this.values.map((value) => () => value.fold(folder))); | ||
| } | ||
| }; | ||
| var BinaryExpr = class BinaryExpr extends Expression { | ||
| kind = "binary"; | ||
| op; | ||
| left; | ||
| right; | ||
| constructor(op, left, right) { | ||
| super(); | ||
| this.op = op; | ||
| this.left = left; | ||
| this.right = right; | ||
| this.freeze(); | ||
| } | ||
| static eq(left, right) { | ||
| return new BinaryExpr("eq", left, right); | ||
| } | ||
| static neq(left, right) { | ||
| return new BinaryExpr("neq", left, right); | ||
| } | ||
| static gt(left, right) { | ||
| return new BinaryExpr("gt", left, right); | ||
| } | ||
| static lt(left, right) { | ||
| return new BinaryExpr("lt", left, right); | ||
| } | ||
| static gte(left, right) { | ||
| return new BinaryExpr("gte", left, right); | ||
| } | ||
| static lte(left, right) { | ||
| return new BinaryExpr("lte", left, right); | ||
| } | ||
| static like(left, right) { | ||
| return new BinaryExpr("like", left, right); | ||
| } | ||
| static in(left, right) { | ||
| return new BinaryExpr("in", left, right); | ||
| } | ||
| static notIn(left, right) { | ||
| return new BinaryExpr("notIn", left, right); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.binary(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new BinaryExpr(this.op, rewriteComparable(this.left, rewriter), rewriteComparable(this.right, rewriter)); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, [() => foldComparable(this.left, folder), () => foldComparable(this.right, folder)]); | ||
| } | ||
| }; | ||
| var AndExpr = class AndExpr extends Expression { | ||
| kind = "and"; | ||
| exprs; | ||
| constructor(exprs) { | ||
| super(); | ||
| this.exprs = frozenArrayCopy(exprs); | ||
| this.freeze(); | ||
| } | ||
| static of(exprs) { | ||
| return new AndExpr(exprs); | ||
| } | ||
| static true() { | ||
| return new AndExpr([]); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.and(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new AndExpr(this.exprs.map((expr) => expr.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder))); | ||
| } | ||
| }; | ||
| var OrExpr = class OrExpr extends Expression { | ||
| kind = "or"; | ||
| exprs; | ||
| constructor(exprs) { | ||
| super(); | ||
| this.exprs = frozenArrayCopy(exprs); | ||
| this.freeze(); | ||
| } | ||
| static of(exprs) { | ||
| return new OrExpr(exprs); | ||
| } | ||
| static false() { | ||
| return new OrExpr([]); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.or(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new OrExpr(this.exprs.map((expr) => expr.rewrite(rewriter))); | ||
| } | ||
| fold(folder) { | ||
| return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder))); | ||
| } | ||
| }; | ||
| var ExistsExpr = class ExistsExpr extends Expression { | ||
| kind = "exists"; | ||
| notExists; | ||
| subquery; | ||
| constructor(subquery, notExists = false) { | ||
| super(); | ||
| this.notExists = notExists; | ||
| this.subquery = subquery; | ||
| this.freeze(); | ||
| } | ||
| static exists(subquery) { | ||
| return new ExistsExpr(subquery, false); | ||
| } | ||
| static notExists(subquery) { | ||
| return new ExistsExpr(subquery, true); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.exists(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new ExistsExpr(this.subquery.rewrite(rewriter), this.notExists); | ||
| } | ||
| fold(folder) { | ||
| return folder.select ? folder.select(this.subquery) : folder.empty; | ||
| } | ||
| }; | ||
| var NullCheckExpr = class NullCheckExpr extends Expression { | ||
| kind = "null-check"; | ||
| expr; | ||
| isNull; | ||
| constructor(expr, isNull) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.isNull = isNull; | ||
| this.freeze(); | ||
| } | ||
| static isNull(expr) { | ||
| return new NullCheckExpr(expr, true); | ||
| } | ||
| static isNotNull(expr) { | ||
| return new NullCheckExpr(expr, false); | ||
| } | ||
| accept(visitor) { | ||
| return visitor.nullCheck(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new NullCheckExpr(this.expr.rewrite(rewriter), this.isNull); | ||
| } | ||
| fold(folder) { | ||
| return this.expr.fold(folder); | ||
| } | ||
| }; | ||
| var NotExpr = class NotExpr extends Expression { | ||
| kind = "not"; | ||
| expr; | ||
| constructor(expr) { | ||
| super(); | ||
| this.expr = expr; | ||
| this.freeze(); | ||
| } | ||
| toWhereExpr() { | ||
| return this; | ||
| } | ||
| accept(visitor) { | ||
| return visitor.not(this); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new NotExpr(this.expr.rewrite(rewriter)); | ||
| } | ||
| fold(folder) { | ||
| return this.expr.fold(folder); | ||
| } | ||
| }; | ||
| var EqColJoinOn = class EqColJoinOn extends AstNode { | ||
| kind = "eq-col-join-on"; | ||
| left; | ||
| right; | ||
| constructor(left, right) { | ||
| super(); | ||
| this.left = left; | ||
| this.right = right; | ||
| this.freeze(); | ||
| } | ||
| static of(left, right) { | ||
| return new EqColJoinOn(left, right); | ||
| } | ||
| rewrite(rewriter) { | ||
| return rewriter.eqColJoinOn ? rewriter.eqColJoinOn(this) : this; | ||
| } | ||
| }; | ||
| var JoinAst = class JoinAst extends AstNode { | ||
| kind = "join"; | ||
| joinType; | ||
| source; | ||
| lateral; | ||
| on; | ||
| constructor(joinType, source, on, lateral = false) { | ||
| super(); | ||
| this.joinType = joinType; | ||
| this.source = source; | ||
| this.lateral = lateral; | ||
| this.on = on; | ||
| this.freeze(); | ||
| } | ||
| static inner(source, on, lateral = false) { | ||
| return new JoinAst("inner", source, on, lateral); | ||
| } | ||
| static left(source, on, lateral = false) { | ||
| return new JoinAst("left", source, on, lateral); | ||
| } | ||
| static right(source, on, lateral = false) { | ||
| return new JoinAst("right", source, on, lateral); | ||
| } | ||
| static full(source, on, lateral = false) { | ||
| return new JoinAst("full", source, on, lateral); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new JoinAst(this.joinType, this.source.rewrite(rewriter), this.on.kind === "eq-col-join-on" ? this.on.rewrite(rewriter) : this.on.rewrite(rewriter), this.lateral); | ||
| } | ||
| }; | ||
| var ProjectionItem = class ProjectionItem extends AstNode { | ||
| kind = "projection-item"; | ||
| alias; | ||
| expr; | ||
| /** | ||
| * Codec identity for the projected cell. Decode-side dispatch resolves the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation collapses repeated lookups for the same logical column onto one shared {@link Codec}. | ||
| * | ||
| * Stays `undefined` for non-column-bound projections (computed expressions, subqueries, raw aliases) whose decoded type the runtime cannot infer from a single contract column. | ||
| */ | ||
| codec; | ||
| constructor(alias, expr, codec) { | ||
| super(); | ||
| this.alias = alias; | ||
| this.expr = expr; | ||
| this.codec = codec ? frozenCodecRef(codec) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static of(alias, expr, codec) { | ||
| return new ProjectionItem(alias, expr, codec); | ||
| } | ||
| withCodec(codec) { | ||
| return new ProjectionItem(this.alias, this.expr, codec); | ||
| } | ||
| }; | ||
| var SelectAst = class SelectAst extends QueryAst { | ||
| kind = "select"; | ||
| from; | ||
| joins; | ||
| projection; | ||
| where; | ||
| orderBy; | ||
| distinct; | ||
| distinctOn; | ||
| groupBy; | ||
| having; | ||
| limit; | ||
| offset; | ||
| selectAllIntent; | ||
| constructor(options) { | ||
| super(); | ||
| this.from = options.from; | ||
| this.joins = options.joins && options.joins.length > 0 ? frozenArrayCopy(options.joins) : void 0; | ||
| this.projection = frozenArrayCopy(options.projection); | ||
| this.where = options.where; | ||
| this.orderBy = options.orderBy && options.orderBy.length > 0 ? frozenArrayCopy(options.orderBy) : void 0; | ||
| this.distinct = options.distinct; | ||
| this.distinctOn = options.distinctOn && options.distinctOn.length > 0 ? frozenArrayCopy(options.distinctOn) : void 0; | ||
| this.groupBy = options.groupBy && options.groupBy.length > 0 ? frozenArrayCopy(options.groupBy) : void 0; | ||
| this.having = options.having; | ||
| this.limit = options.limit; | ||
| this.offset = options.offset; | ||
| this.selectAllIntent = frozenOptionalRecordCopy(options.selectAllIntent); | ||
| this.freeze(); | ||
| } | ||
| static from(from) { | ||
| return new SelectAst({ | ||
| from, | ||
| joins: void 0, | ||
| projection: [], | ||
| where: void 0, | ||
| orderBy: void 0, | ||
| distinct: void 0, | ||
| distinctOn: void 0, | ||
| groupBy: void 0, | ||
| having: void 0, | ||
| limit: void 0, | ||
| offset: void 0, | ||
| selectAllIntent: void 0 | ||
| }); | ||
| } | ||
| static noFrom() { | ||
| return new SelectAst({ | ||
| joins: void 0, | ||
| projection: [], | ||
| where: void 0, | ||
| orderBy: void 0, | ||
| distinct: void 0, | ||
| distinctOn: void 0, | ||
| groupBy: void 0, | ||
| having: void 0, | ||
| limit: void 0, | ||
| offset: void 0, | ||
| selectAllIntent: void 0 | ||
| }); | ||
| } | ||
| toOptions() { | ||
| return { | ||
| ...this.from !== void 0 ? { from: this.from } : {}, | ||
| joins: this.joins, | ||
| projection: this.projection, | ||
| where: this.where, | ||
| orderBy: this.orderBy, | ||
| distinct: this.distinct, | ||
| distinctOn: this.distinctOn, | ||
| groupBy: this.groupBy, | ||
| having: this.having, | ||
| limit: this.limit, | ||
| offset: this.offset, | ||
| selectAllIntent: this.selectAllIntent | ||
| }; | ||
| } | ||
| withFrom(from) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| from | ||
| }); | ||
| } | ||
| withJoins(joins) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| joins: joins.length > 0 ? joins : void 0 | ||
| }); | ||
| } | ||
| withProjection(projection) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| projection | ||
| }); | ||
| } | ||
| addProjection(alias, expr) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| projection: [...this.projection, new ProjectionItem(alias, expr)] | ||
| }); | ||
| } | ||
| withWhere(where) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| where | ||
| }); | ||
| } | ||
| withOrderBy(orderBy) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| orderBy: orderBy.length > 0 ? orderBy : void 0 | ||
| }); | ||
| } | ||
| withDistinct(enabled = true) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| distinct: enabled ? true : void 0 | ||
| }); | ||
| } | ||
| withDistinctOn(distinctOn) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| distinctOn: distinctOn.length > 0 ? distinctOn : void 0 | ||
| }); | ||
| } | ||
| withGroupBy(groupBy) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| groupBy: groupBy.length > 0 ? groupBy : void 0 | ||
| }); | ||
| } | ||
| withHaving(having) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| having | ||
| }); | ||
| } | ||
| withLimit(limit) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| limit | ||
| }); | ||
| } | ||
| withOffset(offset) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| offset | ||
| }); | ||
| } | ||
| withSelectAllIntent(selectAllIntent) { | ||
| return new SelectAst({ | ||
| ...this.toOptions(), | ||
| selectAllIntent | ||
| }); | ||
| } | ||
| rewrite(rewriter) { | ||
| const rewrittenFrom = this.from?.rewrite(rewriter); | ||
| const rewritten = new SelectAst({ | ||
| ...rewrittenFrom !== void 0 ? { from: rewrittenFrom } : {}, | ||
| joins: this.joins?.map((join) => join.rewrite(rewriter)), | ||
| projection: this.projection.map((projection) => new ProjectionItem(projection.alias, projection.expr.kind === "literal" ? rewriter.literal ? rewriter.literal(projection.expr) : projection.expr : projection.expr.rewrite(rewriter), projection.codec)), | ||
| where: this.where?.rewrite(rewriter), | ||
| orderBy: this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter)), | ||
| distinct: this.distinct, | ||
| distinctOn: this.distinctOn?.map((expr) => expr.rewrite(rewriter)), | ||
| groupBy: this.groupBy?.map((expr) => expr.rewrite(rewriter)), | ||
| having: this.having?.rewrite(rewriter), | ||
| limit: rewriteLimitOffset(this.limit, rewriter), | ||
| offset: rewriteLimitOffset(this.offset, rewriter), | ||
| selectAllIntent: this.selectAllIntent | ||
| }); | ||
| return rewriter.select ? rewriter.select(rewritten) : rewritten; | ||
| } | ||
| collectColumnRefs() { | ||
| const refs = []; | ||
| const pushRefs = (columns) => { | ||
| refs.push(...columns); | ||
| }; | ||
| if (this.from?.kind === "derived-table-source") pushRefs(this.from.query.collectColumnRefs()); | ||
| else if (this.from?.kind === "function-source") for (const arg of this.from.args) pushRefs(arg.collectColumnRefs()); | ||
| for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectColumnRefs()); | ||
| if (this.where) pushRefs(this.where.collectColumnRefs()); | ||
| if (this.having) pushRefs(this.having.collectColumnRefs()); | ||
| for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectColumnRefs()); | ||
| for (const expr of this.distinctOn ?? []) pushRefs(expr.collectColumnRefs()); | ||
| for (const expr of this.groupBy ?? []) pushRefs(expr.collectColumnRefs()); | ||
| for (const join of this.joins ?? []) { | ||
| if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectColumnRefs()); | ||
| else if (join.source.kind === "function-source") for (const arg of join.source.args) pushRefs(arg.collectColumnRefs()); | ||
| if (join.on.kind === "eq-col-join-on") refs.push(join.on.left, join.on.right); | ||
| else pushRefs(join.on.collectColumnRefs()); | ||
| } | ||
| if (typeof this.limit === "object") pushRefs(this.limit.collectColumnRefs()); | ||
| if (typeof this.offset === "object") pushRefs(this.offset.collectColumnRefs()); | ||
| return refs; | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| const pushRefs = (params) => { | ||
| refs.push(...params); | ||
| }; | ||
| if (this.from?.kind === "derived-table-source") pushRefs(this.from.query.collectParamRefs()); | ||
| else if (this.from?.kind === "function-source") for (const arg of this.from.args) pushRefs(arg.collectParamRefs()); | ||
| for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectParamRefs()); | ||
| if (this.where) pushRefs(this.where.collectParamRefs()); | ||
| if (this.having) pushRefs(this.having.collectParamRefs()); | ||
| for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectParamRefs()); | ||
| for (const expr of this.distinctOn ?? []) pushRefs(expr.collectParamRefs()); | ||
| for (const expr of this.groupBy ?? []) pushRefs(expr.collectParamRefs()); | ||
| for (const join of this.joins ?? []) { | ||
| if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectParamRefs()); | ||
| else if (join.source.kind === "function-source") for (const arg of join.source.args) pushRefs(arg.collectParamRefs()); | ||
| if (!(join.on.kind === "eq-col-join-on")) pushRefs(join.on.collectParamRefs()); | ||
| } | ||
| if (typeof this.limit === "object") pushRefs(this.limit.collectParamRefs()); | ||
| if (typeof this.offset === "object") pushRefs(this.offset.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| var InsertOnConflictAction = class extends AstNode {}; | ||
| var DoNothingConflictAction = class extends InsertOnConflictAction { | ||
| kind = "do-nothing"; | ||
| constructor() { | ||
| super(); | ||
| this.freeze(); | ||
| } | ||
| toInsertOnConflictAction() { | ||
| return this; | ||
| } | ||
| }; | ||
| var DoUpdateSetConflictAction = class extends InsertOnConflictAction { | ||
| kind = "do-update-set"; | ||
| set; | ||
| constructor(set) { | ||
| super(); | ||
| this.set = frozenRecordCopy(set); | ||
| this.freeze(); | ||
| } | ||
| toInsertOnConflictAction() { | ||
| return this; | ||
| } | ||
| }; | ||
| var InsertOnConflict = class InsertOnConflict extends AstNode { | ||
| kind = "insert-on-conflict"; | ||
| columns; | ||
| action; | ||
| constructor(columns, action) { | ||
| super(); | ||
| this.columns = frozenArrayCopy(columns); | ||
| this.action = action; | ||
| this.freeze(); | ||
| } | ||
| static on(columns) { | ||
| return new InsertOnConflict(columns, new DoNothingConflictAction()); | ||
| } | ||
| doNothing() { | ||
| return new InsertOnConflict(this.columns, new DoNothingConflictAction()); | ||
| } | ||
| doUpdateSet(set) { | ||
| return new InsertOnConflict(this.columns, new DoUpdateSetConflictAction(set)); | ||
| } | ||
| }; | ||
| var InsertAst = class InsertAst extends QueryAst { | ||
| kind = "insert"; | ||
| table; | ||
| rows; | ||
| onConflict; | ||
| returning; | ||
| constructor(table, rows = [{}], onConflict, returning) { | ||
| super(); | ||
| this.table = table; | ||
| this.rows = freezeRows(rows); | ||
| this.onConflict = onConflict; | ||
| this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static into(table) { | ||
| return new InsertAst(table); | ||
| } | ||
| withRows(rows) { | ||
| return new InsertAst(this.table, rows.map((row) => ({ ...row })), this.onConflict, this.returning); | ||
| } | ||
| withReturning(returning) { | ||
| return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), this.onConflict, returning); | ||
| } | ||
| withOnConflict(onConflict) { | ||
| return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), onConflict, this.returning); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new InsertAst(rewriteTableSource(this.table, rewriter), this.rows.map((row) => rewriteInsertRow(row, rewriter)), this.onConflict ? rewriteOnConflict(this.onConflict, rewriter) : void 0, this.returning?.map((item) => rewriteProjectionItem(item, rewriter))); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| for (const row of this.rows) for (const value of Object.values(row)) if (value.kind === "param-ref" || value.kind === "prepared-param-ref") refs.push(value); | ||
| else if (value.kind === "raw-expr") refs.push(...value.collectParamRefs()); | ||
| if (this.onConflict?.action.kind === "do-update-set") { | ||
| for (const value of Object.values(this.onConflict.action.set)) if (value.kind === "param-ref" || value.kind === "prepared-param-ref") refs.push(value); | ||
| } | ||
| for (const item of this.returning ?? []) if (item.expr.kind !== "literal") refs.push(...item.expr.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| var UpdateAst = class UpdateAst extends QueryAst { | ||
| kind = "update"; | ||
| table; | ||
| set; | ||
| where; | ||
| returning; | ||
| constructor(table, set = {}, where, returning) { | ||
| super(); | ||
| this.table = table; | ||
| this.set = frozenRecordCopy(set); | ||
| this.where = where; | ||
| this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static table(table) { | ||
| return new UpdateAst(table); | ||
| } | ||
| withSet(set) { | ||
| return new UpdateAst(this.table, set, this.where, this.returning); | ||
| } | ||
| withWhere(where) { | ||
| return new UpdateAst(this.table, this.set, where, this.returning); | ||
| } | ||
| withReturning(returning) { | ||
| return new UpdateAst(this.table, this.set, this.where, returning); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new UpdateAst(rewriteTableSource(this.table, rewriter), rewriteUpdateSet(this.set, rewriter), this.where?.rewrite(rewriter), this.returning?.map((item) => rewriteProjectionItem(item, rewriter))); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| for (const value of Object.values(this.set)) refs.push(...value.collectParamRefs()); | ||
| if (this.where) refs.push(...this.where.collectParamRefs()); | ||
| for (const item of this.returning ?? []) if (item.expr.kind !== "literal") refs.push(...item.expr.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| var DeleteAst = class DeleteAst extends QueryAst { | ||
| kind = "delete"; | ||
| table; | ||
| where; | ||
| returning; | ||
| constructor(table, where, returning) { | ||
| super(); | ||
| this.table = table; | ||
| this.where = where; | ||
| this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0; | ||
| this.freeze(); | ||
| } | ||
| static from(table) { | ||
| return new DeleteAst(table); | ||
| } | ||
| withWhere(where) { | ||
| return new DeleteAst(this.table, where, this.returning); | ||
| } | ||
| withReturning(returning) { | ||
| return new DeleteAst(this.table, this.where, returning); | ||
| } | ||
| rewrite(rewriter) { | ||
| return new DeleteAst(rewriteTableSource(this.table, rewriter), this.where?.rewrite(rewriter), this.returning?.map((item) => rewriteProjectionItem(item, rewriter))); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| if (this.where) refs.push(...this.where.collectParamRefs()); | ||
| for (const item of this.returning ?? []) if (item.expr.kind !== "literal") refs.push(...item.expr.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| /** | ||
| * Raw-SQL query AST node carrying interpolated parameter / expression nodes | ||
| * embedded inside literal SQL fragments. | ||
| * | ||
| * `fragments` and `args` are interleaved during lowering: | ||
| * `fragments[0] + lower(args[0]) + fragments[1] + ... + fragments[n]`. | ||
| * Construction enforces `fragments.length === args.length + 1`. | ||
| * | ||
| * Extends {@link QueryAst} (whole-query AST, not a sub-expression). | ||
| * Construction does not validate that each arg is a `ParamRef` / | ||
| * `AnyExpression`: the type system already rejects bare values because | ||
| * `args` is typed `readonly AnyExpression[]`. The user-facing `raw\`...\`` | ||
| * factory (separate `sql-raw-factory` component) layers stricter | ||
| * type-level rejection on top of this AST node. | ||
| */ | ||
| var RawSqlExpr = class RawSqlExpr extends QueryAst { | ||
| kind = "raw-sql"; | ||
| fragments; | ||
| args; | ||
| constructor(fragments, args) { | ||
| super(); | ||
| if (fragments.length !== args.length + 1) throw new Error(`RawSqlExpr: fragments.length must equal args.length + 1 (got fragments=${fragments.length}, args=${args.length})`); | ||
| this.fragments = Object.freeze([...fragments]); | ||
| this.args = Object.freeze([...args]); | ||
| this.freeze(); | ||
| } | ||
| static of(fragments, args) { | ||
| return new RawSqlExpr(fragments, args); | ||
| } | ||
| collectParamRefs() { | ||
| const refs = []; | ||
| for (const arg of this.args) if (arg.kind === "param-ref") refs.push(arg); | ||
| else refs.push(...arg.collectParamRefs()); | ||
| return refs; | ||
| } | ||
| toQueryAst() { | ||
| return this; | ||
| } | ||
| }; | ||
| const queryAstKinds = /* @__PURE__ */ new Set([ | ||
| "select", | ||
| "insert", | ||
| "update", | ||
| "delete", | ||
| "raw-sql" | ||
| ]); | ||
| const whereExprKinds = /* @__PURE__ */ new Set([ | ||
| "binary", | ||
| "and", | ||
| "or", | ||
| "exists", | ||
| "null-check", | ||
| "not" | ||
| ]); | ||
| function isQueryAst(value) { | ||
| return typeof value === "object" && value !== null && "kind" in value && queryAstKinds.has(value.kind); | ||
| } | ||
| function isWhereExpr(value) { | ||
| return typeof value === "object" && value !== null && "kind" in value && whereExprKinds.has(value.kind); | ||
| } | ||
| //#endregion | ||
| export { RawSqlExpr as A, OperationExpr as C, PreparedParamRef as D, ParamRef as E, WindowFuncExpr as F, isQueryAst as I, isWhereExpr as L, SubqueryExpr as M, TableSource as N, ProjectionItem as O, UpdateAst as P, queryAstKinds as R, NullCheckExpr as S, OrderByItem as T, JsonArrayAggExpr as _, DefaultValueExpr as a, LiteralExpr as b, DoNothingConflictAction as c, ExistsExpr as d, FunctionSource as f, JoinAst as g, InsertOnConflict as h, ColumnRef as i, SelectAst as j, RawExpr as k, DoUpdateSetConflictAction as l, InsertAst as m, AndExpr as n, DeleteAst as o, IdentifierRef as p, BinaryExpr as r, DerivedTableSource as s, AggregateExpr as t, EqColJoinOn as u, JsonObjectExpr as v, OrExpr as w, NotExpr as x, ListExpression as y, whereExprKinds as z }; | ||
| //# sourceMappingURL=types-DtzFztRV.mjs.map |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
No alert changes
Improved metrics
- Total package byte prevSize
654271
6.94%- Number of package files
84
1.2%- Lines of code
7318
6.77%Dependency changes
+ Added
@prisma-next/contract@0.16.0-dev.10(transitive)+ Added
@prisma-next/framework-components@0.16.0-dev.10(transitive)+ Added
@prisma-next/operations@0.16.0-dev.10(transitive)+ Added
@prisma-next/sql-contract@0.16.0-dev.10(transitive)+ Added
@prisma-next/sql-operations@0.16.0-dev.10(transitive)+ Added
@prisma-next/sql-schema-ir@0.16.0-dev.10(transitive)+ Added
@prisma-next/ts-render@0.16.0-dev.10(transitive)+ Added
@prisma-next/utils@0.16.0-dev.10(transitive)- Removed
@prisma-next/contract@0.16.0-dev.7(transitive)- Removed
@prisma-next/framework-components@0.16.0-dev.7(transitive)- Removed
@prisma-next/operations@0.16.0-dev.7(transitive)- Removed
@prisma-next/sql-contract@0.16.0-dev.7(transitive)- Removed
@prisma-next/sql-operations@0.16.0-dev.7(transitive)- Removed
@prisma-next/sql-schema-ir@0.16.0-dev.7(transitive)- Removed
@prisma-next/ts-render@0.16.0-dev.7(transitive)- Removed
@prisma-next/utils@0.16.0-dev.7(transitive)