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

package/package.json

@@ -1,35 +1,38 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.14.0-dev.8",
+  "version": "0.14.0-dev.80",
   "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.80",
+    "@prisma-next/contract": "0.14.0-dev.80",
+    "@prisma-next/errors": "0.14.0-dev.80",
+    "@prisma-next/family-sql": "0.14.0-dev.80",
+    "@prisma-next/framework-components": "0.14.0-dev.80",
+    "@prisma-next/migration-tools": "0.14.0-dev.80",
+    "@prisma-next/psl-parser": "0.14.0-dev.80",
+    "@prisma-next/sql-contract": "0.14.0-dev.80",
+    "@prisma-next/sql-errors": "0.14.0-dev.80",
+    "@prisma-next/sql-operations": "0.14.0-dev.80",
+    "@prisma-next/sql-relational-core": "0.14.0-dev.80",
+    "@prisma-next/sql-schema-ir": "0.14.0-dev.80",
+    "@prisma-next/ts-render": "0.14.0-dev.80",
+    "@prisma-next/utils": "0.14.0-dev.80",
     "@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.80",
+    "@prisma-next/sql-contract-psl": "0.14.0-dev.80",
+    "@prisma-next/test-utils": "0.14.0-dev.80",
+    "@prisma-next/tsconfig": "0.14.0-dev.80",
+    "@prisma-next/tsdown": "0.14.0-dev.80",
+    "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);
+}