@prisma-next/sql-runtime 0.5.0-dev.9 → 0.6.0-dev.1

package/dist/index.mjs

@@ -1,3 +1,2 @@
-import { a as readContractMarker, c as createSqlExecutionStack, d as lowerSqlPlan, f as extractCodecIds, i as ensureTableStatement, l as lints, m as validateContractCodecMappings, n as withTransaction, o as writeContractMarker, p as validateCodecRegistryCompleteness, r as ensureSchemaStatement, s as createExecutionContext, t as createRuntime, u as budgets } from "./exports-BOHa3Emo.mjs";
-
-export { budgets, createExecutionContext, createRuntime, createSqlExecutionStack, ensureSchemaStatement, ensureTableStatement, extractCodecIds, lints, lowerSqlPlan, readContractMarker, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction, writeContractMarker };
+import { a as ensureTableStatement, c as createExecutionContext, d as budgets, f as parseContractMarkerRow, g as validateContractCodecMappings, h as validateCodecRegistryCompleteness, i as ensureSchemaStatement, l as createSqlExecutionStack, m as extractCodecIds, n as withTransaction, o as readContractMarker, p as lowerSqlPlan, r as APP_SPACE_ID, s as writeContractMarker, t as createRuntime, u as lints } from "./exports-BSTHn_rH.mjs";
+export { APP_SPACE_ID, budgets, createExecutionContext, createRuntime, createSqlExecutionStack, ensureSchemaStatement, ensureTableStatement, extractCodecIds, lints, lowerSqlPlan, parseContractMarkerRow, readContractMarker, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction, writeContractMarker };

package/dist/test/utils.d.mts

@@ -1,25 +1,22 @@
-import { C as SqlRuntimeAdapterInstance, D as SqlRuntimeTargetDescriptor, E as SqlRuntimeExtensionInstance, S as SqlRuntimeAdapterDescriptor, T as SqlRuntimeExtensionDescriptor, _ as ExecutionContext, f as SqlStatement, u as createRuntime, w as SqlRuntimeDriverInstance } from "../index-CZmC2kD3.mjs";
+import { A as SqlRuntimeTargetDescriptor, D as SqlRuntimeDriverInstance, E as SqlRuntimeAdapterInstance, O as SqlRuntimeExtensionDescriptor, T as SqlRuntimeAdapterDescriptor, d as createRuntime, k as SqlRuntimeExtensionInstance, m as SqlStatement, y as ExecutionContext } from "../index-CTCvZOWI.mjs";
 import { ResultType } from "@prisma-next/framework-components/runtime";
-import { Adapter, LoweredStatement, SelectAst } from "@prisma-next/sql-relational-core/ast";
-import * as _prisma_next_framework_components_execution0 from "@prisma-next/framework-components/execution";
+import { Adapter, Codec, ContractCodecRegistry, LoweredStatement, SelectAst } from "@prisma-next/sql-relational-core/ast";
+import * as _$_prisma_next_framework_components_execution0 from "@prisma-next/framework-components/execution";
 import { RuntimeDriverDescriptor } from "@prisma-next/framework-components/execution";
 import { Contract } from "@prisma-next/contract/types";
+import { CodecDescriptor } from "@prisma-next/framework-components/codec";
 import { DevDatabase, collectAsync, createDevDatabase, teardownTestDatabase, withClient } from "@prisma-next/test-utils";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlExecutionPlan, SqlQueryPlan } from "@prisma-next/sql-relational-core/plan";
 import { Client } from "pg";
 
 //#region test/utils.d.ts
-
 /**
- * Executes a plan and collects all results into an array.
- * This helper DRYs up the common pattern of executing plans in tests.
- * The return type is inferred from the plan's type parameter.
+ * Executes a plan and collects all results into an array. This helper DRYs up the common pattern of executing plans in tests. The return type is inferred from the plan's type parameter.
  */
 declare function executePlanAndCollect<P extends SqlExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]>;
 /**
- * Drains a plan execution, consuming all results without collecting them.
- * Useful for testing side effects without memory overhead.
+ * Drains a plan execution, consuming all results without collecting them. Useful for testing side effects without memory overhead.
  */
 declare function drainPlanExecution(runtime: ReturnType<typeof createRuntime>, plan: SqlExecutionPlan | SqlQueryPlan<unknown>): Promise<void>;
 /**
@@ -27,52 +24,59 @@ declare function drainPlanExecution(runtime: ReturnType<typeof createRuntime>, p
  */
 declare function executeStatement(client: Client, statement: SqlStatement): Promise<void>;
 /**
- * Sets up database schema and data, then writes the contract marker.
- * This helper DRYs up the common pattern of database setup in tests.
+ * Sets up database schema and data, then writes the contract marker. This helper DRYs up the common pattern of database setup in tests.
  */
 declare function setupTestDatabase(client: Client, contract: Contract<SqlStorage>, setupFn: (client: Client) => Promise<void>): Promise<void>;
 /**
- * Writes a contract marker to the database.
- * This helper DRYs up the common pattern of writing contract markers in tests.
+ * Writes a contract marker to the database. This helper DRYs up the common pattern of writing contract markers in tests.
  */
 declare function writeTestContractMarker(client: Client, contract: Contract<SqlStorage>): Promise<void>;
 /**
- * Creates a test adapter descriptor from a raw adapter.
- * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions
- * derived from the adapter's codec registry.
+ * Creates a test adapter descriptor from a raw adapter. Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions derived from the adapter's codec registry.
+ */
+/**
+ * Build a {@link ContractCodecRegistry} from a codec array for tests that exercise `encodeParam(s)` / `decodeRow` in isolation. The production runtime builds `ContractCodecRegistry` from contract walk + descriptor list and never goes through this helper; tests use it to wire a hand-built codec set into the surface those functions consume in production.
  */
-declare function createTestAdapterDescriptor(adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>): SqlRuntimeAdapterDescriptor<'postgres'>;
+declare function buildTestContractCodecs(codecs: ReadonlyArray<Codec<string>>): ContractCodecRegistry;
+/**
+ * Synthesize `CodecDescriptor`s from a codec array of non-parameterized codec instances. Test-only: the production synthesis bridge was retired under TML-2357. Lets the existing `createTestAdapterDescriptor` pattern keep wrapping a stub `Adapter` (whose `__codecs` slot still exposes the codec set) into the descriptor-list shape that `SqlStaticContributions.codecs:` now expects. The `Codec` instances carry
+ * `traits`/`targetTypes`/`meta` via the SQL family extension; the structural narrow reads those fields directly.
+ */
+declare function descriptorsFromCodecs(codecs: ReadonlyArray<Codec<string>>): ReadonlyArray<CodecDescriptor>;
+declare function createTestAdapterDescriptor(adapter: StubAdapter): SqlRuntimeAdapterDescriptor<'postgres'>;
 /**
  * Creates a test target descriptor with empty static contributions.
  */
 declare function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'>;
 /**
- * Creates an ExecutionContext for testing.
- * This helper DRYs up the common pattern of context creation in tests.
+ * Creates an ExecutionContext for testing. This helper DRYs up the common pattern of context creation in tests.
  *
- * Accepts a raw adapter and optional extension descriptors, wrapping the
- * adapter in a descriptor internally for descriptor-first context creation.
+ * Accepts a raw adapter and optional extension descriptors, wrapping the adapter in a descriptor internally for descriptor-first context creation.
  */
-declare function createTestContext<TContract extends Contract<SqlStorage>>(contract: TContract, adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>, options?: {
+declare function createTestContext<TContract extends Contract<SqlStorage>>(contract: TContract, adapter: StubAdapter, options?: {
   extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;
 }): ExecutionContext<TContract>;
 declare function createTestStackInstance(options?: {
   extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;
   driver?: RuntimeDriverDescriptor<'sql', 'postgres', unknown, SqlRuntimeDriverInstance<'postgres'>>;
-}): _prisma_next_framework_components_execution0.ExecutionStackInstance<"sql", "postgres", SqlRuntimeAdapterInstance<"postgres">, SqlRuntimeDriverInstance<"postgres">, SqlRuntimeExtensionInstance<"postgres">>;
+}): _$_prisma_next_framework_components_execution0.ExecutionStackInstance<"sql", "postgres", SqlRuntimeAdapterInstance<"postgres">, SqlRuntimeDriverInstance<"postgres">, SqlRuntimeExtensionInstance<"postgres">>;
+/**
+ * Stub-adapter type augments the public {@link Adapter} surface with a `__codecs` slot that exposes the test stub's runtime codec set to descriptor-shaping helpers (`createTestAdapterDescriptor`). Production adapters do not declare this slot — runtime codecs flow through the descriptor list from `SqlRuntimeAdapterDescriptor.codecs()` — so the augmentation is intentionally test-only.
+ */
+type StubAdapter = Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> & {
+  readonly __codecs: ReadonlyArray<Codec<string>>;
+};
 /**
- * Creates a stub adapter for testing.
- * This helper DRYs up the common pattern of adapter creation in tests.
+ * Creates a stub adapter for testing. This helper DRYs up the common pattern of adapter creation in tests.
  *
- * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)
- * to enable type inference in tests without requiring the postgres adapter package.
+ * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1) to enable type inference in tests without requiring the postgres adapter package.
  */
-declare function createStubAdapter(): Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>;
+declare function createStubAdapter(): StubAdapter;
 declare function createTestContract(contract: Partial<Omit<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {
   storageHash?: string;
   profileHash?: string;
   storage?: Omit<SqlStorage, 'storageHash'>;
 }): Contract<SqlStorage>;
 //#endregion
-export { type DevDatabase, collectAsync, createDevDatabase, createStubAdapter, createTestAdapterDescriptor, createTestContext, createTestContract, createTestStackInstance, createTestTargetDescriptor, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, teardownTestDatabase, withClient, writeTestContractMarker };
+export { type DevDatabase, StubAdapter, buildTestContractCodecs, collectAsync, createDevDatabase, createStubAdapter, createTestAdapterDescriptor, createTestContext, createTestContract, createTestStackInstance, createTestTargetDescriptor, descriptorsFromCodecs, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, teardownTestDatabase, withClient, writeTestContractMarker };
 //# sourceMappingURL=utils.d.mts.map

package/dist/test/utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.mts","names":[],"sources":["../../test/utils.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../test/utils.ts"],"mappings":";;;;;;;;;;;;;;;AAyDA;iBAAsB,qBAAA,WACV,gBAAA,CAAiB,UAAA,CAAW,CAAA,KAAM,YAAA,CAAa,UAAA,CAAW,CAAA,GAAA,CACpE,OAAA,EAAS,UAAA,QAAkB,aAAA,GAAgB,IAAA,EAAM,CAAA,GAAI,OAAA,CAAQ,UAAA,CAAW,CAAA;;;;iBAQpD,kBAAA,CACpB,OAAA,EAAS,UAAA,QAAkB,aAAA,GAC3B,IAAA,EAAM,gBAAA,GAAmB,YAAA,YACxB,OAAA;;;;iBAOmB,gBAAA,CAAiB,MAAA,EAAQ,MAAA,EAAQ,SAAA,EAAW,YAAA,GAAe,OAAA;;;;iBAY3D,iBAAA,CACpB,MAAA,EAAQ,MAAA,EACR,QAAA,EAAU,QAAA,CAAS,UAAA,GACnB,OAAA,GAAU,MAAA,EAAQ,MAAA,KAAW,OAAA,SAC5B,OAAA;;;;iBAqBmB,uBAAA,CACpB,MAAA,EAAQ,MAAA,EACR,QAAA,EAAU,QAAA,CAAS,UAAA,IAClB,OAAA;;;;;;;iBAiBa,uBAAA,CACd,MAAA,EAAQ,aAAA,CAAc,KAAA,YACrB,qBAAA;;;;;iBAea,qBAAA,CACd,MAAA,EAAQ,aAAA,CAAc,KAAA,YACrB,aAAA,CAAc,eAAA;AAAA,iBAqBD,2BAAA,CACd,OAAA,EAAS,WAAA,GACR,2BAAA;;;;iBAmBa,0BAAA,CAAA,GAA8B,0BAAA;;;;;;iBAmB9B,iBAAA,mBAAoC,QAAA,CAAS,UAAA,EAAA,CAC3D,QAAA,EAAU,SAAA,EACV,OAAA,EAAS,WAAA,EACT,OAAA;EACE,cAAA,GAAiB,aAAA,CAAc,6BAAA;AAAA,IAEhC,gBAAA,CAAiB,SAAA;AAAA,iBAWJ,uBAAA,CAAwB,OAAA;EACtC,cAAA,GAAiB,aAAA,CAAc,6BAAA;EAC/B,MAAA,GAAS,uBAAA,6BAIP,wBAAA;AAAA,IAEH,8CAAA,CAAA,sBAAA,oBAAA,yBAAA,cAAA,wBAAA,cAAA,2BAAA;;;;KAcW,WAAA,GAAc,OAAA,CAAQ,SAAA,EAAW,QAAA,CAAS,UAAA,GAAa,gBAAA;EAAA,SACxD,QAAA,EAAU,aAAA,CAAc,KAAA;AAAA;AAjLnC;;;;;AAAA,iBAyLgB,iBAAA,CAAA,GAAqB,WAAA;AAAA,iBA4CrB,kBAAA,CACd,QAAA,EAAU,OAAA,CAAQ,IAAA,CAAK,QAAA,CAAS,UAAA;EAC9B,WAAA;EACA,WAAA;EACA,OAAA,GAAU,IAAA,CAAK,UAAA;AAAA,IAEhB,QAAA,CAAS,UAAA"}

package/dist/test/utils.mjs

@@ -1,11 +1,37 @@
-import { c as createSqlExecutionStack, i as ensureTableStatement, o as writeContractMarker, r as ensureSchemaStatement, s as createExecutionContext } from "../exports-BOHa3Emo.mjs";
-import { codec, createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { a as ensureTableStatement, c as createExecutionContext, i as ensureSchemaStatement, l as createSqlExecutionStack, r as APP_SPACE_ID, s as writeContractMarker } from "../exports-BSTHn_rH.mjs";
 import { instantiateExecutionStack } from "@prisma-next/framework-components/execution";
 import { coreHash, profileHash } from "@prisma-next/contract/types";
+import { voidParamsSchema } from "@prisma-next/framework-components/codec";
 import { builtinGeneratorIds } from "@prisma-next/ids";
 import { generateId } from "@prisma-next/ids/runtime";
 import { collectAsync, collectAsync as collectAsync$1, createDevDatabase, drainAsyncIterable, teardownTestDatabase, withClient } from "@prisma-next/test-utils";
-
+//#region test/test-codec.ts
+function defineTestCodec(config) {
+	const identity = (v) => v;
+	const userEncode = config.encode;
+	const userDecode = config.decode;
+	const widenedConfig = config;
+	return {
+		id: config.typeId,
+		encode: (value, ctx) => {
+			try {
+				return Promise.resolve(userEncode(value, ctx));
+			} catch (error) {
+				return Promise.reject(error);
+			}
+		},
+		decode: (wire, ctx) => {
+			try {
+				return Promise.resolve(userDecode(wire, ctx));
+			} catch (error) {
+				return Promise.reject(error);
+			}
+		},
+		encodeJson: widenedConfig.encodeJson ?? identity,
+		decodeJson: widenedConfig.decodeJson ?? identity
+	};
+}
+//#endregion
 //#region test/utils.ts
 function createTestMutationDefaultGenerators() {
 	return builtinGeneratorIds.map((id) => ({
@@ -13,20 +39,18 @@ function createTestMutationDefaultGenerators() {
 		generate: (params) => generateId(params ? {
 			id,
 			params
-		} : { id })
+		} : { id }),
+		stability: "field"
 	}));
 }
 /**
-* Executes a plan and collects all results into an array.
-* This helper DRYs up the common pattern of executing plans in tests.
-* The return type is inferred from the plan's type parameter.
+* Executes a plan and collects all results into an array. This helper DRYs up the common pattern of executing plans in tests. The return type is inferred from the plan's type parameter.
 */
 async function executePlanAndCollect(runtime, plan) {
 	return collectAsync$1(runtime.execute(plan));
 }
 /**
-* Drains a plan execution, consuming all results without collecting them.
-* Useful for testing side effects without memory overhead.
+* Drains a plan execution, consuming all results without collecting them. Useful for testing side effects without memory overhead.
 */
 async function drainPlanExecution(runtime, plan) {
 	return drainAsyncIterable(runtime.execute(plan));
@@ -42,8 +66,7 @@ async function executeStatement(client, statement) {
 	await client.query(statement.sql);
 }
 /**
-* Sets up database schema and data, then writes the contract marker.
-* This helper DRYs up the common pattern of database setup in tests.
+* Sets up database schema and data, then writes the contract marker. This helper DRYs up the common pattern of database setup in tests.
 */
 async function setupTestDatabase(client, contract, setupFn) {
 	await client.query("drop schema if exists prisma_contract cascade");
@@ -52,6 +75,7 @@ async function setupTestDatabase(client, contract, setupFn) {
 	await executeStatement(client, ensureSchemaStatement);
 	await executeStatement(client, ensureTableStatement);
 	await executeStatement(client, writeContractMarker({
+		space: APP_SPACE_ID,
 		storageHash: contract.storage.storageHash,
 		profileHash: contract.profileHash,
 		contractJson: contract,
@@ -59,11 +83,11 @@ async function setupTestDatabase(client, contract, setupFn) {
 	}).insert);
 }
 /**
-* Writes a contract marker to the database.
-* This helper DRYs up the common pattern of writing contract markers in tests.
+* Writes a contract marker to the database. This helper DRYs up the common pattern of writing contract markers in tests.
 */
 async function writeTestContractMarker(client, contract) {
 	await executeStatement(client, writeContractMarker({
+		space: APP_SPACE_ID,
 		storageHash: contract.storage.storageHash,
 		profileHash: contract.profileHash,
 		contractJson: contract,
@@ -71,20 +95,48 @@ async function writeTestContractMarker(client, contract) {
 	}).insert);
 }
 /**
-* Creates a test adapter descriptor from a raw adapter.
-* Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions
-* derived from the adapter's codec registry.
+* Creates a test adapter descriptor from a raw adapter. Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions derived from the adapter's codec registry.
+*/
+/**
+* Build a {@link ContractCodecRegistry} from a codec array for tests that exercise `encodeParam(s)` / `decodeRow` in isolation. The production runtime builds `ContractCodecRegistry` from contract walk + descriptor list and never goes through this helper; tests use it to wire a hand-built codec set into the surface those functions consume in production.
 */
+function buildTestContractCodecs(codecs) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const codec of codecs) byId.set(codec.id, codec);
+	return {
+		forColumn: () => void 0,
+		forCodecId: (codecId) => byId.get(codecId)
+	};
+}
+/**
+* Synthesize `CodecDescriptor`s from a codec array of non-parameterized codec instances. Test-only: the production synthesis bridge was retired under TML-2357. Lets the existing `createTestAdapterDescriptor` pattern keep wrapping a stub `Adapter` (whose `__codecs` slot still exposes the codec set) into the descriptor-list shape that `SqlStaticContributions.codecs:` now expects. The `Codec` instances carry
+* `traits`/`targetTypes`/`meta` via the SQL family extension; the structural narrow reads those fields directly.
+*/
+function descriptorsFromCodecs(codecs) {
+	const descriptors = [];
+	for (const instance of codecs) {
+		const legacy = instance;
+		descriptors.push({
+			codecId: instance.id,
+			traits: legacy.traits ?? [],
+			targetTypes: legacy.targetTypes ?? [],
+			paramsSchema: voidParamsSchema,
+			isParameterized: false,
+			factory: () => () => instance,
+			...legacy.meta !== void 0 ? { meta: legacy.meta } : {}
+		});
+	}
+	return descriptors;
+}
 function createTestAdapterDescriptor(adapter) {
-	const codecRegistry = adapter.profile.codecs();
+	const descriptors = descriptorsFromCodecs(adapter.__codecs);
 	return {
 		kind: "adapter",
 		id: "test-adapter",
 		version: "0.0.1",
 		familyId: "sql",
 		targetId: "postgres",
-		codecs: () => codecRegistry,
-		parameterizedCodecs: () => [],
+		codecs: () => descriptors,
 		mutationDefaultGenerators: createTestMutationDefaultGenerators,
 		create(_stack) {
 			return Object.assign({
@@ -104,8 +156,7 @@ function createTestTargetDescriptor() {
 		version: "0.0.1",
 		familyId: "sql",
 		targetId: "postgres",
-		codecs: () => createCodecRegistry(),
-		parameterizedCodecs: () => [],
+		codecs: () => [],
 		create() {
 			return {
 				familyId: "sql",
@@ -115,11 +166,9 @@ function createTestTargetDescriptor() {
 	};
 }
 /**
-* Creates an ExecutionContext for testing.
-* This helper DRYs up the common pattern of context creation in tests.
+* Creates an ExecutionContext for testing. This helper DRYs up the common pattern of context creation in tests.
 *
-* Accepts a raw adapter and optional extension descriptors, wrapping the
-* adapter in a descriptor internally for descriptor-first context creation.
+* Accepts a raw adapter and optional extension descriptors, wrapping the adapter in a descriptor internally for descriptor-first context creation.
 */
 function createTestContext(contract, adapter, options) {
 	return createExecutionContext({
@@ -140,51 +189,42 @@ function createTestStackInstance(options) {
 	}));
 }
 /**
-* Creates a stub adapter for testing.
-* This helper DRYs up the common pattern of adapter creation in tests.
+* Creates a stub adapter for testing. This helper DRYs up the common pattern of adapter creation in tests.
 *
-* The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)
-* to enable type inference in tests without requiring the postgres adapter package.
+* The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1) to enable type inference in tests without requiring the postgres adapter package.
 */
 function createStubAdapter() {
-	const codecRegistry = createCodecRegistry();
-	codecRegistry.register(codec({
-		typeId: "pg/int4@1",
-		targetTypes: ["int4"],
-		encode: (value) => value,
-		decode: (wire) => wire
-	}));
-	codecRegistry.register(codec({
-		typeId: "pg/text@1",
-		targetTypes: ["text"],
-		encode: (value) => value,
-		decode: (wire) => wire
-	}));
-	codecRegistry.register(codec({
-		typeId: "pg/timestamptz@1",
-		targetTypes: ["timestamptz"],
-		encode: (value) => value instanceof Date ? value.toISOString() : value,
-		decode: (wire) => wire instanceof Date ? wire : new Date(wire),
-		encodeJson: (value) => value instanceof Date ? value.toISOString() : value,
-		decodeJson: (json) => {
-			if (typeof json !== "string") throw new Error("expected ISO date string");
-			return new Date(json);
-		}
-	}));
 	return {
+		__codecs: [
+			defineTestCodec({
+				typeId: "pg/int4@1",
+				targetTypes: ["int4"],
+				encode: (value) => value,
+				decode: (wire) => wire
+			}),
+			defineTestCodec({
+				typeId: "pg/text@1",
+				targetTypes: ["text"],
+				encode: (value) => value,
+				decode: (wire) => wire
+			}),
+			defineTestCodec({
+				typeId: "pg/timestamptz@1",
+				targetTypes: ["timestamptz"],
+				encode: (value) => value,
+				decode: (wire) => wire,
+				encodeJson: (value) => value.toISOString(),
+				decodeJson: (json) => {
+					if (typeof json !== "string") throw new Error("expected ISO date string");
+					return new Date(json);
+				}
+			})
+		],
 		profile: {
 			id: "stub-profile",
 			target: "postgres",
 			capabilities: {},
-			codecs() {
-				return codecRegistry;
-			},
-			readMarkerStatement() {
-				return {
-					sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1",
-					params: [1]
-				};
-			}
+			readMarker: async () => ({ kind: "absent" })
 		},
 		lower(ast, ctx) {
 			const sqlText = JSON.stringify(ast);
@@ -217,7 +257,7 @@ function createTestContract(contract) {
 		profileHash: profileHash(rest["profileHash"] ?? "sha256:testprofile")
 	};
 }
-
 //#endregion
-export { collectAsync, createDevDatabase, createStubAdapter, createTestAdapterDescriptor, createTestContext, createTestContract, createTestStackInstance, createTestTargetDescriptor, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, teardownTestDatabase, withClient, writeTestContractMarker };
+export { buildTestContractCodecs, collectAsync, createDevDatabase, createStubAdapter, createTestAdapterDescriptor, createTestContext, createTestContract, createTestStackInstance, createTestTargetDescriptor, descriptorsFromCodecs, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, teardownTestDatabase, withClient, writeTestContractMarker };
+
 //# sourceMappingURL=utils.mjs.map

package/dist/test/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/utils.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { coreHash, profileHash } from '@prisma-next/contract/types';\nimport {\n  instantiateExecutionStack,\n  type RuntimeDriverDescriptor,\n} from '@prisma-next/framework-components/execution';\nimport type { ResultType } from '@prisma-next/framework-components/runtime';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { Adapter, LoweredStatement, SelectAst } from '@prisma-next/sql-relational-core/ast';\nimport { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlExecutionPlan, SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\nimport { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';\nimport type { Client } from 'pg';\nimport type { SqlStatement } from '../src/exports';\nimport {\n  createExecutionContext,\n  type createRuntime,\n  createSqlExecutionStack,\n  ensureSchemaStatement,\n  ensureTableStatement,\n  writeContractMarker,\n} from '../src/exports';\nimport type {\n  ExecutionContext,\n  SqlRuntimeAdapterDescriptor,\n  SqlRuntimeAdapterInstance,\n  SqlRuntimeDriverInstance,\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeTargetDescriptor,\n} from '../src/sql-context';\n\nfunction createTestMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => generateId(params ? { id, params } : { id }),\n  }));\n}\n\n/**\n * Executes a plan and collects all results into an array.\n * This helper DRYs up the common pattern of executing plans in tests.\n * The return type is inferred from the plan's type parameter.\n */\nexport async function executePlanAndCollect<\n  P extends SqlExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>,\n>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]> {\n  type Row = ResultType<P>;\n  return collectAsync<Row>(runtime.execute<Row>(plan));\n}\n\n/**\n * Drains a plan execution, consuming all results without collecting them.\n * Useful for testing side effects without memory overhead.\n */\nexport async function drainPlanExecution(\n  runtime: ReturnType<typeof createRuntime>,\n  plan: SqlExecutionPlan | SqlQueryPlan<unknown>,\n): Promise<void> {\n  return drainAsyncIterable(runtime.execute(plan));\n}\n\n/**\n * Executes a SQL statement on a database client.\n */\nexport async function executeStatement(client: Client, statement: SqlStatement): Promise<void> {\n  if (statement.params.length > 0) {\n    await client.query(statement.sql, [...statement.params]);\n    return;\n  }\n\n  await client.query(statement.sql);\n}\n\n/**\n * Sets up database schema and data, then writes the contract marker.\n * This helper DRYs up the common pattern of database setup in tests.\n */\nexport async function setupTestDatabase(\n  client: Client,\n  contract: Contract<SqlStorage>,\n  setupFn: (client: Client) => Promise<void>,\n): Promise<void> {\n  await client.query('drop schema if exists prisma_contract cascade');\n  await client.query('create schema if not exists public');\n\n  await setupFn(client);\n\n  await executeStatement(client, ensureSchemaStatement);\n  await executeStatement(client, ensureTableStatement);\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Writes a contract marker to the database.\n * This helper DRYs up the common pattern of writing contract markers in tests.\n */\nexport async function writeTestContractMarker(\n  client: Client,\n  contract: Contract<SqlStorage>,\n): Promise<void> {\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Creates a test adapter descriptor from a raw adapter.\n * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions\n * derived from the adapter's codec registry.\n */\nexport function createTestAdapterDescriptor(\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n): SqlRuntimeAdapterDescriptor<'postgres'> {\n  const codecRegistry = adapter.profile.codecs();\n  return {\n    kind: 'adapter' as const,\n    id: 'test-adapter',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => codecRegistry,\n    parameterizedCodecs: () => [],\n    mutationDefaultGenerators: createTestMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapterInstance<'postgres'> {\n      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);\n    },\n  };\n}\n\n/**\n * Creates a test target descriptor with empty static contributions.\n */\nexport function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {\n  return {\n    kind: 'target' as const,\n    id: 'postgres',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => createCodecRegistry(),\n    parameterizedCodecs: () => [],\n    create() {\n      return { familyId: 'sql' as const, targetId: 'postgres' as const };\n    },\n  };\n}\n\n/**\n * Creates an ExecutionContext for testing.\n * This helper DRYs up the common pattern of context creation in tests.\n *\n * Accepts a raw adapter and optional extension descriptors, wrapping the\n * adapter in a descriptor internally for descriptor-first context creation.\n */\nexport function createTestContext<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n  options?: {\n    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  },\n): ExecutionContext<TContract> {\n  return createExecutionContext({\n    contract,\n    stack: {\n      target: createTestTargetDescriptor(),\n      adapter: createTestAdapterDescriptor(adapter),\n      extensionPacks: options?.extensionPacks ?? [],\n    },\n  });\n}\n\nexport function createTestStackInstance(options?: {\n  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  driver?: RuntimeDriverDescriptor<\n    'sql',\n    'postgres',\n    unknown,\n    SqlRuntimeDriverInstance<'postgres'>\n  >;\n}) {\n  const stack = createSqlExecutionStack({\n    target: createTestTargetDescriptor(),\n    adapter: createTestAdapterDescriptor(createStubAdapter()),\n    driver: options?.driver,\n    extensionPacks: options?.extensionPacks ?? [],\n  });\n\n  return instantiateExecutionStack(stack);\n}\n\n/**\n * Creates a stub adapter for testing.\n * This helper DRYs up the common pattern of adapter creation in tests.\n *\n * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)\n * to enable type inference in tests without requiring the postgres adapter package.\n */\nexport function createStubAdapter(): Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> {\n  const codecRegistry = createCodecRegistry();\n\n  // Register stub codecs for common test types\n  // These match the codec IDs used in test contracts (pg/int4@1, pg/text@1, pg/timestamptz@1)\n  // but don't require importing from the postgres adapter package\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/int4@1',\n      targetTypes: ['int4'],\n      encode: (value: number) => value,\n      decode: (wire: number) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/text@1',\n      targetTypes: ['text'],\n      encode: (value: string) => value,\n      decode: (wire: string) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/timestamptz@1',\n      targetTypes: ['timestamptz'],\n      encode: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),\n      decode: (wire: string | Date) => (wire instanceof Date ? wire : new Date(wire)),\n      // string | Date includes Date which is not assignable to JsonValue, so\n      // the JSON round-trip pair must be supplied explicitly.\n      encodeJson: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),\n      decodeJson: (json) => {\n        if (typeof json !== 'string') throw new Error('expected ISO date string');\n        return new Date(json);\n      },\n    }),\n  );\n\n  return {\n    profile: {\n      id: 'stub-profile',\n      target: 'postgres',\n      capabilities: {},\n      codecs() {\n        return codecRegistry;\n      },\n      readMarkerStatement() {\n        return {\n          sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',\n          params: [1],\n        };\n      },\n    },\n    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] });\n    },\n  };\n}\n\nexport function createTestContract(\n  contract: Partial<Omit<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {\n    storageHash?: string;\n    profileHash?: string;\n    storage?: Omit<SqlStorage, 'storageHash'>;\n  },\n): Contract<SqlStorage> {\n  const { execution, ...rest } = contract;\n  const storageHashValue = coreHash(rest['storageHash'] ?? 'sha256:testcore');\n\n  return {\n    target: rest['target'] ?? 'postgres',\n    targetFamily: rest['targetFamily'] ?? 'sql',\n    storage: rest['storage']\n      ? { ...rest['storage'], storageHash: storageHashValue }\n      : { storageHash: storageHashValue, tables: {} },\n    models: rest['models'] ?? {},\n    roots: rest['roots'] ?? {},\n    capabilities: rest['capabilities'] ?? {},\n    extensionPacks: rest['extensionPacks'] ?? {},\n    meta: rest['meta'] ?? {},\n    ...(execution ? { execution } : {}),\n    profileHash: profileHash(rest['profileHash'] ?? 'sha256:testprofile'),\n  };\n}\n\n// Re-export generic utilities from test-utils\nexport {\n  collectAsync,\n  createDevDatabase,\n  type DevDatabase,\n  teardownTestDatabase,\n  withClient,\n} from '@prisma-next/test-utils';\n"],"mappings":"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"}
+{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/test-codec.ts","../../test/utils.ts"],"sourcesContent":["/**\n * Test-only helper that constructs a SQL-family `Codec` instance from author-side encode/decode functions. Replaces the legacy public `mkCodec()` factory (deleted under TML-2357); tests that need a stub codec for behavioural assertions instantiate one through this helper rather than going through `descriptor.factory(...)`.\n *\n * The body is identical in spirit to the retired `mkCodec`: promise-lift sync author functions onto the framework-required `Promise<…>` boundary, default `encodeJson`/`decodeJson` to identity when `TInput` is JSON-safe, fail loudly otherwise.\n */\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport type { CodecTrait } from '@prisma-next/framework-components/codec';\nimport type { Codec, SqlCodecCallContext } from '@prisma-next/sql-relational-core/ast';\n\ntype JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue]\n  ? {\n      encodeJson?: (value: TInput) => JsonValue;\n      decodeJson?: (json: JsonValue) => TInput;\n    }\n  : {\n      encodeJson: (value: TInput) => JsonValue;\n      decodeJson: (json: JsonValue) => TInput;\n    };\n\nexport function defineTestCodec<\n  Id extends string,\n  const TTraits extends readonly CodecTrait[] = readonly [],\n  TWire = unknown,\n  TInput = unknown,\n>(\n  config: {\n    typeId: Id;\n    targetTypes?: readonly string[];\n    encode: (value: TInput, ctx: SqlCodecCallContext) => TWire | Promise<TWire>;\n    decode: (wire: TWire, ctx: SqlCodecCallContext) => TInput | Promise<TInput>;\n    traits?: TTraits;\n  } & JsonRoundTripConfig<TInput>,\n): Codec<Id, TTraits, TWire, TInput> {\n  const identity = (v: unknown) => v;\n  const userEncode = config.encode;\n  const userDecode = config.decode;\n  const widenedConfig = config as {\n    encodeJson?: (value: TInput) => JsonValue;\n    decodeJson?: (json: JsonValue) => TInput;\n  };\n  return {\n    id: config.typeId,\n    encode: (value, ctx) => {\n      try {\n        return Promise.resolve(userEncode(value, ctx));\n      } catch (error) {\n        return Promise.reject(error);\n      }\n    },\n    decode: (wire, ctx) => {\n      try {\n        return Promise.resolve(userDecode(wire, ctx));\n      } catch (error) {\n        return Promise.reject(error);\n      }\n    },\n    encodeJson: (widenedConfig.encodeJson ?? identity) as (value: TInput) => JsonValue,\n    decodeJson: (widenedConfig.decodeJson ?? identity) as (json: JsonValue) => TInput,\n  } as Codec<Id, TTraits, TWire, TInput>;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { coreHash, profileHash } from '@prisma-next/contract/types';\nimport type {\n  CodecDescriptor,\n  CodecMeta,\n  CodecTrait,\n} from '@prisma-next/framework-components/codec';\nimport { voidParamsSchema } from '@prisma-next/framework-components/codec';\nimport {\n  instantiateExecutionStack,\n  type RuntimeDriverDescriptor,\n} from '@prisma-next/framework-components/execution';\nimport type { ResultType } from '@prisma-next/framework-components/runtime';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type {\n  Adapter,\n  Codec,\n  ContractCodecRegistry,\n  LoweredStatement,\n  SelectAst,\n} from '@prisma-next/sql-relational-core/ast';\nimport type { SqlExecutionPlan, SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\nimport { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';\nimport type { Client } from 'pg';\nimport type { SqlStatement } from '../src/exports';\nimport {\n  APP_SPACE_ID,\n  createExecutionContext,\n  type createRuntime,\n  createSqlExecutionStack,\n  ensureSchemaStatement,\n  ensureTableStatement,\n  writeContractMarker,\n} from '../src/exports';\nimport type {\n  ExecutionContext,\n  SqlRuntimeAdapterDescriptor,\n  SqlRuntimeAdapterInstance,\n  SqlRuntimeDriverInstance,\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeTargetDescriptor,\n} from '../src/sql-context';\nimport { defineTestCodec } from './test-codec';\n\nfunction createTestMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => generateId(params ? { id, params } : { id }),\n    stability: 'field' as const,\n  }));\n}\n\n/**\n * Executes a plan and collects all results into an array. This helper DRYs up the common pattern of executing plans in tests. The return type is inferred from the plan's type parameter.\n */\nexport async function executePlanAndCollect<\n  P extends SqlExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>,\n>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]> {\n  type Row = ResultType<P>;\n  return collectAsync<Row>(runtime.execute<Row>(plan));\n}\n\n/**\n * Drains a plan execution, consuming all results without collecting them. Useful for testing side effects without memory overhead.\n */\nexport async function drainPlanExecution(\n  runtime: ReturnType<typeof createRuntime>,\n  plan: SqlExecutionPlan | SqlQueryPlan<unknown>,\n): Promise<void> {\n  return drainAsyncIterable(runtime.execute(plan));\n}\n\n/**\n * Executes a SQL statement on a database client.\n */\nexport async function executeStatement(client: Client, statement: SqlStatement): Promise<void> {\n  if (statement.params.length > 0) {\n    await client.query(statement.sql, [...statement.params]);\n    return;\n  }\n\n  await client.query(statement.sql);\n}\n\n/**\n * Sets up database schema and data, then writes the contract marker. This helper DRYs up the common pattern of database setup in tests.\n */\nexport async function setupTestDatabase(\n  client: Client,\n  contract: Contract<SqlStorage>,\n  setupFn: (client: Client) => Promise<void>,\n): Promise<void> {\n  await client.query('drop schema if exists prisma_contract cascade');\n  await client.query('create schema if not exists public');\n\n  await setupFn(client);\n\n  await executeStatement(client, ensureSchemaStatement);\n  await executeStatement(client, ensureTableStatement);\n  const write = writeContractMarker({\n    space: APP_SPACE_ID,\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Writes a contract marker to the database. This helper DRYs up the common pattern of writing contract markers in tests.\n */\nexport async function writeTestContractMarker(\n  client: Client,\n  contract: Contract<SqlStorage>,\n): Promise<void> {\n  const write = writeContractMarker({\n    space: APP_SPACE_ID,\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Creates a test adapter descriptor from a raw adapter. Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions derived from the adapter's codec registry.\n */\n/**\n * Build a {@link ContractCodecRegistry} from a codec array for tests that exercise `encodeParam(s)` / `decodeRow` in isolation. The production runtime builds `ContractCodecRegistry` from contract walk + descriptor list and never goes through this helper; tests use it to wire a hand-built codec set into the surface those functions consume in production.\n */\nexport function buildTestContractCodecs(\n  codecs: ReadonlyArray<Codec<string>>,\n): ContractCodecRegistry {\n  const byId = new Map<string, Codec<string>>();\n  for (const codec of codecs) {\n    byId.set(codec.id, codec);\n  }\n  return {\n    forColumn: () => undefined,\n    forCodecId: (codecId) => byId.get(codecId),\n  };\n}\n\n/**\n * Synthesize `CodecDescriptor`s from a codec array of non-parameterized codec instances. Test-only: the production synthesis bridge was retired under TML-2357. Lets the existing `createTestAdapterDescriptor` pattern keep wrapping a stub `Adapter` (whose `__codecs` slot still exposes the codec set) into the descriptor-list shape that `SqlStaticContributions.codecs:` now expects. The `Codec` instances carry\n * `traits`/`targetTypes`/`meta` via the SQL family extension; the structural narrow reads those fields directly.\n */\nexport function descriptorsFromCodecs(\n  codecs: ReadonlyArray<Codec<string>>,\n): ReadonlyArray<CodecDescriptor> {\n  const descriptors: CodecDescriptor[] = [];\n  for (const instance of codecs) {\n    const legacy = instance as {\n      readonly traits?: readonly CodecTrait[];\n      readonly targetTypes?: readonly string[];\n      readonly meta?: CodecMeta;\n    };\n    descriptors.push({\n      codecId: instance.id,\n      traits: legacy.traits ?? [],\n      targetTypes: legacy.targetTypes ?? [],\n      paramsSchema: voidParamsSchema,\n      isParameterized: false,\n      factory: () => () => instance,\n      ...(legacy.meta !== undefined ? { meta: legacy.meta } : {}),\n    });\n  }\n  return descriptors;\n}\n\nexport function createTestAdapterDescriptor(\n  adapter: StubAdapter,\n): SqlRuntimeAdapterDescriptor<'postgres'> {\n  const descriptors = descriptorsFromCodecs(adapter.__codecs);\n  return {\n    kind: 'adapter' as const,\n    id: 'test-adapter',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => descriptors,\n    mutationDefaultGenerators: createTestMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapterInstance<'postgres'> {\n      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);\n    },\n  };\n}\n\n/**\n * Creates a test target descriptor with empty static contributions.\n */\nexport function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {\n  return {\n    kind: 'target' as const,\n    id: 'postgres',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => [],\n    create() {\n      return { familyId: 'sql' as const, targetId: 'postgres' as const };\n    },\n  };\n}\n\n/**\n * Creates an ExecutionContext for testing. This helper DRYs up the common pattern of context creation in tests.\n *\n * Accepts a raw adapter and optional extension descriptors, wrapping the adapter in a descriptor internally for descriptor-first context creation.\n */\nexport function createTestContext<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  adapter: StubAdapter,\n  options?: {\n    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  },\n): ExecutionContext<TContract> {\n  return createExecutionContext({\n    contract,\n    stack: {\n      target: createTestTargetDescriptor(),\n      adapter: createTestAdapterDescriptor(adapter),\n      extensionPacks: options?.extensionPacks ?? [],\n    },\n  });\n}\n\nexport function createTestStackInstance(options?: {\n  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  driver?: RuntimeDriverDescriptor<\n    'sql',\n    'postgres',\n    unknown,\n    SqlRuntimeDriverInstance<'postgres'>\n  >;\n}) {\n  const stack = createSqlExecutionStack({\n    target: createTestTargetDescriptor(),\n    adapter: createTestAdapterDescriptor(createStubAdapter()),\n    driver: options?.driver,\n    extensionPacks: options?.extensionPacks ?? [],\n  });\n\n  return instantiateExecutionStack(stack);\n}\n\n/**\n * Stub-adapter type augments the public {@link Adapter} surface with a `__codecs` slot that exposes the test stub's runtime codec set to descriptor-shaping helpers (`createTestAdapterDescriptor`). Production adapters do not declare this slot — runtime codecs flow through the descriptor list from `SqlRuntimeAdapterDescriptor.codecs()` — so the augmentation is intentionally test-only.\n */\nexport type StubAdapter = Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> & {\n  readonly __codecs: ReadonlyArray<Codec<string>>;\n};\n\n/**\n * Creates a stub adapter for testing. This helper DRYs up the common pattern of adapter creation in tests.\n *\n * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1) to enable type inference in tests without requiring the postgres adapter package.\n */\nexport function createStubAdapter(): StubAdapter {\n  // Stub codecs for common test types — match the codec IDs used in test contracts (pg/int4@1, pg/text@1, pg/timestamptz@1) without importing from the postgres adapter package.\n  const codecs: ReadonlyArray<Codec<string>> = [\n    defineTestCodec({\n      typeId: 'pg/int4@1',\n      targetTypes: ['int4'],\n      encode: (value: number) => value,\n      decode: (wire: number) => wire,\n    }),\n    defineTestCodec({\n      typeId: 'pg/text@1',\n      targetTypes: ['text'],\n      encode: (value: string) => value,\n      decode: (wire: string) => wire,\n    }),\n    defineTestCodec({\n      typeId: 'pg/timestamptz@1',\n      targetTypes: ['timestamptz'],\n      encode: (value: Date) => value,\n      decode: (wire: Date) => wire,\n      // Date is not assignable to JsonValue, so the JSON round-trip pair must be supplied explicitly.\n      encodeJson: (value: Date) => value.toISOString(),\n      decodeJson: (json) => {\n        if (typeof json !== 'string') throw new Error('expected ISO date string');\n        return new Date(json);\n      },\n    }),\n  ];\n\n  return {\n    __codecs: codecs,\n    profile: {\n      id: 'stub-profile',\n      target: 'postgres',\n      capabilities: {},\n      readMarker: async () => ({ kind: 'absent' as const }),\n    },\n    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] });\n    },\n  };\n}\n\nexport function createTestContract(\n  contract: Partial<Omit<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {\n    storageHash?: string;\n    profileHash?: string;\n    storage?: Omit<SqlStorage, 'storageHash'>;\n  },\n): Contract<SqlStorage> {\n  const { execution, ...rest } = contract;\n  const storageHashValue = coreHash(rest['storageHash'] ?? 'sha256:testcore');\n\n  return {\n    target: rest['target'] ?? 'postgres',\n    targetFamily: rest['targetFamily'] ?? 'sql',\n    storage: rest['storage']\n      ? { ...rest['storage'], storageHash: storageHashValue }\n      : { storageHash: storageHashValue, tables: {} },\n    models: rest['models'] ?? {},\n    roots: rest['roots'] ?? {},\n    capabilities: rest['capabilities'] ?? {},\n    extensionPacks: rest['extensionPacks'] ?? {},\n    meta: rest['meta'] ?? {},\n    ...(execution ? { execution } : {}),\n    profileHash: profileHash(rest['profileHash'] ?? 'sha256:testprofile'),\n  };\n}\n\n// Re-export generic utilities from test-utils\nexport {\n  collectAsync,\n  createDevDatabase,\n  type DevDatabase,\n  teardownTestDatabase,\n  withClient,\n} from '@prisma-next/test-utils';\n"],"mappings":"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"}

package/package.json

@@ -1,26 +1,27 @@
 {
   "name": "@prisma-next/sql-runtime",
-  "version": "0.5.0-dev.9",
+  "version": "0.6.0-dev.1",
+  "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL runtime implementation for Prisma Next",
   "dependencies": {
-    "arktype": "^2.1.26",
-    "@prisma-next/utils": "0.5.0-dev.9",
-    "@prisma-next/contract": "0.5.0-dev.9",
-    "@prisma-next/framework-components": "0.5.0-dev.9",
-    "@prisma-next/ids": "0.5.0-dev.9",
-    "@prisma-next/operations": "0.5.0-dev.9",
-    "@prisma-next/sql-contract": "0.5.0-dev.9",
-    "@prisma-next/sql-operations": "0.5.0-dev.9",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.9"
+    "arktype": "^2.1.29",
+    "@prisma-next/contract": "0.6.0-dev.1",
+    "@prisma-next/framework-components": "0.6.0-dev.1",
+    "@prisma-next/operations": "0.6.0-dev.1",
+    "@prisma-next/utils": "0.6.0-dev.1",
+    "@prisma-next/sql-contract": "0.6.0-dev.1",
+    "@prisma-next/sql-operations": "0.6.0-dev.1",
+    "@prisma-next/ids": "0.6.0-dev.1",
+    "@prisma-next/sql-relational-core": "0.6.0-dev.1"
   },
   "devDependencies": {
-    "@types/pg": "8.16.0",
-    "pg": "8.16.3",
-    "tsdown": "0.18.4",
+    "@types/pg": "8.20.0",
+    "pg": "8.20.0",
+    "tsdown": "0.22.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.17",
+    "vitest": "4.1.5",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0",
     "@prisma-next/test-utils": "0.0.1"

package/src/codecs/alias-resolver.ts

@@ -0,0 +1,37 @@
+import type { AnyFromSource, AnyQueryAst } from '@prisma-next/sql-relational-core/ast';
+
+/**
+ * Build a map from query-local table aliases to their underlying source table names.
+ *
+ * Self-joins like `db.sql.post.as('p1').innerJoin(db.sql.post.as('p2'), …)` produce `ColumnRef`s whose `table` is the alias (`p1`, `p2`) — the SQL renderer needs the alias for `SELECT p1.id, …`. Codec dispatch keys `byColumn` by the underlying source table, so aliases must be resolved back to the source name for `forColumn(...)` to hit. Tables that already use their canonical name (no alias) are also entered so a single
+ * lookup works for both shapes.
+ */
+function buildAliasMap(ast: AnyQueryAst): ReadonlyMap<string, string> {
+  const aliases = new Map<string, string>();
+  const recordSource = (source: AnyFromSource): void => {
+    if (source.kind === 'table-source') {
+      const key = source.alias ?? source.name;
+      aliases.set(key, source.name);
+    } else {
+      aliases.set(source.alias, source.alias);
+    }
+  };
+  if (ast.kind === 'select') {
+    recordSource(ast.from);
+    for (const join of ast.joins ?? []) {
+      recordSource(join.source);
+    }
+  } else if (ast.kind === 'raw-sql') {
+    // Raw-SQL ASTs do not bind a single primary table — alias resolution
+    // is driven by inline `IdentifierRef`s the caller embedded directly.
+  } else {
+    recordSource(ast.table);
+  }
+  return aliases;
+}
+
+export function makeAliasResolver(ast: AnyQueryAst | undefined): (alias: string) => string {
+  if (!ast) return (alias) => alias;
+  const map = buildAliasMap(ast);
+  return (alias) => map.get(alias) ?? alias;
+}