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

package/dist/family__psl-infer.mjs

@@ -0,0 +1,2 @@
+import { a as mapDefault, c as toEnumMemberName, d as toModelName, i as inferRelations, l as toEnumName, n as deriveBackRelationFieldName, o as parseRawDefault, r as deriveRelationFieldName, s as pluralize, t as buildChildRelationField, u as toFieldName } from "./psl-infer-DGftl-HW.mjs";
+export { buildChildRelationField, deriveBackRelationFieldName, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, pluralize, toEnumMemberName, toEnumName, toFieldName, toModelName };

package/dist/family__runtime.d.mts

@@ -0,0 +1,3 @@
+import { n as resolveStorageTable, t as ResolvedStorageTable } from "./resolve-storage-table-DUwyRJmP.mjs";
+import { a as timestampNowRuntimeGenerator, i as sqlRuntimeFamilyDescriptor, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-DNewRuec.mjs";
+export { type ResolvedDomainModel, type ResolvedStorageTable, UNBOUND_DOMAIN_NAMESPACE_ID, sqlRuntimeFamilyDescriptor as default, resolveDomainModel, resolveStorageTable, timestampNowRuntimeGenerator };

package/dist/family__runtime.mjs

@@ -0,0 +1,3 @@
+import { t as resolveStorageTable } from "./resolve-storage-table-DZsfnzeW.mjs";
+import { i as timestampNowRuntimeGenerator, n as resolveDomainModel, r as runtime_default, t as UNBOUND_DOMAIN_NAMESPACE_ID } from "./runtime-tIHpGCcG.mjs";
+export { UNBOUND_DOMAIN_NAMESPACE_ID, runtime_default as default, resolveDomainModel, resolveStorageTable, timestampNowRuntimeGenerator };

package/dist/family__verify.d.mts

@@ -0,0 +1,2 @@
+import { n as parseContractMarkerRow, t as ContractMarkerRow } from "./verify-zDRnw0Rn.mjs";
+export { type ContractMarkerRow, parseContractMarkerRow };

package/dist/family__verify.mjs

@@ -0,0 +1,2 @@
+import { n as parseContractMarkerRow } from "./verify-E6Dd2vYp-gYwnlhLm.mjs";
+export { parseContractMarkerRow };

package/dist/foreign-key-BSy9u4O4-BnsOe5Nf.d.mts

@@ -0,0 +1,85 @@
+import { t as SqlNode } from "./sql-node-kEz6YFZo-v2F7delx.mjs";
+import { NamespaceId } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql/1-core/contract/dist/foreign-key-BSy9u4O4.d.mts
+//#region src/ir/foreign-key-reference.d.ts
+/**
+ * Input for a foreign-key reference (one side of a foreign-key declaration).
+ *
+ * When `spaceId` is absent the reference is local — the referenced table lives
+ * in the same contract-space. When `spaceId` is present the reference is
+ * cross-space — the referenced table lives in a different contract-space
+ * identified by `spaceId`.
+ *
+ * Presence-based discrimination keeps local FK JSON byte-identical to
+ * contracts authored before cross-space support was added.
+ */
+interface ForeignKeyReferenceInput {
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly columns: readonly string[];
+  readonly spaceId?: string;
+}
+/**
+ * SQL Contract IR node for one side (source or target) of a foreign-key
+ * declaration. Carries the full coordinate: namespace, table, and columns.
+ *
+ * Cross-space discrimination is based on `spaceId` presence: absent means
+ * local (same contract-space); present means cross-space (the referenced
+ * table lives in the contract-space identified by `spaceId`).
+ *
+ * For local references `spaceId` is absent from JSON, keeping the serialized
+ * shape byte-identical to contracts authored before cross-space support was
+ * added. For cross-space references `spaceId` appears in JSON so round-trips
+ * are lossless.
+ *
+ * Use `UNBOUND_NAMESPACE_ID` from `@internal/framework-components/ir`
+ * as the sentinel `namespaceId` for single-namespace (unbound) references.
+ */
+declare class ForeignKeyReference extends SqlNode {
+  readonly namespaceId: NamespaceId;
+  readonly tableName: string;
+  readonly columns: readonly string[];
+  readonly spaceId?: string;
+  constructor(input: ForeignKeyReferenceInput);
+}
+//#endregion
+//#region src/ir/foreign-key.d.ts
+type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+interface ForeignKeyInput {
+  readonly source: ForeignKeyReference | ForeignKeyReferenceInput;
+  readonly target: ForeignKeyReference | ForeignKeyReferenceInput;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+}
+/**
+ * SQL Contract IR node for a table-level foreign-key declaration — the
+ * referential constraint only (source, target, `onDelete`/`onUpdate`).
+ *
+ * A persisted `foreignKeys[]` entry always denotes a real constraint: whether
+ * to emit the constraint at all, and whether to back it with an index, are
+ * authoring-time decisions (PSL `@relation(index:)`, TS `fk({ constraint,
+ * index })`) resolved once at `contract emit` — a `constraint: false` FK
+ * simply has no entry here, and a backing index (if any) is its own discrete,
+ * named entry in the table's `indexes[]`.
+ *
+ * Each FK carries explicit `source` and `target` {@link ForeignKeyReference}
+ * coordinates (namespace, table, columns). For single-namespace contracts the
+ * sentinel `UNBOUND_NAMESPACE_ID` appears on both sides.
+ *
+ * The nested references are normalised to {@link ForeignKeyReference}
+ * instances inside the constructor so downstream walks see a uniform AST
+ * regardless of whether the input was a JSON literal or an already-constructed
+ * class instance.
+ */
+declare class ForeignKey extends SqlNode {
+  readonly source: ForeignKeyReference;
+  readonly target: ForeignKeyReference;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  constructor(input: ForeignKeyInput);
+}
+//#endregion
+export { ReferentialAction as a, ForeignKeyReferenceInput as i, ForeignKeyInput as n, ForeignKeyReference as r, ForeignKey as t };
+//# sourceMappingURL=foreign-key-BSy9u4O4-BnsOe5Nf.d.mts.map

package/dist/foreign-key-BSy9u4O4-BnsOe5Nf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-BSy9u4O4-BnsOe5Nf.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/foreign-key-BSy9u4O4.d.mts"],"mappings":";;;;;;;;;;;;;;;UAcU;WACC;WACA;WACA;WACA;;;;;;;;;;;;;;;;;;cAkBG,4BAA4B;WAC/B,aAAa;WACb;WACA;WACA;EACT,YAAY,OAAO;;;;KAIhB;UACK;WACC,QAAQ,sBAAsB;WAC9B,QAAQ,sBAAsB;WAC9B;WACA,WAAW;WACX,WAAW;;;;;;;;;;;;;;;;;;;;;;cAsBR,mBAAmB;WACtB,QAAQ;WACR,QAAQ;WACR;WACA,WAAW;WACX,WAAW;EACpB,YAAY,OAAO"}

package/dist/foreign-key-materialization-Ca-wRbmj.d.mts

@@ -0,0 +1,65 @@
+import { a as ReferentialAction, i as ForeignKeyReferenceInput, n as ForeignKeyInput } from "./foreign-key-BSy9u4O4-BnsOe5Nf.mjs";
+import { i as UniqueConstraintInput, n as PrimaryKeyInput } from "./unique-constraint-jQWfH7dg-zLWtFp99.mjs";
+import { r as IndexInput } from "./sql-index-DsI8HAeK-BJsn-jvD.mjs";
+//#region ../../../2-sql/1-core/contract/dist/foreign-key-materialization.d.mts
+//#region src/foreign-key-materialization.d.ts
+type BackingIndexCandidates = {
+  readonly indexes: readonly {
+    readonly columns?: readonly string[];
+  }[];
+  readonly uniques: readonly {
+    readonly columns: readonly string[];
+  }[];
+  readonly primaryKey?: {
+    readonly columns: readonly string[];
+  } | undefined;
+};
+/**
+ * The column-list keys (`"colA,colB"`, order preserved) a table's own
+ * indexes, unique constraints, and primary key already back. A foreign key
+ * whose source columns join to one of these keys needs no separately
+ * derived backing index.
+ *
+ * Shared by {@link isBackedByColumnKeys}'s callers: `materializeForeignKeysAndIndexes`
+ * (deriving the discrete backing-index entities persisted at `contract emit`)
+ * and the postgres PSL inferrer (deciding whether an introspected relation
+ * needs an explicit `index: false`).
+ */
+declare function backingIndexColumnKeys(table: BackingIndexCandidates): readonly string[];
+/**
+ * Whether `columns`, in order, matches one of `backingKeys` (see
+ * {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not
+ * satisfy a backing index declared as `(b, a)`.
+ */
+declare function isBackedByColumnKeys(columns: readonly string[], backingKeys: readonly string[]): boolean;
+/**
+ * A foreign key as authored, before FK1 materialization: the referential
+ * coordinates plus the `constraint`/`index` intent booleans that drive
+ * whether — and how — it survives into the persisted contract.
+ */
+interface ForeignKeyAuthoringInput {
+  readonly source: ForeignKeyReferenceInput;
+  readonly target: ForeignKeyReferenceInput;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly constraint: boolean;
+  readonly index: boolean;
+}
+interface MaterializedTableConstraints {
+  readonly foreignKeys: readonly ForeignKeyInput[];
+  readonly indexes: readonly IndexInput[];
+}
+/**
+ * Lowers a table's authored foreign keys into the discrete entities
+ * `contract.json` persists: a `constraint: false` FK contributes no
+ * `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already
+ * backed by a declared index/unique/primary-key contributes a wire-named
+ * `indexes[]` entry (default prefix + content-hash wire name). Declared
+ * indexes always survive unchanged; a second FK sharing already-synthesized
+ * backing columns does not mint a duplicate index.
+ */
+declare function materializeForeignKeysAndIndexes(tableName: string, foreignKeys: readonly ForeignKeyAuthoringInput[], declaredIndexes: readonly IndexInput[], uniques: readonly UniqueConstraintInput[], primaryKey: PrimaryKeyInput | undefined): MaterializedTableConstraints;
+//#endregion
+export { isBackedByColumnKeys as a, backingIndexColumnKeys as i, ForeignKeyAuthoringInput as n, materializeForeignKeysAndIndexes as o, MaterializedTableConstraints as r, BackingIndexCandidates as t };
+//# sourceMappingURL=foreign-key-materialization-Ca-wRbmj.d.mts.map

package/dist/foreign-key-materialization-Ca-wRbmj.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-materialization-Ca-wRbmj.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/foreign-key-materialization.d.mts"],"mappings":";;;;;KAIK;WACM;aACE;;WAEF;aACE;;WAEF;aACE;;;;;;;;;;;;;;iBAcI,uBAAuB,OAAO;;;;;;iBAM9B,qBAAqB,4BAA4B;;;;;;UAMxD;WACC,QAAQ;WACR,QAAQ;WACR;WACA,WAAW;WACX,WAAW;WACX;WACA;;UAED;WACC,sBAAsB;WACtB,kBAAkB;;;;;;;;;;;iBAWZ,iCAAiC,mBAAmB,sBAAsB,4BAA4B,0BAA0B,cAAc,kBAAkB,yBAAyB,YAAY,8BAA8B"}

package/dist/foreign-key-materialization-HI7BIQrG.mjs

@@ -0,0 +1,72 @@
+import { n as lowerAuthoredIndex } from "./index-naming-BoGBcMmI-DiJAr66H.mjs";
+//#region ../../../2-sql/1-core/contract/dist/foreign-key-materialization.mjs
+/**
+* The column-list keys (`"colA,colB"`, order preserved) a table's own
+* indexes, unique constraints, and primary key already back. A foreign key
+* whose source columns join to one of these keys needs no separately
+* derived backing index.
+*
+* Shared by {@link isBackedByColumnKeys}'s callers: `materializeForeignKeysAndIndexes`
+* (deriving the discrete backing-index entities persisted at `contract emit`)
+* and the postgres PSL inferrer (deciding whether an introspected relation
+* needs an explicit `index: false`).
+*/
+function backingIndexColumnKeys(table) {
+	return [
+		...table.indexes.flatMap((index) => index.columns !== void 0 ? [index.columns.join(",")] : []),
+		...table.uniques.map((unique) => unique.columns.join(",")),
+		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
+	];
+}
+/**
+* Whether `columns`, in order, matches one of `backingKeys` (see
+* {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not
+* satisfy a backing index declared as `(b, a)`.
+*/
+function isBackedByColumnKeys(columns, backingKeys) {
+	return backingKeys.includes(columns.join(","));
+}
+/**
+* Lowers a table's authored foreign keys into the discrete entities
+* `contract.json` persists: a `constraint: false` FK contributes no
+* `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already
+* backed by a declared index/unique/primary-key contributes a wire-named
+* `indexes[]` entry (default prefix + content-hash wire name). Declared
+* indexes always survive unchanged; a second FK sharing already-synthesized
+* backing columns does not mint a duplicate index.
+*/
+function materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexes, uniques, primaryKey) {
+	const satisfiedIndexColumns = new Set(backingIndexColumnKeys({
+		indexes: declaredIndexes,
+		uniques,
+		primaryKey
+	}));
+	const synthesizedIndexes = [];
+	const materializedForeignKeys = [];
+	for (const { constraint, index, ...reference } of foreignKeys) {
+		if (constraint !== false) materializedForeignKeys.push(reference);
+		if (index !== false) {
+			const key = reference.source.columns.join(",");
+			if (!satisfiedIndexColumns.has(key)) {
+				synthesizedIndexes.push(lowerAuthoredIndex(tableName, {
+					columns: reference.source.columns,
+					where: void 0,
+					unique: void 0,
+					map: void 0,
+					name: void 0,
+					type: void 0,
+					options: void 0
+				}));
+				satisfiedIndexColumns.add(key);
+			}
+		}
+	}
+	return {
+		foreignKeys: materializedForeignKeys,
+		indexes: [...declaredIndexes, ...synthesizedIndexes]
+	};
+}
+//#endregion
+export { isBackedByColumnKeys as n, materializeForeignKeysAndIndexes as r, backingIndexColumnKeys as t };
+
+//# sourceMappingURL=foreign-key-materialization-HI7BIQrG.mjs.map

package/dist/foreign-key-materialization-HI7BIQrG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-materialization-HI7BIQrG.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/foreign-key-materialization.mjs"],"sourcesContent":["import { n as lowerAuthoredIndex } from \"./index-naming-BoGBcMmI.mjs\";\n//#region src/foreign-key-materialization.ts\n/**\n* The column-list keys (`\"colA,colB\"`, order preserved) a table's own\n* indexes, unique constraints, and primary key already back. A foreign key\n* whose source columns join to one of these keys needs no separately\n* derived backing index.\n*\n* Shared by {@link isBackedByColumnKeys}'s callers: `materializeForeignKeysAndIndexes`\n* (deriving the discrete backing-index entities persisted at `contract emit`)\n* and the postgres PSL inferrer (deciding whether an introspected relation\n* needs an explicit `index: false`).\n*/\nfunction backingIndexColumnKeys(table) {\n\treturn [\n\t\t...table.indexes.flatMap((index) => index.columns !== void 0 ? [index.columns.join(\",\")] : []),\n\t\t...table.uniques.map((unique) => unique.columns.join(\",\")),\n\t\t...table.primaryKey ? [table.primaryKey.columns.join(\",\")] : []\n\t];\n}\n/**\n* Whether `columns`, in order, matches one of `backingKeys` (see\n* {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not\n* satisfy a backing index declared as `(b, a)`.\n*/\nfunction isBackedByColumnKeys(columns, backingKeys) {\n\treturn backingKeys.includes(columns.join(\",\"));\n}\n/**\n* Lowers a table's authored foreign keys into the discrete entities\n* `contract.json` persists: a `constraint: false` FK contributes no\n* `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already\n* backed by a declared index/unique/primary-key contributes a wire-named\n* `indexes[]` entry (default prefix + content-hash wire name). Declared\n* indexes always survive unchanged; a second FK sharing already-synthesized\n* backing columns does not mint a duplicate index.\n*/\nfunction materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexes, uniques, primaryKey) {\n\tconst satisfiedIndexColumns = new Set(backingIndexColumnKeys({\n\t\tindexes: declaredIndexes,\n\t\tuniques,\n\t\tprimaryKey\n\t}));\n\tconst synthesizedIndexes = [];\n\tconst materializedForeignKeys = [];\n\tfor (const { constraint, index, ...reference } of foreignKeys) {\n\t\tif (constraint !== false) materializedForeignKeys.push(reference);\n\t\tif (index !== false) {\n\t\t\tconst key = reference.source.columns.join(\",\");\n\t\t\tif (!satisfiedIndexColumns.has(key)) {\n\t\t\t\tsynthesizedIndexes.push(lowerAuthoredIndex(tableName, {\n\t\t\t\t\tcolumns: reference.source.columns,\n\t\t\t\t\twhere: void 0,\n\t\t\t\t\tunique: void 0,\n\t\t\t\t\tmap: void 0,\n\t\t\t\t\tname: void 0,\n\t\t\t\t\ttype: void 0,\n\t\t\t\t\toptions: void 0\n\t\t\t\t}));\n\t\t\t\tsatisfiedIndexColumns.add(key);\n\t\t\t}\n\t\t}\n\t}\n\treturn {\n\t\tforeignKeys: materializedForeignKeys,\n\t\tindexes: [...declaredIndexes, ...synthesizedIndexes]\n\t};\n}\n//#endregion\nexport { backingIndexColumnKeys, isBackedByColumnKeys, materializeForeignKeysAndIndexes };\n\n//# sourceMappingURL=foreign-key-materialization.mjs.map"],"mappings":";;;;;;;;;;;;;AAaA,SAAS,uBAAuB,OAAO;CACtC,OAAO;EACN,GAAG,MAAM,QAAQ,SAAS,UAAU,MAAM,YAAY,KAAK,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC;EAC7F,GAAG,MAAM,QAAQ,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG,CAAC;EACzD,GAAG,MAAM,aAAa,CAAC,MAAM,WAAW,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC;CAC/D;AACD;;;;;;AAMA,SAAS,qBAAqB,SAAS,aAAa;CACnD,OAAO,YAAY,SAAS,QAAQ,KAAK,GAAG,CAAC;AAC9C;;;;;;;;;;AAUA,SAAS,iCAAiC,WAAW,aAAa,iBAAiB,SAAS,YAAY;CACvG,MAAM,wBAAwB,IAAI,IAAI,uBAAuB;EAC5D,SAAS;EACT;EACA;CACD,CAAC,CAAC;CACF,MAAM,qBAAqB,CAAC;CAC5B,MAAM,0BAA0B,CAAC;CACjC,KAAK,MAAM,EAAE,YAAY,OAAO,GAAG,eAAe,aAAa;EAC9D,IAAI,eAAe,OAAO,wBAAwB,KAAK,SAAS;EAChE,IAAI,UAAU,OAAO;GACpB,MAAM,MAAM,UAAU,OAAO,QAAQ,KAAK,GAAG;GAC7C,IAAI,CAAC,sBAAsB,IAAI,GAAG,GAAG;IACpC,mBAAmB,KAAK,mBAAmB,WAAW;KACrD,SAAS,UAAU,OAAO;KAC1B,OAAO,KAAK;KACZ,QAAQ,KAAK;KACb,KAAK,KAAK;KACV,MAAM,KAAK;KACX,MAAM,KAAK;KACX,SAAS,KAAK;IACf,CAAC,CAAC;IACF,sBAAsB,IAAI,GAAG;GAC9B;EACD;CACD;CACA,OAAO;EACN,aAAa;EACb,SAAS,CAAC,GAAG,iBAAiB,GAAG,kBAAkB;CACpD;AACD"}