@prisma-next/target-postgres 0.12.0-dev.40 → 0.12.0-dev.42

package/src/core/migrations/planner-sql-checks.ts

@@ -20,11 +20,11 @@ import { resolveColumnTypeMetadata } from './planner-type-resolution';
  * site.
  */
 export function qualifyTableName(schema: string, table: string): string {
-  return postgresCreateNamespace({ id: schema }).qualifyTable(table);
+  return postgresCreateNamespace({ id: schema, entries: { table: {} } }).qualifyTable(table);
 }
 
 export function toRegclassLiteral(schema: string, name: string): string {
-  return postgresCreateNamespace({ id: schema }).regclassLiteral(name);
+  return postgresCreateNamespace({ id: schema, entries: { table: {} } }).regclassLiteral(name);
 }
 
 /**
@@ -43,7 +43,7 @@ export function constraintExistsCheck({
   table?: string;
   exists?: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';
   const tableFilter = table
     ? `AND c.conrelid = to_regclass(${namespace.regclassLiteral(table)})`
@@ -68,7 +68,7 @@ export function columnExistsCheck({
   column: string;
   exists?: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const existsClause = exists ? '' : 'NOT ';
   return `SELECT ${existsClause}EXISTS (
   SELECT 1
@@ -90,7 +90,7 @@ export function columnNullabilityCheck({
   column: string;
   nullable: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const expected = nullable ? 'YES' : 'NO';
   return `SELECT EXISTS (
   SELECT 1
@@ -111,7 +111,7 @@ export function columnHasNoDefaultCheck(opts: {
   table: string;
   column: string;
 }): string {
-  const namespace = postgresCreateNamespace({ id: opts.schema });
+  const namespace = postgresCreateNamespace({ id: opts.schema, entries: { table: {} } });
   return `SELECT NOT EXISTS (
   SELECT 1
   FROM information_schema.columns
@@ -282,7 +282,7 @@ export function columnTypeCheck({
   column: string;
   expectedType: string;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   return `SELECT EXISTS (
   SELECT 1
   FROM pg_attribute a
@@ -307,7 +307,7 @@ export function columnDefaultExistsCheck({
   column: string;
   exists?: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const nullCheck = exists ? 'IS NOT NULL' : 'IS NULL';
   return `SELECT EXISTS (
   SELECT 1
@@ -325,7 +325,7 @@ export function tableHasPrimaryKeyCheck(
   exists: boolean,
   constraintName?: string,
 ): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const comparison = exists ? '' : 'NOT ';
   const constraintFilter = constraintName
     ? `AND c2.relname = '${escapeLiteral(constraintName)}'`

package/src/core/migrations/planner-strategies.ts

@@ -35,6 +35,7 @@ import {
   type StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import { PostgresEnumType } from '../postgres-enum-type';
 import { isPostgresSchema } from '../postgres-schema';
 import {
@@ -93,7 +94,7 @@ export function tableAt(
 ): StorageTable | undefined {
   // Namespace.tables is typed as Record<string, IRNode> at the interface level;
   // SQL family namespaces always hold StorageTable instances.
-  return storage.namespaces[namespaceId]?.tables[tableName] as StorageTable | undefined;
+  return storage.namespaces[namespaceId]?.entries.table[tableName] as StorageTable | undefined;
 }
 
 /**
@@ -134,8 +135,8 @@ const DEFAULT_ENUM_NAMESPACE_ID = 'public';
 
 function namespaceHasEnum(storage: SqlStorage, namespaceId: string, typeName: string): boolean {
   const ns = storage.namespaces[namespaceId];
-  if (!ns || !('enum' in ns) || ns.enum == null) return false;
-  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName] !== undefined;
+  if (!isPostgresSchema(ns)) return false;
+  return ns.entries.type[typeName] !== undefined;
 }
 
 /**
@@ -166,7 +167,7 @@ function resolveColumnEnumNamespace(
 
 /**
  * Finds a type entry by explicit namespace coordinate. Namespace types (e.g.
- * Postgres enums) live under `storage.namespaces[nsId].enum`. Returns the
+ * Postgres enums) live under `storage.namespaces[nsId].entries.type`. Returns the
  * entry from the named namespace only — never scans other namespaces, so two
  * namespaces that hold an enum with the same name resolve independently.
  */
@@ -176,8 +177,12 @@ function locateNamespaceType(
   typeName: string,
 ): PostgresEnumStorageEntry | undefined {
   const ns = storage.namespaces[namespaceId];
-  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
-  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName];
+  const raw = ns?.entries['type']?.[typeName];
+  if (raw === undefined) return undefined;
+  return blindCast<
+    PostgresEnumStorageEntry,
+    'postgres type slot carries PostgresEnumStorageEntry at the postgres target layer'
+  >(raw);
 }
 
 // ============================================================================
@@ -436,7 +441,7 @@ function enumRebuildCallRecipe(
   // same-named enums in distinct namespaces keep their columns disjoint.
   const columnRefs: { namespaceId: string; table: string; column: string }[] = [];
   for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {
-    for (const [tableName, tableNode] of Object.entries(ns.tables)) {
+    for (const [tableName, tableNode] of Object.entries(ns.entries.table)) {
       const table = tableNode as StorageTable;
       for (const [columnName, column] of Object.entries(table.columns)) {
         if (
@@ -639,9 +644,10 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
 function collectPostgresEnumTypes(storage: SqlStorage): ReadonlyMap<string, PostgresEnumType> {
   const result = new Map<string, PostgresEnumType>();
   for (const [nsId, ns] of Object.entries(storage.namespaces)) {
-    if (!('enum' in ns) || ns.enum == null) continue;
-    const nsEnums = ns.enum as Record<string, unknown>;
-    for (const [name, instance] of Object.entries(nsEnums).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!isPostgresSchema(ns)) continue;
+    for (const [name, instance] of Object.entries(ns.entries.type).sort(([a], [b]) =>
+      a.localeCompare(b),
+    )) {
       if (instance instanceof PostgresEnumType) {
         result.set(enumCompoundKey(nsId, name), instance);
       }

package/src/core/migrations/planner.ts

@@ -22,7 +22,6 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { blindCast } from '@prisma-next/utils/casts';
-import { postgresColumnsCompatible } from '../column-type-compatibility';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
 import {
@@ -258,7 +257,6 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       frameworkComponents: options.frameworkComponents,
       normalizeDefault: parsePostgresDefault,
       normalizeNativeType: normalizeSchemaNativeType,
-      columnsCompatible: postgresColumnsCompatible,
       resolveExistingEnumValues: createResolveExistingEnumValues(options.contract.storage),
     };
     const verifyResult = verifySqlSchema(verifyOptions);

package/src/core/migrations/runner.ts

@@ -25,7 +25,6 @@ import type { LoweredStatement } from '@prisma-next/sql-relational-core/ast';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
-import { postgresColumnsCompatible } from '../column-type-compatibility';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
 import { createResolveExistingEnumValues } from './enum-planning';
@@ -141,7 +140,6 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         frameworkComponents: options.frameworkComponents,
         normalizeDefault: parsePostgresDefault,
         normalizeNativeType: normalizeSchemaNativeType,
-        columnsCompatible: postgresColumnsCompatible,
         resolveExistingEnumValues: createResolveExistingEnumValues(
           options.destinationContract.storage,
         ),

package/src/core/postgres-contract-serializer.ts

@@ -14,12 +14,8 @@ import {
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import type {
-  SqlNamespaceTablesInput,
-  SqlStorage,
-  SqlStorageTypeEntry,
-  StorageTable,
-} from '@prisma-next/sql-contract/types';
+import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import type { JsonObject } from '@prisma-next/utils/json';
 import type { Type } from 'arktype';
 import { postgresAuthoringEntityTypes } from './authoring';
@@ -57,9 +53,8 @@ function collectEntityRegistryContributions(namespace: AuthoringEntityTypeNamesp
       if (isAuthoringEntityTypeDescriptor(value)) {
         if (isAuthoringEntityTypeFactoryOutput(value.output)) {
           const { factory } = value.output;
-          entityTypeRegistry.set(
-            value.discriminator,
-            (raw) => factory(raw, POSTGRES_AUTHORING_CTX) as SqlStorageTypeEntry,
+          entityTypeRegistry.set(value.discriminator, (raw) =>
+            factory(raw, POSTGRES_AUTHORING_CTX),
           );
         }
         if (value.validatorSchema !== undefined) {
@@ -91,22 +86,43 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     if (raw instanceof NamespaceBase) {
       return raw;
     }
-    const hydrated = super.hydrateSqlNamespaceEntry(nsId, raw) as {
-      id: string;
-      tables: Readonly<Record<string, StorageTable>>;
-      enum?: Readonly<Record<string, PostgresEnumType>>;
-    };
-    const { id, tables, enum: hydratedNsEnums } = hydrated;
+    const hydrated = blindCast<
+      SqlNamespaceTablesInput,
+      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'
+    >(super.hydrateSqlNamespaceEntry(nsId, raw));
+    const { id, entries } = hydrated;
+
+    // Extract the postgres-specific `type` slot directly from raw input.
+    // The family base handles the `table` slot; the postgres target owns `type`.
+    const rawRecord = raw as Record<string, unknown>;
+    const rawEntries = rawRecord['entries'];
+    let typeSlot: Record<string, PostgresEnumType> | undefined;
+    if (rawEntries !== null && typeof rawEntries === 'object' && !Array.isArray(rawEntries)) {
+      const rawTypeSlot = (rawEntries as Record<string, unknown>)['type'];
+      if (rawTypeSlot !== null && typeof rawTypeSlot === 'object' && !Array.isArray(rawTypeSlot)) {
+        const enumFactory = this.entityTypeRegistry.get('postgres-enum');
+        typeSlot = Object.fromEntries(
+          Object.entries(rawTypeSlot as Record<string, unknown>).map(([name, entry]) => [
+            name,
+            blindCast<PostgresEnumType, 'postgres-enum factory returns PostgresEnumType'>(
+              enumFactory !== undefined ? enumFactory(entry) : entry,
+            ),
+          ]),
+        );
+      }
+    }
 
-    const emptyTables = Object.keys(tables).length === 0;
-    const emptyEnums = !hydratedNsEnums || Object.keys(hydratedNsEnums).length === 0;
-    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyEnums) {
+    const emptyTables = Object.keys(entries.table).length === 0;
+    const emptyTypes = !typeSlot || Object.keys(typeSlot).length === 0;
+    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) {
       return PostgresSchema.unbound;
     }
     return new PostgresSchema({
       id,
-      tables,
-      ...(hydratedNsEnums !== undefined ? { enum: hydratedNsEnums } : {}),
+      entries: {
+        table: entries.table,
+        type: typeSlot ?? {},
+      },
     });
   }
 
@@ -117,30 +133,18 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
       if (isPostgresSchema(ns)) {
         namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
       } else {
-        // Family-level SqlUnboundNamespace or other family-built SQL
-        // namespaces haven't been promoted to a PostgresSchema instance
-        // yet (e.g. they came straight from the TS builder before a target
-        // `createNamespace` factory ran). Serialise them as postgres-schema /
-        // postgres-unbound-schema so the round-trip through
-        // deserializeContract hydrates them back into PostgresSchema
-        // instances.
         const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;
-        const nsEnums = (ns as { readonly enum?: Readonly<Record<string, unknown>> }).enum ?? {};
         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) as JsonObject,
-            ]),
-          ),
-          enum: Object.fromEntries(
-            Object.entries(nsEnums).map(([typeName, entry]) => [
-              typeName,
-              this.serializeJsonValue(entry) as JsonObject,
-            ]),
-          ),
+          entries: {
+            table: Object.fromEntries(
+              Object.entries(ns.entries.table).map(([tableName, table]) => [
+                tableName,
+                this.serializeJsonValue(table) as JsonObject,
+              ]),
+            ),
+          },
         };
       }
     }
@@ -163,18 +167,20 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
 
   private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {
     const tablesOut: Record<string, JsonObject> = {};
-    for (const [tableName, table] of Object.entries(ns.tables)) {
+    for (const [tableName, table] of Object.entries(ns.entries.table)) {
       tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;
     }
-    const enumOut: Record<string, JsonObject> = {};
-    for (const [typeName, ty] of Object.entries(ns.enum)) {
-      enumOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
+    const typeOut: Record<string, JsonObject> = {};
+    for (const [typeName, ty] of Object.entries(ns.entries.type)) {
+      typeOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
     }
     return {
       id: ns.id,
       kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
-      tables: tablesOut,
-      enum: enumOut,
+      entries: {
+        table: tablesOut,
+        type: typeOut,
+      },
     };
   }
 

package/src/core/postgres-schema.ts

@@ -4,6 +4,7 @@ import {
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import {
+  type PostgresEnumStorageEntry,
   type SqlNamespaceTablesInput,
   type SqlStorage,
   StorageTable,
@@ -14,8 +15,10 @@ import { escapeLiteral } from './sql-utils';
 
 export interface PostgresSchemaInput {
   readonly id: string;
-  readonly tables?: Record<string, StorageTable | StorageTableInput>;
-  readonly enum?: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
+  readonly entries: {
+    readonly table: Record<string, StorageTable | StorageTableInput>;
+    readonly type: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
+  };
 }
 
 /**
@@ -24,9 +27,10 @@ export interface PostgresSchemaInput {
  * `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.
+ * `entries` holds entity-kind slot maps (`table`, `type`). 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`.
@@ -43,28 +47,32 @@ export class PostgresSchema extends NamespaceBase {
 
   declare readonly kind: 'schema';
   readonly id: string;
-  readonly tables: Readonly<Record<string, StorageTable>>;
-  readonly enum: Readonly<Record<string, PostgresEnumType>>;
+  readonly entries: Readonly<{
+    readonly table: Readonly<Record<string, StorageTable>>;
+    readonly type: Readonly<Record<string, PostgresEnumType>>;
+  }>;
 
   constructor(input: PostgresSchemaInput) {
     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.entries = Object.freeze({
+      table: Object.freeze(
+        Object.fromEntries(
+          Object.entries(input.entries.table).map(([k, v]) => [
+            k,
+            v instanceof StorageTable ? v : new StorageTable(v as StorageTableInput),
+          ]),
+        ),
       ),
-    );
-    this.enum = Object.freeze(
-      Object.fromEntries(
-        Object.entries(input.enum ?? {}).map(([name, ty]) => [
-          name,
-          ty instanceof PostgresEnumType ? ty : new PostgresEnumType(ty),
-        ]),
+      type: Object.freeze(
+        Object.fromEntries(
+          Object.entries(input.entries.type).map(([k, v]) => [
+            k,
+            v instanceof PostgresEnumType ? v : new PostgresEnumType(v as PostgresEnumTypeInput),
+          ]),
+        ),
       ),
-    );
+    });
     Object.defineProperty(this, 'kind', {
       value: 'schema',
       writable: false,
@@ -154,7 +162,7 @@ export class PostgresUnboundSchema extends PostgresSchema {
   static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();
 
   constructor(input?: PostgresSchemaInput) {
-    super(input ?? { id: UNBOUND_NAMESPACE_ID });
+    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {}, type: {} } });
   }
 
   override qualifier(): string {
@@ -196,9 +204,19 @@ export function isPostgresSchema(ns: unknown): ns is PostgresSchema {
  * by reference and trust the resulting `SqlStorage.namespaces` map to
  * be value-stable for a given input set.
  */
-export function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {
+export function postgresCreateNamespace(
+  input: SqlNamespaceTablesInput,
+  enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>,
+): PostgresSchema {
+  const schemaInput: PostgresSchemaInput = {
+    id: input.id,
+    entries: {
+      table: input.entries.table,
+      type: (enumTypes ?? {}) as Record<string, PostgresEnumTypeInput>,
+    },
+  };
   if (input.id === UNBOUND_NAMESPACE_ID) {
-    return new PostgresUnboundSchema(input);
+    return new PostgresUnboundSchema(schemaInput);
   }
-  return new PostgresSchema(input);
+  return new PostgresSchema(schemaInput);
 }

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 };