@prisma-next/target-postgres 0.12.0-dev.17 → 0.12.0-dev.2

package/src/core/migrations/statement-builders.ts

@@ -40,9 +40,6 @@ export const ensureLedgerTableStatement: SqlStatement = {
   sql: `create table if not exists prisma_contract.ledger (
     id bigserial primary key,
     created_at timestamptz not null default now(),
-    space text not null,
-    migration_name text not null,
-    migration_hash text not null,
     origin_core_hash text,
     origin_profile_hash text,
     destination_core_hash text not null,
@@ -141,9 +138,6 @@ export function buildMergeMarkerStatements(input: MergeMarkerInput): {
 }
 
 export interface LedgerInsertInput {
-  readonly space: string;
-  readonly migrationName: string;
-  readonly migrationHash: string;
   readonly originStorageHash?: string | null;
   readonly originProfileHash?: string | null;
   readonly destinationStorageHash: string;
@@ -156,9 +150,6 @@ export interface LedgerInsertInput {
 export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {
   return {
     sql: `insert into prisma_contract.ledger (
-      space,
-      migration_name,
-      migration_hash,
       origin_core_hash,
       origin_profile_hash,
       destination_core_hash,
@@ -171,17 +162,11 @@ export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStateme
       $2,
       $3,
       $4,
-      $5,
-      $6,
-      $7,
-      $8::jsonb,
-      $9::jsonb,
-      $10::jsonb
+      $5::jsonb,
+      $6::jsonb,
+      $7::jsonb
     )`,
     params: [
-      input.space,
-      input.migrationName,
-      input.migrationHash,
       input.originStorageHash ?? null,
       input.originProfileHash ?? null,
       input.destinationStorageHash,

package/src/core/postgres-enum-type.ts

@@ -1,4 +1,3 @@
-import type { ControlPolicy } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from '@prisma-next/sql-contract/types';
 
@@ -19,7 +18,6 @@ export interface PostgresEnumTypeInput<
    */
   readonly nativeType?: string;
   readonly values: TValues;
-  readonly control?: ControlPolicy;
 }
 
 /** Codec id used by Postgres enum-typed columns (text wire format). */
@@ -66,7 +64,6 @@ export class PostgresEnumType<
    * dispatching through the prototype-only `codecBinding` accessor.
    */
   readonly codecId: typeof PG_ENUM_CODEC_ID = PG_ENUM_CODEC_ID;
-  declare readonly control?: ControlPolicy;
 
   constructor(input: PostgresEnumTypeInput<TName, TValues>) {
     super();
@@ -76,7 +73,6 @@ export class PostgresEnumType<
     // `TValues` literal tuple. Cast preserves the caller-supplied
     // tuple shape so inferred contract types retain literal narrowing.
     this.values = Object.freeze([...input.values] as unknown as TValues);
-    if (input.control !== undefined) this.control = input.control;
     freezeNode(this);
   }
 

package/dist/column-type-compatibility-Dzxz_CkP.mjs

@@ -1,11 +0,0 @@
-//#region src/core/column-type-compatibility.ts
-const EXPLICIT_COMPATIBLE_TYPE_PAIRS = [];
-function postgresColumnsCompatible(declared, live) {
-	if (declared === live) return true;
-	for (const [a, b] of EXPLICIT_COMPATIBLE_TYPE_PAIRS) if (declared === a && live === b || declared === b && live === a) return true;
-	return false;
-}
-//#endregion
-export { postgresColumnsCompatible as t };
-
-//# sourceMappingURL=column-type-compatibility-Dzxz_CkP.mjs.map

package/dist/column-type-compatibility-Dzxz_CkP.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"column-type-compatibility-Dzxz_CkP.mjs","names":[],"sources":["../src/core/column-type-compatibility.ts"],"sourcesContent":["const EXPLICIT_COMPATIBLE_TYPE_PAIRS: ReadonlyArray<readonly [string, string]> = [];\n\nexport function postgresColumnsCompatible(declared: string, live: string): boolean {\n  if (declared === live) {\n    return true;\n  }\n  for (const [a, b] of EXPLICIT_COMPATIBLE_TYPE_PAIRS) {\n    if ((declared === a && live === b) || (declared === b && live === a)) {\n      return true;\n    }\n  }\n  return false;\n}\n"],"mappings":";AAAA,MAAM,iCAA2E,CAAC;AAElF,SAAgB,0BAA0B,UAAkB,MAAuB;CACjF,IAAI,aAAa,MACf,OAAO;CAET,KAAK,MAAM,CAAC,GAAG,MAAM,gCACnB,IAAK,aAAa,KAAK,SAAS,KAAO,aAAa,KAAK,SAAS,GAChE,OAAO;CAGX,OAAO;AACT"}

package/dist/column-type-compatibility.d.mts

@@ -1,5 +0,0 @@
-//#region src/core/column-type-compatibility.d.ts
-declare function postgresColumnsCompatible(declared: string, live: string): boolean;
-//#endregion
-export { postgresColumnsCompatible };
-//# sourceMappingURL=column-type-compatibility.d.mts.map

package/dist/column-type-compatibility.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"column-type-compatibility.d.mts","names":[],"sources":["../src/core/column-type-compatibility.ts"],"mappings":";iBAEgB,yBAAA,CAA0B,QAAA,UAAkB,IAAY"}

package/dist/column-type-compatibility.mjs

@@ -1,2 +0,0 @@
-import { t as postgresColumnsCompatible } from "./column-type-compatibility-Dzxz_CkP.mjs";
-export { postgresColumnsCompatible };

package/dist/contract-free.d.mts

@@ -1,35 +0,0 @@
-import { n as PostgresCreateSchema, r as PostgresCreateTable } from "./nodes-BS8vS8gv.mjs";
-import { DdlColumn, DdlNode } from "@prisma-next/sql-relational-core/ast";
-
-//#region src/contract-free/control-bootstrap.d.ts
-declare function buildSignMarkerBootstrapQueries(): readonly DdlNode[];
-declare function buildControlTableBootstrapQueries(): readonly DdlNode[];
-//#endregion
-//#region src/contract-free/ddl.d.ts
-/**
- * Build a Postgres `CREATE TABLE` query node.
- *
- * Precondition: identifiers (`table`, `schema`, column names/types) are
- * emitted to SQL verbatim — they are not quoted or escaped, so callers must
- * pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal
- * default values, by contrast, are single-quote-escaped (embedded `'` doubled)
- * by the renderer. Identifier quoting for untrusted identifiers is added when
- * the migration planner adopts this lowering path.
- */
-declare function createTable(options: {
-  readonly table: string;
-  readonly schema?: string;
-  readonly ifNotExists?: boolean;
-  readonly columns: readonly DdlColumn[];
-}): PostgresCreateTable;
-/**
- * Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the
- * pre-trusted-identifier precondition.
- */
-declare function createSchema(options: {
-  readonly schema: string;
-  readonly ifNotExists?: boolean;
-}): PostgresCreateSchema;
-//#endregion
-export { buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries, createSchema, createTable };
-//# sourceMappingURL=contract-free.d.mts.map

package/dist/contract-free.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-free.d.mts","names":[],"sources":["../src/contract-free/control-bootstrap.ts","../src/contract-free/ddl.ts"],"mappings":";;;;iBAgDgB,+BAAA,CAAA,YAA4C,OAAO;AAAA,iBAInD,iCAAA,CAAA,YAA8C,OAAO;;;;;AAJrE;;;;AAAmE;AAInE;;;iBCvCgB,WAAA,CAAY,OAAA;EAAA,SACjB,KAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,OAAA,WAAkB,SAAA;AAAA,IACzB,mBAAmB;;;;;iBAQP,YAAA,CAAa,OAAA;EAAA,SAClB,MAAA;EAAA,SACA,WAAA;AAAA,IACP,oBAAoB"}

package/dist/contract-free.mjs

@@ -1,97 +0,0 @@
-import { n as PostgresCreateTable, t as PostgresCreateSchema } from "./nodes-BYSqasmC.mjs";
-import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-import { col, fn, lit } from "@prisma-next/sql-relational-core/contract-free";
-//#region src/contract-free/ddl.ts
-/**
-* Build a Postgres `CREATE TABLE` query node.
-*
-* Precondition: identifiers (`table`, `schema`, column names/types) are
-* emitted to SQL verbatim — they are not quoted or escaped, so callers must
-* pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal
-* default values, by contrast, are single-quote-escaped (embedded `'` doubled)
-* by the renderer. Identifier quoting for untrusted identifiers is added when
-* the migration planner adopts this lowering path.
-*/
-function createTable(options) {
-	return new PostgresCreateTable(options);
-}
-/**
-* Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the
-* pre-trusted-identifier precondition.
-*/
-function createSchema(options) {
-	return new PostgresCreateSchema(options);
-}
-//#endregion
-//#region src/contract-free/control-bootstrap.ts
-const markerColumns = [
-	col("space", "text", {
-		notNull: true,
-		primaryKey: true,
-		default: lit(APP_SPACE_ID)
-	}),
-	col("core_hash", "text", { notNull: true }),
-	col("profile_hash", "text", { notNull: true }),
-	col("contract_json", "jsonb"),
-	col("canonical_version", "int"),
-	col("updated_at", "timestamptz", {
-		notNull: true,
-		default: fn("now()")
-	}),
-	col("app_tag", "text"),
-	col("meta", "jsonb", {
-		notNull: true,
-		default: lit("{}")
-	}),
-	col("invariants", "text[]", {
-		notNull: true,
-		default: lit("{}")
-	})
-];
-const ledgerColumns = [
-	col("id", "bigserial", { primaryKey: true }),
-	col("created_at", "timestamptz", {
-		notNull: true,
-		default: fn("now()")
-	}),
-	col("space", "text", { notNull: true }),
-	col("migration_name", "text", { notNull: true }),
-	col("migration_hash", "text", { notNull: true }),
-	col("origin_core_hash", "text"),
-	col("origin_profile_hash", "text"),
-	col("destination_core_hash", "text", { notNull: true }),
-	col("destination_profile_hash", "text"),
-	col("contract_json_before", "jsonb"),
-	col("contract_json_after", "jsonb"),
-	col("operations", "jsonb", { notNull: true })
-];
-const markerTable = createTable({
-	schema: "prisma_contract",
-	table: "marker",
-	ifNotExists: true,
-	columns: markerColumns
-});
-const ledgerTable = createTable({
-	schema: "prisma_contract",
-	table: "ledger",
-	ifNotExists: true,
-	columns: ledgerColumns
-});
-const controlSchema = createSchema({
-	schema: "prisma_contract",
-	ifNotExists: true
-});
-function buildSignMarkerBootstrapQueries() {
-	return [controlSchema, markerTable];
-}
-function buildControlTableBootstrapQueries() {
-	return [
-		controlSchema,
-		markerTable,
-		ledgerTable
-	];
-}
-//#endregion
-export { buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries, createSchema, createTable };
-
-//# sourceMappingURL=contract-free.mjs.map

package/dist/contract-free.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-free.mjs","names":[],"sources":["../src/contract-free/ddl.ts","../src/contract-free/control-bootstrap.ts"],"sourcesContent":["import type { DdlColumn } from '@prisma-next/sql-relational-core/ast';\nimport { PostgresCreateSchema, PostgresCreateTable } from '../core/ddl/nodes';\n\n/**\n * Build a Postgres `CREATE TABLE` query node.\n *\n * Precondition: identifiers (`table`, `schema`, column names/types) are\n * emitted to SQL verbatim — they are not quoted or escaped, so callers must\n * pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal\n * default values, by contrast, are single-quote-escaped (embedded `'` doubled)\n * by the renderer. Identifier quoting for untrusted identifiers is added when\n * the migration planner adopts this lowering path.\n */\nexport function createTable(options: {\n  readonly table: string;\n  readonly schema?: string;\n  readonly ifNotExists?: boolean;\n  readonly columns: readonly DdlColumn[];\n}): PostgresCreateTable {\n  return new PostgresCreateTable(options);\n}\n\n/**\n * Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the\n * pre-trusted-identifier precondition.\n */\nexport function createSchema(options: {\n  readonly schema: string;\n  readonly ifNotExists?: boolean;\n}): PostgresCreateSchema {\n  return new PostgresCreateSchema(options);\n}\n","import { APP_SPACE_ID } from '@prisma-next/framework-components/control';\nimport type { DdlNode } from '@prisma-next/sql-relational-core/ast';\nimport { col, fn, lit } from '@prisma-next/sql-relational-core/contract-free';\nimport { createSchema, createTable } from './ddl';\n\nconst markerColumns = [\n  col('space', 'text', { notNull: true, primaryKey: true, default: lit(APP_SPACE_ID) }),\n  col('core_hash', 'text', { notNull: true }),\n  col('profile_hash', 'text', { notNull: true }),\n  col('contract_json', 'jsonb'),\n  col('canonical_version', 'int'),\n  col('updated_at', 'timestamptz', { notNull: true, default: fn('now()') }),\n  col('app_tag', 'text'),\n  col('meta', 'jsonb', { notNull: true, default: lit('{}') }),\n  col('invariants', 'text[]', { notNull: true, default: lit('{}') }),\n] as const;\n\nconst ledgerColumns = [\n  col('id', 'bigserial', { primaryKey: true }),\n  col('created_at', 'timestamptz', { notNull: true, default: fn('now()') }),\n  col('space', 'text', { notNull: true }),\n  col('migration_name', 'text', { notNull: true }),\n  col('migration_hash', 'text', { notNull: true }),\n  col('origin_core_hash', 'text'),\n  col('origin_profile_hash', 'text'),\n  col('destination_core_hash', 'text', { notNull: true }),\n  col('destination_profile_hash', 'text'),\n  col('contract_json_before', 'jsonb'),\n  col('contract_json_after', 'jsonb'),\n  col('operations', 'jsonb', { notNull: true }),\n] as const;\n\nconst markerTable = createTable({\n  schema: 'prisma_contract',\n  table: 'marker',\n  ifNotExists: true,\n  columns: markerColumns,\n});\n\nconst ledgerTable = createTable({\n  schema: 'prisma_contract',\n  table: 'ledger',\n  ifNotExists: true,\n  columns: ledgerColumns,\n});\n\nconst controlSchema = createSchema({ schema: 'prisma_contract', ifNotExists: true });\n\nexport function buildSignMarkerBootstrapQueries(): readonly DdlNode[] {\n  return [controlSchema, markerTable];\n}\n\nexport function buildControlTableBootstrapQueries(): readonly DdlNode[] {\n  return [controlSchema, markerTable, ledgerTable];\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,YAAY,SAKJ;CACtB,OAAO,IAAI,oBAAoB,OAAO;AACxC;;;;;AAMA,SAAgB,aAAa,SAGJ;CACvB,OAAO,IAAI,qBAAqB,OAAO;AACzC;;;AC1BA,MAAM,gBAAgB;CACpB,IAAI,SAAS,QAAQ;EAAE,SAAS;EAAM,YAAY;EAAM,SAAS,IAAI,YAAY;CAAE,CAAC;CACpF,IAAI,aAAa,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC1C,IAAI,gBAAgB,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC7C,IAAI,iBAAiB,OAAO;CAC5B,IAAI,qBAAqB,KAAK;CAC9B,IAAI,cAAc,eAAe;EAAE,SAAS;EAAM,SAAS,GAAG,OAAO;CAAE,CAAC;CACxE,IAAI,WAAW,MAAM;CACrB,IAAI,QAAQ,SAAS;EAAE,SAAS;EAAM,SAAS,IAAI,IAAI;CAAE,CAAC;CAC1D,IAAI,cAAc,UAAU;EAAE,SAAS;EAAM,SAAS,IAAI,IAAI;CAAE,CAAC;AACnE;AAEA,MAAM,gBAAgB;CACpB,IAAI,MAAM,aAAa,EAAE,YAAY,KAAK,CAAC;CAC3C,IAAI,cAAc,eAAe;EAAE,SAAS;EAAM,SAAS,GAAG,OAAO;CAAE,CAAC;CACxE,IAAI,SAAS,QAAQ,EAAE,SAAS,KAAK,CAAC;CACtC,IAAI,kBAAkB,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC/C,IAAI,kBAAkB,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC/C,IAAI,oBAAoB,MAAM;CAC9B,IAAI,uBAAuB,MAAM;CACjC,IAAI,yBAAyB,QAAQ,EAAE,SAAS,KAAK,CAAC;CACtD,IAAI,4BAA4B,MAAM;CACtC,IAAI,wBAAwB,OAAO;CACnC,IAAI,uBAAuB,OAAO;CAClC,IAAI,cAAc,SAAS,EAAE,SAAS,KAAK,CAAC;AAC9C;AAEA,MAAM,cAAc,YAAY;CAC9B,QAAQ;CACR,OAAO;CACP,aAAa;CACb,SAAS;AACX,CAAC;AAED,MAAM,cAAc,YAAY;CAC9B,QAAQ;CACR,OAAO;CACP,aAAa;CACb,SAAS;AACX,CAAC;AAED,MAAM,gBAAgB,aAAa;CAAE,QAAQ;CAAmB,aAAa;AAAK,CAAC;AAEnF,SAAgB,kCAAsD;CACpE,OAAO,CAAC,eAAe,WAAW;AACpC;AAEA,SAAgB,oCAAwD;CACtE,OAAO;EAAC;EAAe;EAAa;CAAW;AACjD"}

package/dist/ddl.d.mts

@@ -1,2 +0,0 @@
-import { a as PostgresDdlVisitor, i as PostgresDdlNode, n as PostgresCreateSchema, r as PostgresCreateTable, t as AnyPostgresDdlNode } from "./nodes-BS8vS8gv.mjs";
-export { type AnyPostgresDdlNode, PostgresCreateSchema, PostgresCreateTable, PostgresDdlNode, type PostgresDdlVisitor };

package/dist/ddl.mjs

@@ -1,2 +0,0 @@
-import { n as PostgresCreateTable, r as PostgresDdlNode, t as PostgresCreateSchema } from "./nodes-BYSqasmC.mjs";
-export { PostgresCreateSchema, PostgresCreateTable, PostgresDdlNode };

package/dist/descriptor-meta-BqATo5Dz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-BqATo5Dz.mjs","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringTypes,\n} from './authoring';\nimport { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';\n\nconst postgresTargetDescriptorMetaBase = {\n  ...postgresTargetDescriptorMetaRuntime,\n  defaultNamespaceId: 'public',\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";AAkBA,MAAa,+BAET;CAXF,GAAG;CACH,oBAAoB;CACpB,WAAW;EACT,MAAM;EACN,OAAO;EACP,aAAa;CACf;AAKE"}

package/dist/nodes-BS8vS8gv.d.mts

@@ -1,38 +0,0 @@
-import { DdlColumn, DdlNode } from "@prisma-next/sql-relational-core/ast";
-
-//#region src/core/ddl/nodes.d.ts
-interface PostgresDdlVisitor<R> {
-  createTable(node: PostgresCreateTable): R;
-  createSchema(node: PostgresCreateSchema): R;
-}
-declare abstract class PostgresDdlNode extends DdlNode {
-  abstract accept<R>(visitor: PostgresDdlVisitor<R>): R;
-}
-declare class PostgresCreateTable extends PostgresDdlNode {
-  readonly kind: "create-table";
-  readonly table: string;
-  readonly schema: string | undefined;
-  readonly ifNotExists: boolean | undefined;
-  readonly columns: ReadonlyArray<DdlColumn>;
-  constructor(options: {
-    readonly table: string;
-    readonly schema?: string;
-    readonly ifNotExists?: boolean;
-    readonly columns: readonly DdlColumn[];
-  });
-  accept<R>(visitor: PostgresDdlVisitor<R>): R;
-}
-declare class PostgresCreateSchema extends PostgresDdlNode {
-  readonly kind: "create-schema";
-  readonly schema: string;
-  readonly ifNotExists: boolean | undefined;
-  constructor(options: {
-    readonly schema: string;
-    readonly ifNotExists?: boolean;
-  });
-  accept<R>(visitor: PostgresDdlVisitor<R>): R;
-}
-type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema;
-//#endregion
-export { PostgresDdlVisitor as a, PostgresDdlNode as i, PostgresCreateSchema as n, PostgresCreateTable as r, AnyPostgresDdlNode as t };
-//# sourceMappingURL=nodes-BS8vS8gv.d.mts.map

package/dist/nodes-BS8vS8gv.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodes-BS8vS8gv.d.mts","names":[],"sources":["../src/core/ddl/nodes.ts"],"mappings":";;;UAEiB,kBAAA;EACf,WAAA,CAAY,IAAA,EAAM,mBAAA,GAAsB,CAAA;EACxC,YAAA,CAAa,IAAA,EAAM,oBAAA,GAAuB,CAAA;AAAA;AAAA,uBAGtB,eAAA,SAAwB,OAAA;EAAA,SACnC,MAAA,GAAA,CAAU,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,CAAA;AAAA;AAAA,cAOzC,mBAAA,SAA4B,eAAA;EAAA,SAC9B,IAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,OAAA,EAAS,aAAA,CAAc,SAAA;cAEpB,OAAA;IAAA,SACD,KAAA;IAAA,SACA,MAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;EAAA;EAUpB,MAAA,GAAA,CAAU,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,CAAA;AAAA;AAAA,cAKzC,oBAAA,SAA6B,eAAA;EAAA,SAC/B,IAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;cAEG,OAAA;IAAA,SAAoB,MAAA;IAAA,SAAyB,WAAA;EAAA;EAOhD,MAAA,GAAA,CAAU,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,CAAA;AAAA;AAAA,KAK1C,kBAAA,GAAqB,mBAAA,GAAsB,oBAAoB"}

package/dist/nodes-BYSqasmC.mjs

@@ -1,42 +0,0 @@
-import { DdlNode } from "@prisma-next/sql-relational-core/ast";
-//#region src/core/ddl/nodes.ts
-var PostgresDdlNode = class extends DdlNode {};
-function freezeDdlColumns(columns) {
-	return Object.freeze([...columns]);
-}
-var PostgresCreateTable = class extends PostgresDdlNode {
-	kind = "create-table";
-	table;
-	schema;
-	ifNotExists;
-	columns;
-	constructor(options) {
-		super();
-		this.table = options.table;
-		this.schema = options.schema;
-		this.ifNotExists = options.ifNotExists;
-		this.columns = freezeDdlColumns(options.columns);
-		this.freeze();
-	}
-	accept(visitor) {
-		return visitor.createTable(this);
-	}
-};
-var PostgresCreateSchema = class extends PostgresDdlNode {
-	kind = "create-schema";
-	schema;
-	ifNotExists;
-	constructor(options) {
-		super();
-		this.schema = options.schema;
-		this.ifNotExists = options.ifNotExists;
-		this.freeze();
-	}
-	accept(visitor) {
-		return visitor.createSchema(this);
-	}
-};
-//#endregion
-export { PostgresCreateTable as n, PostgresDdlNode as r, PostgresCreateSchema as t };
-
-//# sourceMappingURL=nodes-BYSqasmC.mjs.map

package/dist/nodes-BYSqasmC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodes-BYSqasmC.mjs","names":[],"sources":["../src/core/ddl/nodes.ts"],"sourcesContent":["import { type DdlColumn, DdlNode } from '@prisma-next/sql-relational-core/ast';\n\nexport interface PostgresDdlVisitor<R> {\n  createTable(node: PostgresCreateTable): R;\n  createSchema(node: PostgresCreateSchema): R;\n}\n\nexport abstract class PostgresDdlNode extends DdlNode {\n  abstract accept<R>(visitor: PostgresDdlVisitor<R>): R;\n}\n\nfunction freezeDdlColumns(columns: readonly DdlColumn[]): ReadonlyArray<DdlColumn> {\n  return Object.freeze([...columns]);\n}\n\nexport class PostgresCreateTable extends PostgresDdlNode {\n  readonly kind = 'create-table' as const;\n  readonly table: string;\n  readonly schema: string | undefined;\n  readonly ifNotExists: boolean | undefined;\n  readonly columns: ReadonlyArray<DdlColumn>;\n\n  constructor(options: {\n    readonly table: string;\n    readonly schema?: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n  }) {\n    super();\n    this.table = options.table;\n    this.schema = options.schema;\n    this.ifNotExists = options.ifNotExists;\n    this.columns = freezeDdlColumns(options.columns);\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.createTable(this);\n  }\n}\n\nexport class PostgresCreateSchema extends PostgresDdlNode {\n  readonly kind = 'create-schema' as const;\n  readonly schema: string;\n  readonly ifNotExists: boolean | undefined;\n\n  constructor(options: { readonly schema: string; readonly ifNotExists?: boolean }) {\n    super();\n    this.schema = options.schema;\n    this.ifNotExists = options.ifNotExists;\n    this.freeze();\n  }\n\n  override accept<R>(visitor: PostgresDdlVisitor<R>): R {\n    return visitor.createSchema(this);\n  }\n}\n\nexport type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema;\n"],"mappings":";;AAOA,IAAsB,kBAAtB,cAA8C,QAAQ,CAEtD;AAEA,SAAS,iBAAiB,SAAyD;CACjF,OAAO,OAAO,OAAO,CAAC,GAAG,OAAO,CAAC;AACnC;AAEA,IAAa,sBAAb,cAAyC,gBAAgB;CACvD,OAAgB;CAChB;CACA;CACA;CACA;CAEA,YAAY,SAKT;EACD,MAAM;EACN,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,cAAc,QAAQ;EAC3B,KAAK,UAAU,iBAAiB,QAAQ,OAAO;EAC/C,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,YAAY,IAAI;CACjC;AACF;AAEA,IAAa,uBAAb,cAA0C,gBAAgB;CACxD,OAAgB;CAChB;CACA;CAEA,YAAY,SAAsE;EAChF,MAAM;EACN,KAAK,SAAS,QAAQ;EACtB,KAAK,cAAc,QAAQ;EAC3B,KAAK,OAAO;CACd;CAEA,OAAmB,SAAmC;EACpD,OAAO,QAAQ,aAAa,IAAI;CAClC;AACF"}

package/dist/planner-B2pK98MX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-B2pK98MX.mjs","names":[],"sources":["../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Resolves the live-database schema name for a given namespace\n * coordinate. Mirrors `resolveDdlSchemaForNamespace` in\n * `planner-strategies.ts` so the verifier's projection and the\n * planner's projection always agree — Postgres-aware namespaces (the\n * production path) dispatch to `ddlSchemaName(storage)`, and bare\n * object payloads (used by some tests) fall back to the coordinate\n * itself.\n */\nfunction resolveDdlSchemaName(storage: SqlStorage, namespaceId: string): string {\n  const namespace = storage.namespaces[namespaceId];\n  if (isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/**\n * Reads the introspected list of schema names from the Postgres-flavoured\n * annotations slot on the schema IR. Defaults to the always-present\n * `public` schema when introspection did not populate the slot — a fresh\n * Postgres database always carries `public` (unless an operator dropped\n * it manually), so any verifier path that runs without an enriched\n * introspection still suppresses the redundant `CREATE SCHEMA \"public\"`.\n *\n * Production introspection (`PostgresControlAdapter.introspect`) is the\n * authoritative source: it queries `pg_namespace` and writes every\n * non-system schema into `annotations.pg.existingSchemas`. Tests that\n * want to assert against a richer initial state pass the slot\n * explicitly via the schema IR.\n */\nfunction existingSchemasFromSchema(schema: SqlSchemaIR): readonly string[] {\n  const annotations = (schema as { annotations?: { pg?: { existingSchemas?: unknown } } })\n    .annotations;\n  const slot = annotations?.pg?.existingSchemas;\n  if (Array.isArray(slot)) {\n    return slot.filter((s): s is string => typeof s === 'string');\n  }\n  return ['public'];\n}\n\n/**\n * Emits a `missing_schema` issue for every contract-declared Postgres\n * namespace whose live container does not yet exist.\n *\n * A namespace's live container is the schema returned by its\n * polymorphic `ddlSchemaName(storage)` method — named schemas resolve\n * to their own id; the unbound singleton returns `UNBOUND_NAMESPACE_ID`\n * and is skipped explicitly (late-bound namespaces have no fixed DDL\n * schema). Issues are emitted only when the resolved name is a real,\n * creatable schema (not the unbound sentinel) and is missing from the\n * introspected list. `public` is suppressed implicitly because the\n * introspection (or its sensible default) always carries it.\n *\n * Each emitted issue stamps `namespaceId` with the contract namespace\n * coordinate so the downstream `mapIssueToCall` re-resolves the DDL\n * schema name through the same polymorphic path — keeping the\n * coordinate, not the resolved name, as the issue's stable identity.\n */\nexport function verifyPostgresNamespacePresence(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIR;\n}): readonly SchemaIssue[] {\n  const { contract, schema } = input;\n  const existing = new Set(existingSchemasFromSchema(schema));\n  const issues: SchemaIssue[] = [];\n  const namespaceIds = Object.keys(contract.storage.namespaces).sort();\n  for (const namespaceId of namespaceIds) {\n    if (namespaceId === UNBOUND_NAMESPACE_ID) continue;\n    const ddlName = resolveDdlSchemaName(contract.storage, namespaceId);\n    if (ddlName === UNBOUND_NAMESPACE_ID) continue;\n    if (existing.has(ddlName)) continue;\n    issues.push({\n      kind: 'missing_schema',\n      namespaceId,\n      message: `Schema \"${ddlName}\" is missing from database`,\n    });\n  }\n  return issues;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport {\n  extractCodecControlHooks,\n  planFieldEventOperations,\n  plannerFailure,\n} from '@prisma-next/family-sql/control';\nimport { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaIssue,\n} from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport { postgresColumnsCompatible } from '../column-type-compatibility';\nimport { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport { createResolveExistingEnumValues } from './enum-planning';\nimport { planIssues } from './issue-planner';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\nimport { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\ntype VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0] & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\nexport function createPostgresMigrationPlanner(): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner();\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` verifies the live schema against the target contract (producing\n * `SchemaIssue[]`) and delegates to `planIssues` with the unified\n * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,\n * type-change, nullable-tightening, codec-hook storage types,\n * component-declared dependency installs, and shared-temp-default /\n * empty-table-guarded NOT-NULL add-column. The same strategy list runs for\n * `migration plan`, `db update`, and `db init`; behavior diverges purely on\n * `policy.allowedOperationClasses` (the data-safe strategies short-circuit\n * when `'data'` is excluded). The issue planner applies operation-class\n * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both\n * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`\n * authoring surface.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n    /**\n     * Contract space this plan applies to. Stamped onto the produced\n     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys\n     * the marker row by the right space.\n     */\n    readonly spaceId: string;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(\n    context: MigrationScaffoldContext,\n    spaceId: string,\n  ): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration(\n      [],\n      {\n        from: context.fromHash,\n        to: context.toHash,\n      },\n      spaceId,\n    );\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {\n    const schemaName =\n      options.schemaName ??\n      Object.keys(options.contract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ??\n      UNBOUND_NAMESPACE_ID;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    const schemaIssues = this.collectSchemaIssues(options);\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n\n    const result = planIssues({\n      issues: schemaIssues,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      schema: options.schema,\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    // Inline `onFieldEvent`-emitted ops after structural DDL. The fixed\n    // ordering is `structural → added → dropped → altered`, with\n    // within-group sorting by `(tableName, fieldName)` so re-emits are\n    // byte-stable. The hook fires only at the application emitter —\n    // extension-space planning never reaches this helper.\n    const fieldEventOps = planFieldEventOperations({\n      priorContract: options.fromContract,\n      newContract: options.contract,\n      codecHooks,\n    });\n    // Codec-emitted calls already conform to `OpFactoryCall` — render +\n    // toOp + importRequirements ride directly through the same emit path\n    // as structural ops, no `RawSqlCall` wrap.\n    const calls = [...result.value.calls, ...fieldEventOps];\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(\n        calls,\n        {\n          from: options.fromContract?.storage.storageHash ?? null,\n          to: options.contract.storage.storageHash,\n        },\n        options.spaceId,\n      ),\n    });\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n\n  private collectSchemaIssues(options: PlannerOptionsWithComponents): readonly SchemaIssue[] {\n    // `db init` uses additive-only policy and intentionally ignores extra\n    // schema objects. Any reconciliation-capable policy (widening or\n    // destructive) must inspect extras to reconcile strict equality.\n    const allowed = options.policy.allowedOperationClasses;\n    const strict = allowed.includes('widening') || allowed.includes('destructive');\n    const verifyOptions: VerifySqlSchemaOptionsWithComponents = {\n      contract: options.contract,\n      schema: options.schema,\n      strict,\n      typeMetadataRegistry: new Map(),\n      frameworkComponents: options.frameworkComponents,\n      normalizeDefault: parsePostgresDefault,\n      normalizeNativeType: normalizeSchemaNativeType,\n      columnsCompatible: postgresColumnsCompatible,\n      resolveExistingEnumValues: createResolveExistingEnumValues(options.contract.storage),\n    };\n    const verifyResult = verifySqlSchema(verifyOptions);\n    // Schema presence is a Postgres-specific concern (no equivalent in\n    // SQLite / Mongo), so the issue emission lives in the target layer\n    // rather than in the family verifier. Stitch it in here so a single\n    // `SchemaIssue[]` flows through `planIssues` and the planner emits\n    // CREATE SCHEMA in the dep bucket before any CreateTableCall.\n    const namespaceIssues = verifyPostgresNamespacePresence({\n      contract: options.contract,\n      schema: options.schema,\n    });\n    if (namespaceIssues.length === 0) {\n      return verifyResult.schema.issues;\n    }\n    return [...namespaceIssues, ...verifyResult.schema.issues];\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgBA,SAAS,qBAAqB,SAAqB,aAA6B;CAC9E,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,iBAAiB,SAAS,GAC5B,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,SAAS,0BAA0B,QAAwC;CAGzE,MAAM,OAFe,OAClB,aACuB,IAAI;CAC9B,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,KAAK,QAAQ,MAAmB,OAAO,MAAM,QAAQ;CAE9D,OAAO,CAAC,QAAQ;AAClB;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,gCAAgC,OAGrB;CACzB,MAAM,EAAE,UAAU,WAAW;CAC7B,MAAM,WAAW,IAAI,IAAI,0BAA0B,MAAM,CAAC;CAC1D,MAAM,SAAwB,CAAC;CAC/B,MAAM,eAAe,OAAO,KAAK,SAAS,QAAQ,UAAU,EAAE,KAAK;CACnE,KAAK,MAAM,eAAe,cAAc;EACtC,IAAI,gBAAgB,sBAAsB;EAC1C,MAAM,UAAU,qBAAqB,SAAS,SAAS,WAAW;EAClE,IAAI,YAAY,sBAAsB;EACtC,IAAI,SAAS,IAAI,OAAO,GAAG;EAC3B,OAAO,KAAK;GACV,MAAM;GACN;GACA,SAAS,WAAW,QAAQ;EAC9B,CAAC;CACH;CACA,OAAO;AACT;;;AC3CA,SAAgB,iCAA2D;CACzE,OAAO,IAAI,yBAAyB;AACtC;;;;;;;;;;;;;;;;;AA6BA,IAAa,2BAAb,MAAqF;CACnF,KAAK,SA2BkB;EACrB,OAAO,KAAK,QAAQ,OAAyC;CAC/D;CAEA,eACE,SACA,SACmC;EACnC,OAAO,IAAI,sCACT,CAAC,GACD;GACE,MAAM,QAAQ;GACd,IAAI,QAAQ;EACd,GACA,OACF;CACF;CAEA,QAAgB,SAA6D;EAC3E,MAAM,aACJ,QAAQ,cACR,OAAO,KAAK,QAAQ,SAAS,QAAQ,UAAU,EAAE,MAAM,OAAO,OAAO,oBAAoB,KACzF;EACF,MAAM,eAAe,KAAK,qBAAqB,QAAQ,MAAM;EAC7D,IAAI,cACF,OAAO;EAGT,MAAM,eAAe,KAAK,oBAAoB,OAAO;EACrD,MAAM,aAAa,yBAAyB,QAAQ,mBAAmB;EACvE,MAAM,eAAe,QAAQ,SAAS,QAAQ,SAAS,CAAC;EAExD,MAAM,SAAS,WAAW;GACxB,QAAQ;GACR,YAAY,QAAQ;GAMpB,cAAc,QAAQ;GACtB;GACA;GACA;GACA,QAAQ,QAAQ;GAChB,QAAQ,QAAQ;GAChB,qBAAqB,QAAQ;GAC7B,YAAY;EACd,CAAC;EAED,IAAI,CAAC,OAAO,IACV,OAAO,eAAe,OAAO,OAAO;EAQtC,MAAM,gBAAgB,yBAAyB;GAC7C,eAAe,QAAQ;GACvB,aAAa,QAAQ;GACrB;EACF,CAAC;EAID,MAAM,QAAQ,CAAC,GAAG,OAAO,MAAM,OAAO,GAAG,aAAa;EAEtD,OAAO,OAAO,OAAO;GACnB,MAAM;GACN,MAAM,IAAI,sCACR,OACA;IACE,MAAM,QAAQ,cAAc,QAAQ,eAAe;IACnD,IAAI,QAAQ,SAAS,QAAQ;GAC/B,GACA,QAAQ,OACV;EACF,CAAC;CACH;CAEA,qBAA6B,QAAkC;EAC7D,IAAI,CAAC,OAAO,wBAAwB,SAAS,UAAU,GACrD,OAAO,eAAe,CACpB;GACE,MAAM;GACN,SAAS;GACT,KAAK;EACP,CACF,CAAC;EAEH,OAAO;CACT;CAEA,oBAA4B,SAA+D;EAIzF,MAAM,UAAU,QAAQ,OAAO;EAC/B,MAAM,SAAS,QAAQ,SAAS,UAAU,KAAK,QAAQ,SAAS,aAAa;EAY7E,MAAM,eAAe,gBAAgB;GAVnC,UAAU,QAAQ;GAClB,QAAQ,QAAQ;GAChB;GACA,sCAAsB,IAAI,IAAI;GAC9B,qBAAqB,QAAQ;GAC7B,kBAAkB;GAClB,qBAAqB;GACrB,mBAAmB;GACnB,2BAA2B,gCAAgC,QAAQ,SAAS,OAAO;EAEpC,CAAC;EAMlD,MAAM,kBAAkB,gCAAgC;GACtD,UAAU,QAAQ;GAClB,QAAQ,QAAQ;EAClB,CAAC;EACD,IAAI,gBAAgB,WAAW,GAC7B,OAAO,aAAa,OAAO;EAE7B,OAAO,CAAC,GAAG,iBAAiB,GAAG,aAAa,OAAO,MAAM;CAC3D;AACF"}

package/dist/postgres-enum-type-Bl6THBPg.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-enum-type-Bl6THBPg.d.mts","names":[],"sources":["../src/core/postgres-enum-type.ts"],"mappings":";;;;UAIiB,qBAAA;;AAAjB;;;;WASW,IAAA,EAAM,KAAA;EAQI;;;;;EAAA,SAFV,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAAA,SACR,OAAA,GAAU,aAAA;AAAA;;cAIf,gBAAA;;;AAJ4B;AACjC;;;;AAGqB;AAyBtB;;;;;;;;;;;;;;;cAAa,gBAAA,+FAGH,OAAA;EAAA,SACU,IAAA;EAAA,SACT,IAAA,EAAM,KAAA;EAAA,SACN,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;EAFF;;;;;;;;;EAAA,SAYN,OAAA,SAAgB,gBAAA;EAAA,SACR,OAAA,GAAU,aAAA;cAEf,KAAA,EAAO,qBAAA,CAAsB,KAAA,EAAO,OAAA;EAAA,IAY5C,YAAA,CAAA;IAAA,SACO,OAAA,SAAgB,gBAAA;IAAA,SAChB,UAAA;MAAA,SAAuB,MAAA,EAAQ,OAAA;IAAA;EAAA;AAAA"}

package/dist/postgres-enum-type-CaGZ2mfI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-enum-type-CaGZ2mfI.mjs","names":[],"sources":["../src/core/postgres-enum-type.ts"],"sourcesContent":["import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresEnumTypeInput<\n  TName extends string = string,\n  TValues extends readonly string[] = readonly string[],\n> {\n  /**\n   * Contract-level enum name (e.g. `'Role'`). Used as the key in\n   * `SqlStorage.types` and as the contract-facing identifier in\n   * planner / verifier diagnostics.\n   */\n  readonly name: TName;\n  /**\n   * Postgres-side native type name created by `CREATE TYPE … AS ENUM`.\n   * Defaults to `name` when not overridden via PSL `@map(...)` or the\n   * TS authoring surface.\n   */\n  readonly nativeType?: string;\n  readonly values: TValues;\n  readonly control?: ControlPolicy;\n}\n\n/** Codec id used by Postgres enum-typed columns (text wire format). */\nconst PG_ENUM_CODEC_ID = 'pg/enum@1';\n\n/**\n * Postgres IR class for the `CREATE TYPE … AS ENUM` concept.\n *\n * Per Decision 18, enum is a target-only concept (Postgres alone today;\n * SQLite emulates via CHECK constraints). There is no family-layer\n * enum abstract — the abstract-earns-existence rule keeps the IR class\n * hierarchy minimal: this class extends `SqlNode` directly and is the\n * single concrete representation of the polymorphic `'postgres-enum'`\n * slot variant.\n *\n * Carries Postgres-specific resolution (`nativeType` defaults to\n * `name`; `values` is frozen at construction time). Constructor calls\n * `freezeNode(this)` per Decision 8 — the instance is fully immutable,\n * JSON-clean, and dispatchable on its enumerable `kind: 'postgres-enum'`\n * literal.\n *\n * The family-layer slot dispatch (verifier, planner, lowering, etc.)\n * narrows polymorphic `StorageType` entries via the `kind` literal\n * (e.g. `isPostgresEnumStorageEntry`) — SQL-domain code must not import\n * `target-postgres` directly (cross-domain layering rule). The\n * structural interface lives at the family layer for that purpose;\n * this class is the runtime concrete that satisfies it.\n */\nexport class PostgresEnumType<\n  TName extends string = string,\n  TValues extends readonly string[] = readonly string[],\n> extends SqlNode {\n  override readonly kind = 'postgres-enum' as const;\n  readonly name: TName;\n  readonly nativeType: string;\n  readonly values: TValues;\n  /**\n   * Enumerable own property so the persisted JSON envelope carries\n   * `codecId: 'pg/enum@1'` alongside `kind: 'postgres-enum'`. The\n   * runtime path (`codecRefForStorageColumn`, `assertColumnCodecIntegrity`)\n   * receives JSON-shaped contracts (e.g. inside a user-written\n   * `migration.ts` that loads `endContract` from `end-contract.json`)\n   * and reads `codecId` directly from the envelope rather than\n   * dispatching through the prototype-only `codecBinding` accessor.\n   */\n  readonly codecId: typeof PG_ENUM_CODEC_ID = PG_ENUM_CODEC_ID;\n  declare readonly control?: ControlPolicy;\n\n  constructor(input: PostgresEnumTypeInput<TName, TValues>) {\n    super();\n    this.name = input.name;\n    this.nativeType = input.nativeType ?? input.name;\n    // `Object.freeze` returns `Readonly<string[]>`, widening past the\n    // `TValues` literal tuple. Cast preserves the caller-supplied\n    // tuple shape so inferred contract types retain literal narrowing.\n    this.values = Object.freeze([...input.values] as unknown as TValues);\n    if (input.control !== undefined) this.control = input.control;\n    freezeNode(this);\n  }\n\n  get codecBinding(): {\n    readonly codecId: typeof PG_ENUM_CODEC_ID;\n    readonly typeParams: { readonly values: TValues };\n  } {\n    return { codecId: PG_ENUM_CODEC_ID, typeParams: { values: this.values } };\n  }\n}\n"],"mappings":";;;;AAyBA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;AAyBzB,IAAa,mBAAb,cAGU,QAAQ;CAChB,OAAyB;CACzB;CACA;CACA;;;;;;;;;;CAUA,UAA4C;CAG5C,YAAY,OAA8C;EACxD,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,aAAa,MAAM,cAAc,MAAM;EAI5C,KAAK,SAAS,OAAO,OAAO,CAAC,GAAG,MAAM,MAAM,CAAuB;EACnE,IAAI,MAAM,YAAY,KAAA,GAAW,KAAK,UAAU,MAAM;EACtD,WAAW,IAAI;CACjB;CAEA,IAAI,eAGF;EACA,OAAO;GAAE,SAAS;GAAkB,YAAY,EAAE,QAAQ,KAAK,OAAO;EAAE;CAC1E;AACF"}

package/dist/statement-builders-Cd311EDF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"statement-builders-Cd311EDF.mjs","names":["APP_SPACE_ID"],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":["import { APP_SPACE_ID } from '@prisma-next/framework-components/control';\n\nexport { APP_SPACE_ID };\n\nexport interface SqlStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n}\n\nexport const ensurePrismaContractSchemaStatement: SqlStatement = {\n  sql: 'create schema if not exists prisma_contract',\n  params: [],\n};\n\n/**\n * Schema for `prisma_contract.marker`. The `space text` primary key\n * supports one row per loaded contract space (`'app'`,\n * `'<extension-id>'`, …); on a brand-new database `CREATE TABLE IF NOT\n * EXISTS` produces this shape directly. The migration runner detects\n * pre-1.0 single-row markers (no `space` column) at boot and fails with\n * a structured `LEGACY_MARKER_SHAPE` error rather than auto-migrating —\n * see `specs/framework-mechanism.spec.md § 2`.\n */\nexport const ensureMarkerTableStatement: SqlStatement = {\n  sql: `create table if not exists prisma_contract.marker (\n    space text not null primary key default '${APP_SPACE_ID}',\n    core_hash text not null,\n    profile_hash text not null,\n    contract_json jsonb,\n    canonical_version int,\n    updated_at timestamptz not null default now(),\n    app_tag text,\n    meta jsonb not null default '{}',\n    invariants text[] not null default '{}'\n  )`,\n  params: [],\n};\n\nexport const ensureLedgerTableStatement: SqlStatement = {\n  sql: `create table if not exists prisma_contract.ledger (\n    id bigserial primary key,\n    created_at timestamptz not null default now(),\n    space text not null,\n    migration_name text not null,\n    migration_hash text not null,\n    origin_core_hash text,\n    origin_profile_hash text,\n    destination_core_hash text not null,\n    destination_profile_hash text,\n    contract_json_before jsonb,\n    contract_json_after jsonb,\n    operations jsonb not null\n  )`,\n  params: [],\n};\n\nexport interface MergeMarkerInput {\n  /**\n   * Logical space identifier for this marker row. Required at every\n   * call site so the type system surfaces every place that needs to\n   * thread the value (rather than letting an `?? APP_SPACE_ID`\n   * fall-through silently collapse per-space markers onto the\n   * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}\n   * (`'app'`); per-extension callers (planner / runner / verifier\n   * extensions over contract spaces) pass the extension's space id.\n   */\n  readonly space: string;\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson?: unknown;\n  readonly canonicalVersion?: number | null;\n  readonly appTag?: string | null;\n  readonly meta?: Record<string, unknown>;\n  /**\n   * Invariants to merge into `marker.invariants`. INSERT writes them as\n   * the initial value (callers are expected to pass a sorted, deduped\n   * array). UPDATE merges them with the existing column server-side via\n   * a single atomic SQL expression.\n   */\n  readonly invariants: readonly string[];\n}\n\nexport function buildMergeMarkerStatements(input: MergeMarkerInput): {\n  readonly insert: SqlStatement;\n  readonly update: SqlStatement;\n} {\n  const params: readonly unknown[] = [\n    input.space,\n    input.storageHash,\n    input.profileHash,\n    jsonParam(input.contractJson),\n    input.canonicalVersion ?? null,\n    input.appTag ?? null,\n    jsonParam(input.meta ?? {}),\n    input.invariants,\n  ];\n\n  return {\n    insert: {\n      sql: `insert into prisma_contract.marker (\n        space,\n        core_hash,\n        profile_hash,\n        contract_json,\n        canonical_version,\n        updated_at,\n        app_tag,\n        meta,\n        invariants\n      ) values (\n        $1,\n        $2,\n        $3,\n        $4::jsonb,\n        $5,\n        now(),\n        $6,\n        $7::jsonb,\n        $8::text[]\n      )`,\n      params,\n    },\n    update: {\n      // `invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)`\n      // reads the current column value under the UPDATE's row lock, unions\n      // with the incoming array, dedupes, and sorts ascending — single\n      // statement, atomic, no read-then-write window.\n      sql: `update prisma_contract.marker set\n        core_hash = $2,\n        profile_hash = $3,\n        contract_json = $4::jsonb,\n        canonical_version = $5,\n        updated_at = now(),\n        app_tag = $6,\n        meta = $7::jsonb,\n        invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)\n      where space = $1`,\n      params,\n    },\n  };\n}\n\nexport interface LedgerInsertInput {\n  readonly space: string;\n  readonly migrationName: string;\n  readonly migrationHash: string;\n  readonly originStorageHash?: string | null;\n  readonly originProfileHash?: string | null;\n  readonly destinationStorageHash: string;\n  readonly destinationProfileHash?: string | null;\n  readonly contractJsonBefore?: unknown;\n  readonly contractJsonAfter?: unknown;\n  readonly operations: unknown;\n}\n\nexport function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {\n  return {\n    sql: `insert into prisma_contract.ledger (\n      space,\n      migration_name,\n      migration_hash,\n      origin_core_hash,\n      origin_profile_hash,\n      destination_core_hash,\n      destination_profile_hash,\n      contract_json_before,\n      contract_json_after,\n      operations\n    ) values (\n      $1,\n      $2,\n      $3,\n      $4,\n      $5,\n      $6,\n      $7,\n      $8::jsonb,\n      $9::jsonb,\n      $10::jsonb\n    )`,\n    params: [\n      input.space,\n      input.migrationName,\n      input.migrationHash,\n      input.originStorageHash ?? null,\n      input.originProfileHash ?? null,\n      input.destinationStorageHash,\n      input.destinationProfileHash ?? null,\n      jsonParam(input.contractJsonBefore),\n      jsonParam(input.contractJsonAfter),\n      jsonParam(input.operations),\n    ],\n  };\n}\n\nfunction jsonParam(value: unknown): string {\n  return JSON.stringify(value ?? null);\n}\n"],"mappings":";;AASA,MAAa,sCAAoD;CAC/D,KAAK;CACL,QAAQ,CAAC;AACX;;;;;;;;;;AAWA,MAAa,6BAA2C;CACtD,KAAK;+CACwCA,eAAa;;;;;;;;;;CAU1D,QAAQ,CAAC;AACX;AAEA,MAAa,6BAA2C;CACtD,KAAK;;;;;;;;;;;;;;CAcL,QAAQ,CAAC;AACX;AA4BA,SAAgB,2BAA2B,OAGzC;CACA,MAAM,SAA6B;EACjC,MAAM;EACN,MAAM;EACN,MAAM;EACN,UAAU,MAAM,YAAY;EAC5B,MAAM,oBAAoB;EAC1B,MAAM,UAAU;EAChB,UAAU,MAAM,QAAQ,CAAC,CAAC;EAC1B,MAAM;CACR;CAEA,OAAO;EACL,QAAQ;GACN,KAAK;;;;;;;;;;;;;;;;;;;;;GAqBL;EACF;EACA,QAAQ;GAKN,KAAK;;;;;;;;;;GAUL;EACF;CACF;AACF;AAeA,SAAgB,2BAA2B,OAAwC;CACjF,OAAO;EACL,KAAK;;;;;;;;;;;;;;;;;;;;;;;EAuBL,QAAQ;GACN,MAAM;GACN,MAAM;GACN,MAAM;GACN,MAAM,qBAAqB;GAC3B,MAAM,qBAAqB;GAC3B,MAAM;GACN,MAAM,0BAA0B;GAChC,UAAU,MAAM,kBAAkB;GAClC,UAAU,MAAM,iBAAiB;GACjC,UAAU,MAAM,UAAU;EAC5B;CACF;AACF;AAEA,SAAS,UAAU,OAAwB;CACzC,OAAO,KAAK,UAAU,SAAS,IAAI;AACrC"}

package/dist/types-DncetAjv.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DncetAjv.d.mts","names":[],"sources":["../src/core/types.ts"],"mappings":";;;KAEY,qBAAA,GACR,aAAa;EAAA,SACF,IAAA;EAAA,SAA2B,IAAA;AAAA"}

package/src/contract-free/control-bootstrap.ts

@@ -1,55 +0,0 @@
-import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
-import type { DdlNode } from '@prisma-next/sql-relational-core/ast';
-import { col, fn, lit } from '@prisma-next/sql-relational-core/contract-free';
-import { createSchema, createTable } from './ddl';
-
-const markerColumns = [
-  col('space', 'text', { notNull: true, primaryKey: true, default: lit(APP_SPACE_ID) }),
-  col('core_hash', 'text', { notNull: true }),
-  col('profile_hash', 'text', { notNull: true }),
-  col('contract_json', 'jsonb'),
-  col('canonical_version', 'int'),
-  col('updated_at', 'timestamptz', { notNull: true, default: fn('now()') }),
-  col('app_tag', 'text'),
-  col('meta', 'jsonb', { notNull: true, default: lit('{}') }),
-  col('invariants', 'text[]', { notNull: true, default: lit('{}') }),
-] as const;
-
-const ledgerColumns = [
-  col('id', 'bigserial', { primaryKey: true }),
-  col('created_at', 'timestamptz', { notNull: true, default: fn('now()') }),
-  col('space', 'text', { notNull: true }),
-  col('migration_name', 'text', { notNull: true }),
-  col('migration_hash', 'text', { notNull: true }),
-  col('origin_core_hash', 'text'),
-  col('origin_profile_hash', 'text'),
-  col('destination_core_hash', 'text', { notNull: true }),
-  col('destination_profile_hash', 'text'),
-  col('contract_json_before', 'jsonb'),
-  col('contract_json_after', 'jsonb'),
-  col('operations', 'jsonb', { notNull: true }),
-] as const;
-
-const markerTable = createTable({
-  schema: 'prisma_contract',
-  table: 'marker',
-  ifNotExists: true,
-  columns: markerColumns,
-});
-
-const ledgerTable = createTable({
-  schema: 'prisma_contract',
-  table: 'ledger',
-  ifNotExists: true,
-  columns: ledgerColumns,
-});
-
-const controlSchema = createSchema({ schema: 'prisma_contract', ifNotExists: true });
-
-export function buildSignMarkerBootstrapQueries(): readonly DdlNode[] {
-  return [controlSchema, markerTable];
-}
-
-export function buildControlTableBootstrapQueries(): readonly DdlNode[] {
-  return [controlSchema, markerTable, ledgerTable];
-}

package/src/contract-free/ddl.ts

@@ -1,32 +0,0 @@
-import type { DdlColumn } from '@prisma-next/sql-relational-core/ast';
-import { PostgresCreateSchema, PostgresCreateTable } from '../core/ddl/nodes';
-
-/**
- * Build a Postgres `CREATE TABLE` query node.
- *
- * Precondition: identifiers (`table`, `schema`, column names/types) are
- * emitted to SQL verbatim — they are not quoted or escaped, so callers must
- * pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal
- * default values, by contrast, are single-quote-escaped (embedded `'` doubled)
- * by the renderer. Identifier quoting for untrusted identifiers is added when
- * the migration planner adopts this lowering path.
- */
-export function createTable(options: {
-  readonly table: string;
-  readonly schema?: string;
-  readonly ifNotExists?: boolean;
-  readonly columns: readonly DdlColumn[];
-}): PostgresCreateTable {
-  return new PostgresCreateTable(options);
-}
-
-/**
- * Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the
- * pre-trusted-identifier precondition.
- */
-export function createSchema(options: {
-  readonly schema: string;
-  readonly ifNotExists?: boolean;
-}): PostgresCreateSchema {
-  return new PostgresCreateSchema(options);
-}

package/src/core/column-type-compatibility.ts

@@ -1,13 +0,0 @@
-const EXPLICIT_COMPATIBLE_TYPE_PAIRS: ReadonlyArray<readonly [string, string]> = [];
-
-export function postgresColumnsCompatible(declared: string, live: string): boolean {
-  if (declared === live) {
-    return true;
-  }
-  for (const [a, b] of EXPLICIT_COMPATIBLE_TYPE_PAIRS) {
-    if ((declared === a && live === b) || (declared === b && live === a)) {
-      return true;
-    }
-  }
-  return false;
-}

package/src/core/ddl/nodes.ts

@@ -1,59 +0,0 @@
-import { type DdlColumn, DdlNode } from '@prisma-next/sql-relational-core/ast';
-
-export interface PostgresDdlVisitor<R> {
-  createTable(node: PostgresCreateTable): R;
-  createSchema(node: PostgresCreateSchema): R;
-}
-
-export abstract class PostgresDdlNode extends DdlNode {
-  abstract accept<R>(visitor: PostgresDdlVisitor<R>): R;
-}
-
-function freezeDdlColumns(columns: readonly DdlColumn[]): ReadonlyArray<DdlColumn> {
-  return Object.freeze([...columns]);
-}
-
-export class PostgresCreateTable extends PostgresDdlNode {
-  readonly kind = 'create-table' as const;
-  readonly table: string;
-  readonly schema: string | undefined;
-  readonly ifNotExists: boolean | undefined;
-  readonly columns: ReadonlyArray<DdlColumn>;
-
-  constructor(options: {
-    readonly table: string;
-    readonly schema?: string;
-    readonly ifNotExists?: boolean;
-    readonly columns: readonly DdlColumn[];
-  }) {
-    super();
-    this.table = options.table;
-    this.schema = options.schema;
-    this.ifNotExists = options.ifNotExists;
-    this.columns = freezeDdlColumns(options.columns);
-    this.freeze();
-  }
-
-  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
-    return visitor.createTable(this);
-  }
-}
-
-export class PostgresCreateSchema extends PostgresDdlNode {
-  readonly kind = 'create-schema' as const;
-  readonly schema: string;
-  readonly ifNotExists: boolean | undefined;
-
-  constructor(options: { readonly schema: string; readonly ifNotExists?: boolean }) {
-    super();
-    this.schema = options.schema;
-    this.ifNotExists = options.ifNotExists;
-    this.freeze();
-  }
-
-  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
-    return visitor.createSchema(this);
-  }
-}
-
-export type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema;

package/src/exports/column-type-compatibility.ts

@@ -1 +0,0 @@
-export { postgresColumnsCompatible } from '../core/column-type-compatibility';

package/src/exports/contract-free.ts

@@ -1,5 +0,0 @@
-export {
-  buildControlTableBootstrapQueries,
-  buildSignMarkerBootstrapQueries,
-} from '../contract-free/control-bootstrap';
-export { createSchema, createTable } from '../contract-free/ddl';

package/src/exports/ddl.ts

@@ -1,7 +0,0 @@
-export {
-  type AnyPostgresDdlNode,
-  PostgresCreateSchema,
-  PostgresCreateTable,
-  PostgresDdlNode,
-  type PostgresDdlVisitor,
-} from '../core/ddl/nodes';