@prisma/orm-family-sql 8.0.0-rc.2-dev.2 → 8.0.0-rc.20

package/dist/pack-DA8HZ2mo.d.mts

@@ -0,0 +1,535 @@
+import { r as SqlExpression } from "./sql-expression-B4BrhGPi.mjs";
+import { a as EnumMemberListDefault, i as EnumMemberDefault, n as DefaultFunctionCall, o as ParsedNullLiteral } from "./attribute-specs-DA_RwQFB.mjs";
+import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CgKIgWq5-pEdfjam5.mjs";
+import { DataTypeSupport, PresetStorageTemplate, TIMESTAMP_NOW_GENERATOR_ID } from "@prisma/orm-framework/components/authoring";
+import { DataTypeId } from "@prisma/orm-framework/components/codec";
+import { GeneratorFunctionContribution } from "@prisma/orm-framework/components/components";
+import { ArgType, AttributeCtx } from "@prisma/orm-framework/psl-parser";
+//#region ../../../2-sql-family/9-family/dist/pack.d.mts
+//#region src/core/authoring-type-constructors.d.ts
+/**
+ * The type constructors every SQL target contributes itself, because their arguments are sizes, such as a length, and only the target names the data type a size is a value of: `sizeType`, such as `pg/int4`.
+ */
+declare function sqlTargetTypeConstructors<const SizeType extends string>(input: {
+  readonly sizeType: SizeType;
+}): {
+  readonly sql: {
+    readonly String: {
+      readonly kind: "typeConstructor";
+      readonly documentation: "Variable-length text with a required maximum character length.";
+      readonly args: readonly [{
+        readonly kind: "value";
+        readonly dataType: SizeType;
+        readonly name: "length";
+      }];
+      readonly output: {
+        readonly codecId: "sql/varchar@1";
+        readonly typeParams: {
+          readonly length: {
+            readonly kind: "arg";
+            readonly index: 0;
+          };
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/core/generator-functions.d.ts
+/** The identifier generator functions bound to a target's text codecs, and `uuid` to its uuid codecs. Each refuses a column too short for what it writes. */
+declare function idGeneratorFunctionBindings(codecs: {
+  readonly text: readonly string[];
+  readonly uuid?: readonly string[];
+}): readonly GeneratorFunctionContribution[];
+/**
+ * The generator functions whose arguments are integers, declared with their signatures: `uuid(version?)`, `cuid(version)` and `nanoid(size?)`. Each argument is a value of `integer`, the target's integer data type, read and cast like a default, then checked by its function. A target declares them, because only it knows its integer type; the family and the target bind them.
+ */
+declare function sqlIntegerArgumentGeneratorFunctions({ integer }: {
+  readonly integer: DataTypeId;
+}): readonly [{
+  readonly name: "uuid";
+  readonly signature: (dataTypes: DataTypeSupport) => {
+    readonly documentation: "Generates a UUID when a value is not supplied.";
+    readonly positional: readonly [{
+      readonly key: "version";
+      readonly type: import("@prisma/orm-framework/psl-parser").OptionalArgType<4 | 7, AttributeCtx, ArgType<4 | 7, AttributeCtx>>;
+      readonly documentation: "The UUID version: `4` or `7`. Defaults to `4`.";
+    }];
+  };
+  readonly bindings: readonly [];
+}, {
+  readonly name: "cuid";
+  readonly signature: (dataTypes: DataTypeSupport) => {
+    readonly documentation: "Generates a CUID2 identifier when a value is not supplied.";
+    readonly positional: readonly [{
+      readonly key: "version";
+      readonly type: ArgType<2, AttributeCtx>;
+      readonly documentation: "The CUID version. Only `2` is supported.";
+    }];
+  };
+  readonly bindings: readonly [];
+}, {
+  readonly name: "nanoid";
+  readonly signature: (dataTypes: DataTypeSupport) => {
+    readonly documentation: "Generates a Nano ID when a value is not supplied.";
+    readonly positional: readonly [{
+      readonly key: "size";
+      readonly type: import("@prisma/orm-framework/psl-parser").OptionalArgType<number, AttributeCtx, ArgType<number, AttributeCtx>>;
+      readonly documentation: "The identifier length, from `2` through `255`. Defaults to 21.";
+    }];
+  };
+  readonly bindings: readonly [];
+}];
+//#endregion
+//#region src/core/timestamp-now-generator.d.ts
+declare function temporalStringAuthoringPresets<const Storage extends PresetStorageTemplate, const GeneratorId extends string = typeof TIMESTAMP_NOW_GENERATOR_ID>(input: Storage & {
+  readonly generatorId?: GeneratorId;
+}): {
+  readonly createdAtString: {
+    readonly kind: "fieldPreset";
+    readonly output: Omit<Storage & {
+      readonly generatorId?: GeneratorId;
+    }, "generatorId"> & {
+      readonly executionDefaults: {
+        readonly onCreate: {
+          readonly kind: "generator";
+          readonly id: GeneratorId | "timestampNow";
+        };
+      };
+    };
+  };
+  readonly updatedAtString: {
+    readonly kind: "fieldPreset";
+    readonly output: Omit<Storage & {
+      readonly generatorId?: GeneratorId;
+    }, "generatorId"> & {
+      readonly executionDefaults: {
+        readonly onCreate: {
+          readonly kind: "generator";
+          readonly id: GeneratorId | "timestampNow";
+        };
+        readonly onUpdate: {
+          readonly kind: "generator";
+          readonly id: GeneratorId | "timestampNow";
+        };
+      };
+    };
+  };
+};
+/**
+ * Builds a `temporal.<codec>` field preset for a codec that takes a precision
+ * parameter (`pg/timestamp-temporal@1`, `pg/timestamptz-temporal@1`). Arguments change field
+ * properties only — never the codec, which the caller fixes here.
+ *
+ * All three arguments are optional: omitting `precision` omits `typeParams`
+ * entirely, and omitting a phase omits that phase (both omitted omits
+ * `executionDefaults`). With `nowTakesPrecision`, the generator a `now` selects
+ * also receives the precision as its `precision` param, so it can write a value
+ * the column stores without rounding.
+ */
+declare function temporalCodecPresetWithPrecision<const CodecId extends string, const SizeType extends string, const GeneratorId extends string = typeof TIMESTAMP_NOW_GENERATOR_ID>(input: {
+  readonly codecId: CodecId;
+  /** The data type of the target's size arguments, which the precision argument is a value of, such as `pg/int4`. */
+  readonly sizeType: SizeType;
+  readonly generatorId?: GeneratorId;
+  readonly nowTakesPrecision?: true;
+}): {
+  readonly kind: "fieldPreset";
+  readonly args: readonly [{
+    readonly name: "precision";
+    readonly kind: "value";
+    readonly dataType: SizeType;
+    readonly optional: true;
+  }, {
+    readonly name: "onCreate";
+    readonly kind: "option";
+    readonly values: readonly ["now"];
+    readonly optional: true;
+  }, {
+    readonly name: "onUpdate";
+    readonly kind: "option";
+    readonly values: readonly ["now"];
+    readonly optional: true;
+  }];
+  readonly output: {
+    readonly codecId: CodecId;
+    readonly typeParams: {
+      readonly precision: {
+        readonly kind: "arg";
+        readonly index: 0;
+      };
+    };
+    readonly executionDefaults: {
+      readonly onCreate: {
+        readonly kind: "select";
+        readonly index: 1;
+        readonly cases: {
+          readonly now: {
+            readonly kind: "generator";
+            readonly id: "timestampNow" | GeneratorId;
+          };
+        };
+      };
+      readonly onUpdate: {
+        readonly kind: "select";
+        readonly index: 2;
+        readonly cases: {
+          readonly now: {
+            readonly kind: "generator";
+            readonly id: "timestampNow" | GeneratorId;
+          };
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/exports/pack.d.ts
+declare const sqlFamilyPackBase: {
+  readonly kind: "family";
+  readonly id: "sql";
+  readonly familyId: "sql";
+  readonly version: "0.0.1";
+  readonly dataTypes: readonly import("@prisma/orm-framework/components/codec").DataType[];
+  readonly authoring: {
+    readonly field: {
+      readonly uuidString: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly typeParams: {
+            readonly length: 36;
+          };
+        };
+      };
+      readonly ulid: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly typeParams: {
+            readonly length: 26;
+          };
+        };
+      };
+      readonly nanoid: {
+        readonly kind: "fieldPreset";
+        readonly args: readonly [{
+          readonly kind: "object";
+          readonly optional: true;
+          readonly properties: {
+            readonly size: {
+              readonly kind: "number";
+              readonly optional: true;
+              readonly integer: true;
+              readonly minimum: 2;
+              readonly maximum: 255;
+            };
+          };
+        }];
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly typeParams: {
+            readonly length: {
+              readonly kind: "arg";
+              readonly index: 0;
+              readonly path: readonly ["size"];
+              readonly default: 21;
+            };
+          };
+        };
+      };
+      readonly cuid2: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly typeParams: {
+            readonly length: 24;
+          };
+        };
+      };
+      readonly ksuid: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly typeParams: {
+            readonly length: 27;
+          };
+        };
+      };
+      readonly id: {
+        readonly uuidv4String: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly typeParams: {
+              readonly length: 36;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "uuidv4";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly uuidv7String: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly typeParams: {
+              readonly length: 36;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "uuidv7";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly ulid: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly typeParams: {
+              readonly length: 26;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "ulid";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly nanoid: {
+          readonly kind: "fieldPreset";
+          readonly args: readonly [{
+            readonly kind: "object";
+            readonly optional: true;
+            readonly properties: {
+              readonly size: {
+                readonly kind: "number";
+                readonly optional: true;
+                readonly integer: true;
+                readonly minimum: 2;
+                readonly maximum: 255;
+              };
+            };
+          }];
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly typeParams: {
+              readonly length: {
+                readonly kind: "arg";
+                readonly index: 0;
+                readonly path: readonly ["size"];
+                readonly default: 21;
+              };
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "nanoid";
+                readonly params: {
+                  readonly size: {
+                    readonly kind: "arg";
+                    readonly index: 0;
+                    readonly path: readonly ["size"];
+                  };
+                };
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly cuid2: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly typeParams: {
+              readonly length: 24;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "cuid2";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly ksuid: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly typeParams: {
+              readonly length: 27;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "ksuid";
+              };
+            };
+            readonly id: true;
+          };
+        };
+      };
+    };
+    readonly type: {
+      readonly Raw: {
+        readonly kind: "typeConstructor";
+        readonly documentation: "A column of a type no other column type covers, written exactly as the database catalog prints it, such as Raw(sql`tsvector`). Its values are typed unknown, and its default is a sql expression.";
+        readonly args: readonly [{
+          readonly kind: "value";
+          readonly dataType: "sql/expression";
+          readonly name: "sql";
+        }];
+        readonly output: {
+          readonly codecId: "sql/raw@1";
+          readonly typeParams: {
+            readonly sql: {
+              readonly kind: "arg";
+              readonly index: 0;
+            };
+          };
+        };
+      };
+    };
+    readonly dataTypes: Readonly<Record<string, import("@prisma/orm-framework/components/authoring").DataTypeAuthoringEntry>>;
+    readonly entityTypes: import("@prisma/orm-framework/components/authoring").AuthoringEntityTypeNamespace;
+    readonly pslBlockDescriptors: {
+      readonly enum: {
+        kind: "pslBlock";
+        keyword: string;
+        documentation: string;
+        discriminator: string;
+        name: {
+          required: true;
+        };
+        spec: typeof sqlFamilyEnumSpec;
+        attributes: {
+          type: () => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+            codecId: string;
+          }, import("@prisma/orm-framework/psl-parser").BlockAttributeCtx>;
+        };
+      };
+    };
+    readonly attributeSpecs: {
+      readonly model: {
+        readonly map: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          name: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly id: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          fields: string[];
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly unique: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          fields: string[];
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly index: (ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          fields?: string[];
+          readonly expression?: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+          readonly where?: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+          readonly unique?: boolean;
+          readonly name?: string;
+          readonly map?: string;
+          readonly type?: string;
+          readonly options?: Record<string, string>;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly check: (ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          readonly expression: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+          readonly name?: string;
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly control: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          policy: "managed" | "tolerated" | "external" | "observed";
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly discriminator: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          field: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly base: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          base: import("@prisma/orm-framework/psl-parser").ResolvedEntityReference<import("@prisma/orm-framework/psl-parser").ModelSymbol>;
+          value: import("@prisma/orm-framework/psl-parser").ParsedWrittenScalar;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+      };
+      readonly field: {
+        readonly map: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          name: string;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly id: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly unique: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly relation: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          name?: string;
+          readonly fields?: string[];
+          readonly references?: string[];
+          readonly map?: string;
+          readonly onDelete?: "NoAction" | "Restrict" | "Cascade" | "SetNull" | "SetDefault";
+          readonly onUpdate?: "NoAction" | "Restrict" | "Cascade" | "SetNull" | "SetDefault";
+          readonly index?: string | boolean;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly default: (ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          value: import("@prisma/orm-framework/psl-parser").ParsedWrittenScalar | ParsedNullLiteral | import("@prisma/orm-framework/psl-parser").ParsedWrittenList<import("@prisma/orm-framework/psl-parser").ParsedWrittenScalar | ParsedNullLiteral> | DefaultFunctionCall | EnumMemberDefault | EnumMemberListDefault;
+        }, import("@prisma/orm-framework/psl-parser").AttributeCtx>;
+        readonly onCreate: (ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          value: import("@prisma/orm-framework/psl-parser").TypedFuncCall;
+        }, import("@prisma/orm-framework/psl-parser").AttributeCtx>;
+        readonly onUpdate: (ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          value: import("@prisma/orm-framework/psl-parser").TypedFuncCall;
+        }, import("@prisma/orm-framework/psl-parser").AttributeCtx>;
+      };
+    };
+  };
+  readonly generatorFunctions: readonly [{
+    readonly name: "now";
+    readonly signature: {
+      readonly documentation: "Writes the current time, as the column's codec represents it.";
+    };
+    readonly bindings: readonly [];
+  }, {
+    readonly name: "uuid";
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "cuid";
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "ulid";
+    readonly signature: {
+      readonly documentation: "Generates a ULID when a value is not supplied.";
+    };
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "nanoid";
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "ksuid";
+    readonly signature: {
+      readonly documentation: "Generates a KSUID when a value is not supplied.";
+    };
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }];
+  readonly controlMutationDefaults: {
+    readonly defaultFunctionRegistry: Map<any, any>;
+    readonly generatorDescriptors: readonly import("@prisma/orm-framework/components/control").MutationDefaultGeneratorDescriptor[];
+  };
+};
+declare const sqlFamilyPack: typeof sqlFamilyPackBase & {
+  readonly __dataTypeArguments?: {
+    readonly 'sql/expression': {
+      readonly argument: SqlExpression;
+      readonly parameter: string;
+    };
+  };
+};
+//#endregion
+export { temporalCodecPresetWithPrecision as a, sqlTargetTypeConstructors as i, sqlFamilyPack as n, temporalStringAuthoringPresets as o, sqlIntegerArgumentGeneratorFunctions as r, idGeneratorFunctionBindings as t };
+//# sourceMappingURL=pack-DA8HZ2mo.d.mts.map

package/dist/pack-DA8HZ2mo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-DA8HZ2mo.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/pack.d.mts"],"mappings":";;;;;;;;;;;;iBAUiB,gCAAgC,yBAAyB;WAC/D,UAAU;;WAEV;aACE;eACE;eACA;eACA;iBACE;iBACA,UAAU;iBACV;;eAEF;iBACE;iBACA;mBACE;qBACE;qBACA;;;;;;;;;;iBAUJ,4BAA4B;WAClC;WACA;aACE;;;;iBAII,uCAAuC;WAC7C,SAAS;;WAET;WACA,YAAY,WAAW;aACrB;aACA;eACE;eACA,qCAAqC,uBAAuB,cAAc,eAAe;eACzF;;;WAGJ;;WAEA;WACA,YAAY,WAAW;aACrB;aACA;eACE;eACA,MAAM,WAAW;eACjB;;;WAGJ;;WAEA;WACA,YAAY,WAAW;aACrB;aACA;eACE;eACA,qCAAqC,wBAAwB,cAAc,gBAAgB;eAC3F;;;WAGJ;;;;iBAIM,qCAAqC,gBAAgB,6BAA6B,oCAAoC,4BAA4B,OAAO;WAC/J,cAAc;;WAEd;aACE;aACA,QAAQ,KAAK;eACX,cAAc;;eAEd;iBACE;mBACE;mBACA,IAAI;;;;;WAKZ;aACE;aACA,QAAQ,KAAK;eACX,cAAc;;eAEd;iBACE;mBACE;mBACA,IAAI;;iBAEN;mBACE;mBACA,IAAI;;;;;;;;;;;;;;;;;iBAiBN,uCAAuC,8BAA8B,+BAA+B,oCAAoC,4BAA4B;WAC1K,SAAS;;WAET,UAAU;WACV,cAAc;WACd;;WAEA;WACA;aACE;aACA;aACA,UAAU;aACV;;aAEA;aACA;aACA;aACA;;aAEA;aACA;aACA;aACA;;WAEF;aACE,SAAS;aACT;eACE;iBACE;iBACA;;;aAGJ;eACE;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA,qBAAqB;;;;eAI3B;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA,qBAAqB;;;;;;;;;cAS5B;WACH;WACA;WACA;WACA;WACA,mEAAmE;WACnE;aACE;eACE;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;mBACA;qBACE;uBACE;uBACA;uBACA;uBACA;uBACA;;;;iBAIN;mBACE;mBACA;qBACE;uBACE;uBACA;uBACA;uBACA;;;;;eAKR;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;yBACE;yBACA;yBACA;yBACA;yBACA;;;;mBAIN;qBACE;qBACA;uBACE;yBACE;yBACA;yBACA;yBACA;;;qBAGJ;uBACE;yBACE;yBACA;yBACA;2BACE;6BACE;6BACA;6BACA;;;;;qBAKR;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;;;aAKR;eACE;iBACE;iBACA;iBACA;mBACE;mBACA;mBACA;;iBAEF;mBACE;mBACA;qBACE;uBACE;uBACA;;;;;;aAMV,WAAW,SAAS,kEAAkE;aACtF,gEAAgE;aAChE;eACE;QACP;QACA;QACA;QACA;QACA;UACE;;QAEF,aAAa;QACb;UACE,2CAA2C;YACzC;4CACgC;;;;aAI/B;eACE;iBACE,MAAM,qCAAqC,wDAAwD;UAC1G;0CACgC;iBACzB,KAAK,qCAAqC,wDAAwD;UACzG;mBACS;0CACuB;iBACzB,SAAS,qCAAqC,wDAAwD;UAC7G;mBACS;0CACuB;iBACzB,QAAQ,oCAAoC,wDAAwD;UAC3G;mBACS,4CAA4C;mBAC5C,uCAAuC;mBACvC;mBACA;mBACA;mBACA;mBACA,UAAU;0CACa;iBACzB,QAAQ,oCAAoC,wDAAwD;mBAClG,2CAA2C;mBAC3C;mBACA;0CACuB;iBACzB,UAAU,qCAAqC,wDAAwD;UAC9G;0CACgC;iBACzB,gBAAgB,qCAAqC,wDAAwD;UACpH;0CACgC;iBACzB,OAAO,qCAAqC,wDAAwD;UAC3G,qCAAqC,uDAAuD;UAC5F,sCAAsC;0CACN;;eAE3B;iBACE,MAAM,qCAAqC,6DAA6D;UAC/G;0CACgC;iBACzB,KAAK,qCAAqC,6DAA6D;mBACrG;0CACuB;iBACzB,SAAS,qCAAqC,6DAA6D;mBACzG;0CACuB;iBACzB,WAAW,qCAAqC,6DAA6D;UACpH;mBACS;mBACA;mBACA;mBACA;mBACA;mBACA;0CACuB;iBACzB,UAAU,oCAAoC,6DAA6D;UAClH,sCAAsC,sBAtCnB,mDAsCiJ,iDAAiD,sBAApG,qBAA+K,sBAA0E,oBAA2E;0CACrZ;iBACzB,WAAW,oCAAoC,6DAA6D;UACnH,sCAAsC;0CACN;iBACzB,WAAW,oCAAoC,6DAA6D;UACnH,sCAAsC;0CACN;;;;WAI/B;aACE;aACA;eACE;;aAEF;;aAEA;aACA,uEAAuE;;aAEvE;aACA,uEAAuE;;aAEvE;aACA;eACE;;aAEF,uEAAuE;;aAEvE;aACA,uEAAuE;;aAEvE;aACA;eACE;;aAEF,uEAAuE;;WAEzE;aACE,yBAAyB;aACzB,gFAAgF;;;cAG/E,sBAAsB;WACzB;aACE;eACE,UAAU;eACV"}

package/dist/pack-gSvGQWqs.mjs

@@ -0,0 +1,80 @@
+import { f as sqlExpressionRegistration } from "./sql-expression-CKgKznXS.mjs";
+import { b as sqlAttributeSpecs } from "./psl-field-resolution-C5KQ7kzP-B0NwuRWV.mjs";
+import { a as sqlFamilyGeneratorDescriptors, i as sqlFamilyEntityTypes, n as sqlFamilyAuthoringFieldPresets, o as sqlFamilyGeneratorFunctions, r as sqlFamilyAuthoringTypes, s as sqlFamilyPslBlockDescriptors } from "./generator-functions-D_qdqBV--Bq296cED.mjs";
+import { TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG, TIMESTAMP_NOW_GENERATOR_ID, temporalAuthoringPresets, temporalPhaseTemplate, temporalPhaseTemplateWithParams } from "@prisma/orm-framework/components/authoring";
+//#region ../../../2-sql-family/9-family/dist/pack.mjs
+function temporalStringAuthoringPresets(input) {
+	const presets = temporalAuthoringPresets(input);
+	return {
+		createdAtString: presets.createdAt,
+		updatedAtString: presets.updatedAt
+	};
+}
+const PRECISION_PARAMS = { precision: {
+	kind: "arg",
+	index: 0
+} };
+/**
+* Builds a `temporal.<codec>` field preset for a codec that takes a precision
+* parameter (`pg/timestamp-temporal@1`, `pg/timestamptz-temporal@1`). Arguments change field
+* properties only — never the codec, which the caller fixes here.
+*
+* All three arguments are optional: omitting `precision` omits `typeParams`
+* entirely, and omitting a phase omits that phase (both omitted omits
+* `executionDefaults`). With `nowTakesPrecision`, the generator a `now` selects
+* also receives the precision as its `precision` param, so it can write a value
+* the column stores without rounding.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function temporalCodecPresetWithPrecision(input) {
+	const generatorId = input.generatorId ?? TIMESTAMP_NOW_GENERATOR_ID;
+	const phase = (index) => input.nowTakesPrecision === true ? temporalPhaseTemplateWithParams(index, generatorId, PRECISION_PARAMS) : temporalPhaseTemplate(index, generatorId);
+	return {
+		kind: "fieldPreset",
+		args: [
+			{
+				name: "precision",
+				kind: "value",
+				dataType: input.sizeType,
+				optional: true
+			},
+			TEMPORAL_ON_CREATE_ARG,
+			TEMPORAL_ON_UPDATE_ARG
+		],
+		output: {
+			codecId: input.codecId,
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} },
+			executionDefaults: {
+				onCreate: phase(1),
+				onUpdate: phase(2)
+			}
+		}
+	};
+}
+const sqlFamilyPack = {
+	kind: "family",
+	id: "sql",
+	familyId: "sql",
+	version: "0.0.1",
+	dataTypes: sqlExpressionRegistration.dataTypes,
+	authoring: {
+		field: sqlFamilyAuthoringFieldPresets,
+		type: sqlFamilyAuthoringTypes,
+		dataTypes: sqlExpressionRegistration.authoring.dataTypes,
+		entityTypes: sqlFamilyEntityTypes,
+		pslBlockDescriptors: sqlFamilyPslBlockDescriptors,
+		attributeSpecs: sqlAttributeSpecs
+	},
+	generatorFunctions: sqlFamilyGeneratorFunctions,
+	controlMutationDefaults: {
+		defaultFunctionRegistry: /* @__PURE__ */ new Map(),
+		generatorDescriptors: sqlFamilyGeneratorDescriptors
+	}
+};
+//#endregion
+export { temporalCodecPresetWithPrecision as n, temporalStringAuthoringPresets as r, sqlFamilyPack as t };
+
+//# sourceMappingURL=pack-gSvGQWqs.mjs.map

package/dist/pack-gSvGQWqs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-gSvGQWqs.mjs","names":[],"sources":["../../../../2-sql-family/9-family/dist/pack.mjs"],"sourcesContent":["import { a as sqlFamilyAuthoringTypes, c as sqlFamilyEntityTypes, i as sqlIntegerArgumentGeneratorFunctions, l as sqlFamilyPslBlockDescriptors, n as sqlFamilyGeneratorDescriptors, o as sqlTargetTypeConstructors, r as sqlFamilyGeneratorFunctions, s as sqlFamilyAuthoringFieldPresets, t as idGeneratorFunctionBindings } from \"./generator-functions-D_qdqBV-.mjs\";\nimport { sqlExpressionRegistration } from \"@internal/sql-contract/sql-expression\";\nimport { sqlAttributeSpecs } from \"@internal/sql-contract-psl/attribute-specs\";\nimport { TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG, TIMESTAMP_NOW_GENERATOR_ID, temporalAuthoringPresets, temporalPhaseTemplate, temporalPhaseTemplateWithParams } from \"@internal/framework-components/authoring\";\n//#region src/core/timestamp-now-generator.ts\nfunction temporalStringAuthoringPresets(input) {\n\tconst presets = temporalAuthoringPresets(input);\n\treturn {\n\t\tcreatedAtString: presets.createdAt,\n\t\tupdatedAtString: presets.updatedAt\n\t};\n}\nconst PRECISION_PARAMS = { precision: {\n\tkind: \"arg\",\n\tindex: 0\n} };\n/**\n* Builds a `temporal.<codec>` field preset for a codec that takes a precision\n* parameter (`pg/timestamp-temporal@1`, `pg/timestamptz-temporal@1`). Arguments change field\n* properties only — never the codec, which the caller fixes here.\n*\n* All three arguments are optional: omitting `precision` omits `typeParams`\n* entirely, and omitting a phase omits that phase (both omitted omits\n* `executionDefaults`). With `nowTakesPrecision`, the generator a `now` selects\n* also receives the precision as its `precision` param, so it can write a value\n* the column stores without rounding.\n*/\n/* @__NO_SIDE_EFFECTS__ */\nfunction temporalCodecPresetWithPrecision(input) {\n\tconst generatorId = input.generatorId ?? TIMESTAMP_NOW_GENERATOR_ID;\n\tconst phase = (index) => input.nowTakesPrecision === true ? temporalPhaseTemplateWithParams(index, generatorId, PRECISION_PARAMS) : temporalPhaseTemplate(index, generatorId);\n\treturn {\n\t\tkind: \"fieldPreset\",\n\t\targs: [\n\t\t\t{\n\t\t\t\tname: \"precision\",\n\t\t\t\tkind: \"value\",\n\t\t\t\tdataType: input.sizeType,\n\t\t\t\toptional: true\n\t\t\t},\n\t\t\tTEMPORAL_ON_CREATE_ARG,\n\t\t\tTEMPORAL_ON_UPDATE_ARG\n\t\t],\n\t\toutput: {\n\t\t\tcodecId: input.codecId,\n\t\t\ttypeParams: { precision: {\n\t\t\t\tkind: \"arg\",\n\t\t\t\tindex: 0\n\t\t\t} },\n\t\t\texecutionDefaults: {\n\t\t\t\tonCreate: phase(1),\n\t\t\t\tonUpdate: phase(2)\n\t\t\t}\n\t\t}\n\t};\n}\n//#endregion\n//#region src/exports/pack.ts\nconst sqlFamilyPack = {\n\tkind: \"family\",\n\tid: \"sql\",\n\tfamilyId: \"sql\",\n\tversion: \"0.0.1\",\n\tdataTypes: sqlExpressionRegistration.dataTypes,\n\tauthoring: {\n\t\tfield: sqlFamilyAuthoringFieldPresets,\n\t\ttype: sqlFamilyAuthoringTypes,\n\t\tdataTypes: sqlExpressionRegistration.authoring.dataTypes,\n\t\tentityTypes: sqlFamilyEntityTypes,\n\t\tpslBlockDescriptors: sqlFamilyPslBlockDescriptors,\n\t\tattributeSpecs: sqlAttributeSpecs\n\t},\n\tgeneratorFunctions: sqlFamilyGeneratorFunctions,\n\tcontrolMutationDefaults: {\n\t\tdefaultFunctionRegistry: /* @__PURE__ */ new Map(),\n\t\tgeneratorDescriptors: sqlFamilyGeneratorDescriptors\n\t}\n};\n//#endregion\nexport { sqlFamilyPack as default, idGeneratorFunctionBindings, sqlIntegerArgumentGeneratorFunctions, sqlTargetTypeConstructors, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets };\n\n//# sourceMappingURL=pack.mjs.map"],"mappings":";;;;;AAKA,SAAS,+BAA+B,OAAO;CAC9C,MAAM,UAAU,yBAAyB,KAAK;CAC9C,OAAO;EACN,iBAAiB,QAAQ;EACzB,iBAAiB,QAAQ;CAC1B;AACD;AACA,MAAM,mBAAmB,EAAE,WAAW;CACrC,MAAM;CACN,OAAO;AACR,EAAE;;;;;;;;;;;;;AAaF,SAAS,iCAAiC,OAAO;CAChD,MAAM,cAAc,MAAM,eAAe;CACzC,MAAM,SAAS,UAAU,MAAM,sBAAsB,OAAO,gCAAgC,OAAO,aAAa,gBAAgB,IAAI,sBAAsB,OAAO,WAAW;CAC5K,OAAO;EACN,MAAM;EACN,MAAM;GACL;IACC,MAAM;IACN,MAAM;IACN,UAAU,MAAM;IAChB,UAAU;GACX;GACA;GACA;EACD;EACA,QAAQ;GACP,SAAS,MAAM;GACf,YAAY,EAAE,WAAW;IACxB,MAAM;IACN,OAAO;GACR,EAAE;GACF,mBAAmB;IAClB,UAAU,MAAM,CAAC;IACjB,UAAU,MAAM,CAAC;GAClB;EACD;CACD;AACD;AAGA,MAAM,gBAAgB;CACrB,MAAM;CACN,IAAI;CACJ,UAAU;CACV,SAAS;CACT,WAAW,0BAA0B;CACrC,WAAW;EACV,OAAO;EACP,MAAM;EACN,WAAW,0BAA0B,UAAU;EAC/C,aAAa;EACb,qBAAqB;EACrB,gBAAgB;CACjB;CACA,oBAAoB;CACpB,yBAAyB;EACxB,yCAAyC,IAAI,IAAI;EACjD,sBAAsB;CACvB;AACD"}

package/dist/{plan-CDxduYaN-pLIyyJaB.d.mts → plan-Cr4azjnG-CuL8FqXC.d.mts}

@@ -1,12 +1,12 @@
-import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import "./types-UcHa2cTe.mjs";
-import { m as AnyQueryAst } from "./types-v3qxLLxo-DCeKv7yY.mjs";
+import { l as SqlStorage } from "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import "./types-CkAd8SWm.mjs";
+import { h as AnyQueryAst } from "./types-DriMIMNQ-BkbsW7w3.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
-import { QueryPlan } from "@prisma/orm-framework/components/runtime";
-//#region ../../../2-sql/4-lanes/relational-core/dist/plan-CDxduYaN.d.mts
+import { AsyncIterableResult, QueryPlan } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql-family/4-lanes/relational-core/dist/plan-Cr4azjnG.d.mts
 //#region src/plan.d.ts
 /**
- * SQL query plan produced by lanes before lowering.
+ * A SQL query plan produced by a lane before lowering.
  *
  * Lanes build ASTs and metadata but do not perform SQL lowering. The `sql`
  * field is absent — `RuntimeCore` (the runtime base class in
@@ -22,6 +22,10 @@ interface SqlQueryPlan<Row = unknown> extends QueryPlan<Row> {
   readonly ast: AnyQueryAst;
   readonly params: readonly unknown[];
 }
+interface Preparable<DbRow, Result> {
+  readonly plan: SqlQueryPlan<DbRow>;
+  consume(rows: AsyncIterableResult<DbRow>): Result;
+}
 /**
  * Wraps an `AnyQueryAst` (typically a `RawQueryAst`, minted by a raw statement
  * terminator or package-internally by an extension's migration factory) in a
@@ -42,5 +46,5 @@ interface SqlQueryPlan<Row = unknown> extends QueryPlan<Row> {
  */
 declare function planFromAst<Row = unknown>(ast: AnyQueryAst, contract: Contract<SqlStorage>, laneId?: string): SqlQueryPlan<Row>;
 //#endregion
-export { planFromAst as n, SqlQueryPlan as t };
-//# sourceMappingURL=plan-CDxduYaN-pLIyyJaB.d.mts.map
+export { SqlQueryPlan as n, planFromAst as r, Preparable as t };
+//# sourceMappingURL=plan-Cr4azjnG-CuL8FqXC.d.mts.map

package/dist/plan-Cr4azjnG-CuL8FqXC.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-Cr4azjnG-CuL8FqXC.d.mts","names":[],"sources":["../../../../2-sql-family/4-lanes/relational-core/dist/plan-Cr4azjnG.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAkBU,aAAa,uBAAuB,UAAU;WAC7C,KAAK;WACL;;UAED,WAAW,OAAO;WACjB,MAAM,aAAa;EAC5B,QAAQ,MAAM,oBAAoB,SAAS;;;;;;;;;;;;;;;;;;;;iBAoB5B,YAAY,eAAe,KAAK,aAAa,UAAU,SAAS,aAAa,kBAAkB,aAAa"}