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

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

@@ -1,70 +1,149 @@
 import type { Contract } from '@prisma-next/contract/types';
+import { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';
 import {
-  SqlContractSerializerBase,
-  type SqlEntityHydrationFactory,
-} from '@prisma-next/family-sql/ir';
-import type { AuthoringEntityContext } from '@prisma-next/framework-components/authoring';
-import type { SqlStorage, SqlStorageTypeEntry } from '@prisma-next/sql-contract/types';
-import { postgresAuthoringEntityTypes } from './authoring';
-import { PostgresEnumType } from './postgres-enum-type';
+  type Namespace,
+  NamespaceBase,
+  UNBOUND_NAMESPACE_ID,
+} from '@prisma-next/framework-components/ir';
+import {
+  type SqlNamespaceTablesInput,
+  type SqlStorage,
+  StorageTable,
+  type StorageTableInput,
+} from '@prisma-next/sql-contract/types';
+import type { JsonObject } from '@prisma-next/utils/json';
+import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
+import { isPostgresSchema, PostgresSchema } from './postgres-schema';
+
+export class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
+  constructor() {
+    // Postgres entity types (enums) are namespace-level and hydrated in
+    // hydrateSqlNamespaceEntry; there are no storage-level codec alias entities
+    // specific to Postgres, so the registry is empty.
+    super(new Map());
+  }
 
-/**
- * Build the hydration registry from this target pack's literal
- * `postgresAuthoringEntityTypes`. Extension-pack-contributed entity
- * types do not reach this registry today; the surface is honest for
- * in-tree consumers (Postgres pack only) and the slot stays
- * deserializable because the family-layer validator's
- * `StorageTypeEntrySchema` only admits kinds whose factory the
- * Postgres pack already ships.
- *
- * Future open (F14): lift the registry build to descriptor-composition
- * time, threading the composed `AuthoringContributions.entityTypes`
- * from extension packs, so a real extension pack shipping a
- * round-trip-needing entity type can be deserialized end-to-end.
- * Earned by the first such extension pack in tree.
- */
-function buildPostgresEntityTypeRegistry(): ReadonlyMap<string, SqlEntityHydrationFactory> {
-  const ctx: AuthoringEntityContext = { family: 'sql', target: 'postgres' };
-  const registry = new Map<string, SqlEntityHydrationFactory>();
-  for (const descriptor of Object.values(postgresAuthoringEntityTypes)) {
-    if (descriptor.kind !== 'entity') {
-      continue;
+  protected override hydrateSqlNamespaceEntry(
+    nsId: string,
+    raw: Namespace | Record<string, unknown>,
+  ): Namespace | SqlNamespaceTablesInput {
+    if (raw instanceof NamespaceBase) {
+      return raw;
     }
-    if (!('factory' in descriptor.output)) {
-      continue;
+    const obj = raw as {
+      id?: string;
+      tables?: Record<string, unknown>;
+      types?: Record<string, unknown>;
+    };
+    const id = obj.id ?? nsId;
+    const tables = Object.fromEntries(
+      Object.entries(obj.tables ?? {}).map(([tableName, table]) => [
+        tableName,
+        table instanceof StorageTable ? table : new StorageTable(table as StorageTableInput),
+      ]),
+    );
+    const typeEntries = obj.types;
+    const hydratedNsTypes =
+      typeEntries !== undefined && Object.keys(typeEntries).length > 0
+        ? Object.fromEntries(
+            Object.entries(typeEntries).map(([typeName, entry]) => {
+              if (entry instanceof PostgresEnumType) {
+                return [typeName, entry];
+              }
+              const plain = entry as Record<string, unknown>;
+              const name = typeof plain['name'] === 'string' ? plain['name'] : typeName;
+              const nativeType =
+                typeof plain['nativeType'] === 'string' ? plain['nativeType'] : name;
+              const values = Array.isArray(plain['values']) ? (plain['values'] as string[]) : [];
+              return [
+                typeName,
+                new PostgresEnumType({ name, nativeType, values } as PostgresEnumTypeInput),
+              ];
+            }),
+          )
+        : undefined;
+
+    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;
     }
-    const factory = descriptor.output.factory as (
-      input: never,
-      ctx: AuthoringEntityContext,
-    ) => SqlStorageTypeEntry;
-    registry.set(descriptor.discriminator, (entry) => {
-      if (entry instanceof PostgresEnumType) {
-        return entry;
-      }
-      return factory(entry as never, ctx);
+    return new PostgresSchema({
+      id,
+      tables,
+      ...(hydratedNsTypes !== undefined ? { types: hydratedNsTypes } : {}),
     });
   }
-  return registry;
-}
 
-/**
- * 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.
- */
-export class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
-  constructor() {
-    super(buildPostgresEntityTypeRegistry());
+  override serializeContract(contract: Contract<SqlStorage>): JsonObject {
+    const { storage, ...rest } = contract;
+    const namespacesJson: Record<string, JsonObject> = {};
+    for (const [nsId, ns] of Object.entries(storage.namespaces)) {
+      if (isPostgresSchema(ns)) {
+        namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
+      } else {
+        // Family-level SqlNamespacePayload / SqlUnboundNamespace haven't
+        // been promoted to a PostgresSchema instance yet (e.g. they came
+        // straight from the TS builder, which uses the family-shared
+        // SqlStorage constructor). 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 nsTypes = (ns as { readonly types?: Readonly<Record<string, unknown>> }).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) as JsonObject,
+            ]),
+          ),
+          types: Object.fromEntries(
+            Object.entries(nsTypes).map(([typeName, entry]) => [
+              typeName,
+              this.serializeJsonValue(entry) as JsonObject,
+            ]),
+          ),
+        };
+      }
+    }
+    const storageOut: Record<string, unknown> = {
+      storageHash: String(storage.storageHash),
+      namespaces: namespacesJson,
+    };
+    if (storage.types !== undefined) {
+      const typesOut: Record<string, JsonObject> = {};
+      for (const [name, entry] of Object.entries(storage.types)) {
+        typesOut[name] = this.serializeJsonValue(entry) as JsonObject;
+      }
+      storageOut['types'] = typesOut;
+    }
+    return {
+      ...rest,
+      storage: storageOut,
+    } as unknown as JsonObject;
+  }
+
+  private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {
+    const tablesOut: Record<string, JsonObject> = {};
+    for (const [tableName, table] of Object.entries(ns.tables)) {
+      tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;
+    }
+    const typesOut: Record<string, JsonObject> = {};
+    for (const [typeName, ty] of Object.entries(ns.types)) {
+      typesOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
+    }
+    return {
+      id: ns.id,
+      kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
+      tables: tablesOut,
+      types: typesOut,
+    };
+  }
+
+  private serializeJsonValue(value: unknown): unknown {
+    return JSON.parse(JSON.stringify(value)) as unknown;
   }
 }

package/src/core/postgres-schema.ts

@@ -0,0 +1,208 @@
+import {
+  freezeNode,
+  NamespaceBase,
+  UNBOUND_NAMESPACE_ID,
+} from '@prisma-next/framework-components/ir';
+import {
+  type SqlNamespaceTablesInput,
+  type SqlStorage,
+  StorageTable,
+  type StorageTableInput,
+} from '@prisma-next/sql-contract/types';
+import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
+import { escapeLiteral } from './sql-utils';
+
+export interface PostgresSchemaInput {
+  readonly id: string;
+  readonly tables?: Record<string, StorageTable | StorageTableInput>;
+  readonly types?: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
+}
+
+/**
+ * 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`.
+ */
+export class PostgresSchema 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: PostgresUnboundSchema;
+
+  readonly kind = 'schema' as const;
+  readonly id: string;
+  readonly tables: Readonly<Record<string, StorageTable>>;
+  readonly types: 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.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(): string {
+    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: string): string {
+    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: string): string {
+    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(): string {
+    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: SqlStorage): string {
+    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`).
+ */
+export class PostgresUnboundSchema extends PostgresSchema {
+  static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();
+
+  constructor(input?: PostgresSchemaInput) {
+    super(input ?? { id: UNBOUND_NAMESPACE_ID });
+  }
+
+  override qualifier(): string {
+    return '';
+  }
+
+  override qualifyTable(tableName: string): string {
+    return `"${tableName}"`;
+  }
+
+  override schemaSqlExpression(): string {
+    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).
+   */
+  override ddlSchemaName(storage: SqlStorage): string {
+    if (storage.namespaces['public'] !== undefined) {
+      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`.
+ */
+export function isPostgresSchema(ns: unknown): ns is PostgresSchema {
+  return (ns as { kind?: unknown } | null | undefined)?.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.
+ */
+export function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {
+  if (input.id === UNBOUND_NAMESPACE_ID) {
+    return new PostgresUnboundSchema(input);
+  }
+  return new PostgresSchema(input);
+}

package/src/exports/types.ts

@@ -1,2 +1,7 @@
 export { PostgresEnumType, type PostgresEnumTypeInput } from '../core/postgres-enum-type';
+export {
+  PostgresSchema,
+  PostgresUnboundSchema,
+  postgresCreateNamespace,
+} from '../core/postgres-schema';
 export type { PostgresColumnDefault } from '../core/types';

package/dist/descriptor-meta-DFUCClk_.mjs

@@ -1,124 +0,0 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
-import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
-//#region src/core/authoring.ts
-const postgresAuthoringTypes = {};
-/**
-* Entity type contributions surface as top-level helpers on the
-* composed-helpers shape (e.g. `helpers.enum({...})`), flattened
-* alongside the built-in `model` / `rel` helpers. Pack contributions
-* still ship via the contribution data structure
-* `authoring.entityTypes.<name>`; the composed-helpers template
-* performs the rename in the type system.
-*
-* `enum` is the first real consumer of the entities-namespace mechanism:
-* the factory constructs a `PostgresEnumType` IR-class instance from
-* the user-supplied input. Both authoring runtimes (TS DSL and PSL)
-* dispatch through this single contribution — PSL `enum Status { … }`
-* declarations are lowered by the interpreter into a factory call
-* with the parsed name + value list; TS DSL `helpers.enum({...})`
-* resolves through the same path. Removing this contribution makes
-* both surfaces fail with a "no entity helper named `enum`" type
-* error at the contract-definition site.
-*/
-/**
-* The factory constructs a `PostgresEnumType` instance natively — the
-* `SqlStorage.types` slot accepts polymorphic IR (the framework
-* `StorageType` alphabet), so no cast is needed at the contribution
-* surface. The declared return type is the structural
-* `PostgresEnumStorageEntry` so the inferred contract type stays
-* portable (it names a type exported from
-* `@prisma-next/sql-contract/types`, a public surface every consumer
-* already imports). Sharpening the inferred contract type to surface
-* enum-specific narrowing through `EntityHelperFunction` is a
-* separable refinement and lives outside this PR.
-*/
-const postgresAuthoringEntityTypes = { enum: {
-	kind: "entity",
-	discriminator: "postgres-enum",
-	output: { factory: (input) => new PostgresEnumType(input) }
-} };
-const postgresTargetDescriptorMeta = {
-	kind: "target",
-	familyId: "sql",
-	targetId: "postgres",
-	id: "postgres",
-	version: "0.0.1",
-	capabilities: {},
-	authoring: {
-		type: postgresAuthoringTypes,
-		field: {
-			text: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/text@1",
-					nativeType: "text"
-				}
-			},
-			int: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/int4@1",
-					nativeType: "int4"
-				}
-			},
-			bigint: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/int8@1",
-					nativeType: "int8"
-				}
-			},
-			float: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/float8@1",
-					nativeType: "float8"
-				}
-			},
-			decimal: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/numeric@1",
-					nativeType: "numeric"
-				}
-			},
-			boolean: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/bool@1",
-					nativeType: "bool"
-				}
-			},
-			json: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/jsonb@1",
-					nativeType: "jsonb"
-				}
-			},
-			bytes: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/bytea@1",
-					nativeType: "bytea"
-				}
-			},
-			dateTime: {
-				kind: "fieldPreset",
-				output: {
-					codecId: "pg/timestamptz@1",
-					nativeType: "timestamptz"
-				}
-			},
-			temporal: temporalAuthoringPresets({
-				codecId: "pg/timestamptz@1",
-				nativeType: "timestamptz"
-			})
-		},
-		entityTypes: postgresAuthoringEntityTypes
-	}
-};
-//#endregion
-export { postgresAuthoringEntityTypes as n, postgresTargetDescriptorMeta as t };
-
-//# sourceMappingURL=descriptor-meta-DFUCClk_.mjs.map