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

package/dist/ddl-types-BMp2bWVS-D1waZJ4n.mjs

@@ -0,0 +1,153 @@
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { isColumnDefaultLiteralInputValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql/4-lanes/relational-core/dist/ddl-types-BMp2bWVS.mjs
+var DdlColumnDefault = class {
+	freeze() {
+		Object.freeze(this);
+	}
+};
+var LiteralColumnDefault = class extends DdlColumnDefault {
+	kind = "literal";
+	value;
+	constructor(value) {
+		super();
+		if (!isColumnDefaultLiteralInputValue(value)) throw structuredError("CONTRACT.DEFAULT_INVALID", "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-BMp2bWVS-D1waZJ4n.mjs.map

package/dist/ddl-types-BMp2bWVS-D1waZJ4n.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl-types-BMp2bWVS-D1waZJ4n.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/ddl-types-BMp2bWVS.mjs"],"sourcesContent":["import { isColumnDefaultLiteralInputValue } from \"@internal/contract/types\";\nimport { structuredError } from \"@internal/utils/structured-error\";\n//#region src/ast/ddl-types.ts\nvar DdlColumnDefault = class {\n\tfreeze() {\n\t\tObject.freeze(this);\n\t}\n};\nvar LiteralColumnDefault = class extends DdlColumnDefault {\n\tkind = \"literal\";\n\tvalue;\n\tconstructor(value) {\n\t\tsuper();\n\t\tif (!isColumnDefaultLiteralInputValue(value)) throw structuredError(\"CONTRACT.DEFAULT_INVALID\", \"Invalid column default literal value\");\n\t\tthis.value = value;\n\t\tthis.freeze();\n\t}\n\taccept(visitor, ctx) {\n\t\treturn visitor.literal(this, ctx);\n\t}\n};\nvar FunctionColumnDefault = class extends DdlColumnDefault {\n\tkind = \"function\";\n\texpression;\n\tconstructor(expression) {\n\t\tsuper();\n\t\tthis.expression = expression;\n\t\tthis.freeze();\n\t}\n\taccept(visitor, ctx) {\n\t\treturn visitor.function(this, ctx);\n\t}\n};\nvar DdlColumn = class {\n\tname;\n\ttype;\n\tnotNull;\n\tprimaryKey;\n\tdefault;\n\t/** 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\tcodecRef;\n\tconstructor(options) {\n\t\tthis.name = options.name;\n\t\tthis.type = options.type;\n\t\tthis.notNull = options.notNull;\n\t\tthis.primaryKey = options.primaryKey;\n\t\tthis.default = options.default;\n\t\tthis.codecRef = options.codecRef;\n\t\tObject.freeze(this);\n\t}\n};\nvar DdlNode = class {\n\t/**\n\t* Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}\n\t* recognise any `DdlNode` subclass — including target-contributed kinds —\n\t* without a central kind registry that subclasses would have to register\n\t* into.\n\t*/\n\tisDdlNode() {\n\t\treturn true;\n\t}\n\tfreeze() {\n\t\tObject.freeze(this);\n\t}\n\tcollectParamRefs() {\n\t\treturn [];\n\t}\n};\nfunction isDdlNode(value) {\n\treturn typeof value === \"object\" && value !== null && \"isDdlNode\" in value && typeof value.isDdlNode === \"function\";\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*/\nvar PrimaryKeyConstraint = class {\n\tkind = \"primary-key\";\n\tcolumns;\n\tname;\n\tconstructor(options) {\n\t\tthis.columns = Object.freeze([...options.columns]);\n\t\tthis.name = options.name;\n\t\tObject.freeze(this);\n\t}\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*/\nvar ForeignKeyConstraint = class {\n\tkind = \"foreign-key\";\n\tcolumns;\n\trefTable;\n\trefColumns;\n\tonDelete;\n\tonUpdate;\n\tname;\n\tconstructor(options) {\n\t\tthis.columns = Object.freeze([...options.columns]);\n\t\tthis.refTable = options.refTable;\n\t\tthis.refColumns = Object.freeze([...options.refColumns]);\n\t\tthis.onDelete = options.onDelete;\n\t\tthis.onUpdate = options.onUpdate;\n\t\tthis.name = options.name;\n\t\tObject.freeze(this);\n\t}\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*/\nvar UniqueConstraint = class {\n\tkind = \"unique\";\n\tcolumns;\n\tname;\n\tconstructor(options) {\n\t\tthis.columns = Object.freeze([...options.columns]);\n\t\tthis.name = options.name;\n\t\tObject.freeze(this);\n\t}\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*/\nvar CheckExpressionConstraint = class {\n\tkind = \"check-expression\";\n\tname;\n\texpression;\n\tconstructor(options) {\n\t\tthis.name = options.name;\n\t\tthis.expression = options.expression;\n\t\tObject.freeze(this);\n\t}\n};\n//#endregion\nexport { 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 };\n\n//# sourceMappingURL=ddl-types-BMp2bWVS.mjs.map"],"mappings":";;;AAGA,IAAI,mBAAmB,MAAM;CAC5B,SAAS;EACR,OAAO,OAAO,IAAI;CACnB;AACD;AACA,IAAI,uBAAuB,cAAc,iBAAiB;CACzD,OAAO;CACP;CACA,YAAY,OAAO;EAClB,MAAM;EACN,IAAI,CAAC,iCAAiC,KAAK,GAAG,MAAM,gBAAgB,4BAA4B,sCAAsC;EACtI,KAAK,QAAQ;EACb,KAAK,OAAO;CACb;CACA,OAAO,SAAS,KAAK;EACpB,OAAO,QAAQ,QAAQ,MAAM,GAAG;CACjC;AACD;AACA,IAAI,wBAAwB,cAAc,iBAAiB;CAC1D,OAAO;CACP;CACA,YAAY,YAAY;EACvB,MAAM;EACN,KAAK,aAAa;EAClB,KAAK,OAAO;CACb;CACA,OAAO,SAAS,KAAK;EACpB,OAAO,QAAQ,SAAS,MAAM,GAAG;CAClC;AACD;AACA,IAAI,YAAY,MAAM;CACrB;CACA;CACA;CACA;CACA;;CAEA;CACA,YAAY,SAAS;EACpB,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;CACnB;AACD;AACA,IAAI,UAAU,MAAM;;;;;;;CAOnB,YAAY;EACX,OAAO;CACR;CACA,SAAS;EACR,OAAO,OAAO,IAAI;CACnB;CACA,mBAAmB;EAClB,OAAO,CAAC;CACT;AACD;AACA,SAAS,UAAU,OAAO;CACzB,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,eAAe,SAAS,OAAO,MAAM,cAAc;AAC1G;;;;;;;;AAQA,IAAI,uBAAuB,MAAM;CAChC,OAAO;CACP;CACA;CACA,YAAY,SAAS;EACpB,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACnB;AACD;;;;;;;;AAQA,IAAI,uBAAuB,MAAM;CAChC,OAAO;CACP;CACA;CACA;CACA;CACA;CACA;CACA,YAAY,SAAS;EACpB,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;CACnB;AACD;;;;;;;;AAQA,IAAI,mBAAmB,MAAM;CAC5B,OAAO;CACP;CACA;CACA,YAAY,SAAS;EACpB,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACnB;AACD;;;;;;;;;;AAUA,IAAI,4BAA4B,MAAM;CACrC,OAAO;CACP;CACA;CACA,YAAY,SAAS;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,aAAa,QAAQ;EAC1B,OAAO,OAAO,IAAI;CACnB;AACD"}

package/dist/ddl-types-rrMsf77U-DGctYf-T.d.mts

@@ -0,0 +1,149 @@
+import { a as CodecRef$1 } from "./codec-types-MOaceoPi-C5eL2sao.mjs";
+import { a as ReferentialAction } from "./foreign-key-BSy9u4O4-BnsOe5Nf.mjs";
+import "./types-BchwQpmO.mjs";
+import { f as AnyParamRef } from "./types-DIBA80mc-wf5wLmON.mjs";
+import { ColumnDefaultLiteralInputValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql/4-lanes/relational-core/dist/ddl-types-rrMsf77U.d.mts
+//#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$1 | undefined;
+  constructor(options: {
+    readonly name: string;
+    readonly type: string;
+    readonly notNull?: boolean;
+    readonly primaryKey?: boolean;
+    readonly default?: AnyDdlColumnDefault;
+    readonly codecRef?: CodecRef$1;
+  });
+}
+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-rrMsf77U-DGctYf-T.d.mts.map

package/dist/ddl-types-rrMsf77U-DGctYf-T.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl-types-rrMsf77U-DGctYf-T.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/ddl-types-rrMsf77U.d.mts"],"mappings":";;;;;;;;;;;;;;;;UAcU;WACC;;UAED,wBAAwB;EAChC,QAAQ,MAAM,sBAAsB,KAAK,yBAAyB;EAClE,SAAS,MAAM,uBAAuB,KAAK,yBAAyB;;uBAE/C;oBACH;WACT,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;YAC5E;;cAEE,6BAA6B;WAChC;WACA,OAAO;EAChB,YAAY,OAAO;EACnB,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;cAEjE,8BAA8B;WACjC;WACA;EACT,YAAY;EACZ,OAAO,GAAG,SAAS,wBAAwB,IAAI,KAAK,yBAAyB;;KAE1E,sBAAsB,uBAAuB;cACpC;WACH;WACA;WACA;WACA;WACA,UAAU;;WAEV,WAAW;EACpB,YAAY;aACD;aACA;aACA;aACA;aACA,UAAU;aACV,WAAW;;;uBAGD;oBACH;;;;;;;EAOlB;YACU;EACV,oBAAoB;;iBAEL,UAAU,iBAAiB,SAAS;;;;;;;;cAQvC;WACH;WACA,SAAS;WACT;EACT,YAAY;aACD;aACA;;;;;;;;;;cAUC;WACH;WACA,SAAS;WACT;WACA,YAAY;WACZ,UAAU;WACV,UAAU;WACV;EACT,YAAY;aACD;aACA;aACA;aACA,WAAW;aACX,WAAW;aACX;;;;;;;;;;cAUC;WACH;WACA,SAAS;WACT;EACT,YAAY;aACD;aACA;;;;;;;;;;;;cAYC;WACH;WACA;WACA;EACT,YAAY;aACD;aACA;;;KAGR,qBAAqB,uBAAuB,uBAAuB,mBAAmB"}

package/dist/diff-B16bL_IR.mjs

@@ -0,0 +1,13 @@
+//#region ../../../2-sql/9-family/dist/diff.mjs
+/**
+* Compares two arrays of strings for equality (order-sensitive).
+*/
+function arraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+//#endregion
+export { arraysEqual as t };
+
+//# sourceMappingURL=diff-B16bL_IR.mjs.map

package/dist/diff-B16bL_IR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-B16bL_IR.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/diff.mjs"],"sourcesContent":["import { a as computeStorageTypeVerdict, i as computeSqlDiffVerdict, n as classifyDiffSubjectGranularity, o as verifySqlSchemaByDiff, r as classifySqlDiffIssue } from \"./schema-verify-vtFZbmGq.mjs\";\n//#region src/core/diff/sql-schema-diff.ts\n/**\n* Compares two arrays of strings for equality (order-sensitive).\n*/\nfunction arraysEqual(a, b) {\n\tif (a.length !== b.length) return false;\n\tfor (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n\treturn true;\n}\n//#endregion\nexport { arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };\n\n//# sourceMappingURL=diff.mjs.map"],"mappings":";;;;AAKA,SAAS,YAAY,GAAG,GAAG;CAC1B,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;CAC7D,OAAO;AACR"}

package/dist/diff-DhlzHOMD.d.mts

@@ -0,0 +1,104 @@
+import { c as SqlStorage } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import "./types-BchwQpmO.mjs";
+import { v as SqlSchemaIRNode } from "./types-CvbBw1Jo-3KQdErJY.mjs";
+import "./types-TvBZ2Ne9.mjs";
+import "./control-adapter-C99J7aEF-C-17lFY8.mjs";
+import { n as CodecControlHooks } from "./types-IqZMLrFC-DtdJNICr.mjs";
+import { t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-g5_iks8G.mjs";
+import { Contract, ControlPolicy } from "@prisma/orm-framework/contract/types";
+import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { DiffSubjectGranularity, SchemaDiffIssue, VerifierIssueCategory, VerifyDatabaseSchemaResult } from "@prisma/orm-framework/components/control";
+//#region ../../../2-sql/9-family/dist/diff.d.mts
+//#region src/core/diff/schema-verify.d.ts
+/**
+ * Resolves an issue's framework-neutral {@link DiffSubjectGranularity} on
+ * demand, from the issue's node's `nodeKind` via the target-provided
+ * `granularityOf` map. The node carries only its `nodeKind` identity, never a
+ * classification, and nothing is stamped onto the issue — every consumer
+ * (the family verdict below, the framework aggregate's unclaimed-elements
+ * sweep via {@link import('@prisma/orm-framework/components/control').SchemaSubjectClassifierCapable})
+ * calls this the same way, resolved by the family/target that owns the node
+ * vocabulary. `undefined` for an issue with no node.
+ */
+declare function classifyDiffSubjectGranularity(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): DiffSubjectGranularity | undefined;
+/**
+ * Re-keys the legacy `classifySqlVerifierIssueKind` category mapping on the
+ * issue's {@link DiffSubjectGranularity} (resolved via `granularityOf`) + the
+ * issue reason. The vocabulary maps one-to-one: an undeclared live entity or
+ * namespace is `extraTopLevelObject`, an undeclared live field
+ * `extraNestedElement`, undeclared auxiliaries (constraints, indexes,
+ * defaults) and structural leaves (policies) `extraAuxiliary`; a value-set
+ * drift on a check node is `valueDrift`; every other paired divergence is
+ * `declaredIncompatible`; anything the database lacks is `declaredMissing`.
+ * `granularityOf` is the target's classifier, so target and extension node
+ * kinds classify without the family importing them.
+ */
+declare function classifySqlDiffIssue(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): VerifierIssueCategory;
+interface SqlDiffVerdictInput {
+  /** The full, ownership-scoped diff issue list from the target's differ. */
+  readonly issues: readonly SchemaDiffIssue[];
+  /** Resolves a diff issue's subject table's declared control policy directly from the contract. */
+  readonly resolveControlPolicy: (issue: SchemaDiffIssue) => ControlPolicy | undefined;
+  readonly strict: boolean;
+  readonly defaultControlPolicy: ControlPolicy | undefined;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+interface SqlDiffVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+/**
+ * Applies the two consumer filters to a diff issue list: strict gating
+ * (relational `not-expected` findings drop in lenient mode) and
+ * control-policy disposition (each surviving issue grades against its
+ * subject table's effective policy; suppressed issues drop, `observed`
+ * subjects warn). The verify verdict is `failures.length === 0`.
+ */
+declare function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdict;
+interface StorageTypeVerdictInput {
+  readonly contract: Contract<SqlStorage>;
+  /**
+   * Expected/actual namespace-node pairs the target's differ input produced:
+   * for a namespaced tree, one entry per expected namespace with a
+   * non-empty table set, paired by DDL schema name (absent actual side for
+   * a schema the database lacks); a flat tree is the sole pair.
+   */
+  readonly namespacePairs: ReadonlyArray<{
+    readonly actual: SqlSchemaIRNode | undefined;
+  }>;
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+/**
+ * Runs the codec `verifyType` hooks the way the legacy walk did: once per
+ * contract namespace with tables, against that namespace's paired actual
+ * node (the hook reads namespace-scoped state such as `enums` off it).
+ * Issue dispositions grade against the contract default policy, matching
+ * the legacy `pushTypeNode` semantics.
+ */
+interface StorageTypeVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+declare function computeStorageTypeVerdict(input: StorageTypeVerdictInput): StorageTypeVerdict;
+interface VerifySqlSchemaByDiffInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /** The target's full-tree node diff (`diffSchema` descriptor hook). */
+  readonly diffSchema: SqlSchemaDiffFn;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+/**
+ * THE SQL schema verify: runs the target's full-tree node diff, grades it
+ * through the family's post-diff filters (strict gating + control-policy
+ * disposition) plus the codec `verifyType` hook findings, and wraps the
+ * verdict in the issue-based result envelope. `ok` holds exactly when both
+ * issue lists are empty — the lists carry the verdict's failures.
+ */
+declare function verifySqlSchemaByDiff(input: VerifySqlSchemaByDiffInput): VerifyDatabaseSchemaResult;
+//#endregion
+export { VerifySqlSchemaByDiffInput as a, computeSqlDiffVerdict as c, StorageTypeVerdictInput as i, computeStorageTypeVerdict as l, SqlDiffVerdictInput as n, classifyDiffSubjectGranularity as o, StorageTypeVerdict as r, classifySqlDiffIssue as s, SqlDiffVerdict as t, verifySqlSchemaByDiff as u };
+//# sourceMappingURL=diff-DhlzHOMD.d.mts.map

package/dist/diff-DhlzHOMD.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-DhlzHOMD.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/diff.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAmBiB,+BAA+B,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;;;;;;;;;;;;;iBAarH,qBAAqB,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;UAClH;;WAEC,iBAAiB;;WAEjB,uBAAuB,OAAO,oBAAoB;WAClD;WACA,sBAAsB;;WAEtB,gBAAgB,qBAAqB;;UAEtC;WACC,mBAAmB;WACnB,mBAAmB;;;;;;;;;iBASb,sBAAsB,OAAO,sBAAsB;UAC1D;WACC,UAAU,SAAS;;;;;;;WAOnB,gBAAgB;aACd,QAAQ;;WAEV,YAAY,oBAAoB;;;;;;;;;UASjC;WACC,mBAAmB;WACnB,mBAAmB;;iBAEb,0BAA0B,OAAO,0BAA0B;UAClE;WACC,UAAU,SAAS;WACnB,QAAQ;WACR;WACA,qBAAqB,cAAc;;WAEnC,YAAY;;WAEZ,gBAAgB,qBAAqB;;;;;;;;;iBAS/B,sBAAsB,OAAO,6BAA6B"}

package/dist/dist-C_q1_QR9.mjs

@@ -0,0 +1,9 @@
+import { createOperationRegistry } from "@prisma/orm-framework/operations";
+//#region ../../../2-sql/1-core/operations/dist/index.mjs
+function createSqlOperationRegistry() {
+	return createOperationRegistry();
+}
+//#endregion
+export { createSqlOperationRegistry as t };
+
+//# sourceMappingURL=dist-C_q1_QR9.mjs.map

package/dist/dist-C_q1_QR9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dist-C_q1_QR9.mjs","names":[],"sources":["../../../../2-sql/1-core/operations/dist/index.mjs"],"sourcesContent":["import { createOperationRegistry } from \"@internal/operations\";\n//#region src/index.ts\nfunction createSqlOperationRegistry() {\n\treturn createOperationRegistry();\n}\n//#endregion\nexport { createSqlOperationRegistry };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":";;AAEA,SAAS,6BAA6B;CACrC,OAAO,wBAAwB;AAChC"}