@prisma-next/sql-runtime 0.14.0-dev.6 → 0.14.0-dev.60

package/dist/test/utils.mjs

@@ -1,16 +1,484 @@
-import { i as createSqlExecutionStack, r as createExecutionContext, t as SqlRuntimeBase } from "../exports-BXdIMaxT.mjs";
+import { a as createExecutionContext, i as decodeRow, o as createSqlExecutionStack, r as buildDecodeContext, t as SqlRuntimeBase } from "../exports-DDMKrdHY.mjs";
 import { canonicalizeJson } from "@prisma-next/framework-components/utils";
 import { runtimeError } from "@prisma-next/framework-components/runtime";
 import { SelectAst, TableSource } from "@prisma-next/sql-relational-core/ast";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { instantiateExecutionStack } from "@prisma-next/framework-components/execution";
-import { coreHash, profileHash } from "@prisma-next/contract/types";
+import { blindCast } from "@prisma-next/utils/casts";
+import { asNamespaceId, coreHash, profileHash } from "@prisma-next/contract/types";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { IRNodeBase, NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
 import { builtinGeneratorIds } from "@prisma-next/ids";
 import { generateId } from "@prisma-next/ids/runtime";
-import { SqlStorage, SqlUnboundNamespace, buildSqlNamespace } from "@prisma-next/sql-contract/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { applicationDomainOf, collectAsync, collectAsync as collectAsync$1, createDevDatabase, drainAsyncIterable, teardownTestDatabase, withClient } from "@prisma-next/test-utils";
+import { type } from "arktype";
+//#region ../1-core/contract/src/ir/storage-entry-schemas.ts
+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({
+	columns: type.string.array().readonly(),
+	"name?": "string",
+	"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,
+	constraint: "boolean",
+	index: "boolean"
+});
+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()
+});
+//#endregion
+//#region ../1-core/contract/src/ir/sql-node.ts
+/**
+* SQL family IR node base. Carries the family-level `kind` discriminator
+* `'sql'` and inherits the framework's `freezeNode` affordance.
+*
+* Single family-level discriminator (not per-leaf) reflects the fact that
+* SQL IR has no polymorphic dispatch today — verifiers and serializers
+* walk by structural position (`storage.tables[name].columns[name]`),
+* not by inspecting `kind`. The abstract bar for per-leaf discriminators
+* isn't earned until a future polymorphic consumer arrives.
+*
+* `kind` is installed as a non-enumerable own property on every instance,
+* which keeps three things clean simultaneously:
+*
+* - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
+*   shape (no `kind` field), so emitted contract.json files and the
+*   `validateSqlContractFully` arktype schemas stay unchanged.
+* - Test assertions that use `toEqual({...})` against the pre-lift flat
+*   shape continue to pass — only enumerable own properties are
+*   compared.
+* - Direct access (`node.kind`) and runtime narrowing
+*   (`if (node.kind === 'sql')`) still work, so future polymorphic
+*   dispatch can begin reading `kind` without a runtime change.
+*
+* Future per-leaf overrides land cleanly: a class that gains a
+* polymorphic-dispatch consumer (e.g. an enum type instance walked
+* alongside other types) overrides `kind` with its narrower literal
+* at that leaf level. Per-leaf overrides will use enumerable kind
+* (matching the Mongo per-class-discriminator precedent) because they
+* encode dispatch-relevant information that callers need to see in
+* JSON envelopes; the family-level `'sql'` is uniform across all SQL
+* IR and carries no dispatch-relevant information.
+*/
+var SqlNode = class extends IRNodeBase {
+	kind;
+	constructor() {
+		super();
+		Object.defineProperty(this, "kind", {
+			value: "sql",
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/check-constraint.ts
+/**
+* SQL Contract IR node for a table-level check constraint that restricts
+* a column to the permitted values of a value-set.
+*
+* The constraint is **structured** (names a column and a value-set
+* reference), not a raw SQL expression. Each target renders its own DDL
+* from the structured form, keeping the contract target-agnostic.
+*
+* Construction is idempotent: passing an existing `CheckConstraint`
+* instance as input produces a new instance with identical fields.
+* The constructor does not use `instanceof` for input discrimination —
+* it reads plain named properties, which is sufficient since
+* `CheckConstraintInput` is a structural type.
+*/
+var CheckConstraint = class extends SqlNode {
+	name;
+	column;
+	valueSet;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.column = input.column;
+		this.valueSet = input.valueSet;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/foreign-key-reference.ts
+/**
+* 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 `@prisma-next/framework-components/ir`
+* as the sentinel `namespaceId` for single-namespace (unbound) references.
+*/
+var ForeignKeyReference = class extends SqlNode {
+	namespaceId;
+	tableName;
+	columns;
+	constructor(input) {
+		super();
+		this.namespaceId = asNamespaceId(input.namespaceId);
+		this.tableName = input.tableName;
+		this.columns = input.columns;
+		if (input.spaceId !== void 0) this.spaceId = input.spaceId;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/foreign-key.ts
+/**
+* SQL Contract IR node for a table-level foreign-key declaration.
+*
+* 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.
+*/
+var ForeignKey = class extends SqlNode {
+	source;
+	target;
+	constraint;
+	index;
+	constructor(input) {
+		super();
+		this.source = input.source instanceof ForeignKeyReference ? input.source : new ForeignKeyReference(input.source);
+		this.target = input.target instanceof ForeignKeyReference ? input.target : new ForeignKeyReference(input.target);
+		this.constraint = input.constraint;
+		this.index = input.index;
+		if (input.name !== void 0) this.name = input.name;
+		if (input.onDelete !== void 0) this.onDelete = input.onDelete;
+		if (input.onUpdate !== void 0) this.onUpdate = input.onUpdate;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/primary-key.ts
+/**
+* SQL Contract IR node for a table's primary-key constraint.
+*/
+var PrimaryKey = class extends SqlNode {
+	columns;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		if (input.name !== void 0) this.name = input.name;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/sql-index.ts
+/**
+* SQL Contract IR node for a table-level secondary index.
+*
+* Note that this class shadows the global TypeScript `Index` lib type
+* at the family-shared name; consumer files that need both should
+* alias one (e.g.
+* `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
+*/
+var Index = class extends SqlNode {
+	columns;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		if (input.name !== void 0) this.name = input.name;
+		if (input.type !== void 0) this.type = input.type;
+		if (input.options !== void 0) this.options = input.options;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/storage-column.ts
+/**
+* SQL Contract IR node for a single column entry in `StorageTable.columns`.
+*
+* Single concrete family-shared class — every SQL target reads the
+* same column shape today, so there is no per-target subclass. The
+* class type accepts any caller that constructs via
+* `new StorageColumn(input)`; literal construction sites must pass
+* through the constructor or the family-base hydration walker.
+*
+* The column's `name` is not on the class — columns are keyed by name
+* in the parent `StorageTable.columns: Record<string, StorageColumn>`
+* map, so a `name` field would be redundant with the key.
+*/
+var StorageColumn = class extends SqlNode {
+	nativeType;
+	codecId;
+	nullable;
+	constructor(input) {
+		super();
+		this.nativeType = input.nativeType;
+		this.codecId = input.codecId;
+		this.nullable = input.nullable;
+		if (input.many !== void 0) this.many = input.many;
+		if (input.typeParams !== void 0) this.typeParams = input.typeParams;
+		if (input.typeRef !== void 0) this.typeRef = input.typeRef;
+		if (input.default !== void 0) this.default = input.default;
+		if (input.control !== void 0) this.control = input.control;
+		if (input.valueSet !== void 0) this.valueSet = input.valueSet;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/unique-constraint.ts
+/**
+* SQL Contract IR node for a table-level unique constraint.
+*/
+var UniqueConstraint = class extends SqlNode {
+	columns;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		if (input.name !== void 0) this.name = input.name;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/storage-table.ts
+/**
+* SQL Contract IR node for a single table entry in a namespace's
+* `tables` map.
+*
+* The constructor normalises nested IR-class fields (columns, primary
+* key, uniques, indexes, foreign keys) into the appropriate class
+* instances so downstream walks see a uniform AST regardless of whether
+* the input was a JSON literal or an already-constructed class.
+*
+* The table's `name` is not on the class — tables are keyed by name in
+* the parent namespace's `tables: Record<string, StorageTable>` map.
+*/
+var StorageTable = class StorageTable extends SqlNode {
+	columns;
+	uniques;
+	indexes;
+	foreignKeys;
+	constructor(input) {
+		super();
+		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([name, col]) => [name, col instanceof StorageColumn ? col : new StorageColumn(col)])));
+		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);
+		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof UniqueConstraint ? u : new UniqueConstraint(u)));
+		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof Index ? i : new Index(i)));
+		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof ForeignKey ? fk : new ForeignKey(fk)));
+		if (input.control !== void 0) this.control = input.control;
+		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((cc) => new CheckConstraint(cc)));
+		freezeNode(this);
+	}
+	/**
+	* Runtime guard that a namespace `table` entry is really a `StorageTable`.
+	* The compiler already types the entry as `StorageTable`, but a
+	* freshly-deserialized contract may carry plain JSON at that slot until
+	* hydration; this duck-types the structural shape. Accepts `undefined` so
+	* optional-chained entry lookups pass straight through.
+	*/
+	static is(value) {
+		if (typeof value !== "object" || value === null) return false;
+		return "columns" in value && "uniques" in value && "indexes" in value && "foreignKeys" in value;
+	}
+	static assert(value, coordinate) {
+		if (!StorageTable.is(value)) throw new Error(`Expected a StorageTable at ${coordinate}`);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/ir/storage-value-set.ts
+/**
+* SQL Contract IR node for a value-set entry in a namespace's `valueSet`
+* map (`SqlNamespace.entries.valueSet`).
+*
+* A value-set records the ordered set of permitted codec-encoded values for
+* an enum-like column restriction. It does not carry a `codecId` — the
+* column that references it already holds the codec; the value-set holds
+* only the permitted values.
+*
+* The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope
+* carries the discriminator and the serializer hydration walker can
+* dispatch on it. This follows the per-leaf enumerable-kind convention
+* established in the SQL-node comment (future polymorphic dispatch on
+* namespace entries needs the discriminator in JSON).
+*
+* The entry's name is not on the class — value-sets are keyed by name in
+* the parent namespace's `valueSet: Record<string, StorageValueSet>` map.
+*/
+var StorageValueSet = class extends SqlNode {
+	kind = "valueSet";
+	values;
+	constructor(input) {
+		super();
+		this.values = Object.freeze([...input.values]);
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region ../1-core/contract/src/entity-kinds.ts
+const tableEntityKind = {
+	kind: "table",
+	schema: StorageTableSchema,
+	construct: (input) => new StorageTable(input)
+};
+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 = new Map([["table", tableEntityKind], ["valueSet", valueSetEntityKind]]);
+	for (const descriptor of packKinds) {
+		if (kinds.has(descriptor.kind)) throw new Error(`composeSqlEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`);
+		kinds.set(descriptor.kind, descriptor);
+	}
+	return kinds;
+}
+//#endregion
+//#region ../1-core/contract/src/ir/sql-storage.ts
+/**
+* Abstract SQL family namespace base class. Target concretions (`PostgresSchema`,
+* `SqliteDatabase`, …) extend this — it is never instantiated directly.
+* `entries` is the open ADR 224 dictionary: `entries[entityKind][entityName]`
+* addresses any entity.
+*/
+var SqlNamespaceBase = class extends NamespaceBase {};
+//#endregion
+//#region ../1-core/contract/test/test-support.ts
+/**
+* Minimal concrete `SqlNamespaceBase` for use in `packages/2-sql/**` unit tests.
+*
+* This is a legitimate target concretion — not a materialised family
+* namespace.  Production code never constructs one; the target-specific
+* concretions (`PostgresSchema`, `SqliteDatabase`) are used in production.
+*/
+var TestSqlNamespace = class extends SqlNamespaceBase {
+	id;
+	entries;
+	constructor(input) {
+		super();
+		this.id = input.id;
+		const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), "carry");
+		this.entries = Object.freeze(blindCast(dispatched));
+		Object.defineProperty(this, "kind", {
+			value: "test-sql-namespace",
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		freezeNode(this);
+	}
+	get table() {
+		return this.entries.table ?? Object.freeze({});
+	}
+	get valueSet() {
+		return this.entries.valueSet;
+	}
+	qualifyTable(tableName) {
+		if (this.id === UNBOUND_NAMESPACE_ID) return `"${tableName}"`;
+		return `"${this.id}"."${tableName}"`;
+	}
+};
+function createTestSqlNamespace(input) {
+	return new TestSqlNamespace(input);
+}
+//#endregion
 //#region test/test-codec.ts
 function defineTestCodec(config) {
 	const identity = (v) => v;
@@ -327,7 +795,7 @@ function createStubAdapter() {
 	};
 }
 function unboundNamespaceWithTables(tables) {
-	return buildSqlNamespace({
+	return createTestSqlNamespace({
 		id: UNBOUND_NAMESPACE_ID,
 		entries: { table: tables }
 	});
@@ -344,10 +812,16 @@ function createTestContract(contract) {
 		storage: rest["storage"] ? new SqlStorage({
 			...rest["storage"],
 			storageHash: storageHashValue,
-			namespaces: rest["storage"].namespaces ?? { __unbound__: SqlUnboundNamespace.instance }
+			namespaces: rest["storage"].namespaces ?? { __unbound__: createTestSqlNamespace({
+				id: "__unbound__",
+				entries: { table: {} }
+			}) }
 		}) : new SqlStorage({
 			storageHash: storageHashValue,
-			namespaces: { __unbound__: SqlUnboundNamespace.instance }
+			namespaces: { __unbound__: createTestSqlNamespace({
+				id: "__unbound__",
+				entries: { table: {} }
+			}) }
 		}),
 		domain: rest["domain"] ?? applicationDomainOf({ models: rest["models"] ?? {} }),
 		roots: rest["roots"] ?? {},
@@ -362,6 +836,6 @@ function stubAst() {
 	return SelectAst.from(TableSource.named("stub"));
 }
 //#endregion
-export { buildTestContractCodecs, collectAsync, createDevDatabase, createStubAdapter, createTestAdapterDescriptor, createTestContext, createTestContract, createTestRuntime, createTestStackInstance, createTestTargetDescriptor, descriptorsFromCodecs, drainPlanExecution, emptySqlTestDomain, executePlanAndCollect, seedTestMarker, setupTestDatabase, stubAst, teardownTestDatabase, unboundNamespaceWithTables, withClient, writeTestContractMarker };
+export { buildDecodeContext, buildTestContractCodecs, collectAsync, createDevDatabase, createStubAdapter, createTestAdapterDescriptor, createTestContext, createTestContract, createTestRuntime, createTestStackInstance, createTestTargetDescriptor, decodeRow, descriptorsFromCodecs, drainPlanExecution, emptySqlTestDomain, executePlanAndCollect, seedTestMarker, setupTestDatabase, stubAst, teardownTestDatabase, unboundNamespaceWithTables, withClient, writeTestContractMarker };
 
 //# sourceMappingURL=utils.mjs.map