@prisma-next/target-postgres 0.11.0 → 0.12.0-dev.10

package/package.json

@@ -1,36 +1,44 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.11.0",
+  "version": "0.12.0-dev.10",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.11.0",
-    "@prisma-next/contract": "0.11.0",
-    "@prisma-next/errors": "0.11.0",
-    "@prisma-next/family-sql": "0.11.0",
-    "@prisma-next/framework-components": "0.11.0",
-    "@prisma-next/migration-tools": "0.11.0",
-    "@prisma-next/ts-render": "0.11.0",
-    "@prisma-next/sql-contract": "0.11.0",
-    "@prisma-next/sql-errors": "0.11.0",
-    "@prisma-next/sql-operations": "0.11.0",
-    "@prisma-next/sql-relational-core": "0.11.0",
-    "@prisma-next/sql-schema-ir": "0.11.0",
-    "@prisma-next/utils": "0.11.0",
+    "@prisma-next/cli": "0.12.0-dev.10",
+    "@prisma-next/contract": "0.12.0-dev.10",
+    "@prisma-next/errors": "0.12.0-dev.10",
+    "@prisma-next/family-sql": "0.12.0-dev.10",
+    "@prisma-next/framework-components": "0.12.0-dev.10",
+    "@prisma-next/migration-tools": "0.12.0-dev.10",
+    "@prisma-next/ts-render": "0.12.0-dev.10",
+    "@prisma-next/sql-contract": "0.12.0-dev.10",
+    "@prisma-next/sql-errors": "0.12.0-dev.10",
+    "@prisma-next/sql-operations": "0.12.0-dev.10",
+    "@prisma-next/sql-relational-core": "0.12.0-dev.10",
+    "@prisma-next/sql-schema-ir": "0.12.0-dev.10",
+    "@prisma-next/utils": "0.12.0-dev.10",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.11.0",
-    "@prisma-next/tsconfig": "0.11.0",
-    "@prisma-next/tsdown": "0.11.0",
+    "@prisma-next/test-utils": "0.12.0-dev.10",
+    "@prisma-next/tsconfig": "0.12.0-dev.10",
+    "@prisma-next/tsdown": "0.12.0-dev.10",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"
   },
+  "peerDependencies": {
+    "typescript": ">=5.9"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
   "files": [
     "dist",
     "src",
@@ -65,13 +73,16 @@
     "./types": "./dist/types.mjs",
     "./package.json": "./package.json"
   },
+  "engines": {
+    "node": ">=24"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/prisma/prisma-next.git",
     "directory": "packages/3-targets/3-targets/postgres"
   },
   "prismaNext": {
-    "minServerVersion": "14"
+    "minServerVersion": "17"
   },
   "scripts": {
     "build": "tsdown",

package/src/core/authoring.ts

@@ -124,7 +124,7 @@ export const postgresAuthoringFieldPresets = {
       nativeType: 'timestamptz',
     },
   },
-  temporal: temporalAuthoringPresets({
+  temporal: /* @__PURE__ */ temporalAuthoringPresets({
     codecId: 'pg/timestamptz@1',
     nativeType: 'timestamptz',
   }),

package/src/core/descriptor-meta-runtime.ts

@@ -0,0 +1,28 @@
+// Runtime-safe slice of the postgres target descriptor metadata.
+//
+// This file exists separately from ./descriptor-meta on purpose: the runtime
+// plane reads only `kind/familyId/targetId/id/version/capabilities` (plus the
+// `__codecTypes` phantom). The `authoring` slot lives on the pack/control
+// descriptor only, because authoring contributions are consumed at
+// contract-construction time by `assembleAuthoringContributions` (control
+// plane) and the PSL interpreter — never at runtime.
+//
+// Keeping the runtime closure free of the `./authoring` import is what lets
+// the bundler tree-shake `@prisma-next/family-sql/control` (and its
+// transitive `verify-sql-schema` chunk) out of the runtime entry. Do not
+// add an `authoring` field here — if you need to, the pack/control meta in
+// `./descriptor-meta` is the right place. See TML-2766 for context.
+import type { CodecTypes } from '../exports/codec-types';
+
+const postgresTargetDescriptorMetaRuntimeBase = {
+  kind: 'target',
+  familyId: 'sql',
+  targetId: 'postgres',
+  id: 'postgres',
+  version: '0.0.1',
+  capabilities: {},
+} as const;
+
+export const postgresTargetDescriptorMetaRuntime: typeof postgresTargetDescriptorMetaRuntimeBase & {
+  readonly __codecTypes?: CodecTypes;
+} = postgresTargetDescriptorMetaRuntimeBase;

package/src/core/descriptor-meta.ts

@@ -4,14 +4,10 @@ import {
   postgresAuthoringFieldPresets,
   postgresAuthoringTypes,
 } from './authoring';
+import { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';
 
 const postgresTargetDescriptorMetaBase = {
-  kind: 'target',
-  familyId: 'sql',
-  targetId: 'postgres',
-  id: 'postgres',
-  version: '0.0.1',
-  capabilities: {},
+  ...postgresTargetDescriptorMetaRuntime,
   authoring: {
     type: postgresAuthoringTypes,
     field: postgresAuthoringFieldPresets,

package/src/core/migrations/enum-planning.ts

@@ -5,9 +5,138 @@
  */
 
 import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { PG_ENUM_CODEC_ID } from '../codec-ids';
 import type { PostgresEnumType } from '../postgres-enum-type';
+import { isPostgresSchema } from '../postgres-schema';
+
+/**
+ * Codec-typed enum entry shape stored under
+ * `schema.annotations.pg.storageTypes[(schemaName, nativeType)]`.
+ */
+interface PgStorageTypeEntry {
+  readonly codecId?: string;
+  readonly typeParams?: { readonly values?: unknown };
+}
+
+/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */
+export interface PostgresSchemaIrAnnotations {
+  readonly schema?: string;
+  readonly storageTypes?: Readonly<Record<string, PgStorageTypeEntry>>;
+}
+
+function readOptionalString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function readPgStorageTypeEntry(value: unknown): PgStorageTypeEntry | undefined {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  const codecId = Reflect.get(value, 'codecId');
+  const typeParamsRaw = Reflect.get(value, 'typeParams');
+  const typeParams =
+    typeParamsRaw !== undefined &&
+    typeParamsRaw !== null &&
+    typeof typeParamsRaw === 'object' &&
+    !Array.isArray(typeParamsRaw)
+      ? { values: Reflect.get(typeParamsRaw, 'values') }
+      : undefined;
+  return {
+    ...(typeof codecId === 'string' ? { codecId } : {}),
+    ...(typeParams !== undefined ? { typeParams } : {}),
+  };
+}
+
+function readPgStorageTypesMap(
+  value: unknown,
+): Readonly<Record<string, PgStorageTypeEntry>> | undefined {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  const entries: Record<string, PgStorageTypeEntry> = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    const entry = readPgStorageTypeEntry(entryValue);
+    if (entry !== undefined) {
+      entries[key] = entry;
+    }
+  }
+  return Object.keys(entries).length > 0 ? entries : undefined;
+}
+
+/**
+ * Reads the Postgres annotation envelope (`schema.annotations.pg`) from
+ * family Schema IR. `SqlAnnotations` is an open target-pack extensibility
+ * map (`Record<string, unknown>`); this accessor narrows the `pg` slot at
+ * runtime so Postgres code can read introspection fields without casts.
+ */
+export function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations {
+  const raw = schema.annotations?.['pg'];
+  if (raw === undefined || raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    return {};
+  }
+  const schemaField = readOptionalString(Reflect.get(raw, 'schema'));
+  const storageTypes = readPgStorageTypesMap(Reflect.get(raw, 'storageTypes'));
+  return {
+    ...(schemaField !== undefined ? { schema: schemaField } : {}),
+    ...(storageTypes !== undefined ? { storageTypes } : {}),
+  };
+}
+
+/**
+ * Separator for `(schemaName, nativeType)` keys in introspected
+ * `schema.annotations.pg.storageTypes`. NUL cannot appear in Postgres
+ * identifiers, so the pair is unambiguous.
+ */
+export const ENUM_STORAGE_KEY_SEP = '\u0000';
+
+/** Builds the schema-qualified storageTypes map key for a live Postgres enum. */
+export function enumStorageCompoundKey(schemaName: string, nativeType: string): string {
+  return `${schemaName}${ENUM_STORAGE_KEY_SEP}${nativeType}`;
+}
+
+/**
+ * Resolves the live-schema name a namespace's enums are introspected under,
+ * for keying `readExistingEnumValues` lookups. The unbound namespace's
+ * `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a
+ * real schema, so for the unbound coordinate we read the *introspected* schema
+ * recorded on `annotations.pg.schema` (the live `current_schema()` the adapter
+ * walked) — that is the schema the enum's `storageTypes` entry is keyed under.
+ * Named namespaces resolve to their own DDL schema, which matches the
+ * per-schema introspection key directly.
+ */
+export function resolveDdlSchemaForNamespaceStorage(
+  storage: SqlStorage,
+  namespaceId: string,
+  schemaIr?: SqlSchemaIR,
+): string {
+  if (namespaceId === UNBOUND_NAMESPACE_ID) {
+    return (schemaIr ? readPostgresSchemaIrAnnotations(schemaIr).schema : undefined) ?? 'public';
+  }
+  const namespace = storage.namespaces[namespaceId];
+  if (namespace && isPostgresSchema(namespace)) {
+    return namespace.ddlSchemaName(storage);
+  }
+  return namespaceId;
+}
+
+/** Contract-scoped bridge for the family verifier's enum value resolver. */
+export function createResolveExistingEnumValues(
+  storage: SqlStorage,
+): (
+  schema: SqlSchemaIR,
+  enumType: PostgresEnumStorageEntry,
+  namespaceId: string,
+) => readonly string[] | null {
+  return (schema, enumType, namespaceId) =>
+    readExistingEnumValues(
+      schema,
+      resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schema),
+      enumType.nativeType,
+    );
+}
 
 /**
  * Categorisation of how an existing enum type's values relate to the
@@ -19,7 +148,7 @@ export type EnumDiff =
   | { readonly kind: 'rebuild'; readonly removedValues: readonly string[] };
 
 /**
- * Reads existing enum values for `nativeType` from the
+ * Reads existing enum values for `(schemaName, nativeType)` from the
  * Postgres-introspected `schema.annotations.pg.storageTypes` map.
  *
  * Schema IR's `storageTypes` slots are always codec-typed
@@ -33,20 +162,11 @@ export type EnumDiff =
  */
 export function readExistingEnumValues(
   schema: SqlSchemaIR,
+  schemaName: string,
   nativeType: string,
 ): readonly string[] | null {
-  const storageTypes = (schema.annotations?.['pg'] as Record<string, unknown> | undefined)?.[
-    'storageTypes'
-  ] as
-    | Record<
-        string,
-        {
-          codecId?: string;
-          typeParams?: { values?: unknown };
-        }
-      >
-    | undefined;
-  const existing = storageTypes?.[nativeType];
+  const storageTypes = readPostgresSchemaIrAnnotations(schema).storageTypes;
+  const existing = storageTypes?.[enumStorageCompoundKey(schemaName, nativeType)];
   if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) {
     return null;
   }
@@ -54,7 +174,7 @@ export function readExistingEnumValues(
   if (!Array.isArray(enumValues) || !enumValues.every((v) => typeof v === 'string')) {
     return null;
   }
-  return enumValues as readonly string[];
+  return enumValues;
 }
 
 /**

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

@@ -63,13 +63,18 @@ import {
 
 export type { CallMigrationStrategy, StrategyContext };
 
-function locateNamespaceTypeInStorage(storage: SqlStorage, typeName: string): unknown {
-  for (const ns of Object.values(storage.namespaces)) {
-    if (!('types' in ns) || ns.types == null) continue;
-    const entry = (ns.types as Record<string, unknown>)[typeName];
-    if (entry !== undefined) return entry;
-  }
-  return undefined;
+/**
+ * Finds a type entry by explicit namespace coordinate. Reads the named
+ * namespace's `enum` slot directly — never scans other namespaces.
+ */
+function locateNamespaceTypeInStorage(
+  storage: SqlStorage,
+  namespaceId: string,
+  typeName: string,
+): unknown {
+  const ns = storage.namespaces[namespaceId];
+  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
+  return (ns.enum as Record<string, unknown>)[typeName];
 }
 
 // ============================================================================
@@ -596,11 +601,14 @@ function mapIssueToCall(
     case 'type_missing': {
       if (!issue.typeName)
         return notOk(issueConflict('unsupportedOperation', 'Type missing issue has no typeName'));
-      // Enum types live in namespace.types; codec aliases live in storage.types.
-      // Check both so the planner handles whichever slot the type is in.
+      // Codec aliases live in storage.types; enum types live in namespace.enum.
+      // Check types first; fall back to the namespace-keyed enum slot using the
+      // issue's namespace coordinate (populated by the verifier for enum-related
+      // issues per the BaseSchemaIssue.namespaceId contract).
+      const namespaceId = resolveNamespaceIdForIssue(issue);
       const typeInstance: unknown =
         ctx.toContract.storage.types?.[issue.typeName] ??
-        locateNamespaceTypeInStorage(ctx.toContract.storage, issue.typeName);
+        locateNamespaceTypeInStorage(ctx.toContract.storage, namespaceId, issue.typeName);
       if (!typeInstance) {
         return notOk(
           issueConflict(
@@ -610,9 +618,10 @@ function mapIssueToCall(
         );
       }
       if (typeInstance instanceof PostgresEnumType) {
+        const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
         return ok([
           new CreateEnumTypeCall(
-            schemaName,
+            ddlSchema,
             issue.typeName,
             typeInstance.values,
             typeInstance.nativeType,

package/src/core/migrations/planner-produced-postgres-migration.ts

@@ -29,7 +29,6 @@ import type {
   OpFactoryCall,
 } from '@prisma-next/framework-components/control';
 import type { MigrationMeta } from '@prisma-next/migration-tools/migration';
-import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 import { PostgresMigration } from './postgres-migration';
 import { renderOps } from './render-ops';
@@ -73,7 +72,6 @@ export class TypeScriptRenderablePostgresMigration
     return renderCallsToTypeScript(this.#calls, {
       from: this.#meta.from,
       to: this.#meta.to,
-      ...ifDefined('labels', this.#meta.labels),
     });
   }
 }