@prisma/orm-family-sql 0.16.0-dev.36

package/dist/entity-handle-lowering-hook-CIvRKBfa.d.mts

@@ -0,0 +1,92 @@
+//#region ../../../2-sql/1-core/contract/dist/entity-handle-lowering-hook.d.mts
+//#region src/entity-handle-lowering-hook.d.ts
+/**
+ * SQL-family extension to the pack authoring contributions: a pack whose
+ * `entityTypes` registers entity kinds may implement a batch lowering hook
+ * that turns author-declared pack-entity handles (the generic `entities`
+ * list on the TS contract input) into `entries` rows.
+ *
+ * The generic contract build (`contract-ts`) owns the kind-agnostic walk: it
+ * groups handles by the pack that registered each `entityKind`, resolves
+ * each handle's declared model refs to storage table coordinates using the
+ * same model→table maps the relation lowering uses, and calls the owning
+ * pack's hook once with all of its claimed handles — batch, so the hook's
+ * diagnostics can see sibling handles. Neither the walk nor these types name
+ * any specific entity kind.
+ *
+ * SQL-family concept — the resolved-ref shape is a table coordinate, so the
+ * hook lives here beside {@link ../value-set-derivation-hook} instead of on
+ * the framework contributions type.
+ */
+/**
+ * An authored pack-entity handle: branded by the `entityKind` its owning
+ * pack registered, optionally declaring model refs under `refs` (actual
+ * model-handle objects, resolved by the generic walk before lowering).
+ */
+interface PackEntityHandle {
+  readonly entityKind: string;
+  readonly refs?: Readonly<Record<string, unknown>>;
+}
+/**
+ * A declared model ref after the generic walk resolved it: a storage table
+ * coordinate for a model of this contract, the coordinate plus `spaceId` for
+ * a cross-space (extensionModel) handle, or `unresolved` when the handle
+ * does not correspond to any model in the contract. `modelName` is carried
+ * for diagnostics where the handle declares one.
+ */
+type ResolvedEntityHandleRef = {
+  readonly kind: 'resolved';
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly modelName?: string;
+} | {
+  readonly kind: 'cross-space';
+  readonly spaceId: string;
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly modelName?: string;
+} | {
+  readonly kind: 'unresolved';
+  readonly modelName?: string;
+};
+/** One claimed handle paired with its resolved declared refs. */
+interface ResolvedPackEntityHandle {
+  readonly handle: PackEntityHandle;
+  readonly refs: Readonly<Record<string, ResolvedEntityHandleRef>>;
+}
+interface EntityHandleLoweringInput {
+  /** Every handle in the `entities` list whose `entityKind` this pack registered, in authored order. */
+  readonly handles: readonly ResolvedPackEntityHandle[];
+  readonly defaultNamespaceId: string;
+}
+/** One lowered entity row: filed into `storage.namespaces[namespaceId].entries[entityKind][key]`. */
+interface LoweredPackEntity {
+  readonly namespaceId: string;
+  readonly entityKind: string;
+  readonly key: string;
+  readonly entity: unknown;
+}
+interface SqlEntityHandleLoweringContribution {
+  /**
+   * Method syntax keeps the declaration bivariant, so a pack's concretely
+   * typed implementation stays structurally compatible (the same convention
+   * as `SqlValueSetDerivingEntityTypeOutput.deriveValueSet`).
+   */
+  lowerEntityHandles(input: EntityHandleLoweringInput): readonly LoweredPackEntity[];
+}
+/** Structural check for {@link SqlEntityHandleLoweringContribution}: no casts. */
+declare function providesEntityHandleLowering(authoring: unknown): authoring is SqlEntityHandleLoweringContribution;
+/**
+ * PSL-side twin of {@link ResolvedEntityHandleRef}: the family interpreter
+ * resolves an extension block's descriptor-declared model ref parameters
+ * (`{ kind: 'ref', refKind: 'model' }`) to storage table names and annotates
+ * the block with this map (keyed by parameter name) before invoking the
+ * entity factory. An unresolved required ref is the interpreter's
+ * diagnostic; a factory never sees one.
+ */
+type ResolvedPslModelRefs = Readonly<Record<string, {
+  readonly tableName: string;
+}>>;
+//#endregion
+export { ResolvedPackEntityHandle as a, providesEntityHandleLowering as c, ResolvedEntityHandleRef as i, LoweredPackEntity as n, ResolvedPslModelRefs as o, PackEntityHandle as r, SqlEntityHandleLoweringContribution as s, EntityHandleLoweringInput as t };
+//# sourceMappingURL=entity-handle-lowering-hook-CIvRKBfa.d.mts.map

package/dist/entity-handle-lowering-hook-CIvRKBfa.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-handle-lowering-hook-CIvRKBfa.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/entity-handle-lowering-hook.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;UAwBU;WACC;WACA,OAAO,SAAS;;;;;;;;;KAStB;WACM;WACA;WACA;WACA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;WACA;;;UAGD;WACC,QAAQ;WACR,MAAM,SAAS,eAAe;;UAE/B;;WAEC,kBAAkB;WAClB;;;UAGD;WACC;WACA;WACA;WACA;;UAED;;;;;;EAMR,mBAAmB,OAAO,qCAAqC;;;iBAGhD,6BAA6B,qBAAqB,aAAa;;;;;;;;;KAS3E,uBAAuB,SAAS;WAC1B"}

package/dist/entity-handle-lowering-hook-DwLIKNiS.mjs

@@ -0,0 +1,11 @@
+//#region ../../../2-sql/1-core/contract/dist/entity-handle-lowering-hook.mjs
+/** Structural check for {@link SqlEntityHandleLoweringContribution}: no casts. */
+function providesEntityHandleLowering(authoring) {
+	if (typeof authoring !== "object" || authoring === null || !("lowerEntityHandles" in authoring)) return false;
+	const { lowerEntityHandles } = authoring;
+	return typeof lowerEntityHandles === "function";
+}
+//#endregion
+export { providesEntityHandleLowering as t };
+
+//# sourceMappingURL=entity-handle-lowering-hook-DwLIKNiS.mjs.map

package/dist/entity-handle-lowering-hook-DwLIKNiS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-handle-lowering-hook-DwLIKNiS.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/entity-handle-lowering-hook.mjs"],"sourcesContent":["//#region src/entity-handle-lowering-hook.ts\n/** Structural check for {@link SqlEntityHandleLoweringContribution}: no casts. */\nfunction providesEntityHandleLowering(authoring) {\n\tif (typeof authoring !== \"object\" || authoring === null || !(\"lowerEntityHandles\" in authoring)) return false;\n\tconst { lowerEntityHandles } = authoring;\n\treturn typeof lowerEntityHandles === \"function\";\n}\n//#endregion\nexport { providesEntityHandleLowering };\n\n//# sourceMappingURL=entity-handle-lowering-hook.mjs.map"],"mappings":";;AAEA,SAAS,6BAA6B,WAAW;CAChD,IAAI,OAAO,cAAc,YAAY,cAAc,QAAQ,EAAE,wBAAwB,YAAY,OAAO;CACxG,MAAM,EAAE,uBAAuB;CAC/B,OAAO,OAAO,uBAAuB;AACtC"}

package/dist/entity-kinds-DKxwKolf-CcsY-iYV.mjs

@@ -0,0 +1,136 @@
+import { t as contractError } from "./contract-errors-BCN6RVI5-5IHBF_lg.mjs";
+import { c as StorageTable, i as Index } from "./storage-table-_LWDmPfv-DFhU2dML.mjs";
+import { n as indexInputFromSerialized, t as StorageValueSet } from "./serialized-index-Dp5_EjXD-DMsw8jf3.mjs";
+import { type } from "arktype";
+//#region ../../../2-sql/1-core/contract/dist/entity-kinds-DKxwKolf.mjs
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+const ColumnDefaultLiteralSchema = type.declare().type({
+	kind: literalKindSchema,
+	value: "string | number | boolean | null | unknown[] | Record<string, unknown>"
+});
+const ColumnDefaultFunctionSchema = type.declare().type({
+	kind: functionKindSchema,
+	expression: "string"
+});
+const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+const StorageValueSetRefSchema = type({
+	plane: "'storage'",
+	namespaceId: "string",
+	entityKind: "'valueSet'",
+	entityName: "string",
+	"spaceId?": "string"
+});
+const StorageColumnSchema = type({
+	"+": "reject",
+	nativeType: "string",
+	codecId: "string",
+	nullable: "boolean",
+	"many?": "boolean",
+	"typeParams?": "Record<string, unknown>",
+	"typeRef?": "string",
+	"default?": ColumnDefaultSchema,
+	"control?": ControlPolicySchema,
+	"valueSet?": StorageValueSetRefSchema
+}).narrow((col, ctx) => {
+	if (col.typeParams !== void 0 && col.typeRef !== void 0) return ctx.mustBe("a column with either typeParams or typeRef, not both");
+	return true;
+});
+/**
+* Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
+* Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
+* ordered `values` array of codec-encoded permitted values.
+*/
+const StorageValueSetSchema = type({
+	kind: "'valueSet'",
+	values: type("string | number | boolean | null | unknown[] | Record<string, unknown>").array().readonly()
+});
+const PrimaryKeySchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const UniqueConstraintSchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const IndexSchema = type({
+	name: "string",
+	"prefix?": "string",
+	"columns?": type.string.array().readonly(),
+	"expression?": "string",
+	"where?": "string",
+	unique: "boolean",
+	"type?": "string",
+	"options?": "Record<string, unknown>"
+});
+const ForeignKeyReferenceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly(),
+	"spaceId?": "string"
+});
+const ForeignKeySourceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly()
+});
+const ReferentialActionSchema = type.declare().type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+const ForeignKeySchema = type.declare().type({
+	source: ForeignKeySourceSchema,
+	target: ForeignKeyReferenceSchema,
+	"name?": "string",
+	"onDelete?": ReferentialActionSchema,
+	"onUpdate?": ReferentialActionSchema
+});
+const CheckConstraintSchema = type({
+	"+": "reject",
+	name: "string",
+	column: "string",
+	valueSet: StorageValueSetRefSchema
+});
+const StorageTableSchema = type({
+	"+": "reject",
+	columns: type({ "[string]": StorageColumnSchema }),
+	"primaryKey?": PrimaryKeySchema,
+	uniques: UniqueConstraintSchema.array().readonly(),
+	indexes: IndexSchema.array().readonly(),
+	foreignKeys: ForeignKeySchema.array().readonly(),
+	"control?": ControlPolicySchema,
+	"checks?": CheckConstraintSchema.array().readonly()
+});
+const tableEntityKind = {
+	kind: "table",
+	schema: StorageTableSchema,
+	construct: (input) => new StorageTable({
+		...input,
+		indexes: input.indexes.map((i) => i instanceof Index ? i : indexInputFromSerialized(i))
+	})
+};
+const valueSetEntityKind = {
+	kind: "valueSet",
+	schema: StorageValueSetSchema,
+	construct: (input) => new StorageValueSet(input)
+};
+/**
+* Assembles the `kind → descriptor` registry for SQL namespaces: the built-in
+* `table` and `valueSet` kinds plus any target `packKinds`. This builds the
+* lookup table — it does not touch contract data. `hydrateNamespaceEntities`
+* later consumes this registry to turn a namespace's raw entries into IR
+* instances, and `createSqlContractSchema` derives validation from the same
+* registry. Throws on a duplicate kind.
+*/
+function composeSqlEntityKinds(packKinds = []) {
+	const kinds = /* @__PURE__ */ new Map([["table", tableEntityKind], ["valueSet", valueSetEntityKind]]);
+	for (const descriptor of packKinds) {
+		if (kinds.has(descriptor.kind)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `composeSqlEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`, { meta: { entityKind: descriptor.kind } });
+		kinds.set(descriptor.kind, descriptor);
+	}
+	return kinds;
+}
+//#endregion
+export { ForeignKeyReferenceSchema as a, IndexSchema as c, StorageValueSetSchema as d, composeSqlEntityKinds as f, ColumnDefaultSchema as i, ReferentialActionSchema as l, valueSetEntityKind as m, ColumnDefaultFunctionSchema as n, ForeignKeySchema as o, tableEntityKind as p, ColumnDefaultLiteralSchema as r, ForeignKeySourceSchema as s, CheckConstraintSchema as t, StorageTableSchema as u };
+
+//# sourceMappingURL=entity-kinds-DKxwKolf-CcsY-iYV.mjs.map

package/dist/entity-kinds-DKxwKolf-CcsY-iYV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-DKxwKolf-CcsY-iYV.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/entity-kinds-DKxwKolf.mjs"],"sourcesContent":["import { t as contractError } from \"./contract-errors-BCN6RVI5.mjs\";\nimport { c as Index, t as StorageTable } from \"./storage-table-_LWDmPfv.mjs\";\nimport { n as StorageValueSet, t as indexInputFromSerialized } from \"./serialized-index-Dp5_EjXD.mjs\";\nimport { type } from \"arktype\";\n//#region src/ir/storage-entry-schemas.ts\nconst literalKindSchema = type(\"'literal'\");\nconst functionKindSchema = type(\"'function'\");\nconst ControlPolicySchema = type(\"'managed' | 'tolerated' | 'external' | 'observed'\");\nconst ColumnDefaultLiteralSchema = type.declare().type({\n\tkind: literalKindSchema,\n\tvalue: \"string | number | boolean | null | unknown[] | Record<string, unknown>\"\n});\nconst ColumnDefaultFunctionSchema = type.declare().type({\n\tkind: functionKindSchema,\n\texpression: \"string\"\n});\nconst ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);\nconst StorageValueSetRefSchema = type({\n\tplane: \"'storage'\",\n\tnamespaceId: \"string\",\n\tentityKind: \"'valueSet'\",\n\tentityName: \"string\",\n\t\"spaceId?\": \"string\"\n});\nconst StorageColumnSchema = type({\n\t\"+\": \"reject\",\n\tnativeType: \"string\",\n\tcodecId: \"string\",\n\tnullable: \"boolean\",\n\t\"many?\": \"boolean\",\n\t\"typeParams?\": \"Record<string, unknown>\",\n\t\"typeRef?\": \"string\",\n\t\"default?\": ColumnDefaultSchema,\n\t\"control?\": ControlPolicySchema,\n\t\"valueSet?\": StorageValueSetRefSchema\n}).narrow((col, ctx) => {\n\tif (col.typeParams !== void 0 && col.typeRef !== void 0) return ctx.mustBe(\"a column with either typeParams or typeRef, not both\");\n\treturn true;\n});\n/**\n* Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.\n* Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an\n* ordered `values` array of codec-encoded permitted values.\n*/\nconst StorageValueSetSchema = type({\n\tkind: \"'valueSet'\",\n\tvalues: type(\"string | number | boolean | null | unknown[] | Record<string, unknown>\").array().readonly()\n});\nconst PrimaryKeySchema = type.declare().type({\n\tcolumns: type.string.array().readonly(),\n\t\"name?\": \"string\"\n});\nconst UniqueConstraintSchema = type.declare().type({\n\tcolumns: type.string.array().readonly(),\n\t\"name?\": \"string\"\n});\nconst IndexSchema = type({\n\tname: \"string\",\n\t\"prefix?\": \"string\",\n\t\"columns?\": type.string.array().readonly(),\n\t\"expression?\": \"string\",\n\t\"where?\": \"string\",\n\tunique: \"boolean\",\n\t\"type?\": \"string\",\n\t\"options?\": \"Record<string, unknown>\"\n});\nconst ForeignKeyReferenceSchema = type({\n\t\"+\": \"reject\",\n\tnamespaceId: \"string\",\n\ttableName: \"string\",\n\tcolumns: type.string.array().readonly(),\n\t\"spaceId?\": \"string\"\n});\nconst ForeignKeySourceSchema = type({\n\t\"+\": \"reject\",\n\tnamespaceId: \"string\",\n\ttableName: \"string\",\n\tcolumns: type.string.array().readonly()\n});\nconst ReferentialActionSchema = type.declare().type(\"'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'\");\nconst ForeignKeySchema = type.declare().type({\n\tsource: ForeignKeySourceSchema,\n\ttarget: ForeignKeyReferenceSchema,\n\t\"name?\": \"string\",\n\t\"onDelete?\": ReferentialActionSchema,\n\t\"onUpdate?\": ReferentialActionSchema\n});\nconst CheckConstraintSchema = type({\n\t\"+\": \"reject\",\n\tname: \"string\",\n\tcolumn: \"string\",\n\tvalueSet: StorageValueSetRefSchema\n});\nconst StorageTableSchema = type({\n\t\"+\": \"reject\",\n\tcolumns: type({ \"[string]\": StorageColumnSchema }),\n\t\"primaryKey?\": PrimaryKeySchema,\n\tuniques: UniqueConstraintSchema.array().readonly(),\n\tindexes: IndexSchema.array().readonly(),\n\tforeignKeys: ForeignKeySchema.array().readonly(),\n\t\"control?\": ControlPolicySchema,\n\t\"checks?\": CheckConstraintSchema.array().readonly()\n});\n//#endregion\n//#region src/entity-kinds.ts\nconst tableEntityKind = {\n\tkind: \"table\",\n\tschema: StorageTableSchema,\n\tconstruct: (input) => new StorageTable({\n\t\t...input,\n\t\tindexes: input.indexes.map((i) => i instanceof Index ? i : indexInputFromSerialized(i))\n\t})\n};\nconst valueSetEntityKind = {\n\tkind: \"valueSet\",\n\tschema: StorageValueSetSchema,\n\tconstruct: (input) => new StorageValueSet(input)\n};\n/**\n* Assembles the `kind → descriptor` registry for SQL namespaces: the built-in\n* `table` and `valueSet` kinds plus any target `packKinds`. This builds the\n* lookup table — it does not touch contract data. `hydrateNamespaceEntities`\n* later consumes this registry to turn a namespace's raw entries into IR\n* instances, and `createSqlContractSchema` derives validation from the same\n* registry. Throws on a duplicate kind.\n*/\nfunction composeSqlEntityKinds(packKinds = []) {\n\tconst kinds = /* @__PURE__ */ new Map([[\"table\", tableEntityKind], [\"valueSet\", valueSetEntityKind]]);\n\tfor (const descriptor of packKinds) {\n\t\tif (kinds.has(descriptor.kind)) throw contractError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `composeSqlEntityKinds: duplicate entity kind \"${descriptor.kind}\" — each kind may be registered only once`, { meta: { entityKind: descriptor.kind } });\n\t\tkinds.set(descriptor.kind, descriptor);\n\t}\n\treturn kinds;\n}\n//#endregion\nexport { ColumnDefaultFunctionSchema as a, ForeignKeyReferenceSchema as c, IndexSchema as d, ReferentialActionSchema as f, CheckConstraintSchema as i, ForeignKeySchema as l, StorageValueSetSchema as m, tableEntityKind as n, ColumnDefaultLiteralSchema as o, StorageTableSchema as p, valueSetEntityKind as r, ColumnDefaultSchema as s, composeSqlEntityKinds as t, ForeignKeySourceSchema as u };\n\n//# sourceMappingURL=entity-kinds-DKxwKolf.mjs.map"],"mappings":"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"}

package/dist/entity-kinds-Dh6VH4uK.d.mts

@@ -0,0 +1,29 @@
+import { t as Index } from "./sql-index-DsI8HAeK-BJsn-jvD.mjs";
+import { a as StorageTable, o as StorageTableInput } from "./storage-table-BBaAmanc-BwR37LMA.mjs";
+import { n as StorageValueSetInput, t as StorageValueSet } from "./storage-value-set-BGlj5Uus-CvZD--GG.mjs";
+import { t as SerializedIndex } from "./serialized-index-B96AwqtU-DcqcB4q_.mjs";
+import { AnyEntityKindDescriptor, EntityKindDescriptor } from "@prisma/orm-framework/components/ir";
+//#region ../../../2-sql/1-core/contract/dist/entity-kinds.d.mts
+//#region src/entity-kinds.d.ts
+/**
+ * A table entry as it reaches hydration: from `contract.json` its indexes are
+ * still the stored flat records, from authoring they are already `Index`
+ * nodes.
+ */
+type HydratableStorageTable = Omit<StorageTableInput, 'indexes'> & {
+  readonly indexes: ReadonlyArray<Index | SerializedIndex>;
+};
+declare const tableEntityKind: EntityKindDescriptor<HydratableStorageTable, StorageTable>;
+declare const valueSetEntityKind: EntityKindDescriptor<StorageValueSetInput, StorageValueSet>;
+/**
+ * Assembles the `kind → descriptor` registry for SQL namespaces: the built-in
+ * `table` and `valueSet` kinds plus any target `packKinds`. This builds the
+ * lookup table — it does not touch contract data. `hydrateNamespaceEntities`
+ * later consumes this registry to turn a namespace's raw entries into IR
+ * instances, and `createSqlContractSchema` derives validation from the same
+ * registry. Throws on a duplicate kind.
+ */
+declare function composeSqlEntityKinds(packKinds?: readonly AnyEntityKindDescriptor[]): ReadonlyMap<string, AnyEntityKindDescriptor>;
+//#endregion
+export { tableEntityKind as n, valueSetEntityKind as r, composeSqlEntityKinds as t };
+//# sourceMappingURL=entity-kinds-Dh6VH4uK.d.mts.map

package/dist/entity-kinds-Dh6VH4uK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-Dh6VH4uK.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/entity-kinds.d.mts"],"mappings":";;;;;;;;;;;;KAWK,yBAAyB,KAAK;WACxB,SAAS,cAAc,QAAQ;;cAE5B,iBAAiB,qBAAqB,wBAAwB;cAC9D,oBAAoB,qBAAqB,sBAAsB;;;;;;;;;iBAS5D,sBAAsB,qBAAqB,4BAA4B,oBAAoB"}

package/dist/errors-B5g0xWro-mWH2C07F.mjs

@@ -0,0 +1,9 @@
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+//#region ../../../2-sql/9-family/dist/errors-B5g0xWro.mjs
+function sqlFamilyError(code, message, options) {
+	return structuredError(code, message, options);
+}
+//#endregion
+export { sqlFamilyError as t };
+
+//# sourceMappingURL=errors-B5g0xWro-mWH2C07F.mjs.map

package/dist/errors-B5g0xWro-mWH2C07F.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-B5g0xWro-mWH2C07F.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/errors-B5g0xWro.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\n//#region src/core/errors.ts\nfunction sqlFamilyError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\n//#endregion\nexport { sqlFamilyError as t };\n\n//# sourceMappingURL=errors-B5g0xWro.mjs.map"],"mappings":";;AAEA,SAAS,eAAe,MAAM,SAAS,SAAS;CAC/C,OAAO,gBAAgB,MAAM,SAAS,OAAO;AAC9C"}

package/dist/errors.d.mts

@@ -0,0 +1,63 @@
+//#region ../../../2-sql/1-core/errors/dist/index.d.mts
+//#region src/errors.d.ts
+interface SqlDriverError<Kind extends string> {
+  readonly kind: Kind;
+}
+/**
+ * SQL query error for query-related failures (syntax errors, constraint violations, permissions).
+ */
+declare class SqlQueryError extends Error implements SqlDriverError<'sql_query'> {
+  static readonly ERROR_NAME: "SqlQueryError";
+  readonly kind: "sql_query";
+  readonly sqlState: string | undefined;
+  readonly constraint: string | undefined;
+  readonly table: string | undefined;
+  readonly column: string | undefined;
+  readonly detail: string | undefined;
+  constructor(message: string, options?: {
+    readonly cause?: Error;
+    readonly sqlState?: string;
+    readonly constraint?: string;
+    readonly table?: string;
+    readonly column?: string;
+    readonly detail?: string;
+  });
+  /**
+   * Type predicate to check if an error is a SqlQueryError.
+   */
+  static is(error: unknown): error is SqlQueryError;
+}
+/**
+ * SQLSTATE for a unique-constraint / primary-key violation — the SQL-standard
+ * `unique_violation` class. Drivers normalize their target-specific codes (e.g.
+ * Postgres `23505`, SQLite `SQLITE_CONSTRAINT_UNIQUE`/`PRIMARYKEY`) onto this
+ * value on {@link SqlQueryError.sqlState}, so consumers classify violations
+ * without knowing any target-specific error shape.
+ */
+declare const UNIQUE_VIOLATION_SQLSTATE = "23505";
+/**
+ * Whether an error is a unique-constraint (or primary-key) violation, decided
+ * solely from the driver-normalized {@link SqlQueryError.sqlState}. Raw driver
+ * errors that were never normalized are not classified — callers run behind the
+ * driver, which always normalizes before the error escapes.
+ */
+declare function isUniqueConstraintViolation(error: unknown): boolean;
+/**
+ * SQL connection error (timeouts, connection resets, etc.).
+ */
+declare class SqlConnectionError extends Error implements SqlDriverError<'sql_connection'> {
+  static readonly ERROR_NAME: "SqlConnectionError";
+  readonly kind: "sql_connection";
+  readonly transient: boolean | undefined;
+  constructor(message: string, options?: {
+    readonly cause?: Error;
+    readonly transient?: boolean;
+  });
+  /**
+   * Type predicate to check if an error is a SqlConnectionError.
+   */
+  static is(error: unknown): error is SqlConnectionError;
+}
+//#endregion
+export { SqlConnectionError, SqlQueryError, UNIQUE_VIOLATION_SQLSTATE, isUniqueConstraintViolation };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../../../2-sql/1-core/errors/dist/index.d.mts"],"mappings":";;UACU,eAAe;WACd,MAAM;;;;;cAKH,sBAAsB,iBAAiB;kBACnC;WACP;WACA;WACA;WACA;WACA;WACA;EACT,YAAY,iBAAiB;aAClB,QAAQ;aACR;aACA;aACA;aACA;aACA;;;;;SAKJ,GAAG,iBAAiB,SAAS;;;;;;;;;cASxB;;;;;;;iBAOG,4BAA4B;;;;cAI/B,2BAA2B,iBAAiB;kBACxC;WACP;WACA;EACT,YAAY,iBAAiB;aAClB,QAAQ;aACR;;;;;SAKJ,GAAG,iBAAiB,SAAS"}

package/dist/errors.mjs

@@ -0,0 +1,2 @@
+import { i as isUniqueConstraintViolation, n as SqlQueryError, r as UNIQUE_VIOLATION_SQLSTATE, t as SqlConnectionError } from "./dist-x6jvtkKM.mjs";
+export { SqlConnectionError, SqlQueryError, UNIQUE_VIOLATION_SQLSTATE, isUniqueConstraintViolation };

package/dist/expression-DIf8F4Mc.d.mts

@@ -0,0 +1,167 @@
+import { a as CodecRef$1 } from "./codec-types-MOaceoPi-C5eL2sao.mjs";
+import { _ as QueryOperationReturn } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import "./types-BchwQpmO.mjs";
+import { t as SqlLoweringSpec } from "./index-BgaTJRxj.mjs";
+import { at as ParamRef, dt as RawSqlLiteral, o as AnyExpression } from "./types-DIBA80mc-wf5wLmON.mjs";
+import { ParamSpec } from "@prisma/orm-framework/operations";
+//#region ../../../2-sql/4-lanes/relational-core/dist/exports/expression.d.mts
+//#region src/expression.d.ts
+type ScopeField = {
+  codecId: string;
+  nullable: boolean;
+  /**
+   * 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).
+   */
+  codec?: CodecRef$1;
+};
+type CodecTypesBase = Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>;
+/**
+ * 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.
+ */
+type Expression<T extends ScopeField> = QueryOperationReturn & {
+  readonly returnType: T;
+  buildAst(): AnyExpression;
+};
+type CodecIdsWithTrait<CT extends Record<string, {
+  readonly input: unknown;
+}>, RequiredTraits extends readonly string[]> = { [K in keyof CT & string]: CT[K] extends {
+  readonly traits: infer T;
+} ? [RequiredTraits[number]] extends [T] ? K : never : never; }[keyof CT & string];
+type NullSuffix<N> = N extends true ? null : never;
+/**
+ * Runtime value type for a slot bound to `CodecId` with the given
+ * nullability — `CT[CodecId]['input']`, plus `null` when `Nullable` is true.
+ */
+type CodecValue<CodecId extends string, Nullable extends boolean, CT extends Record<string, {
+  readonly input: unknown;
+}>> = (CodecId extends keyof CT ? CT[CodecId]['input'] : never) | NullSuffix<Nullable>;
+/**
+ * An expression or literal value targeting a specific codec.
+ *
+ * Accepts any of:
+ * - An `Expression` whose codec matches exactly
+ * - A raw JS value of the codec's `input` type
+ * - `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`.
+ */
+type CodecExpression<CodecId extends string, Nullable extends boolean, CT extends Record<string, {
+  readonly input: unknown;
+}>> = 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`.
+ */
+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.
+ *
+ * Resolves the trait set to the union of matching codec identities via `CodecIdsWithTrait`, then reuses `CodecExpression` for the codec-id form.
+ */
+type TraitExpression<Traits extends readonly string[], Nullable extends boolean, CT extends Record<string, {
+  readonly input: unknown;
+}>> = CodecExpression<CodecIdsWithTrait<CT, Traits>, Nullable, CT>;
+/**
+ * Resolve a raw value or an Expression into an AST expression node.
+ *
+ * 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.
+ *
+ * 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)`).
+ */
+declare function toExpr(value: unknown, codec?: CodecRef$1): AnyExpression;
+/**
+ * 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' })`.
+ */
+declare function param<T>(value: T, opts: {
+  codecId: string;
+}): ParamRef;
+/**
+ * Derive the {@link CodecRef} carried by an expression-like value.
+ *
+ * Resolution order:
+ * 1. `wrapper.codec` — explicit column-bound {@link CodecRef} stamped at field-proxy time.
+ * 2. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.
+ * 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).
+ *
+ * Returns `undefined` for raw scalar values (non-expression-like).
+ */
+declare function codecOf(value: unknown): CodecRef$1 | undefined;
+interface BuildOperationSpec<R extends ScopeField> {
+  readonly method: string;
+  /**
+   * 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.
+   */
+  readonly args: readonly [AnyExpression, ...AnyExpression[]];
+  readonly returns: R & ParamSpec;
+  readonly lowering: SqlLoweringSpec;
+}
+/**
+ * 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.
+ */
+declare function buildOperation<R extends ScopeField>(spec: BuildOperationSpec<R>): Expression<R>;
+/**
+ * Resolves a codec id for a bare JavaScript value interpolated into a raw-SQL
+ * template — e.g. `` rawSql`SELECT ${42}` `` calls `inferCodec(42)` to pick
+ * the codec id (`pg/int4`, `sqlite/integer@1`, etc.) that will encode the
+ * value as a bound parameter.
+ *
+ * Targets implement this once per dialect: examine the JS value's runtime
+ * shape (number, bigint, string, boolean, `Uint8Array`) and return a codec
+ * id known to the target's codec registry. Throw when the value falls
+ * outside the supported set — callers should wrap such values with
+ * `param(value, { codecId })` to declare the codec explicitly.
+ */
+interface RawCodecInferer {
+  inferCodec(value: RawSqlLiteral): string;
+}
+/** The one-method builder returned by a `RawSqlTag` template call before `.returns()` is called. */
+interface RawSqlBuilder {
+  returns<S extends string>(spec: S): Expression<{
+    codecId: S;
+    nullable: false;
+  }>;
+  returns<S extends string, N extends boolean = false>(spec: {
+    readonly codecId: S;
+    readonly nullable?: N;
+  }): Expression<{
+    codecId: S;
+    nullable: N;
+  }>;
+}
+/** Tagged-template function returned by {@link createRawSql}. */
+type RawSqlTag = (strings: TemplateStringsArray, ...values: RawSqlInterpolation[]) => RawSqlBuilder;
+type RawSqlInterpolation = Expression<ScopeField> | ParamRef | RawSqlLiteral;
+/**
+ * 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}.
+ *
+ * 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`).
+ */
+declare function createRawSql(adapter: RawCodecInferer): RawSqlTag;
+//#endregion
+export { Expression as a, RawSqlTag as c, TraitExpression as d, buildOperation as f, toExpr as g, param as h, CodecValue as i, ScalarListExpression as l, createRawSql as m, CodecExpression as n, RawCodecInferer as o, codecOf as p, CodecTypesBase as r, RawSqlBuilder as s, BuildOperationSpec as t, ScopeField as u };
+//# sourceMappingURL=expression-DIf8F4Mc.d.mts.map

package/dist/expression-DIf8F4Mc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-DIf8F4Mc.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/expression.d.mts"],"mappings":";;;;;;;;KAMK;EACH;EACA;;;;;;;;EAQA;;;;EAIA,QAAQ;;KAEL,iBAAiB;WACX;WACA;;;;;KAKN,WAAW,UAAU,cAAc;WAC7B,YAAY;EACrB,YAAY;;KAET,kBAAkB,WAAW;WACvB;IACP,+CAA+C,WAAW,cAAc,GAAG;WACpE,cAAc;KACpB,iCAAiC,KAAK,2BAA2B;KACjE,WAAW,KAAK;;;;;KAKhB,WAAW,wBAAwB,0BAA0B,WAAW;WAClE;OACJ,sBAAsB,KAAK,GAAG,6BAA6B,WAAW;;;;;;;;;;;;;;;KAexE,gBAAgB,wBAAwB,0BAA0B,WAAW;WACvE;MACL;EACJ,SAAS;EACT,UAAU;EACV;KACG,WAAW,SAAS,UAAU;;;;;;;KAO9B,qBAAqB,wBAAwB,4BAA4B;EAC5E,SAAS;EACT,UAAU;EACV;;;;;;;KAOG,gBAAgB,kCAAkC,0BAA0B,WAAW;WACjF;MACL,gBAAgB,kBAAkB,IAAI,SAAS,UAAU;;;;;;;;iBAQ9C,OAAO,gBAAgB,QAAQ,aAAW;;;;iBAI1C,MAAM,GAAG,OAAO,GAAG;EAClC;IACE;;;;;;;;;;;iBAWa,QAAQ,iBAAiB;UAChC,mBAAmB,UAAU;WAC5B;;;;WAIA,gBAAgB,kBAAkB;WAClC,SAAS,IAAI;WACb,UAAU;;;;;iBAKJ,eAAe,UAAU,YAAY,MAAM,mBAAmB,KAAK,WAAW;;;;;;;;;;;;;UAarF;EACR,WAAW,OAAO;;;UAGV;EACR,QAAQ,kBAAkB,MAAM,IAAI;IAClC,SAAS;IACT;;EAEF,QAAQ,kBAAkB,2BAA2B;aAC1C,SAAS;aACT,WAAW;MAClB;IACF,SAAS;IACT,UAAU;;;;KAIT,aAAa,SAAS,yBAAyB,QAAQ,0BAA0B;KACjF,sBAAsB,WAAW,cAAc,WAAW;;;;;;iBAM9C,aAAa,SAAS,kBAAkB"}