@prisma-next/target-postgres 0.14.0-dev.8 → 0.14.0-dev.81

package/dist/wire-name-DbQ9-2RC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire-name-DbQ9-2RC.mjs","names":[],"sources":["../src/core/rls/canonicalize.ts","../src/core/rls/wire-name.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\nexport type RlsPolicyOperation = 'select' | 'insert' | 'update' | 'delete' | 'all';\n\n/**\n * Which predicate each RLS operation admits, mirroring Postgres: SELECT and\n * DELETE decide row visibility/eligibility with `USING` only; INSERT\n * validates the new row with `WITH CHECK` only; UPDATE and ALL take either\n * or both. Single-homed here so the PSL lowering and the TS handle\n * constructors enforce the same matrix.\n */\nexport const POLICY_OPERATION_PREDICATES: Readonly<\n  Record<RlsPolicyOperation, { readonly using: boolean; readonly withCheck: boolean }>\n> = {\n  select: { using: true, withCheck: false },\n  insert: { using: false, withCheck: true },\n  update: { using: true, withCheck: true },\n  delete: { using: true, withCheck: false },\n  all: { using: true, withCheck: true },\n};\n\nexport interface ContentHashParts {\n  readonly using?: string;\n  readonly withCheck?: string;\n  readonly roles: readonly string[];\n  readonly operation: RlsPolicyOperation;\n  readonly permissive: boolean;\n}\n\n/**\n * Stabilizes an authored predicate for hashing: trim, and collapse runs of\n * internal whitespace to a single space.\n *\n * This is deliberately minimal. The content hash is the equivalence relation\n * for a policy, and the wire name (prefix + hash) is the only thing ever\n * compared — we never recompute the hash from an introspected policy body, so\n * there is no need to match Postgres's reprinted form. Minimal normalization\n * also protects the no-collision property: aggressive rewriting (lowercasing,\n * paren-stripping, cast-alias folding) risks collapsing two distinct predicates\n * onto one hash. Out-of-band alteration of a hashed policy is unsupported.\n *\n * The normalizer is a stability commitment: any change re-suffixes all wire names.\n */\nexport function normalizePredicate(sql: string): string {\n  return sql.replace(/\\s+/g, ' ').trim();\n}\n\n/**\n * Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n * canonical content tuple for an RLS policy:\n *\n *   [normalize(using), normalize(withCheck), sortedRoles, operation, permissive]\n *\n * Schema and table are excluded (they are orthogonal to policy equivalence).\n * Uses `JSON.stringify` for a deterministic encoding.\n */\nexport function computeContentHash(parts: ContentHashParts): string {\n  const using = normalizePredicate(parts.using ?? '');\n  const withCheck = normalizePredicate(parts.withCheck ?? '');\n  const roles = [...new Set(parts.roles)].sort();\n  const permissive = parts.permissive ? 'permissive' : 'restrictive';\n\n  const tuple = JSON.stringify([using, withCheck, roles, parts.operation, permissive]);\n  return createHash('sha256').update(tuple).digest('hex').slice(0, 8);\n}\n","export interface RlsPolicyWireName {\n  /** The user-supplied part before the `_<8hex>` suffix. */\n  readonly prefix: string;\n  /** The 8-lowercase-hex content-hash suffix. */\n  readonly hash: string;\n}\n\nconst WIRE_NAME_PATTERN = /^(.+)_([0-9a-f]{8})$/;\n\n/**\n * Assembles an RLS policy wire name from its user-supplied prefix and its\n * 8-hex content-hash suffix. This module owns the `<prefix>_<hash>` format\n * on both sides — construction here and parsing in\n * {@link parseRlsPolicyWireName} — so the two never drift.\n */\nexport function formatRlsPolicyWireName(prefix: string, hash: string): string {\n  return `${prefix}_${hash}`;\n}\n\n/**\n * Splits an RLS policy wire name (`<prefix>_<8hex>`) into its prefix and\n * content-hash suffix. Returns `undefined` when the name does not follow the\n * wire-name shape (e.g. a policy created outside the toolchain) — callers\n * treat such names as all-prefix. Consumed by introspection (prefix\n * extraction) and by rename pairing (same hash, different prefix).\n */\nexport function parseRlsPolicyWireName(name: string): RlsPolicyWireName | undefined {\n  const match = WIRE_NAME_PATTERN.exec(name);\n  const prefix = match?.[1];\n  const hash = match?.[2];\n  if (prefix === undefined || hash === undefined) return undefined;\n  return { prefix, hash };\n}\n"],"mappings":";;;;;;;;;AAWA,MAAa,8BAET;CACF,QAAQ;EAAE,OAAO;EAAM,WAAW;CAAM;CACxC,QAAQ;EAAE,OAAO;EAAO,WAAW;CAAK;CACxC,QAAQ;EAAE,OAAO;EAAM,WAAW;CAAK;CACvC,QAAQ;EAAE,OAAO;EAAM,WAAW;CAAM;CACxC,KAAK;EAAE,OAAO;EAAM,WAAW;CAAK;AACtC;;;;;;;;;;;;;;;AAwBA,SAAgB,mBAAmB,KAAqB;CACtD,OAAO,IAAI,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;AACvC;;;;;;;;;;AAWA,SAAgB,mBAAmB,OAAiC;CAClE,MAAM,QAAQ,mBAAmB,MAAM,SAAS,EAAE;CAClD,MAAM,YAAY,mBAAmB,MAAM,aAAa,EAAE;CAC1D,MAAM,QAAQ,CAAC,GAAG,IAAI,IAAI,MAAM,KAAK,CAAC,CAAC,CAAC,KAAK;CAC7C,MAAM,aAAa,MAAM,aAAa,eAAe;CAErD,MAAM,QAAQ,KAAK,UAAU;EAAC;EAAO;EAAW;EAAO,MAAM;EAAW;CAAU,CAAC;CACnF,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC;AACpE;;;ACzDA,MAAM,oBAAoB;;;;;;;AAQ1B,SAAgB,wBAAwB,QAAgB,MAAsB;CAC5E,OAAO,GAAG,OAAO,GAAG;AACtB;;;;;;;;AASA,SAAgB,uBAAuB,MAA6C;CAClF,MAAM,QAAQ,kBAAkB,KAAK,IAAI;CACzC,MAAM,SAAS,QAAQ;CACvB,MAAM,OAAO,QAAQ;CACrB,IAAI,WAAW,KAAA,KAAa,SAAS,KAAA,GAAW,OAAO,KAAA;CACvD,OAAO;EAAE;EAAQ;CAAK;AACxB"}

package/package.json

@@ -1,35 +1,38 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.14.0-dev.8",
+  "version": "0.14.0-dev.81",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.14.0-dev.8",
-    "@prisma-next/contract": "0.14.0-dev.8",
-    "@prisma-next/errors": "0.14.0-dev.8",
-    "@prisma-next/family-sql": "0.14.0-dev.8",
-    "@prisma-next/framework-components": "0.14.0-dev.8",
-    "@prisma-next/migration-tools": "0.14.0-dev.8",
-    "@prisma-next/ts-render": "0.14.0-dev.8",
-    "@prisma-next/sql-contract": "0.14.0-dev.8",
-    "@prisma-next/sql-errors": "0.14.0-dev.8",
-    "@prisma-next/sql-operations": "0.14.0-dev.8",
-    "@prisma-next/sql-relational-core": "0.14.0-dev.8",
-    "@prisma-next/sql-schema-ir": "0.14.0-dev.8",
-    "@prisma-next/utils": "0.14.0-dev.8",
+    "@prisma-next/cli": "0.14.0-dev.81",
+    "@prisma-next/contract": "0.14.0-dev.81",
+    "@prisma-next/errors": "0.14.0-dev.81",
+    "@prisma-next/family-sql": "0.14.0-dev.81",
+    "@prisma-next/framework-components": "0.14.0-dev.81",
+    "@prisma-next/migration-tools": "0.14.0-dev.81",
+    "@prisma-next/psl-parser": "0.14.0-dev.81",
+    "@prisma-next/sql-contract": "0.14.0-dev.81",
+    "@prisma-next/sql-errors": "0.14.0-dev.81",
+    "@prisma-next/sql-operations": "0.14.0-dev.81",
+    "@prisma-next/sql-relational-core": "0.14.0-dev.81",
+    "@prisma-next/sql-schema-ir": "0.14.0-dev.81",
+    "@prisma-next/ts-render": "0.14.0-dev.81",
+    "@prisma-next/utils": "0.14.0-dev.81",
     "@standard-schema/spec": "^1.1.0",
-    "arktype": "^2.2.0",
+    "arktype": "^2.2.2",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.14.0-dev.8",
-    "@prisma-next/tsconfig": "0.14.0-dev.8",
-    "@prisma-next/tsdown": "0.14.0-dev.8",
-    "tsdown": "0.22.1",
+    "@prisma-next/psl-printer": "0.14.0-dev.81",
+    "@prisma-next/sql-contract-psl": "0.14.0-dev.81",
+    "@prisma-next/test-utils": "0.14.0-dev.81",
+    "@prisma-next/tsconfig": "0.14.0-dev.81",
+    "@prisma-next/tsdown": "0.14.0-dev.81",
+    "tsdown": "0.22.3",
     "typescript": "5.9.3",
-    "vitest": "4.1.8"
+    "vitest": "4.1.10"
   },
   "peerDependencies": {
     "typescript": ">=5.9"
@@ -53,6 +56,7 @@
     "./data-transform": "./dist/data-transform.mjs",
     "./ddl": "./dist/ddl.mjs",
     "./default-normalizer": "./dist/default-normalizer.mjs",
+    "./diff-database-schema": "./dist/diff-database-schema.mjs",
     "./errors": "./dist/errors.mjs",
     "./issue-planner": "./dist/issue-planner.mjs",
     "./migration": "./dist/migration.mjs",
@@ -68,7 +72,9 @@
     "./planner-target-details": "./dist/planner-target-details.mjs",
     "./render-ops": "./dist/render-ops.mjs",
     "./render-typescript": "./dist/render-typescript.mjs",
+    "./rls-canonicalize": "./dist/rls-canonicalize.mjs",
     "./runtime": "./dist/runtime.mjs",
+    "./schema-ir-annotations": "./dist/schema-ir-annotations.mjs",
     "./sql-utils": "./dist/sql-utils.mjs",
     "./types": "./dist/types.mjs",
     "./package.json": "./package.json"

package/src/contract-free/checks.ts

@@ -345,6 +345,79 @@ export function extensionExistsAst(extensionName: string): ExtensionExistsCheckB
   };
 }
 
+export interface RlsPolicyExistsCheckBuilder {
+  policyPresent(): SelectAst;
+  policyAbsent(): SelectAst;
+}
+
+/**
+ * Typed RLS-policy existence check over `pg_policies`, with schema, table,
+ * and policy names bound as text parameters (never inlined). The `schema`
+ * coordinate is the resolved live-database schema name (e.g. `'public'`),
+ * compared against `pg_policies.schemaname` as a bound parameter.
+ */
+export function rlsPolicyExistsAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly policyName: string;
+}): RlsPolicyExistsCheckBuilder {
+  const inner = () =>
+    exprSelect()
+      .from(cfTable('pg_policies'))
+      .project('one', cfExpr.lit(1))
+      .where(
+        cfExpr.allOf([
+          cfExpr.identifierRef('schemaname').eqParam(options.schema, PG_TEXT_CODEC_ID),
+          cfExpr.identifierRef('tablename').eqParam(options.table, PG_TEXT_CODEC_ID),
+          cfExpr.identifierRef('policyname').eqParam(options.policyName, PG_TEXT_CODEC_ID),
+        ]),
+      );
+  return {
+    policyPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),
+    policyAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),
+  };
+}
+
+export interface RlsEnabledCheckBuilder {
+  rlsEnabled(): SelectAst;
+  rlsDisabled(): SelectAst;
+}
+
+/**
+ * Typed row-level-security enabled check over `pg_class` joined to
+ * `pg_namespace`, comparing `pg_class.relrowsecurity` against the expected
+ * boolean. Schema and table names are bound as text parameters.
+ */
+export function rlsEnabledAst(schema: string, table: string): RlsEnabledCheckBuilder {
+  const inner = (enabled: boolean) =>
+    exprSelect()
+      .from(cfTable('pg_class', 'c'))
+      .join(
+        cfTable('pg_namespace', 'n'),
+        cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('c', 'relnamespace')),
+      )
+      .project('one', cfExpr.lit(1))
+      .where(
+        cfExpr.allOf([
+          cfExpr.columnRef('n', 'nspname').eqParam(schema, PG_TEXT_CODEC_ID),
+          cfExpr.columnRef('c', 'relname').eqParam(table, PG_TEXT_CODEC_ID),
+          enabled
+            ? cfExpr.columnRef('c', 'relrowsecurity')
+            : cfExpr.columnRef('c', 'relrowsecurity').not(),
+        ]),
+      );
+  return {
+    rlsEnabled: () =>
+      exprSelect()
+        .project('result', cfExpr.exists(inner(true)))
+        .build(),
+    rlsDisabled: () =>
+      exprSelect()
+        .project('result', cfExpr.exists(inner(false)))
+        .build(),
+  };
+}
+
 export interface IndexExistsCheckBuilder {
   indexPresent(): SelectAst;
   indexAbsent(): SelectAst;
@@ -361,3 +434,83 @@ export function indexExistsAst(schema: string, indexName: string): IndexExistsCh
     indexAbsent: () => exprSelect().project('result', regclass.isNull()).build(),
   };
 }
+
+export interface NativeEnumTypeExistsCheckBuilder {
+  typePresent(): SelectAst;
+  typeAbsent(): SelectAst;
+}
+
+/**
+ * Typed native-enum type existence check over `pg_type` joined to
+ * `pg_namespace`, restricted to enum types (`typtype = 'e'`). Schema and
+ * type name are bound as text parameters; `schema` is a namespace
+ * coordinate (the `__unbound__` sentinel compares against
+ * `current_schema()`), matching {@link tableExistsAst} et al.
+ */
+export function nativeEnumTypeExistsAst(
+  schema: string,
+  typeName: string,
+): NativeEnumTypeExistsCheckBuilder {
+  const inner = () =>
+    exprSelect()
+      .from(cfTable('pg_type', 't'))
+      .join(
+        cfTable('pg_namespace', 'n'),
+        cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('t', 'typnamespace')),
+      )
+      .project('one', cfExpr.lit(1))
+      .where(
+        cfExpr.allOf([
+          cfExpr.columnRef('n', 'nspname').eqExpr(checkNamespace(schema).schemaFilterExpression()),
+          cfExpr.columnRef('t', 'typname').eqParam(typeName, PG_TEXT_CODEC_ID),
+          cfExpr.columnRef('t', 'typtype').eqParam('e', PG_TEXT_CODEC_ID),
+        ]),
+      );
+  return {
+    typePresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),
+    typeAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),
+  };
+}
+
+export interface NativeEnumValueExistsCheckBuilder {
+  valuePresent(): SelectAst;
+  valueAbsent(): SelectAst;
+}
+
+/**
+ * Typed native-enum member-value existence check over `pg_enum` joined to
+ * `pg_type` and `pg_namespace`. Schema, type name, and the candidate member
+ * value are bound as text parameters — used by `addNativeEnumValue`'s
+ * precheck (value absent) and postcheck (value present).
+ */
+export function nativeEnumValueExistsAst(options: {
+  readonly schema: string;
+  readonly typeName: string;
+  readonly value: string;
+}): NativeEnumValueExistsCheckBuilder {
+  const inner = () =>
+    exprSelect()
+      .from(cfTable('pg_enum', 'e'))
+      .join(
+        cfTable('pg_type', 't'),
+        cfExpr.columnRef('t', 'oid').eqExpr(cfExpr.columnRef('e', 'enumtypid')),
+      )
+      .join(
+        cfTable('pg_namespace', 'n'),
+        cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('t', 'typnamespace')),
+      )
+      .project('one', cfExpr.lit(1))
+      .where(
+        cfExpr.allOf([
+          cfExpr
+            .columnRef('n', 'nspname')
+            .eqExpr(checkNamespace(options.schema).schemaFilterExpression()),
+          cfExpr.columnRef('t', 'typname').eqParam(options.typeName, PG_TEXT_CODEC_ID),
+          cfExpr.columnRef('e', 'enumlabel').eqParam(options.value, PG_TEXT_CODEC_ID),
+        ]),
+      );
+  return {
+    valuePresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),
+    valueAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),
+  };
+}

package/src/contract-free/control-bootstrap.ts

@@ -25,11 +25,21 @@ const ledgerColumns = [
   col('origin_profile_hash', 'text'),
   col('destination_core_hash', 'text', { notNull: true }),
   col('destination_profile_hash', 'text'),
-  col('contract_json_before', 'jsonb'),
-  col('contract_json_after', 'jsonb'),
   col('operations', 'jsonb', { notNull: true }),
 ] as const;
 
+// Content-addressed contract store: one row per distinct contract,
+// keyed by its storage hash. The ledger's `origin_core_hash` /
+// `destination_core_hash` are contract identifiers that resolve here by
+// hash equality (no FK — a baseline origin has no stored contract by
+// definition), so both endpoints of every edge are direct lookups and a
+// contract revisited by a rollback cycle is stored exactly once.
+const contractColumns = [
+  col('core_hash', 'text', { notNull: true, primaryKey: true }),
+  col('created_at', 'timestamptz', { notNull: true, default: fn('now()') }),
+  col('contract_json', 'jsonb', { notNull: true }),
+] as const;
+
 const markerTable = createTable({
   schema: 'prisma_contract',
   table: 'marker',
@@ -44,6 +54,13 @@ const ledgerTable = createTable({
   columns: ledgerColumns,
 });
 
+const contractTable = createTable({
+  schema: 'prisma_contract',
+  table: 'contract',
+  ifNotExists: true,
+  columns: contractColumns,
+});
+
 const controlSchema = createSchema({ schema: 'prisma_contract', ifNotExists: true });
 
 export function buildSignMarkerBootstrapQueries(): readonly DdlNode[] {
@@ -51,5 +68,5 @@ export function buildSignMarkerBootstrapQueries(): readonly DdlNode[] {
 }
 
 export function buildControlTableBootstrapQueries(): readonly DdlNode[] {
-  return [controlSchema, markerTable, ledgerTable];
+  return [controlSchema, markerTable, ledgerTable, contractTable];
 }

package/src/contract-free/ddl.ts

@@ -2,9 +2,17 @@ import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-
 import {
   AddColumnAction,
   type AnyAlterTableAction,
+  DropDefaultAction,
+  PostgresAlterPolicyRename,
   PostgresAlterTable,
+  PostgresCreatePolicy,
   PostgresCreateSchema,
   PostgresCreateTable,
+  PostgresCreateType,
+  PostgresDisableRowLevelSecurity,
+  PostgresDropPolicy,
+  PostgresDropType,
+  type RlsPolicyOperation,
 } from '../core/ddl/nodes';
 
 /**
@@ -42,6 +50,31 @@ export function createSchema(options: {
   return new PostgresCreateSchema(options);
 }
 
+/**
+ * Build a Postgres `CREATE TYPE … AS ENUM (…)` DDL node. The type name (and
+ * optional schema) are quoted by the renderer; the enum member `values` are
+ * emitted as single-quote-escaped string literals. An absent `schema` renders
+ * the type name unqualified so the connection's `search_path` resolves it.
+ */
+export function createType(options: {
+  readonly schema?: string;
+  readonly name: string;
+  readonly values: readonly string[];
+}): PostgresCreateType {
+  return new PostgresCreateType(options);
+}
+
+/**
+ * Build a Postgres `DROP TYPE` DDL node. See {@link createType} for the
+ * identifier-quoting and unqualified-when-schemaless behaviour.
+ */
+export function dropType(options: {
+  readonly schema?: string;
+  readonly name: string;
+}): PostgresDropType {
+  return new PostgresDropType(options);
+}
+
 /**
  * Build an `ADD COLUMN` action for use inside {@link alterTable}.
  * The column is a structured `DdlColumn` so codec-encoded defaults flow
@@ -51,9 +84,17 @@ export function addColumnAction(column: DdlColumn): AddColumnAction {
   return new AddColumnAction(column);
 }
 
+/**
+ * Build a `DROP DEFAULT` action (`ALTER COLUMN "<name>" DROP DEFAULT`) for
+ * use inside {@link alterTable}. The renderer quotes the column name.
+ */
+export function dropDefaultAction(columnName: string): DropDefaultAction {
+  return new DropDefaultAction(columnName);
+}
+
 /**
  * Build a Postgres `ALTER TABLE` query node carrying one or more actions.
- * See {@link addColumnAction} for building actions.
+ * See {@link addColumnAction} / {@link dropDefaultAction} for building actions.
  */
 export function alterTable(options: {
   readonly table: string;
@@ -62,3 +103,59 @@ export function alterTable(options: {
 }): PostgresAlterTable {
   return new PostgresAlterTable(options);
 }
+
+/**
+ * Build a Postgres `CREATE POLICY` DDL node.
+ *
+ * Identifiers (`schema`, `table`, `name`) are quoted by the renderer.
+ * `using` and `withCheck` are emitted verbatim as predicate SQL — callers
+ * must supply safe, pre-validated SQL expressions.
+ */
+export function createPolicy(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly name: string;
+  readonly permissive: boolean;
+  readonly operation: RlsPolicyOperation;
+  readonly roles: readonly string[];
+  readonly using?: string;
+  readonly withCheck?: string;
+}): PostgresCreatePolicy {
+  return new PostgresCreatePolicy(options);
+}
+
+/**
+ * Build a Postgres `DROP POLICY` DDL node.
+ * Identifiers (`schema`, `table`, `name`) are quoted by the renderer.
+ */
+export function dropPolicy(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly name: string;
+}): PostgresDropPolicy {
+  return new PostgresDropPolicy(options);
+}
+
+/**
+ * Build a Postgres `ALTER POLICY … RENAME TO` DDL node.
+ * Identifiers (`schema`, `table`, `name`, `newName`) are quoted by the renderer.
+ */
+export function alterPolicyRename(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly name: string;
+  readonly newName: string;
+}): PostgresAlterPolicyRename {
+  return new PostgresAlterPolicyRename(options);
+}
+
+/**
+ * Build a Postgres `ALTER TABLE … DISABLE ROW LEVEL SECURITY` DDL node.
+ * Identifiers (`schema`, `table`) are quoted by the renderer.
+ */
+export function disableRowLevelSecurity(options: {
+  readonly schema: string;
+  readonly table: string;
+}): PostgresDisableRowLevelSecurity {
+  return new PostgresDisableRowLevelSecurity(options);
+}