🎩 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 { o as CodecRef } from "./codec-types-DFLA6Hmj.mjs"; | ||
| import { d as AnyParamRef } from "./types-DQrmgP8Y.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-Cd4p4EbE.d.mts.map |
| {"version":3,"file":"ddl-types-Cd4p4EbE.d.mts","names":[],"sources":["../src/ast/ddl-types.ts"],"mappings":";;;;;;;;AAeA;;;;AACqB;AAGrB;;UAJiB,sBAAA;EAAA,SACN,UAAU;AAAA;AAAA,UAGJ,uBAAA;EACf,OAAA,CAAQ,IAAA,EAAM,oBAAA,EAAsB,GAAA,EAAK,sBAAA,GAAyB,CAAA;EAClE,QAAA,CAAS,IAAA,EAAM,qBAAA,EAAuB,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,uBAGhD,gBAAA;EAAA,kBACF,IAAA;EAAA,SACT,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;EAAA,UAE5E,MAAA;AAAA;AAAA,cAKC,oBAAA,SAA6B,gBAAA;EAAA,SAC/B,IAAA;EAAA,SACA,KAAA,EAAO,8BAAA;cAEJ,KAAA,EAAO,8BAAA;EASV,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,cAK3E,qBAAA,SAA8B,gBAAA;EAAA,SAChC,IAAA;EAAA,SACA,UAAA;cAEG,UAAA;EAMH,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,KAK5E,mBAAA,GAAsB,oBAAA,GAAuB,qBAAqB;AAAA,cAEjE,SAAA;EAAA,SACF,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA,GAAU,mBAAA;EA/CoE;EAAA,SAiD9E,QAAA,GAAW,QAAA;cAER,OAAA;IAAA,SACD,IAAA;IAAA,SACA,IAAA;IAAA,SACA,OAAA;IAAA,SACA,UAAA;IAAA,SACA,OAAA,GAAU,mBAAA;IAAA,SACV,QAAA,GAAW,QAAA;EAAA;AAAA;AAAA,uBAYF,OAAA;EAAA,kBACF,IAAA;EApEF;AAKlB;;;;;EAuEE,SAAA;EAAA,UAIU,MAAA;EAIV,gBAAA,IAAoB,WAAW;AAAA;AAAA,iBAKjB,SAAA,CAAU,KAAA,YAAiB,KAAA,IAAS,OAAO;;;;;;;;cAoB9C,oBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAa;EAAA,SACtB,IAAA;cAEG,OAAA;IAAA,SAAoB,OAAA;IAAA,SAAqC,IAAA;EAAA;AAAA;;;AAhGkB;AAKzF;;;;cAyGa,oBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAA;EAAA,SACT,QAAA;EAAA,SACA,UAAA,EAAY,aAAA;EAAA,SACZ,QAAA,EAAU,iBAAA;EAAA,SACV,QAAA,EAAU,iBAAA;EAAA,SACV,IAAA;cAEG,OAAA;IAAA,SACD,OAAA;IAAA,SACA,QAAA;IAAA,SACA,UAAA;IAAA,SACA,QAAA,GAAW,iBAAA;IAAA,SACX,QAAA,GAAW,iBAAA;IAAA,SACX,IAAA;EAAA;AAAA;;;;AA9G4E;AAKzF;;;cA4Ha,gBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAa;EAAA,SACtB,IAAA;cAEG,OAAA;IAAA,SAAoB,OAAA;IAAA,SAAqC,IAAA;EAAA;AAAA;;;;;;;;;;cAgB1D,yBAAA;EAAA,SACF,IAAA;EAAA,SACA,IAAA;EAAA,SACA,UAAA;cAEG,OAAA;IAAA,SAAoB,IAAA;IAAA,SAAuB,UAAA;EAAA;AAAA;AAAA,KAO7C,kBAAA,GACR,oBAAA,GACA,oBAAA,GACA,gBAAA,GACA,yBAAA"} |
| import { isColumnDefaultLiteralInputValue } from "@prisma-next/contract/types"; | ||
| //#region src/ast/ddl-types.ts | ||
| var DdlColumnDefault = class { | ||
| freeze() { | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| var LiteralColumnDefault = class extends DdlColumnDefault { | ||
| kind = "literal"; | ||
| value; | ||
| constructor(value) { | ||
| super(); | ||
| if (!isColumnDefaultLiteralInputValue(value)) throw new Error("Invalid column default literal value"); | ||
| this.value = value; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor, ctx) { | ||
| return visitor.literal(this, ctx); | ||
| } | ||
| }; | ||
| var FunctionColumnDefault = class extends DdlColumnDefault { | ||
| kind = "function"; | ||
| expression; | ||
| constructor(expression) { | ||
| super(); | ||
| this.expression = expression; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor, ctx) { | ||
| return visitor.function(this, ctx); | ||
| } | ||
| }; | ||
| var DdlColumn = class { | ||
| name; | ||
| type; | ||
| notNull; | ||
| primaryKey; | ||
| default; | ||
| /** 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). */ | ||
| codecRef; | ||
| constructor(options) { | ||
| this.name = options.name; | ||
| this.type = options.type; | ||
| this.notNull = options.notNull; | ||
| this.primaryKey = options.primaryKey; | ||
| this.default = options.default; | ||
| this.codecRef = options.codecRef; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| var DdlNode = class { | ||
| /** | ||
| * 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() { | ||
| return true; | ||
| } | ||
| freeze() { | ||
| Object.freeze(this); | ||
| } | ||
| collectParamRefs() { | ||
| return []; | ||
| } | ||
| }; | ||
| function isDdlNode(value) { | ||
| return typeof value === "object" && value !== null && "isDdlNode" in value && typeof value.isDdlNode === "function"; | ||
| } | ||
| /** | ||
| * 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. | ||
| */ | ||
| var PrimaryKeyConstraint = class { | ||
| kind = "primary-key"; | ||
| columns; | ||
| name; | ||
| constructor(options) { | ||
| this.columns = Object.freeze([...options.columns]); | ||
| this.name = options.name; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| /** | ||
| * 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. | ||
| */ | ||
| var ForeignKeyConstraint = class { | ||
| kind = "foreign-key"; | ||
| columns; | ||
| refTable; | ||
| refColumns; | ||
| onDelete; | ||
| onUpdate; | ||
| name; | ||
| constructor(options) { | ||
| this.columns = Object.freeze([...options.columns]); | ||
| this.refTable = options.refTable; | ||
| this.refColumns = Object.freeze([...options.refColumns]); | ||
| this.onDelete = options.onDelete; | ||
| this.onUpdate = options.onUpdate; | ||
| this.name = options.name; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| /** | ||
| * 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. | ||
| */ | ||
| var UniqueConstraint = class { | ||
| kind = "unique"; | ||
| columns; | ||
| name; | ||
| constructor(options) { | ||
| this.columns = Object.freeze([...options.columns]); | ||
| this.name = options.name; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| /** | ||
| * 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. | ||
| */ | ||
| var CheckExpressionConstraint = class { | ||
| kind = "check-expression"; | ||
| name; | ||
| expression; | ||
| constructor(options) { | ||
| this.name = options.name; | ||
| this.expression = options.expression; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| //#endregion | ||
| export { ForeignKeyConstraint as a, PrimaryKeyConstraint as c, DdlNode as i, UniqueConstraint as l, DdlColumn as n, FunctionColumnDefault as o, DdlColumnDefault as r, LiteralColumnDefault as s, CheckExpressionConstraint as t, isDdlNode as u }; | ||
| //# sourceMappingURL=ddl-types-DFKQr_qQ.mjs.map |
| {"version":3,"file":"ddl-types-DFKQr_qQ.mjs","names":[],"sources":["../src/ast/ddl-types.ts"],"sourcesContent":["import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport { isColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport type { ReferentialAction } from '@prisma-next/sql-contract/types';\nimport type { CodecRef } from './codec-types';\nimport type { AnyParamRef } from './types';\n\n/**\n * Render-time context the column-default visitor needs to make dialect\n * decisions that depend on the parent column. Today only the parent\n * column's native type (`\"jsonb\"`, `\"text\"`, …) — the Postgres renderer\n * uses it to decide whether to emit a `::jsonb` / `::json` cast on JSON\n * literal defaults so the emitted DDL matches the column type without\n * relying on Postgres's implicit text → jsonb cast at default-evaluation\n * time. Additional fields can join without re-shaping the interface.\n */\nexport interface DdlColumnRenderContext {\n readonly nativeType: string;\n}\n\nexport interface DdlColumnDefaultVisitor<R> {\n literal(node: LiteralColumnDefault, ctx: DdlColumnRenderContext): R;\n function(node: FunctionColumnDefault, ctx: DdlColumnRenderContext): R;\n}\n\nexport abstract class DdlColumnDefault {\n abstract readonly kind: string;\n abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R;\n\n protected freeze(): void {\n Object.freeze(this);\n }\n}\n\nexport class LiteralColumnDefault extends DdlColumnDefault {\n readonly kind = 'literal' as const;\n readonly value: ColumnDefaultLiteralInputValue;\n\n constructor(value: ColumnDefaultLiteralInputValue) {\n super();\n if (!isColumnDefaultLiteralInputValue(value)) {\n throw new Error('Invalid column default literal value');\n }\n this.value = value;\n this.freeze();\n }\n\n override accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R {\n return visitor.literal(this, ctx);\n }\n}\n\nexport class FunctionColumnDefault extends DdlColumnDefault {\n readonly kind = 'function' as const;\n readonly expression: string;\n\n constructor(expression: string) {\n super();\n this.expression = expression;\n this.freeze();\n }\n\n override accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R {\n return visitor.function(this, ctx);\n }\n}\n\nexport type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault;\n\nexport class DdlColumn {\n readonly name: string;\n readonly type: string;\n readonly notNull?: boolean | undefined;\n readonly primaryKey?: boolean | undefined;\n readonly default?: AnyDdlColumnDefault | undefined;\n /** 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). */\n readonly codecRef?: CodecRef | undefined;\n\n constructor(options: {\n readonly name: string;\n readonly type: string;\n readonly notNull?: boolean;\n readonly primaryKey?: boolean;\n readonly default?: AnyDdlColumnDefault;\n readonly codecRef?: CodecRef;\n }) {\n this.name = options.name;\n this.type = options.type;\n this.notNull = options.notNull;\n this.primaryKey = options.primaryKey;\n this.default = options.default;\n this.codecRef = options.codecRef;\n Object.freeze(this);\n }\n}\n\nexport abstract class DdlNode {\n abstract readonly kind: string;\n\n /**\n * Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}\n * recognise any `DdlNode` subclass — including target-contributed kinds —\n * without a central kind registry that subclasses would have to register\n * into.\n */\n isDdlNode(): true {\n return true;\n }\n\n protected freeze(): void {\n Object.freeze(this);\n }\n\n collectParamRefs(): AnyParamRef[] {\n return [];\n }\n}\n\nexport function isDdlNode(value: unknown): value is DdlNode {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'isDdlNode' in value &&\n typeof value.isDdlNode === 'function'\n );\n}\n\n// ---------------------------------------------------------------------------\n// Table-level constraint nodes\n// ---------------------------------------------------------------------------\n\n/**\n * A composite (or single-column) PRIMARY KEY constraint on a `CreateTable`\n * node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY\n * (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class PrimaryKeyConstraint {\n readonly kind = 'primary-key' as const;\n readonly columns: ReadonlyArray<string>;\n readonly name: string | undefined;\n\n constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {\n this.columns = Object.freeze([...options.columns]);\n this.name = options.name;\n Object.freeze(this);\n }\n}\n\n/**\n * A FOREIGN KEY constraint on a `CreateTable` node. `onDelete` and `onUpdate`\n * use the same `ReferentialAction` vocabulary already used by the migration\n * planner and the contract IR — no parallel string enum.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class ForeignKeyConstraint {\n readonly kind = 'foreign-key' as const;\n readonly columns: ReadonlyArray<string>;\n readonly refTable: string;\n readonly refColumns: ReadonlyArray<string>;\n readonly onDelete: ReferentialAction | undefined;\n readonly onUpdate: ReferentialAction | undefined;\n readonly name: string | undefined;\n\n constructor(options: {\n readonly columns: readonly string[];\n readonly refTable: string;\n readonly refColumns: readonly string[];\n readonly onDelete?: ReferentialAction;\n readonly onUpdate?: ReferentialAction;\n readonly name?: string;\n }) {\n this.columns = Object.freeze([...options.columns]);\n this.refTable = options.refTable;\n this.refColumns = Object.freeze([...options.refColumns]);\n this.onDelete = options.onDelete;\n this.onUpdate = options.onUpdate;\n this.name = options.name;\n Object.freeze(this);\n }\n}\n\n/**\n * A table-level UNIQUE constraint on a `CreateTable` node. When `name` is\n * set, the adapter renders `CONSTRAINT <name> UNIQUE (…)`; otherwise it\n * renders an anonymous `UNIQUE (…)`.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class UniqueConstraint {\n readonly kind = 'unique' as const;\n readonly columns: ReadonlyArray<string>;\n readonly name: string | undefined;\n\n constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {\n this.columns = Object.freeze([...options.columns]);\n this.name = options.name;\n Object.freeze(this);\n }\n}\n\n/**\n * A table-level CHECK constraint carrying a raw SQL predicate expression. Used\n * for checks that are not enum value-set restrictions — e.g. the element-non-null\n * constraint on a scalar-array column (`array_position(col, NULL) IS NULL`).\n * The `expression` is emitted verbatim, so callers must supply safe,\n * pre-validated SQL.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class CheckExpressionConstraint {\n readonly kind = 'check-expression' as const;\n readonly name: string;\n readonly expression: string;\n\n constructor(options: { readonly name: string; readonly expression: string }) {\n this.name = options.name;\n this.expression = options.expression;\n Object.freeze(this);\n }\n}\n\nexport type DdlTableConstraint =\n | PrimaryKeyConstraint\n | ForeignKeyConstraint\n | UniqueConstraint\n | CheckExpressionConstraint;\n"],"mappings":";;AAwBA,IAAsB,mBAAtB,MAAuC;CAIrC,SAAyB;EACvB,OAAO,OAAO,IAAI;CACpB;AACF;AAEA,IAAa,uBAAb,cAA0C,iBAAiB;CACzD,OAAgB;CAChB;CAEA,YAAY,OAAuC;EACjD,MAAM;EACN,IAAI,CAAC,iCAAiC,KAAK,GACzC,MAAM,IAAI,MAAM,sCAAsC;EAExD,KAAK,QAAQ;EACb,KAAK,OAAO;CACd;CAEA,OAAmB,SAAqC,KAAgC;EACtF,OAAO,QAAQ,QAAQ,MAAM,GAAG;CAClC;AACF;AAEA,IAAa,wBAAb,cAA2C,iBAAiB;CAC1D,OAAgB;CAChB;CAEA,YAAY,YAAoB;EAC9B,MAAM;EACN,KAAK,aAAa;EAClB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAqC,KAAgC;EACtF,OAAO,QAAQ,SAAS,MAAM,GAAG;CACnC;AACF;AAIA,IAAa,YAAb,MAAuB;CACrB;CACA;CACA;CACA;CACA;;CAEA;CAEA,YAAY,SAOT;EACD,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,aAAa,QAAQ;EAC1B,KAAK,UAAU,QAAQ;EACvB,KAAK,WAAW,QAAQ;EACxB,OAAO,OAAO,IAAI;CACpB;AACF;AAEA,IAAsB,UAAtB,MAA8B;;;;;;;CAS5B,YAAkB;EAChB,OAAO;CACT;CAEA,SAAyB;EACvB,OAAO,OAAO,IAAI;CACpB;CAEA,mBAAkC;EAChC,OAAO,CAAC;CACV;AACF;AAEA,SAAgB,UAAU,OAAkC;CAC1D,OACE,OAAO,UAAU,YACjB,UAAU,QACV,eAAe,SACf,OAAO,MAAM,cAAc;AAE/B;;;;;;;;AAaA,IAAa,uBAAb,MAAkC;CAChC,OAAgB;CAChB;CACA;CAEA,YAAY,SAA0E;EACpF,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;AASA,IAAa,uBAAb,MAAkC;CAChC,OAAgB;CAChB;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,SAOT;EACD,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,WAAW,QAAQ;EACxB,KAAK,aAAa,OAAO,OAAO,CAAC,GAAG,QAAQ,UAAU,CAAC;EACvD,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;EACxB,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;AASA,IAAa,mBAAb,MAA8B;CAC5B,OAAgB;CAChB;CACA;CAEA,YAAY,SAA0E;EACpF,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;;;AAWA,IAAa,4BAAb,MAAuC;CACrC,OAAgB;CAChB;CACA;CAEA,YAAY,SAAiE;EAC3E,KAAK,OAAO,QAAQ;EACpB,KAAK,aAAa,QAAQ;EAC1B,OAAO,OAAO,IAAI;CACpB;AACF"} |
| 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
| 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-DFLA6Hmj.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-DQrmgP8Y.mjs"; | ||
| import { a as DdlColumnRenderContext, c as ForeignKeyConstraint, d as PrimaryKeyConstraint, f as UniqueConstraint, i as DdlColumnDefaultVisitor, l as FunctionColumnDefault, n as DdlColumn, o as DdlNode, p as isDdlNode, r as DdlColumnDefault, s as DdlTableConstraint, t as AnyDdlColumnDefault, u as LiteralColumnDefault } from "../ddl-types-BVO002FS.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-Cd4p4EbE.mjs"; | ||
| import { ContractMarkerRecord, JsonValue } from "@prisma-next/contract/types"; | ||
@@ -273,3 +273,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, 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, 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 }; | ||
| //# sourceMappingURL=ast.d.mts.map |
@@ -1,3 +0,3 @@ | ||
| import { a as FunctionColumnDefault, c as UniqueConstraint, i as ForeignKeyConstraint, l as isDdlNode, n as DdlColumnDefault, o as LiteralColumnDefault, r as DdlNode, s as PrimaryKeyConstraint, t as DdlColumn } from "../ddl-types-DAox2c8w.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-lJUc6cY-.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"; | ||
@@ -234,4 +234,4 @@ import { CodecDescriptorImpl, CodecImpl, column, voidParamsSchema } from "@prisma-next/framework-components/codec"; | ||
| //#endregion | ||
| export { AggregateExpr, AndExpr, BinaryExpr, 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, 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 }; | ||
| //# sourceMappingURL=ast.mjs.map |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"codec-descriptor-registry.d.mts","names":[],"sources":["../../src/codec-descriptor-registry.ts","../../src/codec-ref-for-column.ts"],"mappings":";;;;;;;;;AAgBA;;;;;;;iBAAgB,4BAAA,CACd,cAAA,EAAgB,aAAA,CAAc,kBAAA,GAC9B,OAAA,GAAU,UAAA,GACT,uBAAA;;;;;;;AAHH;;;;;;;;;;;iBCIgB,wBAAA,CACd,OAAA,EAAS,UAAA,EACT,WAAA,UACA,SAAA,UACA,UAAA,WACC,QAAQ"} | ||
| {"version":3,"file":"codec-descriptor-registry.d.mts","names":[],"sources":["../../src/codec-descriptor-registry.ts","../../src/codec-ref-for-column.ts"],"mappings":";;;;;;;;;AAgBA;;;;;;;iBAAgB,4BAAA,CACd,cAAA,EAAgB,aAAA,CAAc,kBAAA,GAC9B,OAAA,GAAU,UAAA,GACT,uBAAA;;;;;;;AAHH;;;;;;;;;;;iBCKgB,wBAAA,CACd,OAAA,EAAS,UAAA,EACT,WAAA,UACA,SAAA,UACA,UAAA,WACC,QAAQ"} |
| import { resolveStorageTable } from "@prisma-next/sql-contract/resolve-storage-table"; | ||
| import { isStorageTypeInstance } from "@prisma-next/sql-contract/types"; | ||
| import { blindCast } from "@prisma-next/utils/casts"; | ||
| //#region src/codec-ref-for-column.ts | ||
@@ -36,7 +37,17 @@ /** | ||
| } | ||
| if (columnDef.typeParams !== void 0 && Object.keys(columnDef.typeParams).length > 0) return { | ||
| if (columnDef.typeParams !== void 0 && Object.keys(columnDef.typeParams).length > 0) { | ||
| const typeParams = blindCast(columnDef.typeParams); | ||
| return columnDef.many ? { | ||
| codecId: columnDef.codecId, | ||
| typeParams, | ||
| many: true | ||
| } : { | ||
| codecId: columnDef.codecId, | ||
| typeParams | ||
| }; | ||
| } | ||
| return columnDef.many ? { | ||
| codecId: columnDef.codecId, | ||
| typeParams: columnDef.typeParams | ||
| }; | ||
| return { codecId: columnDef.codecId }; | ||
| many: true | ||
| } : { codecId: columnDef.codecId }; | ||
| } | ||
@@ -43,0 +54,0 @@ //#endregion |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"codec-descriptor-registry.mjs","names":[],"sources":["../../src/codec-ref-for-column.ts","../../src/codec-descriptor-registry.ts"],"sourcesContent":["import type { JsonValue } from '@prisma-next/contract/types';\nimport type { CodecRef } from '@prisma-next/framework-components/codec';\nimport { resolveStorageTable } from '@prisma-next/sql-contract/resolve-storage-table';\nimport { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types';\n\n/**\n * Derive the canonical {@link CodecRef} for a `(table, column)` pair against a {@link SqlStorage}. This is the build-time path every column-bound `ParamRef` / `ProjectionItem` uses to stamp its `codec` slot before the AST is handed to the runtime — the runtime resolver then materialises a memoised {@link import('@prisma-next/sql-relational-core/ast').Codec} for the same `CodecRef` via `forCodecRef`.\n *\n * Resolution rules over namespace `entries.table[table].columns[column]`:\n *\n * - `typeRef` column → `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef share one ref → one memoised codec).\n * - inline `typeParams` column → `{codecId, typeParams}` from the column itself.\n * - non-parameterized column → `{codecId}` with `typeParams` undefined.\n *\n * Returns `undefined` when the table or column is unknown, or when a `typeRef` column references a `storage.types` entry that does not exist.\n *\n * `namespaceId` leads the coordinate args and is always supplied: every\n * model/table sits in an explicit namespace, so the table is resolved strictly\n * within that namespace (see {@link resolveStorageTable}).\n */\nexport function codecRefForStorageColumn(\n storage: SqlStorage,\n namespaceId: string,\n tableName: string,\n columnName: string,\n): CodecRef | undefined {\n const resolved = resolveStorageTable(storage, tableName, namespaceId);\n if (resolved === undefined) return undefined;\n const tableDef = resolved.table;\n const columnDef = tableDef.columns[columnName];\n if (!columnDef) return undefined;\n if (columnDef.typeRef !== undefined) {\n const instance = storage.types?.[columnDef.typeRef];\n if (!instance) return undefined;\n if (isStorageTypeInstance(instance)) {\n const instanceParams = instance.typeParams;\n const hasParamKeys = instanceParams !== undefined && Object.keys(instanceParams).length > 0;\n return hasParamKeys\n ? { codecId: instance.codecId, typeParams: instanceParams as JsonValue }\n : { codecId: instance.codecId };\n }\n return undefined;\n }\n if (columnDef.typeParams !== undefined && Object.keys(columnDef.typeParams).length > 0) {\n return { codecId: columnDef.codecId, typeParams: columnDef.typeParams as JsonValue };\n }\n return { codecId: columnDef.codecId };\n}\n","import type { CodecDescriptor, CodecRef } from '@prisma-next/framework-components/codec';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { AnyCodecDescriptor } from './ast/codec-types';\nimport { codecRefForStorageColumn } from './codec-ref-for-column';\nimport type { CodecDescriptorRegistry } from './query-lane-context';\n\n/**\n * Build a {@link CodecDescriptorRegistry} from a flat descriptor list.\n *\n * Used by:\n * - Each codec-shipping package's `core/registry.ts` to expose a package-scoped registry as the public consumer surface (replacing raw descriptor-array exports). See ADR 208.\n * - The runtime's `buildExecutionContext` to construct the contract-bound combined registry from every contributor's `codecs:` slot.\n *\n * The descriptor map is heterogeneous in `P` — each codec id has its own params shape. The public {@link CodecDescriptorRegistry} interface widens to `CodecDescriptor<unknown>` and consumers narrow per codec id at the call site (the descriptor's `paramsSchema` validates JSON-sourced params before the factory ever sees them, so the runtime narrow is safe). The cast at registration goes through `unknown` because\n * `CodecDescriptor<P>` is invariant in `P` (the `factory` and `renderOutputType` slots use `P` contravariantly).\n */\nexport function buildCodecDescriptorRegistry(\n allDescriptors: ReadonlyArray<AnyCodecDescriptor>,\n storage?: SqlStorage,\n): CodecDescriptorRegistry {\n type AnyDescriptor = CodecDescriptor<unknown>;\n const byId = new Map<string, AnyDescriptor>();\n const byTargetType = new Map<string, Array<AnyDescriptor>>();\n\n for (const descriptor of allDescriptors) {\n if (byId.has(descriptor.codecId)) {\n throw new Error(\n `Duplicate codec descriptor id: '${descriptor.codecId}' — registered twice during registry construction. ` +\n 'Each codecId must be contributed by exactly one component (target / adapter / extension pack).',\n );\n }\n const widened = descriptor as unknown as AnyDescriptor;\n byId.set(descriptor.codecId, widened);\n for (const targetType of descriptor.targetTypes) {\n const list = byTargetType.get(targetType);\n if (list) {\n list.push(widened);\n } else {\n byTargetType.set(targetType, [widened]);\n }\n }\n }\n\n return {\n descriptorFor(codecId: string): AnyDescriptor | undefined {\n return byId.get(codecId);\n },\n codecRefForColumn(namespaceId: string, table: string, column: string): CodecRef | undefined {\n if (!storage) return undefined;\n return codecRefForStorageColumn(storage, namespaceId, table, column);\n },\n *values(): IterableIterator<AnyDescriptor> {\n yield* byId.values();\n },\n byTargetType(targetType: string): readonly AnyDescriptor[] {\n return byTargetType.get(targetType) ?? Object.freeze([]);\n },\n };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,SAAgB,yBACd,SACA,aACA,WACA,YACsB;CACtB,MAAM,WAAW,oBAAoB,SAAS,WAAW,WAAW;CACpE,IAAI,aAAa,KAAA,GAAW,OAAO,KAAA;CAEnC,MAAM,YADW,SAAS,MACC,QAAQ;CACnC,IAAI,CAAC,WAAW,OAAO,KAAA;CACvB,IAAI,UAAU,YAAY,KAAA,GAAW;EACnC,MAAM,WAAW,QAAQ,QAAQ,UAAU;EAC3C,IAAI,CAAC,UAAU,OAAO,KAAA;EACtB,IAAI,sBAAsB,QAAQ,GAAG;GACnC,MAAM,iBAAiB,SAAS;GAEhC,OADqB,mBAAmB,KAAA,KAAa,OAAO,KAAK,cAAc,CAAC,CAAC,SAAS,IAEtF;IAAE,SAAS,SAAS;IAAS,YAAY;GAA4B,IACrE,EAAE,SAAS,SAAS,QAAQ;EAClC;EACA;CACF;CACA,IAAI,UAAU,eAAe,KAAA,KAAa,OAAO,KAAK,UAAU,UAAU,CAAC,CAAC,SAAS,GACnF,OAAO;EAAE,SAAS,UAAU;EAAS,YAAY,UAAU;CAAwB;CAErF,OAAO,EAAE,SAAS,UAAU,QAAQ;AACtC;;;;;;;;;;;;;AC/BA,SAAgB,6BACd,gBACA,SACyB;CAEzB,MAAM,uBAAO,IAAI,IAA2B;CAC5C,MAAM,+BAAe,IAAI,IAAkC;CAE3D,KAAK,MAAM,cAAc,gBAAgB;EACvC,IAAI,KAAK,IAAI,WAAW,OAAO,GAC7B,MAAM,IAAI,MACR,mCAAmC,WAAW,QAAQ,kJAExD;EAEF,MAAM,UAAU;EAChB,KAAK,IAAI,WAAW,SAAS,OAAO;EACpC,KAAK,MAAM,cAAc,WAAW,aAAa;GAC/C,MAAM,OAAO,aAAa,IAAI,UAAU;GACxC,IAAI,MACF,KAAK,KAAK,OAAO;QAEjB,aAAa,IAAI,YAAY,CAAC,OAAO,CAAC;EAE1C;CACF;CAEA,OAAO;EACL,cAAc,SAA4C;GACxD,OAAO,KAAK,IAAI,OAAO;EACzB;EACA,kBAAkB,aAAqB,OAAe,QAAsC;GAC1F,IAAI,CAAC,SAAS,OAAO,KAAA;GACrB,OAAO,yBAAyB,SAAS,aAAa,OAAO,MAAM;EACrE;EACA,CAAC,SAA0C;GACzC,OAAO,KAAK,OAAO;EACrB;EACA,aAAa,YAA8C;GACzD,OAAO,aAAa,IAAI,UAAU,KAAK,OAAO,OAAO,CAAC,CAAC;EACzD;CACF;AACF"} | ||
| {"version":3,"file":"codec-descriptor-registry.mjs","names":[],"sources":["../../src/codec-ref-for-column.ts","../../src/codec-descriptor-registry.ts"],"sourcesContent":["import type { JsonValue } from '@prisma-next/contract/types';\nimport type { CodecRef } from '@prisma-next/framework-components/codec';\nimport { resolveStorageTable } from '@prisma-next/sql-contract/resolve-storage-table';\nimport { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\n\n/**\n * Derive the canonical {@link CodecRef} for a `(table, column)` pair against a {@link SqlStorage}. This is the build-time path every column-bound `ParamRef` / `ProjectionItem` uses to stamp its `codec` slot before the AST is handed to the runtime — the runtime resolver then materialises a memoised {@link import('@prisma-next/sql-relational-core/ast').Codec} for the same `CodecRef` via `forCodecRef`.\n *\n * Resolution rules over namespace `entries.table[table].columns[column]`:\n *\n * - `typeRef` column → `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef share one ref → one memoised codec).\n * - inline `typeParams` column → `{codecId, typeParams}` from the column itself.\n * - non-parameterized column → `{codecId}` with `typeParams` undefined.\n *\n * Returns `undefined` when the table or column is unknown, or when a `typeRef` column references a `storage.types` entry that does not exist.\n *\n * `namespaceId` leads the coordinate args and is always supplied: every\n * model/table sits in an explicit namespace, so the table is resolved strictly\n * within that namespace (see {@link resolveStorageTable}).\n */\nexport function codecRefForStorageColumn(\n storage: SqlStorage,\n namespaceId: string,\n tableName: string,\n columnName: string,\n): CodecRef | undefined {\n const resolved = resolveStorageTable(storage, tableName, namespaceId);\n if (resolved === undefined) return undefined;\n const tableDef = resolved.table;\n const columnDef = tableDef.columns[columnName];\n if (!columnDef) return undefined;\n if (columnDef.typeRef !== undefined) {\n const instance = storage.types?.[columnDef.typeRef];\n if (!instance) return undefined;\n if (isStorageTypeInstance(instance)) {\n const instanceParams = instance.typeParams;\n const hasParamKeys = instanceParams !== undefined && Object.keys(instanceParams).length > 0;\n return hasParamKeys\n ? { codecId: instance.codecId, typeParams: instanceParams as JsonValue }\n : { codecId: instance.codecId };\n }\n return undefined;\n }\n if (columnDef.typeParams !== undefined && Object.keys(columnDef.typeParams).length > 0) {\n const typeParams = blindCast<\n JsonValue,\n 'column typeParams is a validated contract record; its values are JSON-serialisable'\n >(columnDef.typeParams);\n return columnDef.many\n ? { codecId: columnDef.codecId, typeParams, many: true }\n : { codecId: columnDef.codecId, typeParams };\n }\n return columnDef.many\n ? { codecId: columnDef.codecId, many: true }\n : { codecId: columnDef.codecId };\n}\n","import type { CodecDescriptor, CodecRef } from '@prisma-next/framework-components/codec';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { AnyCodecDescriptor } from './ast/codec-types';\nimport { codecRefForStorageColumn } from './codec-ref-for-column';\nimport type { CodecDescriptorRegistry } from './query-lane-context';\n\n/**\n * Build a {@link CodecDescriptorRegistry} from a flat descriptor list.\n *\n * Used by:\n * - Each codec-shipping package's `core/registry.ts` to expose a package-scoped registry as the public consumer surface (replacing raw descriptor-array exports). See ADR 208.\n * - The runtime's `buildExecutionContext` to construct the contract-bound combined registry from every contributor's `codecs:` slot.\n *\n * The descriptor map is heterogeneous in `P` — each codec id has its own params shape. The public {@link CodecDescriptorRegistry} interface widens to `CodecDescriptor<unknown>` and consumers narrow per codec id at the call site (the descriptor's `paramsSchema` validates JSON-sourced params before the factory ever sees them, so the runtime narrow is safe). The cast at registration goes through `unknown` because\n * `CodecDescriptor<P>` is invariant in `P` (the `factory` and `renderOutputType` slots use `P` contravariantly).\n */\nexport function buildCodecDescriptorRegistry(\n allDescriptors: ReadonlyArray<AnyCodecDescriptor>,\n storage?: SqlStorage,\n): CodecDescriptorRegistry {\n type AnyDescriptor = CodecDescriptor<unknown>;\n const byId = new Map<string, AnyDescriptor>();\n const byTargetType = new Map<string, Array<AnyDescriptor>>();\n\n for (const descriptor of allDescriptors) {\n if (byId.has(descriptor.codecId)) {\n throw new Error(\n `Duplicate codec descriptor id: '${descriptor.codecId}' — registered twice during registry construction. ` +\n 'Each codecId must be contributed by exactly one component (target / adapter / extension pack).',\n );\n }\n const widened = descriptor as unknown as AnyDescriptor;\n byId.set(descriptor.codecId, widened);\n for (const targetType of descriptor.targetTypes) {\n const list = byTargetType.get(targetType);\n if (list) {\n list.push(widened);\n } else {\n byTargetType.set(targetType, [widened]);\n }\n }\n }\n\n return {\n descriptorFor(codecId: string): AnyDescriptor | undefined {\n return byId.get(codecId);\n },\n codecRefForColumn(namespaceId: string, table: string, column: string): CodecRef | undefined {\n if (!storage) return undefined;\n return codecRefForStorageColumn(storage, namespaceId, table, column);\n },\n *values(): IterableIterator<AnyDescriptor> {\n yield* byId.values();\n },\n byTargetType(targetType: string): readonly AnyDescriptor[] {\n return byTargetType.get(targetType) ?? Object.freeze([]);\n },\n };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,yBACd,SACA,aACA,WACA,YACsB;CACtB,MAAM,WAAW,oBAAoB,SAAS,WAAW,WAAW;CACpE,IAAI,aAAa,KAAA,GAAW,OAAO,KAAA;CAEnC,MAAM,YADW,SAAS,MACC,QAAQ;CACnC,IAAI,CAAC,WAAW,OAAO,KAAA;CACvB,IAAI,UAAU,YAAY,KAAA,GAAW;EACnC,MAAM,WAAW,QAAQ,QAAQ,UAAU;EAC3C,IAAI,CAAC,UAAU,OAAO,KAAA;EACtB,IAAI,sBAAsB,QAAQ,GAAG;GACnC,MAAM,iBAAiB,SAAS;GAEhC,OADqB,mBAAmB,KAAA,KAAa,OAAO,KAAK,cAAc,CAAC,CAAC,SAAS,IAEtF;IAAE,SAAS,SAAS;IAAS,YAAY;GAA4B,IACrE,EAAE,SAAS,SAAS,QAAQ;EAClC;EACA;CACF;CACA,IAAI,UAAU,eAAe,KAAA,KAAa,OAAO,KAAK,UAAU,UAAU,CAAC,CAAC,SAAS,GAAG;EACtF,MAAM,aAAa,UAGjB,UAAU,UAAU;EACtB,OAAO,UAAU,OACb;GAAE,SAAS,UAAU;GAAS;GAAY,MAAM;EAAK,IACrD;GAAE,SAAS,UAAU;GAAS;EAAW;CAC/C;CACA,OAAO,UAAU,OACb;EAAE,SAAS,UAAU;EAAS,MAAM;CAAK,IACzC,EAAE,SAAS,UAAU,QAAQ;AACnC;;;;;;;;;;;;;ACxCA,SAAgB,6BACd,gBACA,SACyB;CAEzB,MAAM,uBAAO,IAAI,IAA2B;CAC5C,MAAM,+BAAe,IAAI,IAAkC;CAE3D,KAAK,MAAM,cAAc,gBAAgB;EACvC,IAAI,KAAK,IAAI,WAAW,OAAO,GAC7B,MAAM,IAAI,MACR,mCAAmC,WAAW,QAAQ,kJAExD;EAEF,MAAM,UAAU;EAChB,KAAK,IAAI,WAAW,SAAS,OAAO;EACpC,KAAK,MAAM,cAAc,WAAW,aAAa;GAC/C,MAAM,OAAO,aAAa,IAAI,UAAU;GACxC,IAAI,MACF,KAAK,KAAK,OAAO;QAEjB,aAAa,IAAI,YAAY,CAAC,OAAO,CAAC;EAE1C;CACF;CAEA,OAAO;EACL,cAAc,SAA4C;GACxD,OAAO,KAAK,IAAI,OAAO;EACzB;EACA,kBAAkB,aAAqB,OAAe,QAAsC;GAC1F,IAAI,CAAC,SAAS,OAAO,KAAA;GACrB,OAAO,yBAAyB,SAAS,aAAa,OAAO,MAAM;EACrE;EACA,CAAC,SAA0C;GACzC,OAAO,KAAK,OAAO;EACrB;EACA,aAAa,YAA8C;GACzD,OAAO,aAAa,IAAI,UAAU,KAAK,OAAO,OAAO,CAAC,CAAC;EACzD;CACF;AACF"} |
| import { o as CodecRef } from "../codec-types-DFLA6Hmj.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-DQrmgP8Y.mjs"; | ||
| import { c as ForeignKeyConstraint, d as PrimaryKeyConstraint, f as UniqueConstraint, l as FunctionColumnDefault, n as DdlColumn, t as AnyDdlColumnDefault, u as LiteralColumnDefault } from "../ddl-types-BVO002FS.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-Cd4p4EbE.mjs"; | ||
| import { ColumnDefaultLiteralInputValue } from "@prisma-next/contract/types"; | ||
@@ -29,2 +29,3 @@ import { ReferentialAction } from "@prisma-next/sql-contract/types"; | ||
| }): UniqueConstraint; | ||
| declare function checkExpression(name: string, expression: string): CheckExpressionConstraint; | ||
| //#endregion | ||
@@ -218,3 +219,3 @@ //#region src/contract-free/table.d.ts | ||
| //#endregion | ||
| export { CfConflictClause, CfExpr, CfExprSelectQuery, type CfFnOptions, CfInsertQuery, CfSelectQuery, CfUpdateQuery, CfUpsertBuilder, CfUpsertQuery, type ColumnDescriptor, type ColumnProxy, type ColumnSchema, type DdlColumnOptions, type ExcludedProxy, type TableHandle, type TableInsertRow, type TableSetValues, cfExpr, cfTable, col, exprSelect, fn, foreignKey, lit, primaryKey, table, unique }; | ||
| export { CfConflictClause, CfExpr, CfExprSelectQuery, type CfFnOptions, CfInsertQuery, CfSelectQuery, CfUpdateQuery, CfUpsertBuilder, CfUpsertQuery, type ColumnDescriptor, type ColumnProxy, type ColumnSchema, type DdlColumnOptions, type ExcludedProxy, type TableHandle, type TableInsertRow, type TableSetValues, cfExpr, cfTable, checkExpression, col, exprSelect, fn, foreignKey, lit, primaryKey, table, unique }; | ||
| //# sourceMappingURL=contract-free.d.mts.map |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"contract-free.d.mts","names":[],"sources":["../../src/contract-free/column.ts","../../src/contract-free/table.ts"],"mappings":"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"} | ||
| {"version":3,"file":"contract-free.d.mts","names":[],"sources":["../../src/contract-free/column.ts","../../src/contract-free/table.ts"],"mappings":"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"} |
@@ -1,3 +0,3 @@ | ||
| import { a as FunctionColumnDefault, c as UniqueConstraint, i as ForeignKeyConstraint, o as LiteralColumnDefault, s as PrimaryKeyConstraint, t as DdlColumn } from "../ddl-types-DAox2c8w.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-lJUc6cY-.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"; | ||
@@ -38,2 +38,8 @@ //#region src/contract-free/column.ts | ||
| } | ||
| function checkExpression(name, expression) { | ||
| return new CheckExpressionConstraint({ | ||
| name, | ||
| expression | ||
| }); | ||
| } | ||
| //#endregion | ||
@@ -387,4 +393,4 @@ //#region src/contract-free/table.ts | ||
| //#endregion | ||
| export { CfConflictClause, CfExpr, CfExprSelectQuery, CfInsertQuery, CfSelectQuery, CfUpdateQuery, CfUpsertBuilder, CfUpsertQuery, cfExpr, cfTable, col, exprSelect, fn, foreignKey, lit, primaryKey, table, unique }; | ||
| export { CfConflictClause, CfExpr, CfExprSelectQuery, CfInsertQuery, CfSelectQuery, CfUpdateQuery, CfUpsertBuilder, CfUpsertQuery, cfExpr, cfTable, checkExpression, col, exprSelect, fn, foreignKey, lit, primaryKey, table, unique }; | ||
| //# sourceMappingURL=contract-free.mjs.map |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"contract-free.mjs","names":[],"sources":["../../src/contract-free/column.ts","../../src/contract-free/table.ts"],"sourcesContent":["import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport type { ReferentialAction } from '@prisma-next/sql-contract/types';\nimport type { CodecRef } from '../ast/codec-types';\nimport type { AnyDdlColumnDefault } from '../ast/ddl-types';\nimport {\n DdlColumn,\n ForeignKeyConstraint,\n FunctionColumnDefault,\n LiteralColumnDefault,\n PrimaryKeyConstraint,\n UniqueConstraint,\n} from '../ast/ddl-types';\n\nexport interface DdlColumnOptions {\n readonly notNull?: boolean;\n readonly primaryKey?: boolean;\n readonly default?: AnyDdlColumnDefault;\n readonly codecRef?: CodecRef;\n}\n\nexport function lit(value: ColumnDefaultLiteralInputValue): LiteralColumnDefault {\n return new LiteralColumnDefault(value);\n}\n\nexport function fn(expression: string): FunctionColumnDefault {\n return new FunctionColumnDefault(expression);\n}\n\nexport function col(name: string, type: string, options?: DdlColumnOptions): DdlColumn {\n return new DdlColumn({ name, type, ...options });\n}\n\nexport function primaryKey(\n columns: readonly string[],\n options?: { readonly name?: string },\n): PrimaryKeyConstraint {\n return new PrimaryKeyConstraint({ columns, ...options });\n}\n\nexport function foreignKey(\n columns: readonly string[],\n refTable: string,\n refColumns: readonly string[],\n options?: {\n readonly name?: string;\n readonly onDelete?: ReferentialAction;\n readonly onUpdate?: ReferentialAction;\n },\n): ForeignKeyConstraint {\n return new ForeignKeyConstraint({ columns, refTable, refColumns, ...options });\n}\n\nexport function unique(\n columns: readonly string[],\n options?: { readonly name?: string },\n): UniqueConstraint {\n return new UniqueConstraint({ columns, ...options });\n}\n","import type { ParamSpec } from '@prisma-next/operations';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport {\n AggregateExpr,\n AndExpr,\n type AnyExpression,\n type AnyFromSource,\n BinaryExpr,\n ColumnRef,\n ExistsExpr,\n IdentifierRef,\n InsertAst,\n InsertOnConflict,\n type InsertValue,\n JoinAst,\n LiteralExpr,\n NullCheckExpr,\n OperationExpr,\n OrderByItem,\n OrExpr,\n ParamRef,\n ProjectionItem,\n RawExpr,\n SelectAst,\n TableSource,\n UpdateAst,\n} from '../ast/types';\n\nexport interface ColumnDescriptor {\n readonly codecId: string;\n readonly nullable: boolean;\n}\n\nexport type ColumnSchema = Record<string, ColumnDescriptor>;\n\n/**\n * A composable WHERE / ON expression. Wraps an `AnyExpression` and exposes\n * fluent boolean combinators, mirroring the spirit of `sql-builder`'s\n * `Expression` interface without the contract-bound type machinery.\n */\nexport class CfExpr {\n constructor(readonly ast: AnyExpression) {}\n\n and(other: CfExpr): CfExpr {\n return new CfExpr(AndExpr.of([this.ast, other.ast]));\n }\n\n or(other: CfExpr): CfExpr {\n return new CfExpr(OrExpr.of([this.ast, other.ast]));\n }\n\n not(): CfExpr {\n return new CfExpr(this.ast.not());\n }\n\n isNull(): CfExpr {\n return new CfExpr(NullCheckExpr.isNull(this.ast));\n }\n\n isNotNull(): CfExpr {\n return new CfExpr(NullCheckExpr.isNotNull(this.ast));\n }\n\n eqLit(value: number | string | boolean): CfExpr {\n return new CfExpr(BinaryExpr.eq(this.ast, LiteralExpr.of(value)));\n }\n\n gtLit(value: number | string | boolean): CfExpr {\n return new CfExpr(BinaryExpr.gt(this.ast, LiteralExpr.of(value)));\n }\n\n eqParam(value: unknown, codecId: string): CfExpr {\n return new CfExpr(BinaryExpr.eq(this.ast, ParamRef.of(value, { codec: { codecId } })));\n }\n\n eqExpr(other: CfExpr): CfExpr {\n return new CfExpr(BinaryExpr.eq(this.ast, other.ast));\n }\n}\n\nexport interface CfFnOptions {\n readonly method: string;\n readonly template: string;\n readonly self: CfExpr;\n readonly args?: ReadonlyArray<CfExpr>;\n readonly returns: ParamSpec;\n}\n\nexport const cfExpr = {\n countStar(): CfExpr {\n return new CfExpr(AggregateExpr.count());\n },\n lit(value: number | string | boolean): CfExpr {\n return new CfExpr(LiteralExpr.of(value));\n },\n identifierRef(name: string): CfExpr {\n return new CfExpr(IdentifierRef.of(name));\n },\n param(value: unknown, codecId: string): CfExpr {\n return new CfExpr(ParamRef.of(value, { codec: { codecId } }));\n },\n /**\n * Catalog function call lowered via a `'function'`-strategy template\n * (e.g. `to_regclass({{self}})`). Owns the `OperationExpr` assembly so\n * target packages only supply vocabulary: template, codec'd operands,\n * and return spec.\n */\n fn(options: CfFnOptions): CfExpr {\n return new CfExpr(\n new OperationExpr({\n method: options.method,\n self: options.self.ast,\n args: options.args?.map((arg) => arg.ast),\n returns: options.returns,\n lowering: {\n targetFamily: 'sql',\n strategy: 'function',\n template: options.template,\n },\n }),\n );\n },\n columnRef(qualifier: string, name: string): CfExpr {\n return new CfExpr(ColumnRef.of(qualifier, name));\n },\n allOf(exprs: ReadonlyArray<CfExpr>): CfExpr {\n return new CfExpr(AndExpr.of(exprs.map((expr) => expr.ast)));\n },\n /**\n * Opaque DB-side SQL expression (e.g. `current_schema()`) carried as a\n * `RawExpr`. For zero-operand catalog functions where a `'function'`\n * lowering template has nothing to substitute.\n */\n raw(sql: string, returns: ParamSpec): CfExpr {\n return new CfExpr(new RawExpr({ parts: [sql], returns }));\n },\n exists(query: CfExprSelectQuery): CfExpr {\n return new CfExpr(ExistsExpr.exists(query.build()));\n },\n notExists(query: CfExprSelectQuery): CfExpr {\n return new CfExpr(ExistsExpr.notExists(query.build()));\n },\n};\n\n/** Aliased table source for catalog queries (no namespace coordinate). */\nexport function cfTable(name: string, alias?: string): TableSource {\n return TableSource.named(name, alias);\n}\n\nexport class CfExprSelectQuery {\n constructor(\n private readonly src: AnyFromSource | undefined,\n private readonly projectionItems: ReadonlyArray<ProjectionItem>,\n private readonly whereExpr: CfExpr | undefined,\n private readonly joinItems: ReadonlyArray<JoinAst> = [],\n private readonly limitValue: number | undefined = undefined,\n ) {}\n\n from(source: AnyFromSource): CfExprSelectQuery {\n return new CfExprSelectQuery(\n source,\n this.projectionItems,\n this.whereExpr,\n this.joinItems,\n this.limitValue,\n );\n }\n\n join(source: AnyFromSource, on: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n this.whereExpr,\n [...this.joinItems, JoinAst.inner(source, on.ast)],\n this.limitValue,\n );\n }\n\n leftJoin(source: AnyFromSource, on: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n this.whereExpr,\n [...this.joinItems, JoinAst.left(source, on.ast)],\n this.limitValue,\n );\n }\n\n project(alias: string, expr: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n [...this.projectionItems, ProjectionItem.of(alias, expr.ast)],\n this.whereExpr,\n this.joinItems,\n this.limitValue,\n );\n }\n\n where(expr: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n expr,\n this.joinItems,\n this.limitValue,\n );\n }\n\n limit(value: number): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n this.whereExpr,\n this.joinItems,\n value,\n );\n }\n\n build(): SelectAst {\n if (this.joinItems.length > 0 && this.src === undefined) {\n throw new Error('CfExprSelectQuery: cannot add a JOIN without a FROM clause');\n }\n const base =\n this.src !== undefined\n ? SelectAst.from(this.src).withProjection(this.projectionItems)\n : SelectAst.noFrom().withProjection(this.projectionItems);\n const withJoins = this.joinItems.length > 0 ? base.withJoins(this.joinItems) : base;\n const withWhere =\n this.whereExpr !== undefined ? withJoins.withWhere(this.whereExpr.ast) : withJoins;\n return this.limitValue !== undefined ? withWhere.withLimit(this.limitValue) : withWhere;\n }\n}\n\nexport function exprSelect(): CfExprSelectQuery {\n return new CfExprSelectQuery(undefined, [], undefined);\n}\n\n/**\n * Per-column authoring handle exposed as a keyed property on a {@link TableHandle}.\n * Carries codec metadata baked at declaration time so no codec ID, table name, or\n * column name needs to be repeated at the call site.\n */\nexport interface ColumnProxy {\n readonly codecId: string;\n readonly nullable: boolean;\n readonly columnName: string;\n readonly tableName: string;\n eq(value: unknown): CfExpr;\n neq(value: unknown): CfExpr;\n isNull(): CfExpr;\n isNotNull(): CfExpr;\n toRef(): ColumnRef;\n toProjectionItem(alias?: string): ProjectionItem;\n}\n\n/**\n * Object passed to the {@link CfConflictClause.doUpdate} callback. Each key\n * resolves to a `ColumnRef` for the corresponding `excluded.<column>`, so the\n * upsert conflict-update branch can copy proposed values without re-binding\n * parameters.\n */\nexport type ExcludedProxy<Schema extends ColumnSchema> = {\n readonly [K in keyof Schema]: ColumnRef;\n};\n\nexport type TableInsertRow<Schema extends ColumnSchema> = {\n readonly [K in keyof Schema]: unknown;\n};\n\nexport type TableSetValues<Schema extends ColumnSchema> = {\n readonly [K in keyof Schema]?: unknown;\n};\n\n/**\n * Fluent authoring handle for a fixed control-plane table. Column proxies are\n * exposed as keyed properties so `handle.columnName.eq(value)` composes without\n * threading codec IDs, table names, or column refs at the call site.\n */\nexport type TableHandle<Schema extends ColumnSchema> = {\n readonly source: TableSource;\n insert(row: TableInsertRow<Schema>): CfInsertQuery<Schema>;\n upsert(row: TableInsertRow<Schema>): CfUpsertBuilder<Schema>;\n update(): CfUpdateQuery<Schema>;\n select(...columns: ReadonlyArray<ColumnProxy>): CfSelectQuery;\n} & {\n readonly [K in keyof Schema]: ColumnProxy;\n};\n\nexport class CfInsertQuery<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,\n ) {}\n\n returning(...columns: ReadonlyArray<ColumnProxy>): CfInsertQuery<Schema> {\n return new CfInsertQuery(\n this.src,\n this.schema,\n this.rowValues,\n columns.map((col) => col.toProjectionItem()),\n );\n }\n\n build(): InsertAst {\n const row = buildInsertRow(this.schema, this.rowValues);\n const ast = InsertAst.into(this.src).withRows([row]);\n return this.returningItems ? ast.withReturning(this.returningItems) : ast;\n }\n}\n\nexport class CfUpsertBuilder<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n ) {}\n\n onConflict(...columns: ReadonlyArray<ColumnProxy>): CfConflictClause<Schema> {\n return new CfConflictClause(this.src, this.schema, this.rowValues, [...columns]);\n }\n}\n\nexport class CfConflictClause<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n private readonly conflictCols: ReadonlyArray<ColumnProxy>,\n ) {}\n\n doUpdate(\n setOrCallback:\n | TableSetValues<Schema>\n | ((excluded: ExcludedProxy<Schema>) => TableSetValues<Schema>),\n ): CfUpsertQuery<Schema> {\n const set =\n typeof setOrCallback === 'function'\n ? setOrCallback(buildExcludedProxy(this.schema))\n : setOrCallback;\n return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, set);\n }\n\n doNothing(): CfUpsertQuery<Schema> {\n return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, undefined);\n }\n}\n\nexport class CfUpsertQuery<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n private readonly conflictCols: ReadonlyArray<ColumnProxy>,\n private readonly updateSet: TableSetValues<Schema> | undefined,\n ) {}\n\n build(): InsertAst {\n const row = buildInsertRow(this.schema, this.rowValues);\n const conflictRefs = this.conflictCols.map((col) => col.toRef());\n const onConflict =\n this.updateSet === undefined\n ? InsertOnConflict.on(conflictRefs).doNothing()\n : InsertOnConflict.on(conflictRefs).doUpdateSet(buildSetMap(this.schema, this.updateSet));\n return InsertAst.into(this.src).withRows([row]).withOnConflict(onConflict);\n }\n}\n\nexport class CfUpdateQuery<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly setValues: TableSetValues<Schema> | undefined = undefined,\n private readonly whereExpr: CfExpr | undefined = undefined,\n private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,\n ) {}\n\n set(values: TableSetValues<Schema>): CfUpdateQuery<Schema> {\n return new CfUpdateQuery(this.src, this.schema, values, this.whereExpr, this.returningItems);\n }\n\n where(expr: CfExpr): CfUpdateQuery<Schema> {\n return new CfUpdateQuery(this.src, this.schema, this.setValues, expr, this.returningItems);\n }\n\n returning(...columns: ReadonlyArray<ColumnProxy>): CfUpdateQuery<Schema> {\n return new CfUpdateQuery(\n this.src,\n this.schema,\n this.setValues,\n this.whereExpr,\n columns.map((col) => col.toProjectionItem()),\n );\n }\n\n build(): UpdateAst {\n const set = buildSetMap(this.schema, this.setValues);\n const base = UpdateAst.table(this.src).withSet(set);\n const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;\n return this.returningItems ? withWhere.withReturning(this.returningItems) : withWhere;\n }\n}\n\nexport class CfSelectQuery {\n constructor(\n private readonly src: TableSource,\n private readonly projectionItems: ReadonlyArray<ProjectionItem>,\n private readonly whereExpr: CfExpr | undefined = undefined,\n private readonly orderByItems: ReadonlyArray<OrderByItem> = [],\n ) {}\n\n where(expr: CfExpr): CfSelectQuery {\n return new CfSelectQuery(this.src, this.projectionItems, expr, this.orderByItems);\n }\n\n orderBy(column: ColumnProxy, dir: 'asc' | 'desc' = 'asc'): CfSelectQuery {\n const item = dir === 'asc' ? OrderByItem.asc(column.toRef()) : OrderByItem.desc(column.toRef());\n return new CfSelectQuery(this.src, this.projectionItems, this.whereExpr, [\n ...this.orderByItems,\n item,\n ]);\n }\n\n build(): SelectAst {\n const base = SelectAst.from(this.src).withProjection(this.projectionItems);\n const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;\n return this.orderByItems.length > 0 ? withWhere.withOrderBy(this.orderByItems) : withWhere;\n }\n}\n\n/**\n * Declare a control-plane table once, binding column codecs at declaration time.\n * Returns a `TableHandle` whose column properties compose expressions directly\n * without per-call-site codec or column-name threading.\n *\n * ```ts\n * const marker = pgTable({ name: 'marker', schema: 'prisma_contract' }, {\n * space: text(),\n * core_hash: text(),\n * updated_at: timestamptz(),\n * });\n *\n * const query = marker.update()\n * .set({ core_hash: newHash, updated_at: NOW })\n * .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))\n * .returning(marker.space)\n * .build();\n * ```\n */\nexport function table<Schema extends ColumnSchema>(\n source: TableSource,\n schema: Schema,\n): TableHandle<Schema> {\n const proxies: Record<string, ColumnProxy> = {};\n for (const [col, desc] of Object.entries(schema)) {\n proxies[col] = makeColumnProxy(source.alias ?? source.name, col, desc);\n }\n\n const handle = {\n ...proxies,\n source,\n insert: (row: TableInsertRow<Schema>) => new CfInsertQuery(source, schema, row),\n upsert: (row: TableInsertRow<Schema>) => new CfUpsertBuilder(source, schema, row),\n update: () => new CfUpdateQuery(source, schema),\n select: (...cols: ReadonlyArray<ColumnProxy>) =>\n new CfSelectQuery(\n source,\n cols.map((col) => col.toProjectionItem()),\n ),\n };\n\n return blindCast<\n TableHandle<Schema>,\n 'Column proxies are dynamically built from Schema keys — TypeScript cannot verify the per-key ColumnProxy constraint at the spread call site. Construction is correct by construction: every key maps to makeColumnProxy(source.name, key, schema[key]).'\n >(handle);\n}\n\nfunction makeColumnProxy(\n tableName: string,\n columnName: string,\n desc: ColumnDescriptor,\n): ColumnProxy {\n const ref = ColumnRef.of(tableName, columnName);\n return {\n codecId: desc.codecId,\n nullable: desc.nullable,\n columnName,\n tableName,\n eq: (value) =>\n value === null\n ? new CfExpr(NullCheckExpr.isNull(ref))\n : new CfExpr(BinaryExpr.eq(ref, toSetExpression(value, desc))),\n neq: (value) =>\n value === null\n ? new CfExpr(NullCheckExpr.isNotNull(ref))\n : new CfExpr(BinaryExpr.neq(ref, toSetExpression(value, desc))),\n isNull: () => new CfExpr(NullCheckExpr.isNull(ref)),\n isNotNull: () => new CfExpr(NullCheckExpr.isNotNull(ref)),\n toRef: () => ref,\n toProjectionItem: (alias = columnName) =>\n ProjectionItem.of(alias, ref, { codecId: desc.codecId }),\n };\n}\n\nfunction buildExcludedProxy<Schema extends ColumnSchema>(schema: Schema): ExcludedProxy<Schema> {\n return blindCast<\n ExcludedProxy<Schema>,\n 'Object.fromEntries cannot preserve per-key ColumnRef types — correct by construction: every key maps to ColumnRef.of(\"excluded\", key).'\n >(Object.fromEntries(Object.keys(schema).map((col) => [col, ColumnRef.of('excluded', col)])));\n}\n\nfunction isExpressionSource(value: unknown): value is { toExpr(): AnyExpression } {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'toExpr' in value &&\n typeof value.toExpr === 'function'\n );\n}\n\nfunction toInsertValue(value: unknown, desc: ColumnDescriptor): InsertValue {\n if (isExpressionSource(value)) {\n const expr = value.toExpr();\n if (\n expr.kind === 'column-ref' ||\n expr.kind === 'param-ref' ||\n expr.kind === 'prepared-param-ref' ||\n expr.kind === 'raw-expr'\n ) {\n return expr;\n }\n }\n return ParamRef.of(value, { codec: { codecId: desc.codecId } });\n}\n\nfunction toSetExpression(value: unknown, desc: ColumnDescriptor): AnyExpression {\n if (isExpressionSource(value)) {\n return value.toExpr();\n }\n return ParamRef.of(value, { codec: { codecId: desc.codecId } });\n}\n\nfunction buildInsertRow<Schema extends ColumnSchema>(\n schema: Schema,\n values: TableInsertRow<Schema>,\n): Record<string, InsertValue> {\n const row: Record<string, InsertValue> = {};\n const rawValues = blindCast<\n Record<string, unknown>,\n 'TableInsertRow<Schema> maps Schema keys to unknown; indexing by the same string keys is correct by construction'\n >(values);\n for (const [col, desc] of Object.entries(schema)) {\n row[col] = toInsertValue(rawValues[col], desc);\n }\n return row;\n}\n\nfunction buildSetMap<Schema extends ColumnSchema>(\n schema: Schema,\n values: TableSetValues<Schema> | undefined,\n): Record<string, AnyExpression> {\n if (values === undefined) return {};\n const set: Record<string, AnyExpression> = {};\n const rawSchema = blindCast<\n Record<string, ColumnDescriptor>,\n 'Schema extends ColumnSchema = Record<string, ColumnDescriptor>; runtime key access is correct by construction'\n >(schema);\n const rawValues = blindCast<\n Record<string, unknown>,\n 'TableSetValues<Schema> maps Schema keys to unknown; iterating with Object.entries is correct by construction'\n >(values);\n for (const [col, value] of Object.entries(rawValues)) {\n const desc = rawSchema[col];\n if (desc !== undefined) {\n set[col] = toSetExpression(value, desc);\n }\n }\n return set;\n}\n"],"mappings":"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"} | ||
| {"version":3,"file":"contract-free.mjs","names":[],"sources":["../../src/contract-free/column.ts","../../src/contract-free/table.ts"],"sourcesContent":["import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport type { ReferentialAction } from '@prisma-next/sql-contract/types';\nimport type { CodecRef } from '../ast/codec-types';\nimport type { AnyDdlColumnDefault } from '../ast/ddl-types';\nimport {\n CheckExpressionConstraint,\n DdlColumn,\n ForeignKeyConstraint,\n FunctionColumnDefault,\n LiteralColumnDefault,\n PrimaryKeyConstraint,\n UniqueConstraint,\n} from '../ast/ddl-types';\n\nexport interface DdlColumnOptions {\n readonly notNull?: boolean;\n readonly primaryKey?: boolean;\n readonly default?: AnyDdlColumnDefault;\n readonly codecRef?: CodecRef;\n}\n\nexport function lit(value: ColumnDefaultLiteralInputValue): LiteralColumnDefault {\n return new LiteralColumnDefault(value);\n}\n\nexport function fn(expression: string): FunctionColumnDefault {\n return new FunctionColumnDefault(expression);\n}\n\nexport function col(name: string, type: string, options?: DdlColumnOptions): DdlColumn {\n return new DdlColumn({ name, type, ...options });\n}\n\nexport function primaryKey(\n columns: readonly string[],\n options?: { readonly name?: string },\n): PrimaryKeyConstraint {\n return new PrimaryKeyConstraint({ columns, ...options });\n}\n\nexport function foreignKey(\n columns: readonly string[],\n refTable: string,\n refColumns: readonly string[],\n options?: {\n readonly name?: string;\n readonly onDelete?: ReferentialAction;\n readonly onUpdate?: ReferentialAction;\n },\n): ForeignKeyConstraint {\n return new ForeignKeyConstraint({ columns, refTable, refColumns, ...options });\n}\n\nexport function unique(\n columns: readonly string[],\n options?: { readonly name?: string },\n): UniqueConstraint {\n return new UniqueConstraint({ columns, ...options });\n}\n\nexport function checkExpression(name: string, expression: string): CheckExpressionConstraint {\n return new CheckExpressionConstraint({ name, expression });\n}\n","import type { ParamSpec } from '@prisma-next/operations';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport {\n AggregateExpr,\n AndExpr,\n type AnyExpression,\n type AnyFromSource,\n BinaryExpr,\n ColumnRef,\n ExistsExpr,\n IdentifierRef,\n InsertAst,\n InsertOnConflict,\n type InsertValue,\n JoinAst,\n LiteralExpr,\n NullCheckExpr,\n OperationExpr,\n OrderByItem,\n OrExpr,\n ParamRef,\n ProjectionItem,\n RawExpr,\n SelectAst,\n TableSource,\n UpdateAst,\n} from '../ast/types';\n\nexport interface ColumnDescriptor {\n readonly codecId: string;\n readonly nullable: boolean;\n}\n\nexport type ColumnSchema = Record<string, ColumnDescriptor>;\n\n/**\n * A composable WHERE / ON expression. Wraps an `AnyExpression` and exposes\n * fluent boolean combinators, mirroring the spirit of `sql-builder`'s\n * `Expression` interface without the contract-bound type machinery.\n */\nexport class CfExpr {\n constructor(readonly ast: AnyExpression) {}\n\n and(other: CfExpr): CfExpr {\n return new CfExpr(AndExpr.of([this.ast, other.ast]));\n }\n\n or(other: CfExpr): CfExpr {\n return new CfExpr(OrExpr.of([this.ast, other.ast]));\n }\n\n not(): CfExpr {\n return new CfExpr(this.ast.not());\n }\n\n isNull(): CfExpr {\n return new CfExpr(NullCheckExpr.isNull(this.ast));\n }\n\n isNotNull(): CfExpr {\n return new CfExpr(NullCheckExpr.isNotNull(this.ast));\n }\n\n eqLit(value: number | string | boolean): CfExpr {\n return new CfExpr(BinaryExpr.eq(this.ast, LiteralExpr.of(value)));\n }\n\n gtLit(value: number | string | boolean): CfExpr {\n return new CfExpr(BinaryExpr.gt(this.ast, LiteralExpr.of(value)));\n }\n\n eqParam(value: unknown, codecId: string): CfExpr {\n return new CfExpr(BinaryExpr.eq(this.ast, ParamRef.of(value, { codec: { codecId } })));\n }\n\n eqExpr(other: CfExpr): CfExpr {\n return new CfExpr(BinaryExpr.eq(this.ast, other.ast));\n }\n}\n\nexport interface CfFnOptions {\n readonly method: string;\n readonly template: string;\n readonly self: CfExpr;\n readonly args?: ReadonlyArray<CfExpr>;\n readonly returns: ParamSpec;\n}\n\nexport const cfExpr = {\n countStar(): CfExpr {\n return new CfExpr(AggregateExpr.count());\n },\n lit(value: number | string | boolean): CfExpr {\n return new CfExpr(LiteralExpr.of(value));\n },\n identifierRef(name: string): CfExpr {\n return new CfExpr(IdentifierRef.of(name));\n },\n param(value: unknown, codecId: string): CfExpr {\n return new CfExpr(ParamRef.of(value, { codec: { codecId } }));\n },\n /**\n * Catalog function call lowered via a `'function'`-strategy template\n * (e.g. `to_regclass({{self}})`). Owns the `OperationExpr` assembly so\n * target packages only supply vocabulary: template, codec'd operands,\n * and return spec.\n */\n fn(options: CfFnOptions): CfExpr {\n return new CfExpr(\n new OperationExpr({\n method: options.method,\n self: options.self.ast,\n args: options.args?.map((arg) => arg.ast),\n returns: options.returns,\n lowering: {\n targetFamily: 'sql',\n strategy: 'function',\n template: options.template,\n },\n }),\n );\n },\n columnRef(qualifier: string, name: string): CfExpr {\n return new CfExpr(ColumnRef.of(qualifier, name));\n },\n allOf(exprs: ReadonlyArray<CfExpr>): CfExpr {\n return new CfExpr(AndExpr.of(exprs.map((expr) => expr.ast)));\n },\n /**\n * Opaque DB-side SQL expression (e.g. `current_schema()`) carried as a\n * `RawExpr`. For zero-operand catalog functions where a `'function'`\n * lowering template has nothing to substitute.\n */\n raw(sql: string, returns: ParamSpec): CfExpr {\n return new CfExpr(new RawExpr({ parts: [sql], returns }));\n },\n exists(query: CfExprSelectQuery): CfExpr {\n return new CfExpr(ExistsExpr.exists(query.build()));\n },\n notExists(query: CfExprSelectQuery): CfExpr {\n return new CfExpr(ExistsExpr.notExists(query.build()));\n },\n};\n\n/** Aliased table source for catalog queries (no namespace coordinate). */\nexport function cfTable(name: string, alias?: string): TableSource {\n return TableSource.named(name, alias);\n}\n\nexport class CfExprSelectQuery {\n constructor(\n private readonly src: AnyFromSource | undefined,\n private readonly projectionItems: ReadonlyArray<ProjectionItem>,\n private readonly whereExpr: CfExpr | undefined,\n private readonly joinItems: ReadonlyArray<JoinAst> = [],\n private readonly limitValue: number | undefined = undefined,\n ) {}\n\n from(source: AnyFromSource): CfExprSelectQuery {\n return new CfExprSelectQuery(\n source,\n this.projectionItems,\n this.whereExpr,\n this.joinItems,\n this.limitValue,\n );\n }\n\n join(source: AnyFromSource, on: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n this.whereExpr,\n [...this.joinItems, JoinAst.inner(source, on.ast)],\n this.limitValue,\n );\n }\n\n leftJoin(source: AnyFromSource, on: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n this.whereExpr,\n [...this.joinItems, JoinAst.left(source, on.ast)],\n this.limitValue,\n );\n }\n\n project(alias: string, expr: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n [...this.projectionItems, ProjectionItem.of(alias, expr.ast)],\n this.whereExpr,\n this.joinItems,\n this.limitValue,\n );\n }\n\n where(expr: CfExpr): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n expr,\n this.joinItems,\n this.limitValue,\n );\n }\n\n limit(value: number): CfExprSelectQuery {\n return new CfExprSelectQuery(\n this.src,\n this.projectionItems,\n this.whereExpr,\n this.joinItems,\n value,\n );\n }\n\n build(): SelectAst {\n if (this.joinItems.length > 0 && this.src === undefined) {\n throw new Error('CfExprSelectQuery: cannot add a JOIN without a FROM clause');\n }\n const base =\n this.src !== undefined\n ? SelectAst.from(this.src).withProjection(this.projectionItems)\n : SelectAst.noFrom().withProjection(this.projectionItems);\n const withJoins = this.joinItems.length > 0 ? base.withJoins(this.joinItems) : base;\n const withWhere =\n this.whereExpr !== undefined ? withJoins.withWhere(this.whereExpr.ast) : withJoins;\n return this.limitValue !== undefined ? withWhere.withLimit(this.limitValue) : withWhere;\n }\n}\n\nexport function exprSelect(): CfExprSelectQuery {\n return new CfExprSelectQuery(undefined, [], undefined);\n}\n\n/**\n * Per-column authoring handle exposed as a keyed property on a {@link TableHandle}.\n * Carries codec metadata baked at declaration time so no codec ID, table name, or\n * column name needs to be repeated at the call site.\n */\nexport interface ColumnProxy {\n readonly codecId: string;\n readonly nullable: boolean;\n readonly columnName: string;\n readonly tableName: string;\n eq(value: unknown): CfExpr;\n neq(value: unknown): CfExpr;\n isNull(): CfExpr;\n isNotNull(): CfExpr;\n toRef(): ColumnRef;\n toProjectionItem(alias?: string): ProjectionItem;\n}\n\n/**\n * Object passed to the {@link CfConflictClause.doUpdate} callback. Each key\n * resolves to a `ColumnRef` for the corresponding `excluded.<column>`, so the\n * upsert conflict-update branch can copy proposed values without re-binding\n * parameters.\n */\nexport type ExcludedProxy<Schema extends ColumnSchema> = {\n readonly [K in keyof Schema]: ColumnRef;\n};\n\nexport type TableInsertRow<Schema extends ColumnSchema> = {\n readonly [K in keyof Schema]: unknown;\n};\n\nexport type TableSetValues<Schema extends ColumnSchema> = {\n readonly [K in keyof Schema]?: unknown;\n};\n\n/**\n * Fluent authoring handle for a fixed control-plane table. Column proxies are\n * exposed as keyed properties so `handle.columnName.eq(value)` composes without\n * threading codec IDs, table names, or column refs at the call site.\n */\nexport type TableHandle<Schema extends ColumnSchema> = {\n readonly source: TableSource;\n insert(row: TableInsertRow<Schema>): CfInsertQuery<Schema>;\n upsert(row: TableInsertRow<Schema>): CfUpsertBuilder<Schema>;\n update(): CfUpdateQuery<Schema>;\n select(...columns: ReadonlyArray<ColumnProxy>): CfSelectQuery;\n} & {\n readonly [K in keyof Schema]: ColumnProxy;\n};\n\nexport class CfInsertQuery<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,\n ) {}\n\n returning(...columns: ReadonlyArray<ColumnProxy>): CfInsertQuery<Schema> {\n return new CfInsertQuery(\n this.src,\n this.schema,\n this.rowValues,\n columns.map((col) => col.toProjectionItem()),\n );\n }\n\n build(): InsertAst {\n const row = buildInsertRow(this.schema, this.rowValues);\n const ast = InsertAst.into(this.src).withRows([row]);\n return this.returningItems ? ast.withReturning(this.returningItems) : ast;\n }\n}\n\nexport class CfUpsertBuilder<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n ) {}\n\n onConflict(...columns: ReadonlyArray<ColumnProxy>): CfConflictClause<Schema> {\n return new CfConflictClause(this.src, this.schema, this.rowValues, [...columns]);\n }\n}\n\nexport class CfConflictClause<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n private readonly conflictCols: ReadonlyArray<ColumnProxy>,\n ) {}\n\n doUpdate(\n setOrCallback:\n | TableSetValues<Schema>\n | ((excluded: ExcludedProxy<Schema>) => TableSetValues<Schema>),\n ): CfUpsertQuery<Schema> {\n const set =\n typeof setOrCallback === 'function'\n ? setOrCallback(buildExcludedProxy(this.schema))\n : setOrCallback;\n return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, set);\n }\n\n doNothing(): CfUpsertQuery<Schema> {\n return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, undefined);\n }\n}\n\nexport class CfUpsertQuery<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly rowValues: TableInsertRow<Schema>,\n private readonly conflictCols: ReadonlyArray<ColumnProxy>,\n private readonly updateSet: TableSetValues<Schema> | undefined,\n ) {}\n\n build(): InsertAst {\n const row = buildInsertRow(this.schema, this.rowValues);\n const conflictRefs = this.conflictCols.map((col) => col.toRef());\n const onConflict =\n this.updateSet === undefined\n ? InsertOnConflict.on(conflictRefs).doNothing()\n : InsertOnConflict.on(conflictRefs).doUpdateSet(buildSetMap(this.schema, this.updateSet));\n return InsertAst.into(this.src).withRows([row]).withOnConflict(onConflict);\n }\n}\n\nexport class CfUpdateQuery<Schema extends ColumnSchema> {\n constructor(\n private readonly src: TableSource,\n private readonly schema: Schema,\n private readonly setValues: TableSetValues<Schema> | undefined = undefined,\n private readonly whereExpr: CfExpr | undefined = undefined,\n private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,\n ) {}\n\n set(values: TableSetValues<Schema>): CfUpdateQuery<Schema> {\n return new CfUpdateQuery(this.src, this.schema, values, this.whereExpr, this.returningItems);\n }\n\n where(expr: CfExpr): CfUpdateQuery<Schema> {\n return new CfUpdateQuery(this.src, this.schema, this.setValues, expr, this.returningItems);\n }\n\n returning(...columns: ReadonlyArray<ColumnProxy>): CfUpdateQuery<Schema> {\n return new CfUpdateQuery(\n this.src,\n this.schema,\n this.setValues,\n this.whereExpr,\n columns.map((col) => col.toProjectionItem()),\n );\n }\n\n build(): UpdateAst {\n const set = buildSetMap(this.schema, this.setValues);\n const base = UpdateAst.table(this.src).withSet(set);\n const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;\n return this.returningItems ? withWhere.withReturning(this.returningItems) : withWhere;\n }\n}\n\nexport class CfSelectQuery {\n constructor(\n private readonly src: TableSource,\n private readonly projectionItems: ReadonlyArray<ProjectionItem>,\n private readonly whereExpr: CfExpr | undefined = undefined,\n private readonly orderByItems: ReadonlyArray<OrderByItem> = [],\n ) {}\n\n where(expr: CfExpr): CfSelectQuery {\n return new CfSelectQuery(this.src, this.projectionItems, expr, this.orderByItems);\n }\n\n orderBy(column: ColumnProxy, dir: 'asc' | 'desc' = 'asc'): CfSelectQuery {\n const item = dir === 'asc' ? OrderByItem.asc(column.toRef()) : OrderByItem.desc(column.toRef());\n return new CfSelectQuery(this.src, this.projectionItems, this.whereExpr, [\n ...this.orderByItems,\n item,\n ]);\n }\n\n build(): SelectAst {\n const base = SelectAst.from(this.src).withProjection(this.projectionItems);\n const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;\n return this.orderByItems.length > 0 ? withWhere.withOrderBy(this.orderByItems) : withWhere;\n }\n}\n\n/**\n * Declare a control-plane table once, binding column codecs at declaration time.\n * Returns a `TableHandle` whose column properties compose expressions directly\n * without per-call-site codec or column-name threading.\n *\n * ```ts\n * const marker = pgTable({ name: 'marker', schema: 'prisma_contract' }, {\n * space: text(),\n * core_hash: text(),\n * updated_at: timestamptz(),\n * });\n *\n * const query = marker.update()\n * .set({ core_hash: newHash, updated_at: NOW })\n * .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))\n * .returning(marker.space)\n * .build();\n * ```\n */\nexport function table<Schema extends ColumnSchema>(\n source: TableSource,\n schema: Schema,\n): TableHandle<Schema> {\n const proxies: Record<string, ColumnProxy> = {};\n for (const [col, desc] of Object.entries(schema)) {\n proxies[col] = makeColumnProxy(source.alias ?? source.name, col, desc);\n }\n\n const handle = {\n ...proxies,\n source,\n insert: (row: TableInsertRow<Schema>) => new CfInsertQuery(source, schema, row),\n upsert: (row: TableInsertRow<Schema>) => new CfUpsertBuilder(source, schema, row),\n update: () => new CfUpdateQuery(source, schema),\n select: (...cols: ReadonlyArray<ColumnProxy>) =>\n new CfSelectQuery(\n source,\n cols.map((col) => col.toProjectionItem()),\n ),\n };\n\n return blindCast<\n TableHandle<Schema>,\n 'Column proxies are dynamically built from Schema keys — TypeScript cannot verify the per-key ColumnProxy constraint at the spread call site. Construction is correct by construction: every key maps to makeColumnProxy(source.name, key, schema[key]).'\n >(handle);\n}\n\nfunction makeColumnProxy(\n tableName: string,\n columnName: string,\n desc: ColumnDescriptor,\n): ColumnProxy {\n const ref = ColumnRef.of(tableName, columnName);\n return {\n codecId: desc.codecId,\n nullable: desc.nullable,\n columnName,\n tableName,\n eq: (value) =>\n value === null\n ? new CfExpr(NullCheckExpr.isNull(ref))\n : new CfExpr(BinaryExpr.eq(ref, toSetExpression(value, desc))),\n neq: (value) =>\n value === null\n ? new CfExpr(NullCheckExpr.isNotNull(ref))\n : new CfExpr(BinaryExpr.neq(ref, toSetExpression(value, desc))),\n isNull: () => new CfExpr(NullCheckExpr.isNull(ref)),\n isNotNull: () => new CfExpr(NullCheckExpr.isNotNull(ref)),\n toRef: () => ref,\n toProjectionItem: (alias = columnName) =>\n ProjectionItem.of(alias, ref, { codecId: desc.codecId }),\n };\n}\n\nfunction buildExcludedProxy<Schema extends ColumnSchema>(schema: Schema): ExcludedProxy<Schema> {\n return blindCast<\n ExcludedProxy<Schema>,\n 'Object.fromEntries cannot preserve per-key ColumnRef types — correct by construction: every key maps to ColumnRef.of(\"excluded\", key).'\n >(Object.fromEntries(Object.keys(schema).map((col) => [col, ColumnRef.of('excluded', col)])));\n}\n\nfunction isExpressionSource(value: unknown): value is { toExpr(): AnyExpression } {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'toExpr' in value &&\n typeof value.toExpr === 'function'\n );\n}\n\nfunction toInsertValue(value: unknown, desc: ColumnDescriptor): InsertValue {\n if (isExpressionSource(value)) {\n const expr = value.toExpr();\n if (\n expr.kind === 'column-ref' ||\n expr.kind === 'param-ref' ||\n expr.kind === 'prepared-param-ref' ||\n expr.kind === 'raw-expr'\n ) {\n return expr;\n }\n }\n return ParamRef.of(value, { codec: { codecId: desc.codecId } });\n}\n\nfunction toSetExpression(value: unknown, desc: ColumnDescriptor): AnyExpression {\n if (isExpressionSource(value)) {\n return value.toExpr();\n }\n return ParamRef.of(value, { codec: { codecId: desc.codecId } });\n}\n\nfunction buildInsertRow<Schema extends ColumnSchema>(\n schema: Schema,\n values: TableInsertRow<Schema>,\n): Record<string, InsertValue> {\n const row: Record<string, InsertValue> = {};\n const rawValues = blindCast<\n Record<string, unknown>,\n 'TableInsertRow<Schema> maps Schema keys to unknown; indexing by the same string keys is correct by construction'\n >(values);\n for (const [col, desc] of Object.entries(schema)) {\n row[col] = toInsertValue(rawValues[col], desc);\n }\n return row;\n}\n\nfunction buildSetMap<Schema extends ColumnSchema>(\n schema: Schema,\n values: TableSetValues<Schema> | undefined,\n): Record<string, AnyExpression> {\n if (values === undefined) return {};\n const set: Record<string, AnyExpression> = {};\n const rawSchema = blindCast<\n Record<string, ColumnDescriptor>,\n 'Schema extends ColumnSchema = Record<string, ColumnDescriptor>; runtime key access is correct by construction'\n >(schema);\n const rawValues = blindCast<\n Record<string, unknown>,\n 'TableSetValues<Schema> maps Schema keys to unknown; iterating with Object.entries is correct by construction'\n >(values);\n for (const [col, value] of Object.entries(rawValues)) {\n const desc = rawSchema[col];\n if (desc !== undefined) {\n set[col] = toSetExpression(value, desc);\n }\n }\n return set;\n}\n"],"mappings":"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"} |
@@ -12,2 +12,10 @@ import { o as CodecRef } from "../codec-types-DFLA6Hmj.mjs"; | ||
| /** | ||
| * Marks a list-typed (scalar-array) field. When `true`, the field is an | ||
| * array of `codecId`-typed elements; list operations target it and the | ||
| * element type is `codecId`. Absent/`false` for scalar fields. Carried so | ||
| * `X` and `X[]` stay distinct at the type level (a list expression is not | ||
| * assignable to a scalar `CodecExpression` slot). | ||
| */ | ||
| many?: boolean; | ||
| /** | ||
| * Optional {@link CodecRef} derived from contract storage at scope construction time. Builder paths that mint column-bound `ParamRef` / `ProjectionItem` nodes stamp this slot onto the AST so encode/decode dispatch resolves through `contractCodecs.forCodecRef`. Leave `undefined` when the scope was built without contract storage (rare — tests, ad-hoc scopes). | ||
@@ -48,2 +56,8 @@ */ | ||
| * - `null` when `Nullable` is true | ||
| * | ||
| * `many?: never` makes this a *scalar* slot: a list expression (whose | ||
| * `returnType` carries `many: true`) is rejected here, while scalar | ||
| * expressions — which carry no `many` key at all — pass unchanged. The | ||
| * discriminant lives on this operand slot, so scalar expression and scope | ||
| * types never have to spell out `many: false`. | ||
| */ | ||
@@ -55,4 +69,16 @@ type CodecExpression<CodecId extends string, Nullable extends boolean, CT extends Record<string, { | ||
| nullable: Nullable; | ||
| many?: never; | ||
| }> | CodecValue<CodecId, Nullable, CT>; | ||
| /** | ||
| * A list-typed expression: an {@link Expression} whose element codec is | ||
| * `CodecId` and whose `returnType` carries `many: true`. The element identity | ||
| * is the codec id, so list operations stay generic over the element type while | ||
| * tying any element argument back to this list's `CodecId`. | ||
| */ | ||
| type ScalarListExpression<CodecId extends string, Nullable extends boolean> = Expression<{ | ||
| codecId: CodecId; | ||
| nullable: Nullable; | ||
| many: true; | ||
| }>; | ||
| /** | ||
| * An expression or literal value targeting any codec whose trait set contains all the required traits. | ||
@@ -142,3 +168,3 @@ * | ||
| //#endregion | ||
| export { BuildOperationSpec, CodecExpression, CodecTypesBase, CodecValue, Expression, RawCodecInferer, RawSqlBuilder, RawSqlTag, ScopeField, TraitExpression, buildOperation, codecOf, createRawSql, param, toExpr }; | ||
| export { BuildOperationSpec, CodecExpression, CodecTypesBase, CodecValue, Expression, RawCodecInferer, RawSqlBuilder, RawSqlTag, ScalarListExpression, ScopeField, TraitExpression, buildOperation, codecOf, createRawSql, param, toExpr }; | ||
| //# sourceMappingURL=expression.d.mts.map |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"expression.d.mts","names":[],"sources":["../../src/expression.ts"],"mappings":";;;;;;;KAQY,UAAA;EACV,OAAA;EACA,QAAA;;;;EAIA,KAAA,GAAQ,QAAQ;AAAA;AAAA,KAGN,cAAA,GAAiB,MAAM;EAAA,SAAoB,KAAA;EAAA,SAAyB,MAAA;AAAA;;;;KAKpE,UAAA,WAAqB,UAAA,IAAc,oBAAA;EAAA,SACpC,UAAA,EAAY,CAAA;EACrB,QAAA,IAAY,aAAA;AAAA;AAAA,KAGT,iBAAA,YACQ,MAAA;EAAA,SAA0B,KAAA;AAAA,8DAGzB,EAAA,YAAc,EAAA,CAAG,CAAA;EAAA,SAAsB,MAAA;AAAA,KAC9C,cAAA,mBAAiC,CAAA,IAChC,CAAA,yBAGA,EAAA;AAAA,KAEH,UAAA,MAAgB,CAAC;;;;;KAMV,UAAA,8DAGC,MAAA;EAAA,SAA0B,KAAA;AAAA,OAClC,OAAA,eAAsB,EAAA,GAAK,EAAA,CAAG,OAAA,sBAA6B,UAAA,CAAW,QAAA;;;;AAxBhD;AACzB;;;;KAiCU,eAAA,8DAGC,MAAA;EAAA,SAA0B,KAAA;AAAA,MACnC,UAAA;EAAa,OAAA,EAAS,OAAA;EAAS,QAAA,EAAU,QAAA;AAAA,KAAc,UAAA,CAAW,OAAA,EAAS,QAAA,EAAU,EAAA;;;;;;KAO7E,eAAA,wEAGC,MAAA;EAAA,SAA0B,KAAA;AAAA,MACnC,eAAA,CAAgB,iBAAA,CAAkB,EAAA,EAAI,MAAA,GAAS,QAAA,EAAU,EAAA;;;;;;;;iBAS7C,MAAA,CAAO,KAAA,WAAgB,KAAA,GAAQ,QAAA,GAAW,aAAa;;;AA9C7D;iBA+DM,KAAA,IAAS,KAAA,EAAO,CAAA,EAAG,IAAA;EAAQ,OAAA;AAAA,IAAoB,QAAQ;;AA7DjD;AAMtB;;;;;;;;iBAqEgB,OAAA,CAAQ,KAAA,YAAiB,QAAQ;AAAA,UAqBhC,kBAAA,WAA6B,UAAA;EAAA,SACnC,MAAA;EAvF+D;;;EAAA,SA2F/D,IAAA,YAAgB,aAAA,KAAkB,aAAA;EAAA,SAClC,OAAA,EAAS,CAAA,GAAI,SAAA;EAAA,SACb,QAAA,EAAU,eAAA;AAAA;;;;iBAML,cAAA,WAAyB,UAAA,EAAY,IAAA,EAAM,kBAAA,CAAmB,CAAA,IAAK,UAAA,CAAW,CAAA;;;AAnGX;AAUnF;;;;;;;;;UAoHiB,eAAA;EACf,UAAA,CAAW,KAAA,EAAO,aAAa;AAAA;;UAIhB,aAAA;EACf,OAAA,mBAA0B,IAAA,EAAM,CAAA,GAAI,UAAA;IAAa,OAAA,EAAS,CAAA;IAAG,QAAA;EAAA;EAC7D,OAAA,8CAAqD,IAAA;IAAA,SAC1C,OAAA,EAAS,CAAA;IAAA,SACT,QAAA,GAAW,CAAA;EAAA,IAClB,UAAA;IAAa,OAAA,EAAS,CAAA;IAAG,QAAA,EAAU,CAAA;EAAA;AAAA;;KAI7B,SAAA,IACV,OAAA,EAAS,oBAAA,KACN,MAAA,EAAQ,mBAAA,OACR,aAAA;AAAA,KAEA,mBAAA,GAAsB,UAAA,CAAW,UAAA,IAAc,QAAA,GAAW,aAAA;AA5H/D;;;;;AAAA,iBA8JgB,YAAA,CAAa,OAAA,EAAS,eAAA,GAAkB,SAAS"} | ||
| {"version":3,"file":"expression.d.mts","names":[],"sources":["../../src/expression.ts"],"mappings":";;;;;;;KAQY,UAAA;EACV,OAAA;EACA,QAAA;;;;;;;;EAQA,IAAA;EAIgB;AAGlB;;EAHE,KAAA,GAAQ,QAAQ;AAAA;AAAA,KAGN,cAAA,GAAiB,MAAM;EAAA,SAAoB,KAAA;EAAA,SAAyB,MAAA;AAAA;AAAM;AAKtF;;AALsF,KAK1E,UAAA,WAAqB,UAAA,IAAc,oBAAA;EAAA,SACpC,UAAA,EAAY,CAAA;EACrB,QAAA,IAAY,aAAA;AAAA;AAAA,KAGT,iBAAA,YACQ,MAAA;EAAA,SAA0B,KAAA;AAAA,8DAGzB,EAAA,YAAc,EAAA,CAAG,CAAA;EAAA,SAAsB,MAAA;AAAA,KAC9C,cAAA,mBAAiC,CAAA,IAChC,CAAA,yBAGA,EAAA;AAAA,KAEH,UAAA,MAAgB,CAAC;;;;AAdK;KAoBf,UAAA,8DAGC,MAAA;EAAA,SAA0B,KAAA;AAAA,OAClC,OAAA,eAAsB,EAAA,GAAK,EAAA,CAAG,OAAA,sBAA6B,UAAA,CAAW,QAAA;;;;;;;;;;;;;;;KAgB/D,eAAA,8DAGC,MAAA;EAAA,SAA0B,KAAA;AAAA,MAEnC,UAAA;EAAa,OAAA,EAAS,OAAA;EAAS,QAAA,EAAU,QAAA;EAAU,IAAA;AAAA,KACnD,UAAA,CAAW,OAAA,EAAS,QAAA,EAAU,EAAA;;;;;AAlCxB;AAAA;KA0CE,oBAAA,qDAAyE,UAAA;EACnF,OAAA,EAAS,OAAA;EACT,QAAA,EAAU,QAAA;EACV,IAAA;AAAA;;;;;;KAQU,eAAA,wEAGC,MAAA;EAAA,SAA0B,KAAA;AAAA,MACnC,eAAA,CAAgB,iBAAA,CAAkB,EAAA,EAAI,MAAA,GAAS,QAAA,EAAU,EAAA;;;;;;;;iBAS7C,MAAA,CAAO,KAAA,WAAgB,KAAA,GAAQ,QAAA,GAAW,aAAa;;;;iBAiBvD,KAAA,IAAS,KAAA,EAAO,CAAA,EAAG,IAAA;EAAQ,OAAA;AAAA,IAAoB,QAAQ;;AAvEY;AAgBnF;;;;;;;;iBAqEgB,OAAA,CAAQ,KAAA,YAAiB,QAAQ;AAAA,UAqBhC,kBAAA,WAA6B,UAAA;EAAA,SACnC,MAAA;EArFG;;;EAAA,SAyFH,IAAA,YAAgB,aAAA,KAAkB,aAAA;EAAA,SAClC,OAAA,EAAS,CAAA,GAAI,SAAA;EAAA,SACb,QAAA,EAAU,eAAA;AAAA;;;;iBAML,cAAA,WAAyB,UAAA,EAAY,IAAA,EAAM,kBAAA,CAAmB,CAAA,IAAK,UAAA,CAAW,CAAA;;;;;;;;AAjG1D;AAQpC;;;;UAoHiB,eAAA;EACf,UAAA,CAAW,KAAA,EAAO,aAAa;AAAA;;UAIhB,aAAA;EACf,OAAA,mBAA0B,IAAA,EAAM,CAAA,GAAI,UAAA;IAAa,OAAA,EAAS,CAAA;IAAG,QAAA;EAAA;EAC7D,OAAA,8CAAqD,IAAA;IAAA,SAC1C,OAAA,EAAS,CAAA;IAAA,SACT,QAAA,GAAW,CAAA;EAAA,IAClB,UAAA;IAAa,OAAA,EAAS,CAAA;IAAG,QAAA,EAAU,CAAA;EAAA;AAAA;;KAI7B,SAAA,IACV,OAAA,EAAS,oBAAA,KACN,MAAA,EAAQ,mBAAA,OACR,aAAA;AAAA,KAEA,mBAAA,GAAsB,UAAA,CAAW,UAAA,IAAc,QAAA,GAAW,aAAA;;;;;;iBAkC/C,YAAA,CAAa,OAAA,EAAS,eAAA,GAAkB,SAAS"} |
@@ -1,2 +0,2 @@ | ||
| import { C as OperationExpr, E as ParamRef, k as RawExpr } from "../types-lJUc6cY-.mjs"; | ||
| import { C as OperationExpr, E as ParamRef, k as RawExpr } from "../types-DtzFztRV.mjs"; | ||
| import { runtimeError } from "@prisma-next/framework-components/runtime"; | ||
@@ -3,0 +3,0 @@ //#region src/expression.ts |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"expression.mjs","names":[],"sources":["../../src/expression.ts"],"sourcesContent":["import { runtimeError } from '@prisma-next/framework-components/runtime';\nimport type { ParamSpec } from '@prisma-next/operations';\nimport type { QueryOperationReturn } from '@prisma-next/sql-contract/types';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\nimport type { CodecRef } from './ast/codec-types';\nimport type { AnyExpression as AstExpression, RawSqlLiteral } from './ast/types';\nimport { OperationExpr, ParamRef, RawExpr } from './ast/types';\n\nexport type ScopeField = {\n codecId: string;\n nullable: boolean;\n /**\n * Optional {@link CodecRef} derived from contract storage at scope construction time. Builder paths that mint column-bound `ParamRef` / `ProjectionItem` nodes stamp this slot onto the AST so encode/decode dispatch resolves through `contractCodecs.forCodecRef`. Leave `undefined` when the scope was built without contract storage (rare — tests, ad-hoc scopes).\n */\n codec?: CodecRef;\n};\n\nexport type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\n/**\n * A typed SQL expression. Identity is carried by the `returnType` descriptor (inherited from `QueryOperationReturn` and narrowed to `T`) — distinct `T` makes distinct Expression types structurally. `buildAst()` materialises the underlying AST node.\n */\nexport type Expression<T extends ScopeField> = QueryOperationReturn & {\n readonly returnType: T;\n buildAst(): AstExpression;\n};\n\ntype CodecIdsWithTrait<\n CT extends Record<string, { readonly input: unknown }>,\n RequiredTraits extends readonly string[],\n> = {\n [K in keyof CT & string]: CT[K] extends { readonly traits: infer T }\n ? [RequiredTraits[number]] extends [T]\n ? K\n : never\n : never;\n}[keyof CT & string];\n\ntype NullSuffix<N> = N extends true ? null : never;\n\n/**\n * Runtime value type for a slot bound to `CodecId` with the given\n * nullability — `CT[CodecId]['input']`, plus `null` when `Nullable` is true.\n */\nexport type CodecValue<\n CodecId extends string,\n Nullable extends boolean,\n CT extends Record<string, { readonly input: unknown }>,\n> = (CodecId extends keyof CT ? CT[CodecId]['input'] : never) | NullSuffix<Nullable>;\n\n/**\n * An expression or literal value targeting a specific codec.\n *\n * Accepts any of:\n * - An `Expression` whose codec matches exactly\n * - A raw JS value of the codec's `input` type\n * - `null` when `Nullable` is true\n */\nexport type CodecExpression<\n CodecId extends string,\n Nullable extends boolean,\n CT extends Record<string, { readonly input: unknown }>,\n> = Expression<{ codecId: CodecId; nullable: Nullable }> | CodecValue<CodecId, Nullable, CT>;\n\n/**\n * An expression or literal value targeting any codec whose trait set contains all the required traits.\n *\n * Resolves the trait set to the union of matching codec identities via `CodecIdsWithTrait`, then reuses `CodecExpression` for the codec-id form.\n */\nexport type TraitExpression<\n Traits extends readonly string[],\n Nullable extends boolean,\n CT extends Record<string, { readonly input: unknown }>,\n> = CodecExpression<CodecIdsWithTrait<CT, Traits>, Nullable, CT>;\n\n/**\n * Resolve a raw value or an Expression into an AST expression node.\n *\n * When `value` is an Expression (duck-typed by its `buildAst` method), the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.\n *\n * Operation implementations that compare a column-bound expression to a user value derive the column's {@link CodecRef} from the column-bound side (via {@link codecOf}) and forward it here so encode-side dispatch resolves to the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).\n */\nexport function toExpr(value: unknown, codec?: CodecRef): AstExpression {\n if (isExpressionLike(value)) {\n return value.buildAst();\n }\n if (codec === undefined) {\n throw runtimeError(\n 'RUNTIME.PARAM_REF_CODEC_REQUIRED',\n `Cannot construct a ParamRef for a ${value === null ? 'null' : typeof value} value without an explicit codec. ` +\n 'Provide a CodecRef at the call site or use a column-bound builder path.',\n );\n }\n return ParamRef.of(value, { codec });\n}\n\n/**\n * Construct a `ParamRef` for a value whose codec identity is known at call time. Use this when interpolating a value into a raw SQL expression and the codec cannot be inferred from context — e.g. `param(myDate, { codecId: 'pg/timestamptz@1' })`.\n */\nexport function param<T>(value: T, opts: { codecId: string }): ParamRef {\n return ParamRef.of(value, { codec: { codecId: opts.codecId } });\n}\n\n/**\n * Derive the {@link CodecRef} carried by an expression-like value.\n *\n * Resolution order:\n * 1. `wrapper.codec` — explicit column-bound {@link CodecRef} stamped at field-proxy time.\n * 2. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.\n * 3. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).\n *\n * Returns `undefined` for raw scalar values (non-expression-like).\n */\nexport function codecOf(value: unknown): CodecRef | undefined {\n if (!isExpressionLike(value)) return undefined;\n const wrapper = value as {\n codec?: CodecRef;\n returnType?: { codec?: CodecRef; codecId?: string };\n };\n if (wrapper.codec) return wrapper.codec;\n if (wrapper.returnType?.codec) return wrapper.returnType.codec;\n if (wrapper.returnType?.codecId) return { codecId: wrapper.returnType.codecId };\n return undefined;\n}\n\nfunction isExpressionLike(value: unknown): value is Expression<ScopeField> {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'buildAst' in value &&\n typeof (value as { buildAst: unknown }).buildAst === 'function'\n );\n}\n\nexport interface BuildOperationSpec<R extends ScopeField> {\n readonly method: string;\n /**\n * The operation's arguments. The first element is the self argument (the value the operation is being applied to); the rest are the remaining user-supplied arguments.\n */\n readonly args: readonly [AstExpression, ...AstExpression[]];\n readonly returns: R & ParamSpec;\n readonly lowering: SqlLoweringSpec;\n}\n\n/**\n * Construct an OperationExpr AST node and wrap it as a typed Expression. Operation implementations use this to turn their user-facing arguments into the AST node the compilation pipeline eventually lowers to SQL.\n */\nexport function buildOperation<R extends ScopeField>(spec: BuildOperationSpec<R>): Expression<R> {\n const [self, ...rest] = spec.args;\n const op = new OperationExpr({\n method: spec.method,\n self,\n args: rest.length > 0 ? rest : undefined,\n returns: spec.returns,\n lowering: spec.lowering,\n });\n return {\n returnType: spec.returns,\n buildAst: () => op,\n };\n}\n\n/**\n * Resolves a codec id for a bare JavaScript value interpolated into a raw-SQL\n * template — e.g. `` rawSql`SELECT ${42}` `` calls `inferCodec(42)` to pick\n * the codec id (`pg/int4`, `sqlite/integer@1`, etc.) that will encode the\n * value as a bound parameter.\n *\n * Targets implement this once per dialect: examine the JS value's runtime\n * shape (number, bigint, string, boolean, `Uint8Array`) and return a codec\n * id known to the target's codec registry. Throw when the value falls\n * outside the supported set — callers should wrap such values with\n * `param(value, { codecId })` to declare the codec explicitly.\n */\nexport interface RawCodecInferer {\n inferCodec(value: RawSqlLiteral): string;\n}\n\n/** The one-method builder returned by a `RawSqlTag` template call before `.returns()` is called. */\nexport interface RawSqlBuilder {\n returns<S extends string>(spec: S): Expression<{ codecId: S; nullable: false }>;\n returns<S extends string, N extends boolean = false>(spec: {\n readonly codecId: S;\n readonly nullable?: N;\n }): Expression<{ codecId: S; nullable: N }>;\n}\n\n/** Tagged-template function returned by {@link createRawSql}. */\nexport type RawSqlTag = (\n strings: TemplateStringsArray,\n ...values: RawSqlInterpolation[]\n) => RawSqlBuilder;\n\ntype RawSqlInterpolation = Expression<ScopeField> | ParamRef | RawSqlLiteral;\n\nfunction resolveInterpolation(\n adapter: RawCodecInferer,\n value: RawSqlInterpolation,\n): AstExpression | ParamRef {\n if (isExpressionLike(value)) {\n return value.buildAst();\n }\n if (value instanceof ParamRef) {\n return value;\n }\n if (\n typeof value === 'number' ||\n typeof value === 'bigint' ||\n typeof value === 'string' ||\n typeof value === 'boolean' ||\n value instanceof Uint8Array\n ) {\n return ParamRef.of(value, { codec: { codecId: adapter.inferCodec(value) } });\n }\n\n value satisfies never;\n throw runtimeError(\n 'RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION',\n 'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n );\n}\n\n/**\n * Create a tagged-template builder for raw SQL expressions. The returned tag accepts SQL string fragments interleaved with typed {@link Expression}, {@link ParamRef}, or bare {@link RawSqlLiteral} interpolations. Call `.returns(spec)` on the result to obtain a typed {@link Expression} whose AST is a {@link RawExpr}.\n *\n * Bare {@link RawSqlLiteral} interpolations are wrapped as `ParamRef` nodes with the codec resolved via `adapter.inferCodec(value)`. Use {@link param} when the codec cannot be inferred from the value alone (e.g. `Date`).\n */\nexport function createRawSql(adapter: RawCodecInferer): RawSqlTag {\n return (strings, ...values) => {\n const parts: (string | AstExpression | ParamRef)[] = [];\n parts.push(strings[0] ?? '');\n values.forEach((value, i) => {\n parts.push(resolveInterpolation(adapter, value));\n parts.push(strings[i + 1] ?? '');\n });\n return new RawSqlBuilderImpl(parts);\n };\n}\n\nclass RawSqlBuilderImpl implements RawSqlBuilder {\n constructor(private readonly parts: readonly (string | AstExpression | ParamRef)[]) {}\n\n returns<S extends string>(spec: S): Expression<{ codecId: S; nullable: false }>;\n returns<S extends string, N extends boolean = false>(spec: {\n readonly codecId: S;\n readonly nullable?: N;\n }): Expression<{ codecId: S; nullable: N }>;\n returns(\n spec: string | { readonly codecId: string; readonly nullable?: boolean },\n ): Expression<{ codecId: string; nullable: boolean }> {\n const codecId = typeof spec === 'string' ? spec : spec.codecId;\n const nullable = typeof spec === 'string' ? false : (spec.nullable ?? false);\n const paramSpec: ParamSpec = { codecId, nullable };\n const node = new RawExpr({ parts: this.parts, returns: paramSpec });\n return {\n returnType: { codecId, nullable },\n buildAst: () => node,\n };\n }\n}\n"],"mappings":";;;;;;;;;;AAkFA,SAAgB,OAAO,OAAgB,OAAiC;CACtE,IAAI,iBAAiB,KAAK,GACxB,OAAO,MAAM,SAAS;CAExB,IAAI,UAAU,KAAA,GACZ,MAAM,aACJ,oCACA,qCAAqC,UAAU,OAAO,SAAS,OAAO,MAAM,0GAE9E;CAEF,OAAO,SAAS,GAAG,OAAO,EAAE,MAAM,CAAC;AACrC;;;;AAKA,SAAgB,MAAS,OAAU,MAAqC;CACtE,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC;AAChE;;;;;;;;;;;AAYA,SAAgB,QAAQ,OAAsC;CAC5D,IAAI,CAAC,iBAAiB,KAAK,GAAG,OAAO,KAAA;CACrC,MAAM,UAAU;CAIhB,IAAI,QAAQ,OAAO,OAAO,QAAQ;CAClC,IAAI,QAAQ,YAAY,OAAO,OAAO,QAAQ,WAAW;CACzD,IAAI,QAAQ,YAAY,SAAS,OAAO,EAAE,SAAS,QAAQ,WAAW,QAAQ;AAEhF;AAEA,SAAS,iBAAiB,OAAiD;CACzE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,cAAc,SACd,OAAQ,MAAgC,aAAa;AAEzD;;;;AAeA,SAAgB,eAAqC,MAA4C;CAC/F,MAAM,CAAC,MAAM,GAAG,QAAQ,KAAK;CAC7B,MAAM,KAAK,IAAI,cAAc;EAC3B,QAAQ,KAAK;EACb;EACA,MAAM,KAAK,SAAS,IAAI,OAAO,KAAA;EAC/B,SAAS,KAAK;EACd,UAAU,KAAK;CACjB,CAAC;CACD,OAAO;EACL,YAAY,KAAK;EACjB,gBAAgB;CAClB;AACF;AAmCA,SAAS,qBACP,SACA,OAC0B;CAC1B,IAAI,iBAAiB,KAAK,GACxB,OAAO,MAAM,SAAS;CAExB,IAAI,iBAAiB,UACnB,OAAO;CAET,IACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,aACjB,iBAAiB,YAEjB,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,QAAQ,WAAW,KAAK,EAAE,EAAE,CAAC;CAI7E,MAAM,aACJ,6CACA,6GACF;AACF;;;;;;AAOA,SAAgB,aAAa,SAAqC;CAChE,QAAQ,SAAS,GAAG,WAAW;EAC7B,MAAM,QAA+C,CAAC;EACtD,MAAM,KAAK,QAAQ,MAAM,EAAE;EAC3B,OAAO,SAAS,OAAO,MAAM;GAC3B,MAAM,KAAK,qBAAqB,SAAS,KAAK,CAAC;GAC/C,MAAM,KAAK,QAAQ,IAAI,MAAM,EAAE;EACjC,CAAC;EACD,OAAO,IAAI,kBAAkB,KAAK;CACpC;AACF;AAEA,IAAM,oBAAN,MAAiD;CAClB;CAA7B,YAAY,OAAwE;EAAvD,KAAA,QAAA;CAAwD;CAOrF,QACE,MACoD;EACpD,MAAM,UAAU,OAAO,SAAS,WAAW,OAAO,KAAK;EACvD,MAAM,WAAW,OAAO,SAAS,WAAW,QAAS,KAAK,YAAY;EACtE,MAAM,YAAuB;GAAE;GAAS;EAAS;EACjD,MAAM,OAAO,IAAI,QAAQ;GAAE,OAAO,KAAK;GAAO,SAAS;EAAU,CAAC;EAClE,OAAO;GACL,YAAY;IAAE;IAAS;GAAS;GAChC,gBAAgB;EAClB;CACF;AACF"} | ||
| {"version":3,"file":"expression.mjs","names":[],"sources":["../../src/expression.ts"],"sourcesContent":["import { runtimeError } from '@prisma-next/framework-components/runtime';\nimport type { ParamSpec } from '@prisma-next/operations';\nimport type { QueryOperationReturn } from '@prisma-next/sql-contract/types';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\nimport type { CodecRef } from './ast/codec-types';\nimport type { AnyExpression as AstExpression, RawSqlLiteral } from './ast/types';\nimport { OperationExpr, ParamRef, RawExpr } from './ast/types';\n\nexport type ScopeField = {\n codecId: string;\n nullable: boolean;\n /**\n * Marks a list-typed (scalar-array) field. When `true`, the field is an\n * array of `codecId`-typed elements; list operations target it and the\n * element type is `codecId`. Absent/`false` for scalar fields. Carried so\n * `X` and `X[]` stay distinct at the type level (a list expression is not\n * assignable to a scalar `CodecExpression` slot).\n */\n many?: boolean;\n /**\n * Optional {@link CodecRef} derived from contract storage at scope construction time. Builder paths that mint column-bound `ParamRef` / `ProjectionItem` nodes stamp this slot onto the AST so encode/decode dispatch resolves through `contractCodecs.forCodecRef`. Leave `undefined` when the scope was built without contract storage (rare — tests, ad-hoc scopes).\n */\n codec?: CodecRef;\n};\n\nexport type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\n/**\n * A typed SQL expression. Identity is carried by the `returnType` descriptor (inherited from `QueryOperationReturn` and narrowed to `T`) — distinct `T` makes distinct Expression types structurally. `buildAst()` materialises the underlying AST node.\n */\nexport type Expression<T extends ScopeField> = QueryOperationReturn & {\n readonly returnType: T;\n buildAst(): AstExpression;\n};\n\ntype CodecIdsWithTrait<\n CT extends Record<string, { readonly input: unknown }>,\n RequiredTraits extends readonly string[],\n> = {\n [K in keyof CT & string]: CT[K] extends { readonly traits: infer T }\n ? [RequiredTraits[number]] extends [T]\n ? K\n : never\n : never;\n}[keyof CT & string];\n\ntype NullSuffix<N> = N extends true ? null : never;\n\n/**\n * Runtime value type for a slot bound to `CodecId` with the given\n * nullability — `CT[CodecId]['input']`, plus `null` when `Nullable` is true.\n */\nexport type CodecValue<\n CodecId extends string,\n Nullable extends boolean,\n CT extends Record<string, { readonly input: unknown }>,\n> = (CodecId extends keyof CT ? CT[CodecId]['input'] : never) | NullSuffix<Nullable>;\n\n/**\n * An expression or literal value targeting a specific codec.\n *\n * Accepts any of:\n * - An `Expression` whose codec matches exactly\n * - A raw JS value of the codec's `input` type\n * - `null` when `Nullable` is true\n *\n * `many?: never` makes this a *scalar* slot: a list expression (whose\n * `returnType` carries `many: true`) is rejected here, while scalar\n * expressions — which carry no `many` key at all — pass unchanged. The\n * discriminant lives on this operand slot, so scalar expression and scope\n * types never have to spell out `many: false`.\n */\nexport type CodecExpression<\n CodecId extends string,\n Nullable extends boolean,\n CT extends Record<string, { readonly input: unknown }>,\n> =\n | Expression<{ codecId: CodecId; nullable: Nullable; many?: never }>\n | CodecValue<CodecId, Nullable, CT>;\n\n/**\n * A list-typed expression: an {@link Expression} whose element codec is\n * `CodecId` and whose `returnType` carries `many: true`. The element identity\n * is the codec id, so list operations stay generic over the element type while\n * tying any element argument back to this list's `CodecId`.\n */\nexport type ScalarListExpression<CodecId extends string, Nullable extends boolean> = Expression<{\n codecId: CodecId;\n nullable: Nullable;\n many: true;\n}>;\n\n/**\n * An expression or literal value targeting any codec whose trait set contains all the required traits.\n *\n * Resolves the trait set to the union of matching codec identities via `CodecIdsWithTrait`, then reuses `CodecExpression` for the codec-id form.\n */\nexport type TraitExpression<\n Traits extends readonly string[],\n Nullable extends boolean,\n CT extends Record<string, { readonly input: unknown }>,\n> = CodecExpression<CodecIdsWithTrait<CT, Traits>, Nullable, CT>;\n\n/**\n * Resolve a raw value or an Expression into an AST expression node.\n *\n * When `value` is an Expression (duck-typed by its `buildAst` method), the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.\n *\n * Operation implementations that compare a column-bound expression to a user value derive the column's {@link CodecRef} from the column-bound side (via {@link codecOf}) and forward it here so encode-side dispatch resolves to the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).\n */\nexport function toExpr(value: unknown, codec?: CodecRef): AstExpression {\n if (isExpressionLike(value)) {\n return value.buildAst();\n }\n if (codec === undefined) {\n throw runtimeError(\n 'RUNTIME.PARAM_REF_CODEC_REQUIRED',\n `Cannot construct a ParamRef for a ${value === null ? 'null' : typeof value} value without an explicit codec. ` +\n 'Provide a CodecRef at the call site or use a column-bound builder path.',\n );\n }\n return ParamRef.of(value, { codec });\n}\n\n/**\n * Construct a `ParamRef` for a value whose codec identity is known at call time. Use this when interpolating a value into a raw SQL expression and the codec cannot be inferred from context — e.g. `param(myDate, { codecId: 'pg/timestamptz@1' })`.\n */\nexport function param<T>(value: T, opts: { codecId: string }): ParamRef {\n return ParamRef.of(value, { codec: { codecId: opts.codecId } });\n}\n\n/**\n * Derive the {@link CodecRef} carried by an expression-like value.\n *\n * Resolution order:\n * 1. `wrapper.codec` — explicit column-bound {@link CodecRef} stamped at field-proxy time.\n * 2. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.\n * 3. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).\n *\n * Returns `undefined` for raw scalar values (non-expression-like).\n */\nexport function codecOf(value: unknown): CodecRef | undefined {\n if (!isExpressionLike(value)) return undefined;\n const wrapper = value as {\n codec?: CodecRef;\n returnType?: { codec?: CodecRef; codecId?: string };\n };\n if (wrapper.codec) return wrapper.codec;\n if (wrapper.returnType?.codec) return wrapper.returnType.codec;\n if (wrapper.returnType?.codecId) return { codecId: wrapper.returnType.codecId };\n return undefined;\n}\n\nfunction isExpressionLike(value: unknown): value is Expression<ScopeField> {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'buildAst' in value &&\n typeof (value as { buildAst: unknown }).buildAst === 'function'\n );\n}\n\nexport interface BuildOperationSpec<R extends ScopeField> {\n readonly method: string;\n /**\n * The operation's arguments. The first element is the self argument (the value the operation is being applied to); the rest are the remaining user-supplied arguments.\n */\n readonly args: readonly [AstExpression, ...AstExpression[]];\n readonly returns: R & ParamSpec;\n readonly lowering: SqlLoweringSpec;\n}\n\n/**\n * Construct an OperationExpr AST node and wrap it as a typed Expression. Operation implementations use this to turn their user-facing arguments into the AST node the compilation pipeline eventually lowers to SQL.\n */\nexport function buildOperation<R extends ScopeField>(spec: BuildOperationSpec<R>): Expression<R> {\n const [self, ...rest] = spec.args;\n const op = new OperationExpr({\n method: spec.method,\n self,\n args: rest.length > 0 ? rest : undefined,\n returns: spec.returns,\n lowering: spec.lowering,\n });\n return {\n returnType: spec.returns,\n buildAst: () => op,\n };\n}\n\n/**\n * Resolves a codec id for a bare JavaScript value interpolated into a raw-SQL\n * template — e.g. `` rawSql`SELECT ${42}` `` calls `inferCodec(42)` to pick\n * the codec id (`pg/int4`, `sqlite/integer@1`, etc.) that will encode the\n * value as a bound parameter.\n *\n * Targets implement this once per dialect: examine the JS value's runtime\n * shape (number, bigint, string, boolean, `Uint8Array`) and return a codec\n * id known to the target's codec registry. Throw when the value falls\n * outside the supported set — callers should wrap such values with\n * `param(value, { codecId })` to declare the codec explicitly.\n */\nexport interface RawCodecInferer {\n inferCodec(value: RawSqlLiteral): string;\n}\n\n/** The one-method builder returned by a `RawSqlTag` template call before `.returns()` is called. */\nexport interface RawSqlBuilder {\n returns<S extends string>(spec: S): Expression<{ codecId: S; nullable: false }>;\n returns<S extends string, N extends boolean = false>(spec: {\n readonly codecId: S;\n readonly nullable?: N;\n }): Expression<{ codecId: S; nullable: N }>;\n}\n\n/** Tagged-template function returned by {@link createRawSql}. */\nexport type RawSqlTag = (\n strings: TemplateStringsArray,\n ...values: RawSqlInterpolation[]\n) => RawSqlBuilder;\n\ntype RawSqlInterpolation = Expression<ScopeField> | ParamRef | RawSqlLiteral;\n\nfunction resolveInterpolation(\n adapter: RawCodecInferer,\n value: RawSqlInterpolation,\n): AstExpression | ParamRef {\n if (isExpressionLike(value)) {\n return value.buildAst();\n }\n if (value instanceof ParamRef) {\n return value;\n }\n if (\n typeof value === 'number' ||\n typeof value === 'bigint' ||\n typeof value === 'string' ||\n typeof value === 'boolean' ||\n value instanceof Uint8Array\n ) {\n return ParamRef.of(value, { codec: { codecId: adapter.inferCodec(value) } });\n }\n\n value satisfies never;\n throw runtimeError(\n 'RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION',\n 'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n );\n}\n\n/**\n * Create a tagged-template builder for raw SQL expressions. The returned tag accepts SQL string fragments interleaved with typed {@link Expression}, {@link ParamRef}, or bare {@link RawSqlLiteral} interpolations. Call `.returns(spec)` on the result to obtain a typed {@link Expression} whose AST is a {@link RawExpr}.\n *\n * Bare {@link RawSqlLiteral} interpolations are wrapped as `ParamRef` nodes with the codec resolved via `adapter.inferCodec(value)`. Use {@link param} when the codec cannot be inferred from the value alone (e.g. `Date`).\n */\nexport function createRawSql(adapter: RawCodecInferer): RawSqlTag {\n return (strings, ...values) => {\n const parts: (string | AstExpression | ParamRef)[] = [];\n parts.push(strings[0] ?? '');\n values.forEach((value, i) => {\n parts.push(resolveInterpolation(adapter, value));\n parts.push(strings[i + 1] ?? '');\n });\n return new RawSqlBuilderImpl(parts);\n };\n}\n\nclass RawSqlBuilderImpl implements RawSqlBuilder {\n constructor(private readonly parts: readonly (string | AstExpression | ParamRef)[]) {}\n\n returns<S extends string>(spec: S): Expression<{ codecId: S; nullable: false }>;\n returns<S extends string, N extends boolean = false>(spec: {\n readonly codecId: S;\n readonly nullable?: N;\n }): Expression<{ codecId: S; nullable: N }>;\n returns(\n spec: string | { readonly codecId: string; readonly nullable?: boolean },\n ): Expression<{ codecId: string; nullable: boolean }> {\n const codecId = typeof spec === 'string' ? spec : spec.codecId;\n const nullable = typeof spec === 'string' ? false : (spec.nullable ?? false);\n const paramSpec: ParamSpec = { codecId, nullable };\n const node = new RawExpr({ parts: this.parts, returns: paramSpec });\n return {\n returnType: { codecId, nullable },\n buildAst: () => node,\n };\n }\n}\n"],"mappings":";;;;;;;;;;AA8GA,SAAgB,OAAO,OAAgB,OAAiC;CACtE,IAAI,iBAAiB,KAAK,GACxB,OAAO,MAAM,SAAS;CAExB,IAAI,UAAU,KAAA,GACZ,MAAM,aACJ,oCACA,qCAAqC,UAAU,OAAO,SAAS,OAAO,MAAM,0GAE9E;CAEF,OAAO,SAAS,GAAG,OAAO,EAAE,MAAM,CAAC;AACrC;;;;AAKA,SAAgB,MAAS,OAAU,MAAqC;CACtE,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC;AAChE;;;;;;;;;;;AAYA,SAAgB,QAAQ,OAAsC;CAC5D,IAAI,CAAC,iBAAiB,KAAK,GAAG,OAAO,KAAA;CACrC,MAAM,UAAU;CAIhB,IAAI,QAAQ,OAAO,OAAO,QAAQ;CAClC,IAAI,QAAQ,YAAY,OAAO,OAAO,QAAQ,WAAW;CACzD,IAAI,QAAQ,YAAY,SAAS,OAAO,EAAE,SAAS,QAAQ,WAAW,QAAQ;AAEhF;AAEA,SAAS,iBAAiB,OAAiD;CACzE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,cAAc,SACd,OAAQ,MAAgC,aAAa;AAEzD;;;;AAeA,SAAgB,eAAqC,MAA4C;CAC/F,MAAM,CAAC,MAAM,GAAG,QAAQ,KAAK;CAC7B,MAAM,KAAK,IAAI,cAAc;EAC3B,QAAQ,KAAK;EACb;EACA,MAAM,KAAK,SAAS,IAAI,OAAO,KAAA;EAC/B,SAAS,KAAK;EACd,UAAU,KAAK;CACjB,CAAC;CACD,OAAO;EACL,YAAY,KAAK;EACjB,gBAAgB;CAClB;AACF;AAmCA,SAAS,qBACP,SACA,OAC0B;CAC1B,IAAI,iBAAiB,KAAK,GACxB,OAAO,MAAM,SAAS;CAExB,IAAI,iBAAiB,UACnB,OAAO;CAET,IACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,aACjB,iBAAiB,YAEjB,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,QAAQ,WAAW,KAAK,EAAE,EAAE,CAAC;CAI7E,MAAM,aACJ,6CACA,6GACF;AACF;;;;;;AAOA,SAAgB,aAAa,SAAqC;CAChE,QAAQ,SAAS,GAAG,WAAW;EAC7B,MAAM,QAA+C,CAAC;EACtD,MAAM,KAAK,QAAQ,MAAM,EAAE;EAC3B,OAAO,SAAS,OAAO,MAAM;GAC3B,MAAM,KAAK,qBAAqB,SAAS,KAAK,CAAC;GAC/C,MAAM,KAAK,QAAQ,IAAI,MAAM,EAAE;EACjC,CAAC;EACD,OAAO,IAAI,kBAAkB,KAAK;CACpC;AACF;AAEA,IAAM,oBAAN,MAAiD;CAClB;CAA7B,YAAY,OAAwE;EAAvD,KAAA,QAAA;CAAwD;CAOrF,QACE,MACoD;EACpD,MAAM,UAAU,OAAO,SAAS,WAAW,OAAO,KAAK;EACvD,MAAM,WAAW,OAAO,SAAS,WAAW,QAAS,KAAK,YAAY;EACtE,MAAM,YAAuB;GAAE;GAAS;EAAS;EACjD,MAAM,OAAO,IAAI,QAAQ;GAAE,OAAO,KAAK;GAAO,SAAS;EAAU,CAAC;EAClE,OAAO;GACL,YAAY;IAAE;IAAS;GAAS;GAChC,gBAAgB;EAClB;CACF;AACF"} |
+3
-3
| 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-DFLA6Hmj.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-DQrmgP8Y.mjs"; | ||
| import { a as DdlColumnRenderContext, c as ForeignKeyConstraint, d as PrimaryKeyConstraint, f as UniqueConstraint, i as DdlColumnDefaultVisitor, l as FunctionColumnDefault, n as DdlColumn, o as DdlNode, p as isDdlNode, r as DdlColumnDefault, s as DdlTableConstraint, t as AnyDdlColumnDefault, u as LiteralColumnDefault } from "./ddl-types-BVO002FS.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-Cd4p4EbE.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"; | ||
@@ -9,6 +9,6 @@ import { a as MutationDefaultsOptions, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as TypeHelperRegistry, r as ExecutionContext, t as AppliedMutationDefault } from "./query-lane-context-DFnJVqUH.mjs"; | ||
| import { n as planUnsupported, t as planInvalid } from "./errors-COyZClzw.mjs"; | ||
| import { BuildOperationSpec, CodecExpression, CodecTypesBase, CodecValue, Expression, RawCodecInferer, RawSqlBuilder, RawSqlTag, ScopeField, TraitExpression, buildOperation, codecOf, createRawSql, param, toExpr } from "./exports/expression.mjs"; | ||
| import { BuildOperationSpec, CodecExpression, CodecTypesBase, CodecValue, Expression, RawCodecInferer, RawSqlBuilder, RawSqlTag, ScalarListExpression, ScopeField, TraitExpression, buildOperation, codecOf, createRawSql, param, toExpr } from "./exports/expression.mjs"; | ||
| import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-Dyyo4IP1.mjs"; | ||
| import { n as planFromAst, t as SqlQueryPlan } from "./plan-DUjdGLY3.mjs"; | ||
| import { n as SqlOrmPlan, t as RuntimeScope } from "./types-CUHnDsdV.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, 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, RuntimeError, 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, 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, planInvalid, planUnsupported, 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 { 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, RuntimeError, 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, planInvalid, planUnsupported, 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
@@ -1,3 +0,3 @@ | ||
| import { a as FunctionColumnDefault, c as UniqueConstraint, i as ForeignKeyConstraint, l as isDdlNode, n as DdlColumnDefault, o as LiteralColumnDefault, r as DdlNode, s as PrimaryKeyConstraint, t as DdlColumn } from "./ddl-types-DAox2c8w.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-lJUc6cY-.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"; | ||
@@ -11,2 +11,2 @@ 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 "./exports/types.mjs"; | ||
| export { AggregateExpr, AndExpr, BinaryExpr, 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, planInvalid, planUnsupported, 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, 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, planInvalid, planUnsupported, 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 }; |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"types-DQrmgP8Y.d.mts","names":[],"sources":["../src/ast/types.ts"],"mappings":"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"} | ||
| {"version":3,"file":"types-DQrmgP8Y.d.mts","names":[],"sources":["../src/ast/types.ts"],"mappings":"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"} |
+14
-14
| { | ||
| "name": "@prisma-next/sql-relational-core", | ||
| "version": "0.14.0", | ||
| "version": "0.15.0-dev.1", | ||
| "license": "Apache-2.0", | ||
@@ -9,20 +9,20 @@ "type": "module", | ||
| "dependencies": { | ||
| "@prisma-next/contract": "0.14.0", | ||
| "@prisma-next/framework-components": "0.14.0", | ||
| "@prisma-next/operations": "0.14.0", | ||
| "@prisma-next/sql-contract": "0.14.0", | ||
| "@prisma-next/sql-operations": "0.14.0", | ||
| "@prisma-next/utils": "0.14.0", | ||
| "@prisma-next/contract": "0.15.0-dev.1", | ||
| "@prisma-next/framework-components": "0.15.0-dev.1", | ||
| "@prisma-next/operations": "0.15.0-dev.1", | ||
| "@prisma-next/sql-contract": "0.15.0-dev.1", | ||
| "@prisma-next/sql-operations": "0.15.0-dev.1", | ||
| "@prisma-next/utils": "0.15.0-dev.1", | ||
| "@standard-schema/spec": "^1.1.0", | ||
| "arktype": "^2.2.0", | ||
| "arktype": "^2.2.2", | ||
| "ts-toolbelt": "^9.6.0" | ||
| }, | ||
| "devDependencies": { | ||
| "@prisma-next/sql-contract-ts": "0.14.0", | ||
| "@prisma-next/test-utils": "0.14.0", | ||
| "@prisma-next/tsconfig": "0.14.0", | ||
| "@prisma-next/tsdown": "0.14.0", | ||
| "tsdown": "0.22.1", | ||
| "@prisma-next/sql-contract-ts": "0.15.0-dev.1", | ||
| "@prisma-next/test-utils": "0.15.0-dev.1", | ||
| "@prisma-next/tsconfig": "0.15.0-dev.1", | ||
| "@prisma-next/tsdown": "0.15.0-dev.1", | ||
| "tsdown": "0.22.3", | ||
| "typescript": "5.9.3", | ||
| "vitest": "4.1.8" | ||
| "vitest": "4.1.10" | ||
| }, | ||
@@ -29,0 +29,0 @@ "peerDependencies": { |
+1
-1
@@ -96,3 +96,3 @@ # @prisma-next/sql-relational-core | ||
| Codec authors extend the framework `CodecImpl` (and pair the codec with a `CodecDescriptorImpl` registration) per [ADR 208 — Higher-order codecs for parameterized types](../../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md). Each codec class declares the four conversion methods (`encode`, `decode`, `encodeJson`, `decodeJson`); the descriptor class declares static metadata (`codecId`, `traits`, `targetTypes`, `meta`, `paramsSchema`, optional `renderOutputType`) and a `factory` returning a per-instance codec. | ||
| SQL codec authors extend the framework `CodecImpl` base (and pair the codec with a `CodecDescriptorImpl` registration) per [ADR 208 — Higher-order codecs for parameterized types](../../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md). Each codec class declares `encode`, `decode`, `encodeJson`, and `decodeJson`. The JSON methods use the exact scalar shape produced by the corresponding database inside JSON values; include decoding calls `decodeJson`, while ordinary column decoding calls `decode`. | ||
@@ -99,0 +99,0 @@ - Query-time methods (`encode` / `decode`) are typed as `Promise<…>`-returning at the public boundary; sync method bodies are accepted via TypeScript bivariance and the runtime always awaits. |
+26
-1
@@ -203,2 +203,27 @@ import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types'; | ||
| export type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint; | ||
| /** | ||
| * 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. | ||
| */ | ||
| export class CheckExpressionConstraint { | ||
| readonly kind = 'check-expression' as const; | ||
| readonly name: string; | ||
| readonly expression: string; | ||
| constructor(options: { readonly name: string; readonly expression: string }) { | ||
| this.name = options.name; | ||
| this.expression = options.expression; | ||
| Object.freeze(this); | ||
| } | ||
| } | ||
| export type DdlTableConstraint = | ||
| | PrimaryKeyConstraint | ||
| | ForeignKeyConstraint | ||
| | UniqueConstraint | ||
| | CheckExpressionConstraint; |
+5
-3
@@ -110,5 +110,7 @@ import type { ParamSpec } from '@prisma-next/operations'; | ||
| : (structuredClone(codec.typeParams) as CodecRef['typeParams']); | ||
| return Object.freeze( | ||
| typeParams === undefined ? { codecId: codec.codecId } : { codecId: codec.codecId, typeParams }, | ||
| ); | ||
| const base = { | ||
| codecId: codec.codecId, | ||
| ...ifDefined('typeParams', typeParams), | ||
| }; | ||
| return Object.freeze(codec.many ? { ...base, many: true } : base); | ||
| } | ||
@@ -115,0 +117,0 @@ |
@@ -5,2 +5,3 @@ import type { JsonValue } from '@prisma-next/contract/types'; | ||
| import { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types'; | ||
| import { blindCast } from '@prisma-next/utils/casts'; | ||
@@ -46,5 +47,13 @@ /** | ||
| if (columnDef.typeParams !== undefined && Object.keys(columnDef.typeParams).length > 0) { | ||
| return { codecId: columnDef.codecId, typeParams: columnDef.typeParams as JsonValue }; | ||
| const typeParams = blindCast< | ||
| JsonValue, | ||
| 'column typeParams is a validated contract record; its values are JSON-serialisable' | ||
| >(columnDef.typeParams); | ||
| return columnDef.many | ||
| ? { codecId: columnDef.codecId, typeParams, many: true } | ||
| : { codecId: columnDef.codecId, typeParams }; | ||
| } | ||
| return { codecId: columnDef.codecId }; | ||
| return columnDef.many | ||
| ? { codecId: columnDef.codecId, many: true } | ||
| : { codecId: columnDef.codecId }; | ||
| } |
@@ -6,2 +6,3 @@ import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types'; | ||
| import { | ||
| CheckExpressionConstraint, | ||
| DdlColumn, | ||
@@ -60,1 +61,5 @@ ForeignKeyConstraint, | ||
| } | ||
| export function checkExpression(name: string, expression: string): CheckExpressionConstraint { | ||
| return new CheckExpressionConstraint({ name, expression }); | ||
| } |
| export { | ||
| checkExpression, | ||
| col, | ||
@@ -3,0 +4,0 @@ type DdlColumnOptions, |
+29
-1
@@ -13,2 +13,10 @@ import { runtimeError } from '@prisma-next/framework-components/runtime'; | ||
| /** | ||
| * Marks a list-typed (scalar-array) field. When `true`, the field is an | ||
| * array of `codecId`-typed elements; list operations target it and the | ||
| * element type is `codecId`. Absent/`false` for scalar fields. Carried so | ||
| * `X` and `X[]` stay distinct at the type level (a list expression is not | ||
| * assignable to a scalar `CodecExpression` slot). | ||
| */ | ||
| many?: boolean; | ||
| /** | ||
| * Optional {@link CodecRef} derived from contract storage at scope construction time. Builder paths that mint column-bound `ParamRef` / `ProjectionItem` nodes stamp this slot onto the AST so encode/decode dispatch resolves through `contractCodecs.forCodecRef`. Leave `undefined` when the scope was built without contract storage (rare — tests, ad-hoc scopes). | ||
@@ -59,2 +67,8 @@ */ | ||
| * - `null` when `Nullable` is true | ||
| * | ||
| * `many?: never` makes this a *scalar* slot: a list expression (whose | ||
| * `returnType` carries `many: true`) is rejected here, while scalar | ||
| * expressions — which carry no `many` key at all — pass unchanged. The | ||
| * discriminant lives on this operand slot, so scalar expression and scope | ||
| * types never have to spell out `many: false`. | ||
| */ | ||
@@ -65,5 +79,19 @@ export type CodecExpression< | ||
| CT extends Record<string, { readonly input: unknown }>, | ||
| > = Expression<{ codecId: CodecId; nullable: Nullable }> | CodecValue<CodecId, Nullable, CT>; | ||
| > = | ||
| | Expression<{ codecId: CodecId; nullable: Nullable; many?: never }> | ||
| | CodecValue<CodecId, Nullable, CT>; | ||
| /** | ||
| * A list-typed expression: an {@link Expression} whose element codec is | ||
| * `CodecId` and whose `returnType` carries `many: true`. The element identity | ||
| * is the codec id, so list operations stay generic over the element type while | ||
| * tying any element argument back to this list's `CodecId`. | ||
| */ | ||
| export type ScalarListExpression<CodecId extends string, Nullable extends boolean> = Expression<{ | ||
| codecId: CodecId; | ||
| nullable: Nullable; | ||
| many: true; | ||
| }>; | ||
| /** | ||
| * An expression or literal value targeting any codec whose trait set contains all the required traits. | ||
@@ -70,0 +98,0 @@ * |
| import { o as CodecRef } from "./codec-types-DFLA6Hmj.mjs"; | ||
| import { d as AnyParamRef } from "./types-DQrmgP8Y.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; | ||
| }); | ||
| } | ||
| type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint; | ||
| //#endregion | ||
| export { DdlColumnRenderContext as a, ForeignKeyConstraint as c, PrimaryKeyConstraint as d, UniqueConstraint as f, DdlColumnDefaultVisitor as i, FunctionColumnDefault as l, DdlColumn as n, DdlNode as o, isDdlNode as p, DdlColumnDefault as r, DdlTableConstraint as s, AnyDdlColumnDefault as t, LiteralColumnDefault as u }; | ||
| //# sourceMappingURL=ddl-types-BVO002FS.d.mts.map |
| {"version":3,"file":"ddl-types-BVO002FS.d.mts","names":[],"sources":["../src/ast/ddl-types.ts"],"mappings":";;;;;;;;AAeA;;;;AACqB;AAGrB;;UAJiB,sBAAA;EAAA,SACN,UAAU;AAAA;AAAA,UAGJ,uBAAA;EACf,OAAA,CAAQ,IAAA,EAAM,oBAAA,EAAsB,GAAA,EAAK,sBAAA,GAAyB,CAAA;EAClE,QAAA,CAAS,IAAA,EAAM,qBAAA,EAAuB,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,uBAGhD,gBAAA;EAAA,kBACF,IAAA;EAAA,SACT,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;EAAA,UAE5E,MAAA;AAAA;AAAA,cAKC,oBAAA,SAA6B,gBAAA;EAAA,SAC/B,IAAA;EAAA,SACA,KAAA,EAAO,8BAAA;cAEJ,KAAA,EAAO,8BAAA;EASV,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,cAK3E,qBAAA,SAA8B,gBAAA;EAAA,SAChC,IAAA;EAAA,SACA,UAAA;cAEG,UAAA;EAMH,MAAA,IAAU,OAAA,EAAS,uBAAA,CAAwB,CAAA,GAAI,GAAA,EAAK,sBAAA,GAAyB,CAAA;AAAA;AAAA,KAK5E,mBAAA,GAAsB,oBAAA,GAAuB,qBAAqB;AAAA,cAEjE,SAAA;EAAA,SACF,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA,GAAU,mBAAA;EA/CoE;EAAA,SAiD9E,QAAA,GAAW,QAAA;cAER,OAAA;IAAA,SACD,IAAA;IAAA,SACA,IAAA;IAAA,SACA,OAAA;IAAA,SACA,UAAA;IAAA,SACA,OAAA,GAAU,mBAAA;IAAA,SACV,QAAA,GAAW,QAAA;EAAA;AAAA;AAAA,uBAYF,OAAA;EAAA,kBACF,IAAA;EApEF;AAKlB;;;;;EAuEE,SAAA;EAAA,UAIU,MAAA;EAIV,gBAAA,IAAoB,WAAW;AAAA;AAAA,iBAKjB,SAAA,CAAU,KAAA,YAAiB,KAAA,IAAS,OAAO;;;;;;;;cAoB9C,oBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAa;EAAA,SACtB,IAAA;cAEG,OAAA;IAAA,SAAoB,OAAA;IAAA,SAAqC,IAAA;EAAA;AAAA;;;AAhGkB;AAKzF;;;;cAyGa,oBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAA;EAAA,SACT,QAAA;EAAA,SACA,UAAA,EAAY,aAAA;EAAA,SACZ,QAAA,EAAU,iBAAA;EAAA,SACV,QAAA,EAAU,iBAAA;EAAA,SACV,IAAA;cAEG,OAAA;IAAA,SACD,OAAA;IAAA,SACA,QAAA;IAAA,SACA,UAAA;IAAA,SACA,QAAA,GAAW,iBAAA;IAAA,SACX,QAAA,GAAW,iBAAA;IAAA,SACX,IAAA;EAAA;AAAA;;;;AA9G4E;AAKzF;;;cA4Ha,gBAAA;EAAA,SACF,IAAA;EAAA,SACA,OAAA,EAAS,aAAa;EAAA,SACtB,IAAA;cAEG,OAAA;IAAA,SAAoB,OAAA;IAAA,SAAqC,IAAA;EAAA;AAAA;AAAA,KAO3D,kBAAA,GAAqB,oBAAA,GAAuB,oBAAA,GAAuB,gBAAA"} |
| import { isColumnDefaultLiteralInputValue } from "@prisma-next/contract/types"; | ||
| //#region src/ast/ddl-types.ts | ||
| var DdlColumnDefault = class { | ||
| freeze() { | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| var LiteralColumnDefault = class extends DdlColumnDefault { | ||
| kind = "literal"; | ||
| value; | ||
| constructor(value) { | ||
| super(); | ||
| if (!isColumnDefaultLiteralInputValue(value)) throw new Error("Invalid column default literal value"); | ||
| this.value = value; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor, ctx) { | ||
| return visitor.literal(this, ctx); | ||
| } | ||
| }; | ||
| var FunctionColumnDefault = class extends DdlColumnDefault { | ||
| kind = "function"; | ||
| expression; | ||
| constructor(expression) { | ||
| super(); | ||
| this.expression = expression; | ||
| this.freeze(); | ||
| } | ||
| accept(visitor, ctx) { | ||
| return visitor.function(this, ctx); | ||
| } | ||
| }; | ||
| var DdlColumn = class { | ||
| name; | ||
| type; | ||
| notNull; | ||
| primaryKey; | ||
| default; | ||
| /** 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). */ | ||
| codecRef; | ||
| constructor(options) { | ||
| this.name = options.name; | ||
| this.type = options.type; | ||
| this.notNull = options.notNull; | ||
| this.primaryKey = options.primaryKey; | ||
| this.default = options.default; | ||
| this.codecRef = options.codecRef; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| var DdlNode = class { | ||
| /** | ||
| * 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() { | ||
| return true; | ||
| } | ||
| freeze() { | ||
| Object.freeze(this); | ||
| } | ||
| collectParamRefs() { | ||
| return []; | ||
| } | ||
| }; | ||
| function isDdlNode(value) { | ||
| return typeof value === "object" && value !== null && "isDdlNode" in value && typeof value.isDdlNode === "function"; | ||
| } | ||
| /** | ||
| * 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. | ||
| */ | ||
| var PrimaryKeyConstraint = class { | ||
| kind = "primary-key"; | ||
| columns; | ||
| name; | ||
| constructor(options) { | ||
| this.columns = Object.freeze([...options.columns]); | ||
| this.name = options.name; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| /** | ||
| * 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. | ||
| */ | ||
| var ForeignKeyConstraint = class { | ||
| kind = "foreign-key"; | ||
| columns; | ||
| refTable; | ||
| refColumns; | ||
| onDelete; | ||
| onUpdate; | ||
| name; | ||
| constructor(options) { | ||
| this.columns = Object.freeze([...options.columns]); | ||
| this.refTable = options.refTable; | ||
| this.refColumns = Object.freeze([...options.refColumns]); | ||
| this.onDelete = options.onDelete; | ||
| this.onUpdate = options.onUpdate; | ||
| this.name = options.name; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| /** | ||
| * 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. | ||
| */ | ||
| var UniqueConstraint = class { | ||
| kind = "unique"; | ||
| columns; | ||
| name; | ||
| constructor(options) { | ||
| this.columns = Object.freeze([...options.columns]); | ||
| this.name = options.name; | ||
| Object.freeze(this); | ||
| } | ||
| }; | ||
| //#endregion | ||
| export { FunctionColumnDefault as a, UniqueConstraint as c, ForeignKeyConstraint as i, isDdlNode as l, DdlColumnDefault as n, LiteralColumnDefault as o, DdlNode as r, PrimaryKeyConstraint as s, DdlColumn as t }; | ||
| //# sourceMappingURL=ddl-types-DAox2c8w.mjs.map |
| {"version":3,"file":"ddl-types-DAox2c8w.mjs","names":[],"sources":["../src/ast/ddl-types.ts"],"sourcesContent":["import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport { isColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport type { ReferentialAction } from '@prisma-next/sql-contract/types';\nimport type { CodecRef } from './codec-types';\nimport type { AnyParamRef } from './types';\n\n/**\n * Render-time context the column-default visitor needs to make dialect\n * decisions that depend on the parent column. Today only the parent\n * column's native type (`\"jsonb\"`, `\"text\"`, …) — the Postgres renderer\n * uses it to decide whether to emit a `::jsonb` / `::json` cast on JSON\n * literal defaults so the emitted DDL matches the column type without\n * relying on Postgres's implicit text → jsonb cast at default-evaluation\n * time. Additional fields can join without re-shaping the interface.\n */\nexport interface DdlColumnRenderContext {\n readonly nativeType: string;\n}\n\nexport interface DdlColumnDefaultVisitor<R> {\n literal(node: LiteralColumnDefault, ctx: DdlColumnRenderContext): R;\n function(node: FunctionColumnDefault, ctx: DdlColumnRenderContext): R;\n}\n\nexport abstract class DdlColumnDefault {\n abstract readonly kind: string;\n abstract accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R;\n\n protected freeze(): void {\n Object.freeze(this);\n }\n}\n\nexport class LiteralColumnDefault extends DdlColumnDefault {\n readonly kind = 'literal' as const;\n readonly value: ColumnDefaultLiteralInputValue;\n\n constructor(value: ColumnDefaultLiteralInputValue) {\n super();\n if (!isColumnDefaultLiteralInputValue(value)) {\n throw new Error('Invalid column default literal value');\n }\n this.value = value;\n this.freeze();\n }\n\n override accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R {\n return visitor.literal(this, ctx);\n }\n}\n\nexport class FunctionColumnDefault extends DdlColumnDefault {\n readonly kind = 'function' as const;\n readonly expression: string;\n\n constructor(expression: string) {\n super();\n this.expression = expression;\n this.freeze();\n }\n\n override accept<R>(visitor: DdlColumnDefaultVisitor<R>, ctx: DdlColumnRenderContext): R {\n return visitor.function(this, ctx);\n }\n}\n\nexport type AnyDdlColumnDefault = LiteralColumnDefault | FunctionColumnDefault;\n\nexport class DdlColumn {\n readonly name: string;\n readonly type: string;\n readonly notNull?: boolean | undefined;\n readonly primaryKey?: boolean | undefined;\n readonly default?: AnyDdlColumnDefault | undefined;\n /** 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). */\n readonly codecRef?: CodecRef | undefined;\n\n constructor(options: {\n readonly name: string;\n readonly type: string;\n readonly notNull?: boolean;\n readonly primaryKey?: boolean;\n readonly default?: AnyDdlColumnDefault;\n readonly codecRef?: CodecRef;\n }) {\n this.name = options.name;\n this.type = options.type;\n this.notNull = options.notNull;\n this.primaryKey = options.primaryKey;\n this.default = options.default;\n this.codecRef = options.codecRef;\n Object.freeze(this);\n }\n}\n\nexport abstract class DdlNode {\n abstract readonly kind: string;\n\n /**\n * Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}\n * recognise any `DdlNode` subclass — including target-contributed kinds —\n * without a central kind registry that subclasses would have to register\n * into.\n */\n isDdlNode(): true {\n return true;\n }\n\n protected freeze(): void {\n Object.freeze(this);\n }\n\n collectParamRefs(): AnyParamRef[] {\n return [];\n }\n}\n\nexport function isDdlNode(value: unknown): value is DdlNode {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'isDdlNode' in value &&\n typeof value.isDdlNode === 'function'\n );\n}\n\n// ---------------------------------------------------------------------------\n// Table-level constraint nodes\n// ---------------------------------------------------------------------------\n\n/**\n * A composite (or single-column) PRIMARY KEY constraint on a `CreateTable`\n * node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY\n * (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class PrimaryKeyConstraint {\n readonly kind = 'primary-key' as const;\n readonly columns: ReadonlyArray<string>;\n readonly name: string | undefined;\n\n constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {\n this.columns = Object.freeze([...options.columns]);\n this.name = options.name;\n Object.freeze(this);\n }\n}\n\n/**\n * A FOREIGN KEY constraint on a `CreateTable` node. `onDelete` and `onUpdate`\n * use the same `ReferentialAction` vocabulary already used by the migration\n * planner and the contract IR — no parallel string enum.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class ForeignKeyConstraint {\n readonly kind = 'foreign-key' as const;\n readonly columns: ReadonlyArray<string>;\n readonly refTable: string;\n readonly refColumns: ReadonlyArray<string>;\n readonly onDelete: ReferentialAction | undefined;\n readonly onUpdate: ReferentialAction | undefined;\n readonly name: string | undefined;\n\n constructor(options: {\n readonly columns: readonly string[];\n readonly refTable: string;\n readonly refColumns: readonly string[];\n readonly onDelete?: ReferentialAction;\n readonly onUpdate?: ReferentialAction;\n readonly name?: string;\n }) {\n this.columns = Object.freeze([...options.columns]);\n this.refTable = options.refTable;\n this.refColumns = Object.freeze([...options.refColumns]);\n this.onDelete = options.onDelete;\n this.onUpdate = options.onUpdate;\n this.name = options.name;\n Object.freeze(this);\n }\n}\n\n/**\n * A table-level UNIQUE constraint on a `CreateTable` node. When `name` is\n * set, the adapter renders `CONSTRAINT <name> UNIQUE (…)`; otherwise it\n * renders an anonymous `UNIQUE (…)`.\n *\n * Frozen on construction — immutable after creation.\n */\nexport class UniqueConstraint {\n readonly kind = 'unique' as const;\n readonly columns: ReadonlyArray<string>;\n readonly name: string | undefined;\n\n constructor(options: { readonly columns: readonly string[]; readonly name?: string }) {\n this.columns = Object.freeze([...options.columns]);\n this.name = options.name;\n Object.freeze(this);\n }\n}\n\nexport type DdlTableConstraint = PrimaryKeyConstraint | ForeignKeyConstraint | UniqueConstraint;\n"],"mappings":";;AAwBA,IAAsB,mBAAtB,MAAuC;CAIrC,SAAyB;EACvB,OAAO,OAAO,IAAI;CACpB;AACF;AAEA,IAAa,uBAAb,cAA0C,iBAAiB;CACzD,OAAgB;CAChB;CAEA,YAAY,OAAuC;EACjD,MAAM;EACN,IAAI,CAAC,iCAAiC,KAAK,GACzC,MAAM,IAAI,MAAM,sCAAsC;EAExD,KAAK,QAAQ;EACb,KAAK,OAAO;CACd;CAEA,OAAmB,SAAqC,KAAgC;EACtF,OAAO,QAAQ,QAAQ,MAAM,GAAG;CAClC;AACF;AAEA,IAAa,wBAAb,cAA2C,iBAAiB;CAC1D,OAAgB;CAChB;CAEA,YAAY,YAAoB;EAC9B,MAAM;EACN,KAAK,aAAa;EAClB,KAAK,OAAO;CACd;CAEA,OAAmB,SAAqC,KAAgC;EACtF,OAAO,QAAQ,SAAS,MAAM,GAAG;CACnC;AACF;AAIA,IAAa,YAAb,MAAuB;CACrB;CACA;CACA;CACA;CACA;;CAEA;CAEA,YAAY,SAOT;EACD,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,aAAa,QAAQ;EAC1B,KAAK,UAAU,QAAQ;EACvB,KAAK,WAAW,QAAQ;EACxB,OAAO,OAAO,IAAI;CACpB;AACF;AAEA,IAAsB,UAAtB,MAA8B;;;;;;;CAS5B,YAAkB;EAChB,OAAO;CACT;CAEA,SAAyB;EACvB,OAAO,OAAO,IAAI;CACpB;CAEA,mBAAkC;EAChC,OAAO,CAAC;CACV;AACF;AAEA,SAAgB,UAAU,OAAkC;CAC1D,OACE,OAAO,UAAU,YACjB,UAAU,QACV,eAAe,SACf,OAAO,MAAM,cAAc;AAE/B;;;;;;;;AAaA,IAAa,uBAAb,MAAkC;CAChC,OAAgB;CAChB;CACA;CAEA,YAAY,SAA0E;EACpF,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;AASA,IAAa,uBAAb,MAAkC;CAChC,OAAgB;CAChB;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,SAOT;EACD,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,WAAW,QAAQ;EACxB,KAAK,aAAa,OAAO,OAAO,CAAC,GAAG,QAAQ,UAAU,CAAC;EACvD,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;EACxB,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;AASA,IAAa,mBAAb,MAA8B;CAC5B,OAAgB;CAChB;CACA;CAEA,YAAY,SAA0E;EACpF,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACpB;AACF"} |
| 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); | ||
| return Object.freeze(typeParams === void 0 ? { codecId: codec.codecId } : { | ||
| codecId: codec.codecId, | ||
| typeParams | ||
| }); | ||
| } | ||
| 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) { | ||
| return new SubqueryExpr(this.query.rewrite(rewriter)); | ||
| } | ||
| 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 = new Set([ | ||
| "select", | ||
| "insert", | ||
| "update", | ||
| "delete", | ||
| "raw-sql" | ||
| ]); | ||
| const whereExprKinds = 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-lJUc6cY-.mjs.map |
Sorry, the diff of this file is too big to display
No alert changes
Improved metrics
- Total package byte prevSize
636638
1.5%- Lines of code
6941
1.58%Dependency changes
+ Added
@prisma-next/contract@0.15.0-dev.1(transitive)+ Added
@prisma-next/framework-components@0.15.0-dev.1(transitive)+ Added
@prisma-next/operations@0.15.0-dev.1(transitive)+ Added
@prisma-next/sql-contract@0.15.0-dev.1(transitive)+ Added
@prisma-next/sql-operations@0.15.0-dev.1(transitive)+ Added
@prisma-next/sql-schema-ir@0.15.0-dev.1(transitive)+ Added
@prisma-next/ts-render@0.15.0-dev.1(transitive)+ Added
@prisma-next/utils@0.15.0-dev.1(transitive)- Removed
@prisma-next/contract@0.14.0(transitive)- Removed
@prisma-next/framework-components@0.14.0(transitive)- Removed
@prisma-next/operations@0.14.0(transitive)- Removed
@prisma-next/sql-contract@0.14.0(transitive)- Removed
@prisma-next/sql-operations@0.14.0(transitive)- Removed
@prisma-next/ts-render@0.14.0(transitive)- Removed
@prisma-next/utils@0.14.0(transitive)Updated
arktype@^2.2.2