@prisma-next/target-postgres 0.9.0 → 0.10.0-dev.10

package/dist/planner-sql-checks.d.mts

@@ -2,6 +2,17 @@ import { CodecControlHooks } from "@prisma-next/family-sql/control";
 import { PostgresEnumStorageEntry, StorageColumn, StorageTypeInstance } from "@prisma-next/sql-contract/types";
 
 //#region src/core/migrations/planner-sql-checks.d.ts
+/**
+ * String-keyed entry points the migration ops use to render
+ * schema-qualified DDL and catalog checks. The `schema` argument is
+ * interpreted as a namespace coordinate: the framework `__unbound__`
+ * sentinel resolves to the late-bound `PostgresUnboundSchema` singleton
+ * (which elides the qualifier so `search_path` decides at runtime); any
+ * other id materialises a `PostgresSchema(id)` whose qualifier is the
+ * named schema. Helpers route through these `Namespace` concretions so
+ * the unbound branch lives in the polymorphic override, not the call
+ * site.
+ */
 declare function qualifyTableName(schema: string, table: string): string;
 declare function toRegclassLiteral(schema: string, name: string): string;
 /**

package/dist/planner-sql-checks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-sql-checks.d.mts","names":[],"sources":["../src/core/migrations/planner-sql-checks.ts"],"mappings":";;;;iBASgB,gBAAA,CAAiB,MAAA,UAAgB,KAAA;AAAA,iBAIjC,iBAAA,CAAkB,MAAA,UAAgB,IAAA;AAJlD;;;;;AAAA,iBAcgB,qBAAA,CAAA;EACd,cAAA;EACA,MAAA;EACA,KAAA;EACA;AAAA;EAEA,cAAA;EACA,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAec,iBAAA,CAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,MAAA;AAAA;AAAA,iBAYc,sBAAA,CAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,QAAA;AAAA;AAAA,iBAac,iBAAA,CAAkB,kBAAA;AAAA,iBAIlB,uBAAA,CAAwB,IAAA;EACtC,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAwIc,uBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,GAAA,SAAY,iBAAA,GACxB,YAAA,GAAc,MAAA,SAAe,mBAAA,GAAsB,wBAAA;AAAA,iBAoErC,uBAAA,CACd,MAAA,UACA,KAAA,UACA,MAAA,WACA,cAAA"}
+{"version":3,"file":"planner-sql-checks.d.mts","names":[],"sources":["../src/core/migrations/planner-sql-checks.ts"],"mappings":";;;;;;AAqBA;;;;;AAIA;;;;iBAJgB,gBAAA,CAAiB,MAAA,UAAgB,KAAA;AAAA,iBAIjC,iBAAA,CAAkB,MAAA,UAAgB,IAAA;;;;;;iBASlC,qBAAA,CAAA;EACd,cAAA;EACA,MAAA;EACA,KAAA;EACA;AAAA;EAEA,cAAA;EACA,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAgBc,iBAAA,CAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,MAAA;AAAA;AAAA,iBAac,sBAAA,CAAA;EACd,MAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA;EAEA,MAAA;EACA,KAAA;EACA,MAAA;EACA,QAAA;AAAA;AAAA,iBAcc,iBAAA,CAAkB,kBAAA;AAAA,iBAIlB,uBAAA,CAAwB,IAAA;EACtC,MAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,iBAyIc,uBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,GAAA,SAAY,iBAAA,GACxB,YAAA,GAAc,MAAA,SAAe,mBAAA,GAAsB,wBAAA;AAAA,iBAsErC,uBAAA,CACd,MAAA,UACA,KAAA,UACA,MAAA,WACA,cAAA"}

package/dist/planner-sql-checks.mjs

@@ -1,2 +1,2 @@
-import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, i as columnHasNoDefaultCheck, l as tableHasPrimaryKeyCheck, r as columnExistsCheck, s as constraintExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-Cd016Ycs.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, i as columnHasNoDefaultCheck, l as tableHasPrimaryKeyCheck, r as columnExistsCheck, s as constraintExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-BM4sD6Xc.mjs";
 export { buildExpectedFormatType, columnExistsCheck, columnHasNoDefaultCheck, columnNullabilityCheck, constraintExistsCheck, qualifyTableName, tableHasPrimaryKeyCheck, tableIsEmptyCheck, toRegclassLiteral };

package/dist/{planner-target-details-iYJwzFHP.d.mts → planner-target-details-CIj61DUj.d.mts}

@@ -8,4 +8,4 @@ interface PostgresPlanTargetDetails {
 }
 //#endregion
 export { PostgresPlanTargetDetails as t };
-//# sourceMappingURL=planner-target-details-iYJwzFHP.d.mts.map
+//# sourceMappingURL=planner-target-details-CIj61DUj.d.mts.map

package/dist/{planner-target-details-iYJwzFHP.d.mts.map → planner-target-details-CIj61DUj.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-target-details-iYJwzFHP.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"mappings":";KAEY,cAAA;AAAA,UAUK,yBAAA;EAAA,SACN,MAAA;EAAA,SACA,UAAA,EAAY,cAAA;EAAA,SACZ,IAAA;EAAA,SACA,KAAA;AAAA"}
+{"version":3,"file":"planner-target-details-CIj61DUj.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"mappings":";KAEY,cAAA;AAAA,UAUK,yBAAA;EAAA,SACN,MAAA;EAAA,SACA,UAAA,EAAY,cAAA;EAAA,SACZ,IAAA;EAAA,SACA,KAAA;AAAA"}

package/dist/planner-target-details.d.mts

@@ -1,2 +1,2 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-iYJwzFHP.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIj61DUj.mjs";
 export { type PostgresPlanTargetDetails };

package/dist/planner.d.mts

@@ -1,4 +1,4 @@
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-D34ftfEK.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-c9lpjPv1.mjs";
 import { MigrationOperationPolicy, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
 import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
 import { Contract } from "@prisma-next/contract/types";

package/dist/planner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"mappings":";;;;;;;UAwCU,aAAA;EAAA,SACC,aAAA;AAAA;AAAA,iBAOK,8BAAA,CACd,MAAA,GAAQ,OAAA,CAAQ,aAAA,IACf,wBAAA;;;;AAFH;;;;KAgBY,kBAAA;EAAA,SACG,IAAA;EAAA,SAA0B,IAAA,EAAM,qCAAA;AAAA,IAC3C,uBAAA;;;;;;;AAFJ;;;;;;;;;;cAoBa,wBAAA,YAAoC,gBAAA;EAAA,iBAClB,MAAA;cAAA,MAAA,EAAQ,aAAA;EAErC,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IAiBa;;;;;;;;;;;;;;IAAA,SAFrB,YAAA,EAAc,QAAA;IAAA,SACd,UAAA;IAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;IAFnC;;;;;IAAA,SAQA,OAAA;EAAA,IACP,kBAAA;EAIJ,cAAA,CACE,OAAA,EAAS,wBAAA,EACT,OAAA,WACC,iCAAA;EAAA,QAWK,OAAA;EAAA,QA6DA,oBAAA;EAAA,QAaA,mBAAA;AAAA"}
+{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"mappings":";;;;;;;UAyCU,aAAA;EAAA,SACC,aAAA;AAAA;AAAA,iBAOK,8BAAA,CACd,MAAA,GAAQ,OAAA,CAAQ,aAAA,IACf,wBAAA;;;;AAFH;;;;KAgBY,kBAAA;EAAA,SACG,IAAA;EAAA,SAA0B,IAAA,EAAM,qCAAA;AAAA,IAC3C,uBAAA;;;;;;;AAFJ;;;;;;;;;;cAoBa,wBAAA,YAAoC,gBAAA;EAAA,iBAClB,MAAA;cAAA,MAAA,EAAQ,aAAA;EAErC,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IAiBa;;;;;;;;;;;;;;IAAA,SAFrB,YAAA,EAAc,QAAA;IAAA,SACd,UAAA;IAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;IAFnC;;;;;IAAA,SAQA,OAAA;EAAA,IACP,kBAAA;EAIJ,cAAA,CACE,OAAA,EAAS,wBAAA,EACT,OAAA,WACC,iCAAA;EAAA,QAWK,OAAA;EAAA,QA6DA,oBAAA;EAAA,QAaA,mBAAA;AAAA"}

package/dist/planner.mjs

@@ -1,2 +1,2 @@
-import { t as createPostgresMigrationPlanner } from "./planner-DnzPpv1j.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-C8yhbXOq.mjs";
 export { createPostgresMigrationPlanner };

package/dist/postgres-contract-serializer-CcZO9ukP.mjs

@@ -0,0 +1,83 @@
+import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
+import { r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-BosNxhWq.mjs";
+import { NamespaceBase, UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { StorageTable } from "@prisma-next/sql-contract/types";
+import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
+//#region src/core/postgres-contract-serializer.ts
+var PostgresContractSerializer = class extends SqlContractSerializerBase {
+	constructor() {
+		super(/* @__PURE__ */ new Map());
+	}
+	hydrateSqlNamespaceEntry(nsId, raw) {
+		if (raw instanceof NamespaceBase) return raw;
+		const obj = raw;
+		const id = obj.id ?? nsId;
+		const tables = Object.fromEntries(Object.entries(obj.tables ?? {}).map(([tableName, table]) => [tableName, table instanceof StorageTable ? table : new StorageTable(table)]));
+		const typeEntries = obj.types;
+		const hydratedNsTypes = typeEntries !== void 0 && Object.keys(typeEntries).length > 0 ? Object.fromEntries(Object.entries(typeEntries).map(([typeName, entry]) => {
+			if (entry instanceof PostgresEnumType) return [typeName, entry];
+			const plain = entry;
+			const name = typeof plain["name"] === "string" ? plain["name"] : typeName;
+			return [typeName, new PostgresEnumType({
+				name,
+				nativeType: typeof plain["nativeType"] === "string" ? plain["nativeType"] : name,
+				values: Array.isArray(plain["values"]) ? plain["values"] : []
+			})];
+		})) : void 0;
+		const emptyTables = Object.keys(tables).length === 0;
+		const emptyTypes = !hydratedNsTypes || Object.keys(hydratedNsTypes).length === 0;
+		if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) return PostgresSchema.unbound;
+		return new PostgresSchema({
+			id,
+			tables,
+			...hydratedNsTypes !== void 0 ? { types: hydratedNsTypes } : {}
+		});
+	}
+	serializeContract(contract) {
+		const { storage, ...rest } = contract;
+		const namespacesJson = {};
+		for (const [nsId, ns] of Object.entries(storage.namespaces)) if (isPostgresSchema(ns)) namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
+		else {
+			const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;
+			const nsTypes = ns.types ?? {};
+			namespacesJson[nsId] = {
+				id: nsId,
+				kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
+				tables: Object.fromEntries(Object.entries(ns.tables).map(([tableName, table]) => [tableName, this.serializeJsonValue(table)])),
+				types: Object.fromEntries(Object.entries(nsTypes).map(([typeName, entry]) => [typeName, this.serializeJsonValue(entry)]))
+			};
+		}
+		const storageOut = {
+			storageHash: String(storage.storageHash),
+			namespaces: namespacesJson
+		};
+		if (storage.types !== void 0) {
+			const typesOut = {};
+			for (const [name, entry] of Object.entries(storage.types)) typesOut[name] = this.serializeJsonValue(entry);
+			storageOut["types"] = typesOut;
+		}
+		return {
+			...rest,
+			storage: storageOut
+		};
+	}
+	serializePostgresNamespace(ns, isUnboundSlot) {
+		const tablesOut = {};
+		for (const [tableName, table] of Object.entries(ns.tables)) tablesOut[tableName] = this.serializeJsonValue(table);
+		const typesOut = {};
+		for (const [typeName, ty] of Object.entries(ns.types)) typesOut[typeName] = this.serializeJsonValue(ty);
+		return {
+			id: ns.id,
+			kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
+			tables: tablesOut,
+			types: typesOut
+		};
+	}
+	serializeJsonValue(value) {
+		return JSON.parse(JSON.stringify(value));
+	}
+};
+//#endregion
+export { PostgresContractSerializer as t };
+
+//# sourceMappingURL=postgres-contract-serializer-CcZO9ukP.mjs.map

package/dist/postgres-contract-serializer-CcZO9ukP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-contract-serializer-CcZO9ukP.mjs","names":[],"sources":["../src/core/postgres-contract-serializer.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';\nimport {\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport {\n  type SqlNamespaceTablesInput,\n  type SqlStorage,\n  StorageTable,\n  type StorageTableInput,\n} from '@prisma-next/sql-contract/types';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\nimport { isPostgresSchema, PostgresSchema } from './postgres-schema';\n\nexport class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    // Postgres entity types (enums) are namespace-level and hydrated in\n    // hydrateSqlNamespaceEntry; there are no storage-level codec alias entities\n    // specific to Postgres, so the registry is empty.\n    super(new Map());\n  }\n\n  protected override hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const obj = raw as {\n      id?: string;\n      tables?: Record<string, unknown>;\n      types?: Record<string, unknown>;\n    };\n    const id = obj.id ?? nsId;\n    const tables = Object.fromEntries(\n      Object.entries(obj.tables ?? {}).map(([tableName, table]) => [\n        tableName,\n        table instanceof StorageTable ? table : new StorageTable(table as StorageTableInput),\n      ]),\n    );\n    const typeEntries = obj.types;\n    const hydratedNsTypes =\n      typeEntries !== undefined && Object.keys(typeEntries).length > 0\n        ? Object.fromEntries(\n            Object.entries(typeEntries).map(([typeName, entry]) => {\n              if (entry instanceof PostgresEnumType) {\n                return [typeName, entry];\n              }\n              const plain = entry as Record<string, unknown>;\n              const name = typeof plain['name'] === 'string' ? plain['name'] : typeName;\n              const nativeType =\n                typeof plain['nativeType'] === 'string' ? plain['nativeType'] : name;\n              const values = Array.isArray(plain['values']) ? (plain['values'] as string[]) : [];\n              return [\n                typeName,\n                new PostgresEnumType({ name, nativeType, values } as PostgresEnumTypeInput),\n              ];\n            }),\n          )\n        : undefined;\n\n    const emptyTables = Object.keys(tables).length === 0;\n    const emptyTypes = !hydratedNsTypes || Object.keys(hydratedNsTypes).length === 0;\n    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) {\n      return PostgresSchema.unbound;\n    }\n    return new PostgresSchema({\n      id,\n      tables,\n      ...(hydratedNsTypes !== undefined ? { types: hydratedNsTypes } : {}),\n    });\n  }\n\n  override serializeContract(contract: Contract<SqlStorage>): JsonObject {\n    const { storage, ...rest } = contract;\n    const namespacesJson: Record<string, JsonObject> = {};\n    for (const [nsId, ns] of Object.entries(storage.namespaces)) {\n      if (isPostgresSchema(ns)) {\n        namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);\n      } else {\n        // Family-level SqlNamespacePayload / SqlUnboundNamespace haven't\n        // been promoted to a PostgresSchema instance yet (e.g. they came\n        // straight from the TS builder, which uses the family-shared\n        // SqlStorage constructor). Serialise them as postgres-schema /\n        // postgres-unbound-schema so the round-trip through\n        // deserializeContract hydrates them back into PostgresSchema\n        // instances.\n        const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;\n        const nsTypes = (ns as { readonly types?: Readonly<Record<string, unknown>> }).types ?? {};\n        namespacesJson[nsId] = {\n          id: nsId,\n          kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',\n          tables: Object.fromEntries(\n            Object.entries(ns.tables).map(([tableName, table]) => [\n              tableName,\n              this.serializeJsonValue(table) as JsonObject,\n            ]),\n          ),\n          types: Object.fromEntries(\n            Object.entries(nsTypes).map(([typeName, entry]) => [\n              typeName,\n              this.serializeJsonValue(entry) as JsonObject,\n            ]),\n          ),\n        };\n      }\n    }\n    const storageOut: Record<string, unknown> = {\n      storageHash: String(storage.storageHash),\n      namespaces: namespacesJson,\n    };\n    if (storage.types !== undefined) {\n      const typesOut: Record<string, JsonObject> = {};\n      for (const [name, entry] of Object.entries(storage.types)) {\n        typesOut[name] = this.serializeJsonValue(entry) as JsonObject;\n      }\n      storageOut['types'] = typesOut;\n    }\n    return {\n      ...rest,\n      storage: storageOut,\n    } as unknown as JsonObject;\n  }\n\n  private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {\n    const tablesOut: Record<string, JsonObject> = {};\n    for (const [tableName, table] of Object.entries(ns.tables)) {\n      tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;\n    }\n    const typesOut: Record<string, JsonObject> = {};\n    for (const [typeName, ty] of Object.entries(ns.types)) {\n      typesOut[typeName] = this.serializeJsonValue(ty) as JsonObject;\n    }\n    return {\n      id: ns.id,\n      kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',\n      tables: tablesOut,\n      types: typesOut,\n    };\n  }\n\n  private serializeJsonValue(value: unknown): unknown {\n    return JSON.parse(JSON.stringify(value)) as unknown;\n  }\n}\n"],"mappings":";;;;;;AAiBA,IAAa,6BAAb,cAAgD,0BAAgD;CAC9F,cAAc;EAIZ,sBAAM,IAAI,KAAK,CAAC;;CAGlB,yBACE,MACA,KACqC;EACrC,IAAI,eAAe,eACjB,OAAO;EAET,MAAM,MAAM;EAKZ,MAAM,KAAK,IAAI,MAAM;EACrB,MAAM,SAAS,OAAO,YACpB,OAAO,QAAQ,IAAI,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,WAAW,WAAW,CAC3D,WACA,iBAAiB,eAAe,QAAQ,IAAI,aAAa,MAA2B,CACrF,CAAC,CACH;EACD,MAAM,cAAc,IAAI;EACxB,MAAM,kBACJ,gBAAgB,KAAA,KAAa,OAAO,KAAK,YAAY,CAAC,SAAS,IAC3D,OAAO,YACL,OAAO,QAAQ,YAAY,CAAC,KAAK,CAAC,UAAU,WAAW;GACrD,IAAI,iBAAiB,kBACnB,OAAO,CAAC,UAAU,MAAM;GAE1B,MAAM,QAAQ;GACd,MAAM,OAAO,OAAO,MAAM,YAAY,WAAW,MAAM,UAAU;GAIjE,OAAO,CACL,UACA,IAAI,iBAAiB;IAAE;IAAM,YAJ7B,OAAO,MAAM,kBAAkB,WAAW,MAAM,gBAAgB;IAIvB,QAH5B,MAAM,QAAQ,MAAM,UAAU,GAAI,MAAM,YAAyB,EAAE;IAG/B,CAA0B,CAC5E;IACD,CACH,GACD,KAAA;EAEN,MAAM,cAAc,OAAO,KAAK,OAAO,CAAC,WAAW;EACnD,MAAM,aAAa,CAAC,mBAAmB,OAAO,KAAK,gBAAgB,CAAC,WAAW;EAC/E,IAAI,OAAO,wBAAwB,eAAe,YAChD,OAAO,eAAe;EAExB,OAAO,IAAI,eAAe;GACxB;GACA;GACA,GAAI,oBAAoB,KAAA,IAAY,EAAE,OAAO,iBAAiB,GAAG,EAAE;GACpE,CAAC;;CAGJ,kBAA2B,UAA4C;EACrE,MAAM,EAAE,SAAS,GAAG,SAAS;EAC7B,MAAM,iBAA6C,EAAE;EACrD,KAAK,MAAM,CAAC,MAAM,OAAO,OAAO,QAAQ,QAAQ,WAAW,EACzD,IAAI,iBAAiB,GAAG,EACtB,eAAe,QAAQ,KAAK,2BAA2B,IAAI,GAAG,OAAO,qBAAqB;OACrF;GAQL,MAAM,gBAAgB,SAAS;GAC/B,MAAM,UAAW,GAA8D,SAAS,EAAE;GAC1F,eAAe,QAAQ;IACrB,IAAI;IACJ,MAAM,gBAAgB,4BAA4B;IAClD,QAAQ,OAAO,YACb,OAAO,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,WAAW,CACpD,WACA,KAAK,mBAAmB,MAAM,CAC/B,CAAC,CACH;IACD,OAAO,OAAO,YACZ,OAAO,QAAQ,QAAQ,CAAC,KAAK,CAAC,UAAU,WAAW,CACjD,UACA,KAAK,mBAAmB,MAAM,CAC/B,CAAC,CACH;IACF;;EAGL,MAAM,aAAsC;GAC1C,aAAa,OAAO,QAAQ,YAAY;GACxC,YAAY;GACb;EACD,IAAI,QAAQ,UAAU,KAAA,GAAW;GAC/B,MAAM,WAAuC,EAAE;GAC/C,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,MAAM,EACvD,SAAS,QAAQ,KAAK,mBAAmB,MAAM;GAEjD,WAAW,WAAW;;EAExB,OAAO;GACL,GAAG;GACH,SAAS;GACV;;CAGH,2BAAmC,IAAoB,eAAoC;EACzF,MAAM,YAAwC,EAAE;EAChD,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,OAAO,EACxD,UAAU,aAAa,KAAK,mBAAmB,MAAM;EAEvD,MAAM,WAAuC,EAAE;EAC/C,KAAK,MAAM,CAAC,UAAU,OAAO,OAAO,QAAQ,GAAG,MAAM,EACnD,SAAS,YAAY,KAAK,mBAAmB,GAAG;EAElD,OAAO;GACL,IAAI,GAAG;GACP,MAAM,gBAAgB,4BAA4B;GAClD,QAAQ;GACR,OAAO;GACR;;CAGH,mBAA2B,OAAyB;EAClD,OAAO,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC"}

package/dist/{postgres-enum-type-CrKq8au9.d.mts → postgres-enum-type-CNhPTDhy.d.mts}

@@ -66,4 +66,4 @@ declare class PostgresEnumType<TName extends string = string, TValues extends re
 }
 //#endregion
 export { PostgresEnumTypeInput as n, PostgresEnumType as t };
-//# sourceMappingURL=postgres-enum-type-CrKq8au9.d.mts.map
+//# sourceMappingURL=postgres-enum-type-CNhPTDhy.d.mts.map

package/dist/{postgres-enum-type-CrKq8au9.d.mts.map → postgres-enum-type-CNhPTDhy.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-enum-type-CrKq8au9.d.mts","names":[],"sources":["../src/core/postgres-enum-type.ts"],"mappings":";;;UAGiB,qBAAA;;AAAjB;;;;WASW,IAAA,EAAM,KAAA;EAPf;;;;;EAAA,SAaS,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;AAAA;AAClB;AAAA,cAGK,gBAAA;;;;AAyBN;;;;;;;;;;;;;;;;;;;;cAAa,gBAAA,+FAGH,OAAA;EAAA,SACU,IAAA;EAAA,SACT,IAAA,EAAM,KAAA;EAAA,SACN,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;;;;;;;;;;WAUR,OAAA,SAAgB,gBAAA;cAEb,KAAA,EAAO,qBAAA,CAAsB,KAAA,EAAO,OAAA;EAAA,IAW5C,YAAA,CAAA;IAAA,SACO,OAAA,SAAgB,gBAAA;IAAA,SAChB,UAAA;MAAA,SAAuB,MAAA,EAAQ,OAAA;IAAA;EAAA;AAAA"}
+{"version":3,"file":"postgres-enum-type-CNhPTDhy.d.mts","names":[],"sources":["../src/core/postgres-enum-type.ts"],"mappings":";;;UAGiB,qBAAA;;AAAjB;;;;WASW,IAAA,EAAM,KAAA;EAPf;;;;;EAAA,SAaS,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;AAAA;AAClB;AAAA,cAGK,gBAAA;;;;AAyBN;;;;;;;;;;;;;;;;;;;;cAAa,gBAAA,+FAGH,OAAA;EAAA,SACU,IAAA;EAAA,SACT,IAAA,EAAM,KAAA;EAAA,SACN,UAAA;EAAA,SACA,MAAA,EAAQ,OAAA;;;;;;;;;;WAUR,OAAA,SAAgB,gBAAA;cAEb,KAAA,EAAO,qBAAA,CAAsB,KAAA,EAAO,OAAA;EAAA,IAW5C,YAAA,CAAA;IAAA,SACO,OAAA,SAAgB,gBAAA;IAAA,SAChB,UAAA;MAAA,SAAuB,MAAA,EAAQ,OAAA;IAAA;EAAA;AAAA"}

package/dist/{postgres-migration-q4oWyNJE.mjs → postgres-migration-C5os-tkl.mjs}

@@ -1,5 +1,5 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors-BiOloWUh.mjs";
-import { t as dataTransform } from "./data-transform-COkGR6Ns.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors--zafB5_n.mjs";
+import { t as dataTransform } from "./data-transform-CdtGUWp2.mjs";
 import { Migration } from "@prisma-next/family-sql/migration";
 //#region src/core/migrations/postgres-migration.ts
 /**
@@ -48,4 +48,4 @@ var PostgresMigration = class extends Migration {
 //#endregion
 export { PostgresMigration as t };
 
-//# sourceMappingURL=postgres-migration-q4oWyNJE.mjs.map
+//# sourceMappingURL=postgres-migration-C5os-tkl.mjs.map

package/dist/{postgres-migration-q4oWyNJE.mjs.map → postgres-migration-C5os-tkl.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-migration-q4oWyNJE.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a target-specific re-export of this\n * class from `@prisma-next/target-postgres/migration`, keeping the\n * authoring surface target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,WAAoB;;;;;;;CAQpB;CAEA,YAAY,OAAyC;EACnD,MAAM,MAAM;EAIZ,KAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,MAAM,GAC5B,KAAA;;;;;;;CAQN,cACE,UACA,MACA,SACsD;EACtD,IAAI,CAAC,KAAK,gBACR,MAAM,oCAAoC;EAE5C,OAAO,cAAc,UAAU,MAAM,SAAS,KAAK,eAAe"}
+{"version":3,"file":"postgres-migration-C5os-tkl.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a target-specific re-export of this\n * class from `@prisma-next/target-postgres/migration`, keeping the\n * authoring surface target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,WAAoB;;;;;;;CAQpB;CAEA,YAAY,OAAyC;EACnD,MAAM,MAAM;EAIZ,KAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,MAAM,GAC5B,KAAA;;;;;;;CAQN,cACE,UACA,MACA,SACsD;EACtD,IAAI,CAAC,KAAK,gBACR,MAAM,oCAAoC;EAE5C,OAAO,cAAc,UAAU,MAAM,SAAS,KAAK,eAAe"}

package/dist/{postgres-migration-CiQzhcMe.d.mts → postgres-migration-jvsKgUDM.d.mts}

@@ -1,5 +1,5 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-iYJwzFHP.mjs";
-import { n as DataTransformOptions } from "./data-transform-B6p02mFJ.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIj61DUj.mjs";
+import { n as DataTransformOptions } from "./data-transform-bmOKkygi.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { Migration } from "@prisma-next/family-sql/migration";
@@ -47,4 +47,4 @@ declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDet
 }
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration-CiQzhcMe.d.mts.map
+//# sourceMappingURL=postgres-migration-jvsKgUDM.d.mts.map

package/dist/{postgres-migration-CiQzhcMe.d.mts.map → postgres-migration-jvsKgUDM.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-migration-CiQzhcMe.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"mappings":";;;;;;;;;;;;AA8BA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,SAAA,CAC9C,yBAAA;EAAA,SAGS,QAAA;;;;;;;qBAQU,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAgBlB;;;;;EAAA,UADQ,aAAA,mBAAgC,QAAA,CAAS,UAAA,EAAA,CACjD,QAAA,EAAU,SAAA,EACV,IAAA,UACA,OAAA,EAAS,oBAAA,GACR,yBAAA,CAA0B,yBAAA;AAAA"}
+{"version":3,"file":"postgres-migration-jvsKgUDM.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"mappings":";;;;;;;;;;;;AA8BA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,SAAA,CAC9C,yBAAA;EAAA,SAGS,QAAA;;;;;;;qBAQU,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAgBlB;;;;;EAAA,UADQ,aAAA,mBAAgC,QAAA,CAAS,UAAA,EAAA,CACjD,QAAA,EAAU,SAAA,EACV,IAAA,UACA,OAAA,EAAS,oBAAA,GACR,yBAAA,CAA0B,yBAAA;AAAA"}

package/dist/postgres-schema-BosNxhWq.mjs

@@ -0,0 +1,163 @@
+import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
+import { n as escapeLiteral } from "./sql-utils-BewXAnsG.mjs";
+import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode } from "@prisma-next/framework-components/ir";
+import { StorageTable } from "@prisma-next/sql-contract/types";
+//#region src/core/postgres-schema.ts
+/**
+* Postgres target `Namespace` concretion — a Postgres schema (`CREATE
+* SCHEMA …`). Each Postgres `SqlStorage` carries a
+* `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
+* the Postgres PSL interpreter from `namespace { … }` AST buckets.
+*
+* Qualifier emission is the rendering seam: DDL / SQL emission asks the
+* namespace for its qualifier (`"<schema>"`) or for a qualified table
+* name (`"<schema>"."<table>"`) and consumes the result polymorphically.
+* The unbound singleton below overrides these methods to elide the
+* prefix entirely — call sites stay polymorphic and never branch on
+* `id === UNBOUND_NAMESPACE_ID`.
+*/
+var PostgresSchema = class extends NamespaceBase {
+	/**
+	* Stable singleton reference for the late-bound slot. Materialised
+	* lazily below the singleton subclass declaration so the static
+	* initialiser sees the subclass before assigning. Consumers always
+	* reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`
+	* — same identity).
+	*/
+	static unbound;
+	kind = "schema";
+	id;
+	tables;
+	types;
+	constructor(input) {
+		super();
+		this.id = input.id;
+		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables ?? {}).map(([name, t]) => [name, t instanceof StorageTable ? t : new StorageTable(t)])));
+		this.types = Object.freeze(Object.fromEntries(Object.entries(input.types ?? {}).map(([name, ty]) => [name, ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty)])));
+		freezeNode(this);
+	}
+	/**
+	* The bare schema qualifier as it would appear in a rendered SQL
+	* fragment (already quoted). The unbound-schema singleton overrides
+	* this to return `''`.
+	*/
+	qualifier() {
+		return `"${this.id}"`;
+	}
+	/**
+	* Qualify a table name with the schema prefix
+	* (`"<schema>"."<table>"`). The unbound-schema singleton overrides
+	* this to emit just `"<table>"` so the resolved DDL is unqualified
+	* and `search_path` decides where the object lands at runtime.
+	*/
+	qualifyTable(tableName) {
+		return `"${this.id}"."${tableName}"`;
+	}
+	/**
+	* Render a SQL string-literal containing the qualified-name form
+	* suitable for `to_regclass(...)` arguments (e.g. `'"public"."user"'`).
+	* The unbound singleton overrides this to elide the schema prefix
+	* (`'"user"'`) so `search_path` resolves the object at runtime.
+	*/
+	regclassLiteral(name) {
+		return `'${escapeLiteral(this.qualifyTable(name))}'`;
+	}
+	/**
+	* Render a SQL expression that evaluates to this namespace's schema
+	* name at runtime, ready to drop into a `WHERE table_schema = …` /
+	* `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL
+	* literal (`'public'`); the unbound singleton overrides this to emit
+	* `current_schema()` so catalog queries match whichever schema the
+	* connection's `search_path` resolved at runtime.
+	*/
+	schemaSqlExpression() {
+		return `'${escapeLiteral(this.id)}'`;
+	}
+	/**
+	* The bare schema name a DDL planner should target when emitting
+	* statements that need to identify this namespace in the live
+	* database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
+	* catalog filters, planner conflict lookups). Named schemas resolve
+	* to their own id; the unbound singleton overrides this to project
+	* to `'public'` when a sibling public namespace exists in the same
+	* contract — and falls back to the framework sentinel otherwise so
+	* the planner can detect the missing-projection case explicitly.
+	*/
+	ddlSchemaName(_storage) {
+		return this.id;
+	}
+};
+/**
+* Singleton subclass for the reserved sentinel namespace id
+* (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding
+* the connection's `search_path` resolves at runtime. Overrides
+* qualifier emission to elide the schema prefix; call sites that consume
+* `qualifier()` / `qualifyTable()` get unqualified output without
+* branching on the namespace id.
+*
+* This is the target-side materialization of "the framework provides
+* affordances; targets implement specifics": the framework names the
+* sentinel; Postgres decides what late-bound means here (the table
+* name, naked — the schema is supplied by the live connection's
+* `search_path`).
+*/
+var PostgresUnboundSchema = class PostgresUnboundSchema extends PostgresSchema {
+	static instance = new PostgresUnboundSchema();
+	constructor(input) {
+		super(input ?? { id: UNBOUND_NAMESPACE_ID });
+	}
+	qualifier() {
+		return "";
+	}
+	qualifyTable(tableName) {
+		return `"${tableName}"`;
+	}
+	schemaSqlExpression() {
+		return "current_schema()";
+	}
+	/**
+	* The unbound slot has no schema name of its own, so DDL emission
+	* projects it onto a sibling when one is available: if the contract
+	* carries a `public` namespace, the late-bound slot resolves to
+	* `'public'` (the default Postgres landing schema); otherwise it
+	* resolves to the framework sentinel `UNBOUND_NAMESPACE_ID` so the
+	* planner can recognise the unprojected case and route accordingly
+	* (e.g. emit a conflict instead of silently picking a schema).
+	*/
+	ddlSchemaName(storage) {
+		if (storage.namespaces["public"] !== void 0) return "public";
+		return UNBOUND_NAMESPACE_ID;
+	}
+};
+PostgresSchema.unbound = PostgresUnboundSchema.instance;
+/**
+* Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`
+* so callers can dispatch to the polymorphic emission methods without
+* branching at the call site. Uses the structural `kind` discriminator
+* (`'schema'`) rather than `instanceof` so the check survives realm /
+* bundle / hot-reload boundaries — matching the rest of the IR's
+* narrowing convention. `PostgresUnboundSchema` passes through because
+* it inherits the same `kind: 'schema'` from `PostgresSchema`.
+*/
+function isPostgresSchema(ns) {
+	return ns?.kind === "schema";
+}
+/**
+* Target-supplied `Namespace` factory the Postgres target plumbs
+* through `defineContract({ createNamespace })` and the SQL PSL
+* interpreter. Returns the unbound singleton for the framework
+* sentinel and a fresh `PostgresSchema` for any other coordinate.
+*
+* The factory has no per-call state — every named id deterministically
+* maps to a distinct schema instance — so callers can pass it through
+* by reference and trust the resulting `SqlStorage.namespaces` map to
+* be value-stable for a given input set.
+*/
+function postgresCreateNamespace(input) {
+	if (input.id === UNBOUND_NAMESPACE_ID) return new PostgresUnboundSchema(input);
+	return new PostgresSchema(input);
+}
+//#endregion
+export { postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
+
+//# sourceMappingURL=postgres-schema-BosNxhWq.mjs.map

package/dist/postgres-schema-BosNxhWq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-BosNxhWq.mjs","names":[],"sources":["../src/core/postgres-schema.ts"],"sourcesContent":["import {\n  freezeNode,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport {\n  type SqlNamespaceTablesInput,\n  type SqlStorage,\n  StorageTable,\n  type StorageTableInput,\n} from '@prisma-next/sql-contract/types';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\nimport { escapeLiteral } from './sql-utils';\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly tables?: Record<string, StorageTable | StorageTableInput>;\n  readonly types?: Record<string, PostgresEnumType | PostgresEnumTypeInput>;\n}\n\n/**\n * Postgres target `Namespace` concretion — a Postgres schema (`CREATE\n * SCHEMA …`). Each Postgres `SqlStorage` carries a\n * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by\n * the Postgres PSL interpreter from `namespace { … }` AST buckets.\n *\n * Qualifier emission is the rendering seam: DDL / SQL emission asks the\n * namespace for its qualifier (`\"<schema>\"`) or for a qualified table\n * name (`\"<schema>\".\"<table>\"`) and consumes the result polymorphically.\n * The unbound singleton below overrides these methods to elide the\n * prefix entirely — call sites stay polymorphic and never branch on\n * `id === UNBOUND_NAMESPACE_ID`.\n */\nexport class PostgresSchema extends NamespaceBase {\n  /**\n   * Stable singleton reference for the late-bound slot. Materialised\n   * lazily below the singleton subclass declaration so the static\n   * initialiser sees the subclass before assigning. Consumers always\n   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`\n   * — same identity).\n   */\n  static unbound: PostgresUnboundSchema;\n\n  readonly kind = 'schema' as const;\n  readonly id: string;\n  readonly tables: Readonly<Record<string, StorageTable>>;\n  readonly types: Readonly<Record<string, PostgresEnumType>>;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n    this.tables = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.tables ?? {}).map(([name, t]) => [\n          name,\n          t instanceof StorageTable ? t : new StorageTable(t),\n        ]),\n      ),\n    );\n    this.types = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.types ?? {}).map(([name, ty]) => [\n          name,\n          ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty),\n        ]),\n      ),\n    );\n    freezeNode(this);\n  }\n\n  /**\n   * The bare schema qualifier as it would appear in a rendered SQL\n   * fragment (already quoted). The unbound-schema singleton overrides\n   * this to return `''`.\n   */\n  qualifier(): string {\n    return `\"${this.id}\"`;\n  }\n\n  /**\n   * Qualify a table name with the schema prefix\n   * (`\"<schema>\".\"<table>\"`). The unbound-schema singleton overrides\n   * this to emit just `\"<table>\"` so the resolved DDL is unqualified\n   * and `search_path` decides where the object lands at runtime.\n   */\n  qualifyTable(tableName: string): string {\n    return `\"${this.id}\".\"${tableName}\"`;\n  }\n\n  /**\n   * Render a SQL string-literal containing the qualified-name form\n   * suitable for `to_regclass(...)` arguments (e.g. `'\"public\".\"user\"'`).\n   * The unbound singleton overrides this to elide the schema prefix\n   * (`'\"user\"'`) so `search_path` resolves the object at runtime.\n   */\n  regclassLiteral(name: string): string {\n    return `'${escapeLiteral(this.qualifyTable(name))}'`;\n  }\n\n  /**\n   * Render a SQL expression that evaluates to this namespace's schema\n   * name at runtime, ready to drop into a `WHERE table_schema = …` /\n   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL\n   * literal (`'public'`); the unbound singleton overrides this to emit\n   * `current_schema()` so catalog queries match whichever schema the\n   * connection's `search_path` resolved at runtime.\n   */\n  schemaSqlExpression(): string {\n    return `'${escapeLiteral(this.id)}'`;\n  }\n\n  /**\n   * The bare schema name a DDL planner should target when emitting\n   * statements that need to identify this namespace in the live\n   * database (e.g. `CREATE TABLE \"<ddlSchemaName>\".\"<table>\" …`,\n   * catalog filters, planner conflict lookups). Named schemas resolve\n   * to their own id; the unbound singleton overrides this to project\n   * to `'public'` when a sibling public namespace exists in the same\n   * contract — and falls back to the framework sentinel otherwise so\n   * the planner can detect the missing-projection case explicitly.\n   */\n  ddlSchemaName(_storage: SqlStorage): string {\n    return this.id;\n  }\n}\n\n/**\n * Singleton subclass for the reserved sentinel namespace id\n * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding\n * the connection's `search_path` resolves at runtime. Overrides\n * qualifier emission to elide the schema prefix; call sites that consume\n * `qualifier()` / `qualifyTable()` get unqualified output without\n * branching on the namespace id.\n *\n * This is the target-side materialization of \"the framework provides\n * affordances; targets implement specifics\": the framework names the\n * sentinel; Postgres decides what late-bound means here (the table\n * name, naked — the schema is supplied by the live connection's\n * `search_path`).\n */\nexport class PostgresUnboundSchema extends PostgresSchema {\n  static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();\n\n  constructor(input?: PostgresSchemaInput) {\n    super(input ?? { id: UNBOUND_NAMESPACE_ID });\n  }\n\n  override qualifier(): string {\n    return '';\n  }\n\n  override qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n\n  override schemaSqlExpression(): string {\n    return 'current_schema()';\n  }\n\n  /**\n   * The unbound slot has no schema name of its own, so DDL emission\n   * projects it onto a sibling when one is available: if the contract\n   * carries a `public` namespace, the late-bound slot resolves to\n   * `'public'` (the default Postgres landing schema); otherwise it\n   * resolves to the framework sentinel `UNBOUND_NAMESPACE_ID` so the\n   * planner can recognise the unprojected case and route accordingly\n   * (e.g. emit a conflict instead of silently picking a schema).\n   */\n  override ddlSchemaName(storage: SqlStorage): string {\n    if (storage.namespaces['public'] !== undefined) {\n      return 'public';\n    }\n    return UNBOUND_NAMESPACE_ID;\n  }\n}\n\nPostgresSchema.unbound = PostgresUnboundSchema.instance;\n\n/**\n * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`\n * so callers can dispatch to the polymorphic emission methods without\n * branching at the call site. Uses the structural `kind` discriminator\n * (`'schema'`) rather than `instanceof` so the check survives realm /\n * bundle / hot-reload boundaries — matching the rest of the IR's\n * narrowing convention. `PostgresUnboundSchema` passes through because\n * it inherits the same `kind: 'schema'` from `PostgresSchema`.\n */\nexport function isPostgresSchema(ns: unknown): ns is PostgresSchema {\n  return (ns as { kind?: unknown } | null | undefined)?.kind === 'schema';\n}\n\n/**\n * Target-supplied `Namespace` factory the Postgres target plumbs\n * through `defineContract({ createNamespace })` and the SQL PSL\n * interpreter. Returns the unbound singleton for the framework\n * sentinel and a fresh `PostgresSchema` for any other coordinate.\n *\n * The factory has no per-call state — every named id deterministically\n * maps to a distinct schema instance — so callers can pass it through\n * by reference and trust the resulting `SqlStorage.namespaces` map to\n * be value-stable for a given input set.\n */\nexport function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(input);\n  }\n  return new PostgresSchema(input);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiCA,IAAa,iBAAb,cAAoC,cAAc;;;;;;;;CAQhD,OAAO;CAEP,OAAgB;CAChB;CACA;CACA;CAEA,YAAY,OAA4B;EACtC,OAAO;EACP,KAAK,KAAK,MAAM;EAChB,KAAK,SAAS,OAAO,OACnB,OAAO,YACL,OAAO,QAAQ,MAAM,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,OAAO,CACpD,MACA,aAAa,eAAe,IAAI,IAAI,aAAa,EAAE,CACpD,CAAC,CACH,CACF;EACD,KAAK,QAAQ,OAAO,OAClB,OAAO,YACL,OAAO,QAAQ,MAAM,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,QAAQ,CACpD,MACA,cAAc,mBAAmB,KAAK,IAAI,iBAAiB,GAAG,CAC/D,CAAC,CACH,CACF;EACD,WAAW,KAAK;;;;;;;CAQlB,YAAoB;EAClB,OAAO,IAAI,KAAK,GAAG;;;;;;;;CASrB,aAAa,WAA2B;EACtC,OAAO,IAAI,KAAK,GAAG,KAAK,UAAU;;;;;;;;CASpC,gBAAgB,MAAsB;EACpC,OAAO,IAAI,cAAc,KAAK,aAAa,KAAK,CAAC,CAAC;;;;;;;;;;CAWpD,sBAA8B;EAC5B,OAAO,IAAI,cAAc,KAAK,GAAG,CAAC;;;;;;;;;;;;CAapC,cAAc,UAA8B;EAC1C,OAAO,KAAK;;;;;;;;;;;;;;;;;AAkBhB,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,uBAAuB;CAE7E,YAAY,OAA6B;EACvC,MAAM,SAAS,EAAE,IAAI,sBAAsB,CAAC;;CAG9C,YAA6B;EAC3B,OAAO;;CAGT,aAAsB,WAA2B;EAC/C,OAAO,IAAI,UAAU;;CAGvB,sBAAuC;EACrC,OAAO;;;;;;;;;;;CAYT,cAAuB,SAA6B;EAClD,IAAI,QAAQ,WAAW,cAAc,KAAA,GACnC,OAAO;EAET,OAAO;;;AAIX,eAAe,UAAU,sBAAsB;;;;;;;;;;AAW/C,SAAgB,iBAAiB,IAAmC;CAClE,OAAQ,IAA8C,SAAS;;;;;;;;;;;;;AAcjE,SAAgB,wBAAwB,OAAgD;CACtF,IAAI,MAAM,OAAO,sBACf,OAAO,IAAI,sBAAsB,MAAM;CAEzC,OAAO,IAAI,eAAe,MAAM"}

package/dist/{render-ops-CkiuHSNj.mjs → render-ops-BC2PtCkj.mjs}

@@ -20,4 +20,4 @@ function renderOps(calls) {
 //#endregion
 export { renderOps as t };
 
-//# sourceMappingURL=render-ops-CkiuHSNj.mjs.map
+//# sourceMappingURL=render-ops-BC2PtCkj.mjs.map

package/dist/{render-ops-CkiuHSNj.mjs.map → render-ops-BC2PtCkj.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"render-ops-CkiuHSNj.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(\n  op: ReturnType<OpFactoryCall['toOp']>,\n  callFactoryName: string,\n): asserts op is Op {\n  const targetId = (op as Partial<Op>).target?.id;\n  if (targetId !== 'postgres') {\n    throw new Error(\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n    );\n  }\n}\n\nexport function renderOps(calls: readonly OpFactoryCall[]): Op[] {\n  return calls.map((c) => {\n    const op = c.toOp();\n    assertPostgresOp(op, c.factoryName);\n    return op;\n  });\n}\n"],"mappings":";;;;;;;;AAaA,SAAS,iBACP,IACA,iBACkB;CAClB,MAAM,WAAY,GAAmB,QAAQ;CAC7C,IAAI,aAAa,YACf,MAAM,IAAI,MACR,sDAAsD,OAAO,SAAS,CAAC,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,2HAC/H;;AAIL,SAAgB,UAAU,OAAuC;CAC/D,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,KAAK,EAAE,MAAM;EACnB,iBAAiB,IAAI,EAAE,YAAY;EACnC,OAAO;GACP"}
+{"version":3,"file":"render-ops-BC2PtCkj.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(\n  op: ReturnType<OpFactoryCall['toOp']>,\n  callFactoryName: string,\n): asserts op is Op {\n  const targetId = (op as Partial<Op>).target?.id;\n  if (targetId !== 'postgres') {\n    throw new Error(\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n    );\n  }\n}\n\nexport function renderOps(calls: readonly OpFactoryCall[]): Op[] {\n  return calls.map((c) => {\n    const op = c.toOp();\n    assertPostgresOp(op, c.factoryName);\n    return op;\n  });\n}\n"],"mappings":";;;;;;;;AAaA,SAAS,iBACP,IACA,iBACkB;CAClB,MAAM,WAAY,GAAmB,QAAQ;CAC7C,IAAI,aAAa,YACf,MAAM,IAAI,MACR,sDAAsD,OAAO,SAAS,CAAC,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,2HAC/H;;AAIL,SAAgB,UAAU,OAAuC;CAC/D,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,KAAK,EAAE,MAAM;EACnB,iBAAiB,IAAI,EAAE,YAAY;EACnC,OAAO;GACP"}

package/dist/render-ops.d.mts

@@ -1,4 +1,4 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-iYJwzFHP.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIj61DUj.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { OpFactoryCall } from "@prisma-next/framework-components/control";
 

package/dist/render-ops.mjs

@@ -1,2 +1,2 @@
-import { t as renderOps } from "./render-ops-CkiuHSNj.mjs";
+import { t as renderOps } from "./render-ops-BC2PtCkj.mjs";
 export { renderOps };

package/dist/{render-typescript-C9XWI8Ld.mjs → render-typescript-nRHbqLbI.mjs}

@@ -70,4 +70,4 @@ function indent(text, spaces) {
 //#endregion
 export { renderCallsToTypeScript as t };
 
-//# sourceMappingURL=render-typescript-C9XWI8Ld.mjs.map
+//# sourceMappingURL=render-typescript-nRHbqLbI.mjs.map

package/dist/{render-typescript-C9XWI8Ld.mjs.map → render-typescript-nRHbqLbI.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"render-typescript-C9XWI8Ld.mjs","names":[],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":["/**\n * Polymorphic TypeScript emitter for the Postgres migration IR.\n *\n * Each `OpFactoryCall` renders itself via `renderTypeScript()` and\n * declares its own `importRequirements()`; this file just composes the module\n * source around those contributions. The design mirrors the Mongo target's\n * `render-typescript.ts` deliberately — byte-for-byte alignment isn't required\n * (different factory module specifiers, different base-class name) but the\n * shape is, so future consolidation to a framework-level helper is mechanical.\n */\n\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';\nimport { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';\n\nexport interface RenderMigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n  readonly labels?: readonly string[];\n}\n\n/**\n * Always-present base imports for the rendered scaffold. Both come from\n * `@prisma-next/target-postgres/migration` so an authored Postgres\n * `migration.ts` only needs a single dependency for its base class and\n * its CLI entrypoint:\n *\n * - `Migration` — the target-owned re-export fixes the `SqlMigration`\n *   generic to `PostgresPlanTargetDetails` and the abstract `targetId`\n *   to `'postgres'`, so user-authored migrations don't need to thread\n *   target-details or redeclare `targetId`.\n * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n *   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,\n *   assembles a `ControlStack`, and instantiates the migration class.\n *   The migration file owns this dependency directly: pulling CLI\n *   machinery in at script run time is acceptable because the script's\n *   whole purpose is to be invoked from the project that owns the\n *   config.\n */\nconst BASE_IMPORTS: readonly ImportRequirement[] = [\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'Migration' },\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'MigrationCLI' },\n];\n\nexport function renderCallsToTypeScript(\n  calls: ReadonlyArray<OpFactoryCall>,\n  meta: RenderMigrationMeta,\n): string {\n  const imports = buildImports(calls);\n  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\\n');\n\n  return [\n    shebangLineFor(detectScaffoldRuntime()),\n    imports,\n    '',\n    'export default class M extends Migration {',\n    buildDescribeMethod(meta),\n    '  override get operations() {',\n    '    return [',\n    indent(operationsBody, 6),\n    '    ];',\n    '  }',\n    '}',\n    '',\n    'MigrationCLI.run(import.meta.url, M);',\n    '',\n  ].join('\\n');\n}\n\nfunction buildImports(calls: ReadonlyArray<OpFactoryCall>): string {\n  const requirements: ImportRequirement[] = [...BASE_IMPORTS];\n  for (const call of calls) {\n    for (const req of call.importRequirements()) {\n      requirements.push(req);\n    }\n  }\n  return renderImports(requirements);\n}\n\nfunction buildDescribeMethod(meta: RenderMigrationMeta): string {\n  const lines: string[] = [];\n  lines.push('  override describe() {');\n  lines.push('    return {');\n  lines.push(`      from: ${JSON.stringify(meta.from)},`);\n  lines.push(`      to: ${JSON.stringify(meta.to)},`);\n  if (meta.labels && meta.labels.length > 0) {\n    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);\n  }\n  lines.push('    };');\n  lines.push('  }');\n  lines.push('');\n  return lines.join('\\n');\n}\n\nfunction indent(text: string, spaces: number): string {\n  const pad = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${pad}${line}` : line))\n    .join('\\n');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuCA,MAAM,eAA6C,CACjD;CAAE,iBAAiB;CAA0C,QAAQ;CAAa,EAClF;CAAE,iBAAiB;CAA0C,QAAQ;CAAgB,CACtF;AAED,SAAgB,wBACd,OACA,MACQ;CACR,MAAM,UAAU,aAAa,MAAM;CACnC,MAAM,iBAAiB,MAAM,KAAK,MAAM,EAAE,kBAAkB,CAAC,CAAC,KAAK,MAAM;CAEzE,OAAO;EACL,eAAe,uBAAuB,CAAC;EACvC;EACA;EACA;EACA,oBAAoB,KAAK;EACzB;EACA;EACA,OAAO,gBAAgB,EAAE;EACzB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK;;AAGd,SAAS,aAAa,OAA6C;CACjE,MAAM,eAAoC,CAAC,GAAG,aAAa;CAC3D,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,OAAO,KAAK,oBAAoB,EACzC,aAAa,KAAK,IAAI;CAG1B,OAAO,cAAc,aAAa;;AAGpC,SAAS,oBAAoB,MAAmC;CAC9D,MAAM,QAAkB,EAAE;CAC1B,MAAM,KAAK,0BAA0B;CACrC,MAAM,KAAK,eAAe;CAC1B,MAAM,KAAK,eAAe,KAAK,UAAU,KAAK,KAAK,CAAC,GAAG;CACvD,MAAM,KAAK,aAAa,KAAK,UAAU,KAAK,GAAG,CAAC,GAAG;CACnD,IAAI,KAAK,UAAU,KAAK,OAAO,SAAS,GACtC,MAAM,KAAK,iBAAiB,eAAe,KAAK,OAAO,CAAC,GAAG;CAE7D,MAAM,KAAK,SAAS;CACpB,MAAM,KAAK,MAAM;CACjB,MAAM,KAAK,GAAG;CACd,OAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,OAAO,MAAc,QAAwB;CACpD,MAAM,MAAM,IAAI,OAAO,OAAO;CAC9B,OAAO,KACJ,MAAM,KAAK,CACX,KAAK,SAAU,KAAK,MAAM,GAAG,GAAG,MAAM,SAAS,KAAM,CACrD,KAAK,KAAK"}
+{"version":3,"file":"render-typescript-nRHbqLbI.mjs","names":[],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":["/**\n * Polymorphic TypeScript emitter for the Postgres migration IR.\n *\n * Each `OpFactoryCall` renders itself via `renderTypeScript()` and\n * declares its own `importRequirements()`; this file just composes the module\n * source around those contributions. The design mirrors the Mongo target's\n * `render-typescript.ts` deliberately — byte-for-byte alignment isn't required\n * (different factory module specifiers, different base-class name) but the\n * shape is, so future consolidation to a framework-level helper is mechanical.\n */\n\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';\nimport { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';\n\nexport interface RenderMigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n  readonly labels?: readonly string[];\n}\n\n/**\n * Always-present base imports for the rendered scaffold. Both come from\n * `@prisma-next/target-postgres/migration` so an authored Postgres\n * `migration.ts` only needs a single dependency for its base class and\n * its CLI entrypoint:\n *\n * - `Migration` — the target-owned re-export fixes the `SqlMigration`\n *   generic to `PostgresPlanTargetDetails` and the abstract `targetId`\n *   to `'postgres'`, so user-authored migrations don't need to thread\n *   target-details or redeclare `targetId`.\n * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n *   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,\n *   assembles a `ControlStack`, and instantiates the migration class.\n *   The migration file owns this dependency directly: pulling CLI\n *   machinery in at script run time is acceptable because the script's\n *   whole purpose is to be invoked from the project that owns the\n *   config.\n */\nconst BASE_IMPORTS: readonly ImportRequirement[] = [\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'Migration' },\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'MigrationCLI' },\n];\n\nexport function renderCallsToTypeScript(\n  calls: ReadonlyArray<OpFactoryCall>,\n  meta: RenderMigrationMeta,\n): string {\n  const imports = buildImports(calls);\n  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\\n');\n\n  return [\n    shebangLineFor(detectScaffoldRuntime()),\n    imports,\n    '',\n    'export default class M extends Migration {',\n    buildDescribeMethod(meta),\n    '  override get operations() {',\n    '    return [',\n    indent(operationsBody, 6),\n    '    ];',\n    '  }',\n    '}',\n    '',\n    'MigrationCLI.run(import.meta.url, M);',\n    '',\n  ].join('\\n');\n}\n\nfunction buildImports(calls: ReadonlyArray<OpFactoryCall>): string {\n  const requirements: ImportRequirement[] = [...BASE_IMPORTS];\n  for (const call of calls) {\n    for (const req of call.importRequirements()) {\n      requirements.push(req);\n    }\n  }\n  return renderImports(requirements);\n}\n\nfunction buildDescribeMethod(meta: RenderMigrationMeta): string {\n  const lines: string[] = [];\n  lines.push('  override describe() {');\n  lines.push('    return {');\n  lines.push(`      from: ${JSON.stringify(meta.from)},`);\n  lines.push(`      to: ${JSON.stringify(meta.to)},`);\n  if (meta.labels && meta.labels.length > 0) {\n    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);\n  }\n  lines.push('    };');\n  lines.push('  }');\n  lines.push('');\n  return lines.join('\\n');\n}\n\nfunction indent(text: string, spaces: number): string {\n  const pad = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${pad}${line}` : line))\n    .join('\\n');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuCA,MAAM,eAA6C,CACjD;CAAE,iBAAiB;CAA0C,QAAQ;CAAa,EAClF;CAAE,iBAAiB;CAA0C,QAAQ;CAAgB,CACtF;AAED,SAAgB,wBACd,OACA,MACQ;CACR,MAAM,UAAU,aAAa,MAAM;CACnC,MAAM,iBAAiB,MAAM,KAAK,MAAM,EAAE,kBAAkB,CAAC,CAAC,KAAK,MAAM;CAEzE,OAAO;EACL,eAAe,uBAAuB,CAAC;EACvC;EACA;EACA;EACA,oBAAoB,KAAK;EACzB;EACA;EACA,OAAO,gBAAgB,EAAE;EACzB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK;;AAGd,SAAS,aAAa,OAA6C;CACjE,MAAM,eAAoC,CAAC,GAAG,aAAa;CAC3D,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,OAAO,KAAK,oBAAoB,EACzC,aAAa,KAAK,IAAI;CAG1B,OAAO,cAAc,aAAa;;AAGpC,SAAS,oBAAoB,MAAmC;CAC9D,MAAM,QAAkB,EAAE;CAC1B,MAAM,KAAK,0BAA0B;CACrC,MAAM,KAAK,eAAe;CAC1B,MAAM,KAAK,eAAe,KAAK,UAAU,KAAK,KAAK,CAAC,GAAG;CACvD,MAAM,KAAK,aAAa,KAAK,UAAU,KAAK,GAAG,CAAC,GAAG;CACnD,IAAI,KAAK,UAAU,KAAK,OAAO,SAAS,GACtC,MAAM,KAAK,iBAAiB,eAAe,KAAK,OAAO,CAAC,GAAG;CAE7D,MAAM,KAAK,SAAS;CACpB,MAAM,KAAK,MAAM;CACjB,MAAM,KAAK,GAAG;CACd,OAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,OAAO,MAAc,QAAwB;CACpD,MAAM,MAAM,IAAI,OAAO,OAAO;CAC9B,OAAO,KACJ,MAAM,KAAK,CACX,KAAK,SAAU,KAAK,MAAM,GAAG,GAAG,MAAM,SAAS,KAAM,CACrD,KAAK,KAAK"}

package/dist/render-typescript.mjs

@@ -1,2 +1,2 @@
-import { t as renderCallsToTypeScript } from "./render-typescript-C9XWI8Ld.mjs";
+import { t as renderCallsToTypeScript } from "./render-typescript-nRHbqLbI.mjs";
 export { renderCallsToTypeScript };

package/dist/runtime.d.mts

@@ -1,28 +1,18 @@
 import { AnyCodecDescriptor } from "@prisma-next/framework-components/codec";
-import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { Namespace } from "@prisma-next/framework-components/ir";
+import { SqlNamespaceTablesInput, SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { Contract } from "@prisma-next/contract/types";
 import { RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma-next/framework-components/execution";
+import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/core/postgres-contract-serializer.d.ts
-/**
- * Postgres target `ContractSerializer` concretion. Inherits the full
- * SQL-family deserialization pipeline (structural validation +
- * hydration walker that materialises the SQL Contract IR class
- * hierarchy from the validated JSON envelope). Polymorphic
- * `storage.types` entries hydrate through the pack contribution registry
- * keyed by each entity type's declared `discriminator` (matching the
- * enumerable `kind` on the persisted JSON envelope).
- *
- * `serializeContract` falls through to the family-base default —
- * Postgres' contract is JSON-clean today (`PostgresEnumType`
- * instances are frozen with enumerable own properties, so
- * `JSON.stringify` produces the canonical envelope shape). Once
- * target-only fields land (e.g. per-target derived storage fields)
- * this is the home for stripping them from the persisted envelope.
- */
 declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor();
+  protected hydrateSqlNamespaceEntry(nsId: string, raw: Namespace | Record<string, unknown>): Namespace | SqlNamespaceTablesInput;
+  serializeContract(contract: Contract<SqlStorage>): JsonObject;
+  private serializePostgresNamespace;
+  private serializeJsonValue;
 }
 //#endregion
 //#region src/exports/runtime.d.ts

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;;;AAiEA;;;;;;;;;;;;cAAa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;;;;;UCxDlE,6BAAA,SAAsC,qBAAA;;;ADwDvD;;;;cChDM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cAiBa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;;YAQ9D,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EAiDN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QAmDpD,0BAAA;EAAA,QAiBA,kBAAA;AAAA;;;UCxIO,6BAAA,SAAsC,qBAAA;;;;;ADQvD;;cCAM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DFUCClk_.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-D5VJk6lo.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-zrZzWmJF.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-CcZO9ukP.mjs";
 //#region src/exports/runtime.ts
 /**
 * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor` from `@prisma-next/sql-runtime`. The target package is a control-plane residence and must not pull the SQL execution-plane package into its dependency closure. The runtime descriptor here is shaped to satisfy the framework's `RuntimeTargetDescriptor` plus the structural `SqlStaticContributions` (`codecs:` returning a descriptor list) that

package/dist/{shared-DLYdmYo-.d.mts → shared-ByhSooBS.d.mts}

@@ -1,4 +1,4 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-iYJwzFHP.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIj61DUj.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { ReferentialAction } from "@prisma-next/sql-contract/types";
 
@@ -23,13 +23,15 @@ interface ColumnSpec {
   readonly nullable: boolean;
 }
 /**
- * Literal-args shape for a foreign key definition. The referenced table is
- * assumed to live in the same schema as the constrained table.
+ * Literal-args shape for a foreign key definition. `references.schema`
+ * carries the target table's namespace (schema) coordinate so the rendered
+ * DDL qualifies the REFERENCES clause correctly for cross-schema FKs.
  */
 interface ForeignKeySpec {
   readonly name: string;
   readonly columns: readonly string[];
   readonly references: {
+    readonly schema: string;
     readonly table: string;
     readonly columns: readonly string[];
   };
@@ -38,4 +40,4 @@ interface ForeignKeySpec {
 }
 //#endregion
 export { ForeignKeySpec as n, Op as r, ColumnSpec as t };
-//# sourceMappingURL=shared-DLYdmYo-.d.mts.map
+//# sourceMappingURL=shared-ByhSooBS.d.mts.map

package/dist/shared-ByhSooBS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-ByhSooBS.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"mappings":";;;;;KAMY,EAAA,GAAK,yBAAA,CAA0B,yBAAA;;AAA3C;;;;;AAcA;;;;;;UAAiB,UAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;AAAA;;;;;;UAQM,cAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;IAAA,SACE,MAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA;EAAA,SAEF,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAA;AAAA"}

package/dist/{statement-builders-BSIQMClE.mjs → statement-builders-vImtdfmM.mjs}

@@ -128,4 +128,4 @@ function jsonParam(value) {
 //#endregion
 export { ensureMarkerTableStatement as a, ensureLedgerTableStatement as i, buildLedgerInsertStatement as n, ensurePrismaContractSchemaStatement as o, buildMergeMarkerStatements as r, APP_SPACE_ID$1 as t };
 
-//# sourceMappingURL=statement-builders-BSIQMClE.mjs.map
+//# sourceMappingURL=statement-builders-vImtdfmM.mjs.map