@prisma-next/sql-runtime 0.3.0-pr.93.5 → 0.3.0-pr.94.1

package/dist/test/utils.d.mts

@@ -0,0 +1,63 @@
+import { S as RuntimeContext, h as SqlStatement, m as createRuntime, w as SqlRuntimeExtensionDescriptor } from "../index-Bycr1UG5.mjs";
+import { Adapter, LoweredStatement, SelectAst } from "@prisma-next/sql-relational-core/ast";
+import { DevDatabase, collectAsync, createDevDatabase, teardownTestDatabase, withClient } from "@prisma-next/test-utils";
+import { SqlContract, SqlStorage } from "@prisma-next/sql-contract/types";
+import { ExecutionPlan, ResultType } from "@prisma-next/contract/types";
+import { 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.
+ */
+declare function executePlanAndCollect<P extends ExecutionPlan<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.
+ */
+declare function drainPlanExecution(runtime: ReturnType<typeof createRuntime>, plan: ExecutionPlan | SqlQueryPlan<unknown>): Promise<void>;
+/**
+ * Executes a SQL statement on a database client.
+ */
+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.
+ */
+declare function setupTestDatabase(client: Client, contract: SqlContract<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.
+ */
+declare function writeTestContractMarker(client: Client, contract: SqlContract<SqlStorage>): Promise<void>;
+/**
+ * Creates a runtime context with standard test configuration.
+ * 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.
+ */
+declare function createTestContext<TContract extends SqlContract<SqlStorage>>(contract: TContract, adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>, options?: {
+  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;
+}): RuntimeContext<TContract>;
+/**
+ * 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.
+ */
+declare function createStubAdapter(): Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>;
+/**
+ * Creates a valid test contract without using validateContract.
+ * Ensures all required fields are present (mappings, capabilities, extensionPacks, meta, sources)
+ * and returns the contract with proper typing.
+ * This helper allows tests to create contracts without depending on sql-query.
+ */
+declare function createTestContract<T extends SqlContract<SqlStorage>>(contract: Partial<T> & Omit<T, 'mappings' | 'capabilities' | 'extensionPacks' | 'meta' | 'sources'>): T;
+//#endregion
+export { type DevDatabase, collectAsync, createDevDatabase, createStubAdapter, createTestContext, createTestContract, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, teardownTestDatabase, withClient, writeTestContractMarker };
+//# sourceMappingURL=utils.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../test/utils.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA0BA;;;;AACmE,iBAD7C,qBAC6C,CAAA,UAAvD,aAAuD,CAAzC,UAAyC,CAA9B,CAA8B,CAAA,CAAA,GAAxB,YAAwB,CAAX,UAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EACxD,UADwD,CAAA,OACtC,aADsC,CAAA,EAAA,IAAA,EAChB,CADgB,CAAA,EACZ,OADY,CACJ,UADI,CACO,CADP,CAAA,EAAA,CAAA;;;;;AAChB,iBAS7B,kBAAA,CAT6B,OAAA,EAUxC,UAVwC,CAAA,OAUtB,aAVsB,CAAA,EAAA,IAAA,EAW3C,aAX2C,GAW3B,YAX2B,CAAA,OAAA,CAAA,CAAA,EAYhD,OAZgD,CAAA,IAAA,CAAA;;;;AAAW,iBAmBxC,gBAAA,CAnBwC,MAAA,EAmBf,MAnBe,EAAA,SAAA,EAmBI,YAnBJ,CAAA,EAmBmB,OAnBnB,CAAA,IAAA,CAAA;AAS9D;;;;AAEwB,iBAqBF,iBAAA,CArBE,MAAA,EAsBd,MAtBc,EAAA,QAAA,EAuBZ,WAvBY,CAuBA,UAvBA,CAAA,EAAA,OAAA,EAAA,CAAA,MAAA,EAwBJ,MAxBI,EAAA,GAwBO,OAxBP,CAAA,IAAA,CAAA,CAAA,EAyBrB,OAzBqB,CAAA,IAAA,CAAA;;;AAQxB;;AAAkE,iBAsC5C,uBAAA,CAtC4C,MAAA,EAuCxD,MAvCwD,EAAA,QAAA,EAwCtD,WAxCsD,CAwC1C,UAxC0C,CAAA,CAAA,EAyC/D,OAzC+D,CAAA,IAAA,CAAA;;;AAalE;;;;;AAG+B,iBAoGf,iBApGe,CAAA,kBAoGqB,WApGrB,CAoGiC,UApGjC,CAAA,CAAA,CAAA,QAAA,EAqGnB,SArGmB,EAAA,OAAA,EAsGpB,OAtGoB,CAsGZ,SAtGY,EAsGD,WAtGC,CAsGW,UAtGX,CAAA,EAsGwB,gBAtGxB,CAAA,EAAA,OACrB,CADqB,EAAA;EAC5B,cAAA,CAAA,EAuGkB,aAvGlB,CAuGgC,6BAvGhC,CAAA,UAAA,CAAA,CAAA;CAAO,CAAA,EAyGP,cAzGO,CAyGQ,SAzGR,CAAA;AAqBV;;;;;;AA8EA;AAAgE,iBAsBhD,iBAAA,CAAA,CAtBgD,EAsB3B,OAtB2B,CAsBnB,SAtBmB,EAsBR,WAtBQ,CAsBI,UAtBJ,CAAA,EAsBiB,gBAtBjB,CAAA;;;;;;;AAErD,iBA+EK,kBA/EL,CAAA,UA+EkC,WA/ElC,CA+E8C,UA/E9C,CAAA,CAAA,CAAA,QAAA,EAgFC,OAhFD,CAgFS,CAhFT,CAAA,GAiFP,IAjFO,CAiFF,CAjFE,EAAA,UAAA,GAAA,cAAA,GAAA,gBAAA,GAAA,MAAA,GAAA,SAAA,CAAA,CAAA,EAkFR,CAlFQ"}

package/dist/test/utils.mjs

@@ -0,0 +1,184 @@
+import { a as ensureTableStatement, c as createRuntimeContext, i as ensureSchemaStatement, s as writeContractMarker } from "../exports-BI-iW86w.mjs";
+import { codec, createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { collectAsync, collectAsync as collectAsync$1, createDevDatabase, drainAsyncIterable, teardownTestDatabase, withClient } from "@prisma-next/test-utils";
+
+//#region test/utils.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.
+*/
+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.
+*/
+async function drainPlanExecution(runtime, plan) {
+	return drainAsyncIterable(runtime.execute(plan));
+}
+/**
+* Executes a SQL statement on a database client.
+*/
+async function executeStatement(client, statement) {
+	if (statement.params.length > 0) {
+		await client.query(statement.sql, [...statement.params]);
+		return;
+	}
+	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.
+*/
+async function setupTestDatabase(client, contract, setupFn) {
+	await client.query("drop schema if exists prisma_contract cascade");
+	await client.query("create schema if not exists public");
+	await setupFn(client);
+	await executeStatement(client, ensureSchemaStatement);
+	await executeStatement(client, ensureTableStatement);
+	await executeStatement(client, writeContractMarker({
+		coreHash: contract.coreHash,
+		profileHash: contract.profileHash ?? contract.coreHash,
+		contractJson: contract,
+		canonicalVersion: 1
+	}).insert);
+}
+/**
+* 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({
+		coreHash: contract.coreHash,
+		profileHash: contract.profileHash ?? contract.coreHash,
+		contractJson: contract,
+		canonicalVersion: 1
+	}).insert);
+}
+/**
+* Creates a test adapter descriptor from a raw adapter.
+* This wraps the adapter in a descriptor for descriptor-first context creation in tests.
+* The adapter instance IS an Adapter (via intersection), with identity properties added.
+*/
+function createTestAdapterDescriptor(adapter) {
+	return {
+		kind: "adapter",
+		id: "test-adapter",
+		version: "0.0.1",
+		familyId: "sql",
+		targetId: "postgres",
+		create() {
+			return Object.assign({
+				familyId: "sql",
+				targetId: "postgres"
+			}, adapter);
+		}
+	};
+}
+/**
+* Creates a test target descriptor.
+* This is a minimal descriptor for descriptor-first context creation in tests.
+*/
+function createTestTargetDescriptor() {
+	return {
+		kind: "target",
+		id: "postgres",
+		version: "0.0.1",
+		familyId: "sql",
+		targetId: "postgres",
+		create() {
+			return {
+				familyId: "sql",
+				targetId: "postgres"
+			};
+		}
+	};
+}
+/**
+* Creates a runtime context with standard test configuration.
+* 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.
+*/
+function createTestContext(contract, adapter, options) {
+	return createRuntimeContext({
+		contract,
+		target: createTestTargetDescriptor(),
+		adapter: createTestAdapterDescriptor(adapter),
+		extensionPacks: options?.extensionPacks ?? []
+	});
+}
+/**
+* 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.
+*/
+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) => typeof wire === "string" ? wire : wire instanceof Date ? wire.toISOString() : String(wire)
+	}));
+	return {
+		profile: {
+			id: "stub-profile",
+			target: "postgres",
+			capabilities: {},
+			codecs() {
+				return codecRegistry;
+			}
+		},
+		lower(ast, ctx) {
+			const sqlText = JSON.stringify(ast);
+			return {
+				profileId: this.profile.id,
+				body: Object.freeze({
+					sql: sqlText,
+					params: ctx.params ? [...ctx.params] : []
+				})
+			};
+		}
+	};
+}
+/**
+* Creates a valid test contract without using validateContract.
+* Ensures all required fields are present (mappings, capabilities, extensionPacks, meta, sources)
+* and returns the contract with proper typing.
+* This helper allows tests to create contracts without depending on sql-query.
+*/
+function createTestContract(contract) {
+	return {
+		...contract,
+		mappings: contract.mappings ?? {
+			codecTypes: {},
+			operationTypes: {}
+		},
+		capabilities: contract.capabilities ?? {},
+		extensionPacks: contract.extensionPacks ?? {},
+		meta: contract.meta ?? {},
+		sources: contract.sources ?? {}
+	};
+}
+
+//#endregion
+export { collectAsync, createDevDatabase, createStubAdapter, createTestContext, createTestContract, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, teardownTestDatabase, withClient, writeTestContractMarker };
+//# sourceMappingURL=utils.mjs.map

package/dist/test/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/utils.ts"],"sourcesContent":["import type { ExecutionPlan, ResultType } from '@prisma-next/contract/types';\nimport type { SqlContract, 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 { 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  type createRuntime,\n  createRuntimeContext,\n  ensureSchemaStatement,\n  ensureTableStatement,\n  writeContractMarker,\n} from '../src/exports';\nimport type {\n  RuntimeContext,\n  SqlRuntimeAdapterInstance,\n  SqlRuntimeExtensionDescriptor,\n} from '../src/sql-context';\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 ExecutionPlan<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: ExecutionPlan | 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: SqlContract<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    coreHash: contract.coreHash,\n    profileHash: contract.profileHash ?? contract.coreHash,\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: SqlContract<SqlStorage>,\n): Promise<void> {\n  const write = writeContractMarker({\n    coreHash: contract.coreHash,\n    profileHash: contract.profileHash ?? contract.coreHash,\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 * This wraps the adapter in a descriptor for descriptor-first context creation in tests.\n * The adapter instance IS an Adapter (via intersection), with identity properties added.\n */\nfunction createTestAdapterDescriptor(\n  adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,\n): {\n  readonly kind: 'adapter';\n  readonly id: string;\n  readonly version: string;\n  readonly familyId: 'sql';\n  readonly targetId: 'postgres';\n  create(): SqlRuntimeAdapterInstance<'postgres'>;\n} {\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    create(): SqlRuntimeAdapterInstance<'postgres'> {\n      // Return an object that combines identity properties with the adapter's methods\n      return Object.assign(\n        {\n          familyId: 'sql' as const,\n          targetId: 'postgres' as const,\n        },\n        adapter,\n      );\n    },\n  };\n}\n\n/**\n * Creates a test target descriptor.\n * This is a minimal descriptor for descriptor-first context creation in tests.\n */\nfunction createTestTargetDescriptor(): {\n  readonly kind: 'target';\n  readonly id: string;\n  readonly version: string;\n  readonly familyId: 'sql';\n  readonly targetId: 'postgres';\n  create(): { readonly familyId: 'sql'; readonly targetId: 'postgres' };\n} {\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    create() {\n      return { familyId: 'sql' as const, targetId: 'postgres' as const };\n    },\n  };\n}\n\n/**\n * Creates a runtime context with standard test configuration.\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 SqlContract<SqlStorage>>(\n  contract: TContract,\n  adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,\n  options?: {\n    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  },\n): RuntimeContext<TContract> {\n  return createRuntimeContext<TContract, 'postgres'>({\n    contract,\n    target: createTestTargetDescriptor(),\n    adapter: createTestAdapterDescriptor(adapter),\n    extensionPacks: options?.extensionPacks ?? [],\n  });\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, SqlContract<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) =>\n        typeof wire === 'string' ? wire : wire instanceof Date ? wire.toISOString() : String(wire),\n    }),\n  );\n\n  return {\n    profile: {\n      id: 'stub-profile',\n      target: 'postgres',\n      capabilities: {},\n      codecs() {\n        return codecRegistry;\n      },\n    },\n    lower(ast: SelectAst, ctx: { contract: SqlContract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return {\n        profileId: this.profile.id,\n        body: Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] }),\n      };\n    },\n  };\n}\n\n/**\n * Creates a valid test contract without using validateContract.\n * Ensures all required fields are present (mappings, capabilities, extensionPacks, meta, sources)\n * and returns the contract with proper typing.\n * This helper allows tests to create contracts without depending on sql-query.\n */\nexport function createTestContract<T extends SqlContract<SqlStorage>>(\n  contract: Partial<T> &\n    Omit<T, 'mappings' | 'capabilities' | 'extensionPacks' | 'meta' | 'sources'>,\n): T {\n  return {\n    ...contract,\n    mappings: contract.mappings ?? { codecTypes: {}, operationTypes: {} },\n    capabilities: contract.capabilities ?? {},\n    extensionPacks: contract.extensionPacks ?? {},\n    meta: contract.meta ?? {},\n    sources: contract.sources ?? {},\n  } as T;\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":";;;;;;;;;;AA0BA,eAAsB,sBAEpB,SAA2C,MAAmC;AAE9E,QAAOA,eAAkB,QAAQ,QAAa,KAAK,CAAC;;;;;;AAOtD,eAAsB,mBACpB,SACA,MACe;AACf,QAAO,mBAAmB,QAAQ,QAAQ,KAAK,CAAC;;;;;AAMlD,eAAsB,iBAAiB,QAAgB,WAAwC;AAC7F,KAAI,UAAU,OAAO,SAAS,GAAG;AAC/B,QAAM,OAAO,MAAM,UAAU,KAAK,CAAC,GAAG,UAAU,OAAO,CAAC;AACxD;;AAGF,OAAM,OAAO,MAAM,UAAU,IAAI;;;;;;AAOnC,eAAsB,kBACpB,QACA,UACA,SACe;AACf,OAAM,OAAO,MAAM,gDAAgD;AACnE,OAAM,OAAO,MAAM,qCAAqC;AAExD,OAAM,QAAQ,OAAO;AAErB,OAAM,iBAAiB,QAAQ,sBAAsB;AACrD,OAAM,iBAAiB,QAAQ,qBAAqB;AAOpD,OAAM,iBAAiB,QANT,oBAAoB;EAChC,UAAU,SAAS;EACnB,aAAa,SAAS,eAAe,SAAS;EAC9C,cAAc;EACd,kBAAkB;EACnB,CAAC,CACmC,OAAO;;;;;;AAO9C,eAAsB,wBACpB,QACA,UACe;AAOf,OAAM,iBAAiB,QANT,oBAAoB;EAChC,UAAU,SAAS;EACnB,aAAa,SAAS,eAAe,SAAS;EAC9C,cAAc;EACd,kBAAkB;EACnB,CAAC,CACmC,OAAO;;;;;;;AAQ9C,SAAS,4BACP,SAQA;AACA,QAAO;EACL,MAAM;EACN,IAAI;EACJ,SAAS;EACT,UAAU;EACV,UAAU;EACV,SAAgD;AAE9C,UAAO,OAAO,OACZ;IACE,UAAU;IACV,UAAU;IACX,EACD,QACD;;EAEJ;;;;;;AAOH,SAAS,6BAOP;AACA,QAAO;EACL,MAAM;EACN,IAAI;EACJ,SAAS;EACT,UAAU;EACV,UAAU;EACV,SAAS;AACP,UAAO;IAAE,UAAU;IAAgB,UAAU;IAAqB;;EAErE;;;;;;;;;AAUH,SAAgB,kBACd,UACA,SACA,SAG2B;AAC3B,QAAO,qBAA4C;EACjD;EACA,QAAQ,4BAA4B;EACpC,SAAS,4BAA4B,QAAQ;EAC7C,gBAAgB,SAAS,kBAAkB,EAAE;EAC9C,CAAC;;;;;;;;;AAUJ,SAAgB,oBAAmF;CACjG,MAAM,gBAAgB,qBAAqB;AAK3C,eAAc,SACZ,MAAM;EACJ,QAAQ;EACR,aAAa,CAAC,OAAO;EACrB,SAAS,UAAkB;EAC3B,SAAS,SAAiB;EAC3B,CAAC,CACH;AAED,eAAc,SACZ,MAAM;EACJ,QAAQ;EACR,aAAa,CAAC,OAAO;EACrB,SAAS,UAAkB;EAC3B,SAAS,SAAiB;EAC3B,CAAC,CACH;AAED,eAAc,SACZ,MAAM;EACJ,QAAQ;EACR,aAAa,CAAC,cAAc;EAC5B,SAAS,UAA0B,iBAAiB,OAAO,MAAM,aAAa,GAAG;EACjF,SAAS,SACP,OAAO,SAAS,WAAW,OAAO,gBAAgB,OAAO,KAAK,aAAa,GAAG,OAAO,KAAK;EAC7F,CAAC,CACH;AAED,QAAO;EACL,SAAS;GACP,IAAI;GACJ,QAAQ;GACR,cAAc,EAAE;GAChB,SAAS;AACP,WAAO;;GAEV;EACD,MAAM,KAAgB,KAAyE;GAC7F,MAAM,UAAU,KAAK,UAAU,IAAI;AACnC,UAAO;IACL,WAAW,KAAK,QAAQ;IACxB,MAAM,OAAO,OAAO;KAAE,KAAK;KAAS,QAAQ,IAAI,SAAS,CAAC,GAAG,IAAI,OAAO,GAAG,EAAE;KAAE,CAAC;IACjF;;EAEJ;;;;;;;;AASH,SAAgB,mBACd,UAEG;AACH,QAAO;EACL,GAAG;EACH,UAAU,SAAS,YAAY;GAAE,YAAY,EAAE;GAAE,gBAAgB,EAAE;GAAE;EACrE,cAAc,SAAS,gBAAgB,EAAE;EACzC,gBAAgB,SAAS,kBAAkB,EAAE;EAC7C,MAAM,SAAS,QAAQ,EAAE;EACzB,SAAS,SAAS,WAAW,EAAE;EAChC"}

package/package.json

@@ -1,26 +1,30 @@
 {
   "name": "@prisma-next/sql-runtime",
-  "version": "0.3.0-pr.93.5",
+  "version": "0.3.0-pr.94.1",
   "type": "module",
   "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
   "description": "SQL runtime implementation for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.3.0-pr.93.5",
-    "@prisma-next/core-execution-plane": "0.3.0-pr.93.5",
-    "@prisma-next/operations": "0.3.0-pr.93.5",
-    "@prisma-next/runtime-executor": "0.3.0-pr.93.5",
-    "@prisma-next/sql-contract": "0.3.0-pr.93.5",
-    "@prisma-next/sql-operations": "0.3.0-pr.93.5",
-    "@prisma-next/sql-relational-core": "0.3.0-pr.93.5"
+    "@prisma-next/contract": "0.3.0-pr.94.1",
+    "@prisma-next/core-execution-plane": "0.3.0-pr.94.1",
+    "@prisma-next/operations": "0.3.0-pr.94.1",
+    "@prisma-next/runtime-executor": "0.3.0-pr.94.1",
+    "@prisma-next/sql-contract": "0.3.0-pr.94.1",
+    "@prisma-next/sql-operations": "0.3.0-pr.94.1",
+    "@prisma-next/sql-relational-core": "0.3.0-pr.94.1",
+    "@prisma-next/test-utils": "0.0.1"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
     "pg": "8.16.3",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
-    "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
@@ -28,17 +32,15 @@
     "test"
   ],
   "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./test/utils": {
-      "types": "./dist/test/utils.d.ts",
-      "import": "./dist/test/utils.js"
-    }
+    ".": "./dist/index.mjs",
+    "./test/utils": "./dist/test/utils.mjs",
+    "./package.json": "./package.json"
   },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "scripts": {
-    "build": "tsup && tsc",
+    "build": "tsdown",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
     "typecheck": "tsc --noEmit",