@prisma-next/target-postgres 0.14.0-dev.5 → 0.14.0-dev.50

package/src/core/postgres-schema.ts

@@ -1,24 +1,38 @@
+import type { Contract } from '@prisma-next/contract/types';
 import {
   freezeNode,
   hydrateNamespaceEntities,
-  NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';
-import type {
-  SqlNamespaceEntries,
-  SqlNamespaceTablesInput,
-  SqlStorage,
-  StorageTable,
-  StorageValueSet,
+import {
+  SqlNamespaceBase,
+  type SqlNamespaceEntries,
+  type SqlNamespaceInput,
+  type SqlStorage,
+  type StorageTable,
+  type StorageValueSet,
 } from '@prisma-next/sql-contract/types';
+
 import { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresTableSource } from './ast/table-source';
 import { PG_TEXT_CODEC_ID } from './codec-ids';
+import { nativeEnumEntityKind, policyEntityKind, roleEntityKind } from './entity-kinds';
+import type { PostgresNativeEnum } from './postgres-native-enum';
+import type { PostgresRlsPolicy } from './postgres-rls-policy';
+import type { PostgresRole } from './postgres-role';
 import { escapeLiteral } from './sql-utils';
 
+export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };
+
+export type PostgresNamespaceEntries = SqlNamespaceEntries & {
+  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
+  readonly role?: Readonly<Record<string, PostgresRole>>;
+  readonly native_enum?: Readonly<Record<string, PostgresNativeEnum>>;
+};
+
 export interface PostgresSchemaInput {
   readonly id: string;
   readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
@@ -38,7 +52,7 @@ export interface PostgresSchemaInput {
  * prefix entirely — call sites stay polymorphic and never branch on
  * `id === UNBOUND_NAMESPACE_ID`.
  */
-export class PostgresSchema extends NamespaceBase {
+export class PostgresSchema extends SqlNamespaceBase {
   /**
    * Stable singleton reference for the late-bound slot. Materialised
    * lazily below the singleton subclass declaration so the static
@@ -50,13 +64,17 @@ export class PostgresSchema extends NamespaceBase {
 
   declare readonly kind: 'schema';
   readonly id: string;
-  readonly entries: SqlNamespaceEntries;
+  readonly entries: PostgresNamespaceEntries;
 
   constructor(input: PostgresSchemaInput) {
     super();
     this.id = input.id;
 
-    const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), 'carry');
+    const dispatched = hydrateNamespaceEntities(
+      input.entries,
+      composeSqlEntityKinds([policyEntityKind, roleEntityKind, nativeEnumEntityKind]),
+      'carry',
+    );
 
     // Drop an empty valueSet so presence signals non-emptiness.
     const valueSetRaw = dispatched['valueSet'];
@@ -65,11 +83,33 @@ export class PostgresSchema extends NamespaceBase {
         ? { ...dispatched, valueSet: undefined }
         : dispatched;
 
+    // `native_enum` is authoring-time-only (`PostgresContractSerializer`
+    // never re-emits it; its member values live on via the `valueSet`
+    // entry it derives). Carried as a non-enumerable property — like
+    // `kind` below — so `JSON.stringify` (the hashing pipeline's
+    // canonicalization step, `computeStorageHash` via `hashContract`)
+    // walks past it and the storage hash matches what actually gets
+    // serialized. Direct property access (`ns.entries.native_enum`)
+    // still resolves normally; only enumeration is affected.
+    const nativeEnumRaw = dispatched['native_enum'];
+    const entriesInput: Record<string, Readonly<Record<string, unknown>> | undefined> = {
+      ...withPresence,
+    };
+    delete entriesInput['native_enum'];
+    if (nativeEnumRaw !== undefined) {
+      Object.defineProperty(entriesInput, 'native_enum', {
+        value: nativeEnumRaw,
+        enumerable: false,
+        writable: false,
+        configurable: true,
+      });
+    }
+
     this.entries = Object.freeze(
       blindCast<
-        SqlNamespaceEntries,
-        'composeSqlEntityKinds() supplies table→StorageTable and valueSet→StorageValueSet descriptors, so this open-dict result holds exactly the typed members SqlNamespaceEntries declares; the descriptor Map erases those per-kind Node types from the return.'
-      >(withPresence),
+        PostgresNamespaceEntries,
+        'composeSqlEntityKinds([policyEntityKind, roleEntityKind, nativeEnumEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole, native_enum→PostgresNativeEnum descriptors'
+      >(entriesInput),
     );
     Object.defineProperty(this, 'kind', {
       value: 'schema',
@@ -88,6 +128,14 @@ export class PostgresSchema extends NamespaceBase {
     return this.entries.valueSet;
   }
 
+  get policy(): Readonly<Record<string, PostgresRlsPolicy>> {
+    return this.entries.policy ?? Object.freeze({});
+  }
+
+  get role(): Readonly<Record<string, PostgresRole>> {
+    return this.entries.role ?? Object.freeze({});
+  }
+
   /**
    * The bare schema qualifier as it would appear in a rendered SQL
    * fragment (already quoted). The unbound-schema singleton overrides
@@ -247,7 +295,7 @@ 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: SqlNamespaceInput): PostgresSchema {
   const schemaInput: PostgresSchemaInput = {
     id: input.id,
     entries: {

package/src/core/postgres-validators.ts

@@ -0,0 +1,27 @@
+import { type } from 'arktype';
+
+export const PostgresRoleSchema = type({
+  kind: "'role'",
+  name: 'string',
+  namespaceId: 'string',
+});
+
+export const PostgresRlsPolicySchema = type({
+  kind: "'policy'",
+  name: 'string',
+  prefix: 'string',
+  tableName: 'string',
+  namespaceId: 'string',
+  operation: "'select' | 'insert' | 'update' | 'delete' | 'all'",
+  roles: type.string.array().readonly(),
+  'using?': 'string',
+  'withCheck?': 'string',
+  permissive: 'boolean',
+});
+
+export const PostgresNativeEnumSchema = type({
+  kind: "'postgres-enum'",
+  typeName: 'string',
+  members: type.string.array().readonly(),
+  'control?': "'managed' | 'tolerated' | 'external' | 'observed'",
+});