@prisma-next/target-postgres 0.13.0 → 0.14.0

package/src/contract-free/checks.ts

@@ -0,0 +1,363 @@
+import type { SelectAst } from '@prisma-next/sql-relational-core/ast';
+import {
+  type CfExpr,
+  type CfExprSelectQuery,
+  cfExpr,
+  cfTable,
+  exprSelect,
+} from '@prisma-next/sql-relational-core/contract-free';
+import { PostgresTableSource } from '../core/ast/table-source';
+import { PG_TEXT_CODEC_ID } from '../core/codec-ids';
+import { postgresCreateNamespace } from '../core/postgres-schema';
+
+/**
+ * `to_regclass($1)` with the qualified table name bound as a text parameter.
+ * Thin vocabulary wrapper over the core `cfExpr.fn` helper — the target
+ * supplies only the template and the codec'd operand.
+ */
+export function toRegclass(qualifiedName: string): CfExpr {
+  return cfExpr.fn({
+    method: 'to_regclass',
+    template: 'to_regclass({{self}})',
+    self: cfExpr.param(qualifiedName, PG_TEXT_CODEC_ID),
+    returns: { codecId: PG_TEXT_CODEC_ID, nullable: true },
+  });
+}
+
+export interface TableExistsCheckBuilder {
+  tableAbsent(): SelectAst;
+  tablePresent(): SelectAst;
+}
+
+/**
+ * Typed builder for the migration planner's table-existence checks. Produces
+ * FROM-less `SELECT to_regclass($1) IS [NOT] NULL AS "result"` ASTs with the
+ * qualified table name bound as a text parameter — never inlined into the SQL.
+ *
+ * `schema` is a namespace coordinate: the framework `__unbound__` sentinel
+ * elides the qualifier (search_path decides at runtime); any other id
+ * qualifies as `"schema"."table"`.
+ */
+export function tableExistsAst(schema: string, table: string): TableExistsCheckBuilder {
+  const qualified = postgresCreateNamespace({ id: schema, entries: { table: {} } }).qualifyTable(
+    table,
+  );
+  const regclass = toRegclass(qualified);
+  return {
+    tableAbsent: () => exprSelect().project('result', regclass.isNull()).build(),
+    tablePresent: () => exprSelect().project('result', regclass.isNotNull()).build(),
+  };
+}
+
+export interface ConstraintExistsCheckBuilder {
+  constraintPresent(): SelectAst;
+  constraintAbsent(): SelectAst;
+}
+
+/**
+ * Typed builder for the migration planner's constraint-existence checks.
+ * Produces `SELECT [NOT ]EXISTS (SELECT 1 FROM pg_constraint c JOIN
+ * pg_namespace n ON n.oid = c.connamespace WHERE c.conname = $1 AND
+ * n.nspname = $2 [AND c.conrelid = to_regclass($3)]) AS "result"` with the
+ * constraint name, schema name, and qualified table name bound as text
+ * parameters.
+ *
+ * When `table` is omitted the check matches by name + schema across all
+ * tables. Pass `table` to scope the check to a single table (prevents false
+ * matches on identically-named constraints in different tables). `schema`
+ * is a namespace coordinate: the `__unbound__` sentinel compares `nspname`
+ * against `current_schema()` instead of a bound parameter.
+ */
+export function constraintExistsAst(options: {
+  readonly constraintName: string;
+  readonly schema: string;
+  readonly table?: string;
+}): ConstraintExistsCheckBuilder {
+  const namespace = postgresCreateNamespace({ id: options.schema, entries: { table: {} } });
+  const conditions = [
+    cfExpr.columnRef('c', 'conname').eqParam(options.constraintName, PG_TEXT_CODEC_ID),
+    cfExpr.columnRef('n', 'nspname').eqExpr(namespace.schemaFilterExpression()),
+  ];
+  if (options.table !== undefined) {
+    conditions.push(
+      cfExpr.columnRef('c', 'conrelid').eqExpr(toRegclass(namespace.qualifyTable(options.table))),
+    );
+  }
+  const inner = (): CfExprSelectQuery =>
+    exprSelect()
+      .from(cfTable('pg_constraint', 'c'))
+      .join(
+        cfTable('pg_namespace', 'n'),
+        cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('c', 'connamespace')),
+      )
+      .project('one', cfExpr.lit(1))
+      .where(cfExpr.allOf(conditions));
+  return {
+    constraintPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),
+    constraintAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),
+  };
+}
+
+function checkNamespace(schema: string) {
+  return postgresCreateNamespace({ id: schema, entries: { table: {} } });
+}
+
+function informationSchemaColumns(): PostgresTableSource {
+  return new PostgresTableSource({ schema: 'information_schema', name: 'columns' });
+}
+
+function infoSchemaColumnConditions(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+}): CfExpr[] {
+  return [
+    cfExpr
+      .identifierRef('table_schema')
+      .eqExpr(checkNamespace(options.schema).schemaFilterExpression()),
+    cfExpr.identifierRef('table_name').eqParam(options.table, PG_TEXT_CODEC_ID),
+    cfExpr.identifierRef('column_name').eqParam(options.column, PG_TEXT_CODEC_ID),
+  ];
+}
+
+function infoSchemaColumnQuery(conditions: ReadonlyArray<CfExpr>): CfExprSelectQuery {
+  return exprSelect()
+    .from(informationSchemaColumns())
+    .project('one', cfExpr.lit(1))
+    .where(cfExpr.allOf(conditions));
+}
+
+export interface ColumnExistsCheckBuilder {
+  columnPresent(): SelectAst;
+  columnAbsent(): SelectAst;
+}
+
+/**
+ * Typed builder for column-existence checks over
+ * `information_schema.columns`, with schema, table, and column names bound
+ * as text parameters.
+ */
+export function columnExistsAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+}): ColumnExistsCheckBuilder {
+  const inner = () => infoSchemaColumnQuery(infoSchemaColumnConditions(options));
+  return {
+    columnPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),
+    columnAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),
+  };
+}
+
+/**
+ * Typed nullability check: EXISTS over `information_schema.columns` with
+ * `is_nullable` compared against the bound `'YES'` / `'NO'` marker.
+ */
+export function columnNullabilityAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+  readonly nullable: boolean;
+}): SelectAst {
+  const conditions = [
+    ...infoSchemaColumnConditions(options),
+    cfExpr.identifierRef('is_nullable').eqParam(options.nullable ? 'YES' : 'NO', PG_TEXT_CODEC_ID),
+  ];
+  return exprSelect()
+    .project('result', cfExpr.exists(infoSchemaColumnQuery(conditions)))
+    .build();
+}
+
+export interface ColumnDefaultCheckBuilder {
+  defaultPresent(): SelectAst;
+  defaultAbsent(): SelectAst;
+  noDefault(): SelectAst;
+}
+
+/**
+ * Typed default-presence checks over `information_schema.columns`.
+ * `defaultPresent` / `defaultAbsent` assert the column row exists with a
+ * non-null / null `column_default`; `noDefault` is the NOT EXISTS variant
+ * (also true when the column row is missing entirely).
+ */
+export function columnDefaultAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+}): ColumnDefaultCheckBuilder {
+  const withDefault = () =>
+    infoSchemaColumnQuery([
+      ...infoSchemaColumnConditions(options),
+      cfExpr.identifierRef('column_default').isNotNull(),
+    ]);
+  const withoutDefault = () =>
+    infoSchemaColumnQuery([
+      ...infoSchemaColumnConditions(options),
+      cfExpr.identifierRef('column_default').isNull(),
+    ]);
+  return {
+    defaultPresent: () => exprSelect().project('result', cfExpr.exists(withDefault())).build(),
+    defaultAbsent: () => exprSelect().project('result', cfExpr.exists(withoutDefault())).build(),
+    noDefault: () => exprSelect().project('result', cfExpr.notExists(withDefault())).build(),
+  };
+}
+
+/**
+ * Typed column-type check: EXISTS over `pg_attribute` joined to `pg_class`
+ * and `pg_namespace`, comparing `format_type(a.atttypid, a.atttypmod)`
+ * against the bound expected display type and excluding dropped columns.
+ */
+export function columnTypeAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+  readonly expectedType: string;
+}): SelectAst {
+  const formatType = cfExpr.fn({
+    method: 'format_type',
+    template: 'format_type({{self}}, {{arg0}})',
+    self: cfExpr.columnRef('a', 'atttypid'),
+    args: [cfExpr.columnRef('a', 'atttypmod')],
+    returns: { codecId: PG_TEXT_CODEC_ID, nullable: false },
+  });
+  const inner = exprSelect()
+    .from(cfTable('pg_attribute', 'a'))
+    .join(
+      cfTable('pg_class', 'c'),
+      cfExpr.columnRef('c', 'oid').eqExpr(cfExpr.columnRef('a', 'attrelid')),
+    )
+    .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')
+          .eqExpr(checkNamespace(options.schema).schemaFilterExpression()),
+        cfExpr.columnRef('c', 'relname').eqParam(options.table, PG_TEXT_CODEC_ID),
+        cfExpr.columnRef('a', 'attname').eqParam(options.column, PG_TEXT_CODEC_ID),
+        formatType.eqParam(options.expectedType, PG_TEXT_CODEC_ID),
+        cfExpr.columnRef('a', 'attisdropped').not(),
+      ]),
+    );
+  return exprSelect().project('result', cfExpr.exists(inner)).build();
+}
+
+export interface TablePrimaryKeyCheckBuilder {
+  pkPresent(): SelectAst;
+  pkAbsent(): SelectAst;
+}
+
+/**
+ * Typed primary-key existence check over `pg_index` joined to `pg_class`
+ * and `pg_namespace`, with a LEFT JOIN on the index relation so an
+ * optional `constraintName` can scope the match to a named constraint.
+ */
+export function tablePrimaryKeyAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly constraintName?: string;
+}): TablePrimaryKeyCheckBuilder {
+  const conditions = [
+    cfExpr
+      .columnRef('n', 'nspname')
+      .eqExpr(checkNamespace(options.schema).schemaFilterExpression()),
+    cfExpr.columnRef('c', 'relname').eqParam(options.table, PG_TEXT_CODEC_ID),
+    cfExpr.columnRef('i', 'indisprimary'),
+  ];
+  if (options.constraintName !== undefined) {
+    conditions.push(
+      cfExpr.columnRef('c2', 'relname').eqParam(options.constraintName, PG_TEXT_CODEC_ID),
+    );
+  }
+  const inner = () =>
+    exprSelect()
+      .from(cfTable('pg_index', 'i'))
+      .join(
+        cfTable('pg_class', 'c'),
+        cfExpr.columnRef('c', 'oid').eqExpr(cfExpr.columnRef('i', 'indrelid')),
+      )
+      .join(
+        cfTable('pg_namespace', 'n'),
+        cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('c', 'relnamespace')),
+      )
+      .leftJoin(
+        cfTable('pg_class', 'c2'),
+        cfExpr.columnRef('c2', 'oid').eqExpr(cfExpr.columnRef('i', 'indexrelid')),
+      )
+      .project('one', cfExpr.lit(1))
+      .where(cfExpr.allOf(conditions));
+  return {
+    pkPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),
+    pkAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),
+  };
+}
+
+/**
+ * Typed emptiness check: NOT EXISTS over the user table itself with
+ * `LIMIT 1`. The table is addressed through the namespace's polymorphic
+ * `tableSource` (qualified for named schemas, bare for the unbound slot).
+ */
+export function tableIsEmptyAst(schema: string, table: string): SelectAst {
+  const inner = exprSelect()
+    .from(checkNamespace(schema).tableSource(table))
+    .project('one', cfExpr.lit(1))
+    .limit(1);
+  return exprSelect().project('result', cfExpr.notExists(inner)).build();
+}
+
+/**
+ * Typed no-NULL-values data check used by `SET NOT NULL` prechecks:
+ * NOT EXISTS over the user table where the column IS NULL.
+ */
+export function noNullValuesAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+}): SelectAst {
+  const inner = exprSelect()
+    .from(checkNamespace(options.schema).tableSource(options.table))
+    .project('one', cfExpr.lit(1))
+    .where(cfExpr.identifierRef(options.column).isNull());
+  return exprSelect().project('result', cfExpr.notExists(inner)).build();
+}
+
+export interface ExtensionExistsCheckBuilder {
+  extensionPresent(): SelectAst;
+  extensionAbsent(): SelectAst;
+}
+
+/**
+ * Typed extension existence check over `pg_extension`, with the extension
+ * name bound as a text parameter.
+ */
+export function extensionExistsAst(extensionName: string): ExtensionExistsCheckBuilder {
+  const inner = () =>
+    exprSelect()
+      .from(cfTable('pg_extension'))
+      .project('one', cfExpr.lit(1))
+      .where(cfExpr.identifierRef('extname').eqParam(extensionName, PG_TEXT_CODEC_ID));
+  return {
+    extensionPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),
+    extensionAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),
+  };
+}
+
+export interface IndexExistsCheckBuilder {
+  indexPresent(): SelectAst;
+  indexAbsent(): SelectAst;
+}
+
+/**
+ * Typed index existence check riding the same `to_regclass` vocabulary as
+ * `tableExistsAst`, with the qualified index name bound as a text parameter.
+ */
+export function indexExistsAst(schema: string, indexName: string): IndexExistsCheckBuilder {
+  const regclass = toRegclass(checkNamespace(schema).qualifyTable(indexName));
+  return {
+    indexPresent: () => exprSelect().project('result', regclass.isNotNull()).build(),
+    indexAbsent: () => exprSelect().project('result', regclass.isNull()).build(),
+  };
+}

package/src/contract-free/ddl.ts

@@ -1,5 +1,11 @@
 import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
-import { PostgresCreateSchema, PostgresCreateTable } from '../core/ddl/nodes';
+import {
+  AddColumnAction,
+  type AnyAlterTableAction,
+  PostgresAlterTable,
+  PostgresCreateSchema,
+  PostgresCreateTable,
+} from '../core/ddl/nodes';
 
 /**
  * Build a Postgres `CREATE TABLE` query node.
@@ -35,3 +41,24 @@ export function createSchema(options: {
 }): PostgresCreateSchema {
   return new PostgresCreateSchema(options);
 }
+
+/**
+ * Build an `ADD COLUMN` action for use inside {@link alterTable}.
+ * The column is a structured `DdlColumn` so codec-encoded defaults flow
+ * through the adapter's `pgRenderDdlColumn` → `pgRenderDdlColumnDefault` path.
+ */
+export function addColumnAction(column: DdlColumn): AddColumnAction {
+  return new AddColumnAction(column);
+}
+
+/**
+ * Build a Postgres `ALTER TABLE` query node carrying one or more actions.
+ * See {@link addColumnAction} for building actions.
+ */
+export function alterTable(options: {
+  readonly table: string;
+  readonly schema?: string;
+  readonly actions: readonly AnyAlterTableAction[];
+}): PostgresAlterTable {
+  return new PostgresAlterTable(options);
+}

package/src/core/authoring.ts

@@ -4,53 +4,10 @@ import type {
   AuthoringFieldNamespace,
   AuthoringTypeNamespace,
 } from '@prisma-next/framework-components/authoring';
-import type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';
-import { PostgresEnumTypeSchema } from '@prisma-next/sql-contract/validators';
-import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
 
 export const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;
 
-/**
- * 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.
- */
-export const postgresAuthoringEntityTypes = {
-  enum: {
-    kind: 'entity',
-    discriminator: 'postgres-enum',
-    validatorSchema: PostgresEnumTypeSchema,
-    output: {
-      factory: (input: PostgresEnumTypeInput): PostgresEnumStorageEntry =>
-        new PostgresEnumType(input),
-    },
-  },
-} as const satisfies AuthoringEntityTypeNamespace;
+export const postgresAuthoringEntityTypes = {} as const satisfies AuthoringEntityTypeNamespace;
 
 /**
  * Field presets contributed by the Postgres target pack.
@@ -59,6 +16,11 @@ export const postgresAuthoringEntityTypes = {
  * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
  * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
  * surface (e.g. `Int`) lowers to byte-identical contracts.
+ *
+ * The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the
+ * native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target
+ * portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from
+ * the family pack instead.
  */
 export const postgresAuthoringFieldPresets = {
   text: {
@@ -128,4 +90,41 @@ export const postgresAuthoringFieldPresets = {
     codecId: 'pg/timestamptz@1',
     nativeType: 'timestamptz',
   }),
+  uuidNative: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/uuid@1',
+      nativeType: 'uuid',
+    },
+  },
+  id: {
+    uuidv4Native: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: 'pg/uuid@1',
+        nativeType: 'uuid',
+        executionDefaults: {
+          onCreate: {
+            kind: 'generator',
+            id: 'uuidv4',
+          },
+        },
+        id: true,
+      },
+    },
+    uuidv7Native: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: 'pg/uuid@1',
+        nativeType: 'uuid',
+        executionDefaults: {
+          onCreate: {
+            kind: 'generator',
+            id: 'uuidv7',
+          },
+        },
+        id: true,
+      },
+    },
+  },
 } as const satisfies AuthoringFieldNamespace;

package/src/core/codec-helpers.ts

@@ -109,23 +109,6 @@ export const pgIntervalDecode = (wire: string | Record<string, unknown>): string
   return JSON.stringify(wire);
 };
 
-export const pgEnumRenderOutputType = (typeParams: {
-  readonly values?: readonly unknown[];
-}): string => {
-  const values = typeParams.values;
-  if (!Array.isArray(values)) {
-    throw new Error(
-      `renderOutputType: expected array "values" in typeParams for enum, got ${typeof values}`,
-    );
-  }
-  if (!values.every((v): v is string => typeof v === 'string')) {
-    throw new Error(`renderOutputType: expected string[] "values" in typeParams for enum`);
-  }
-  return values
-    .map((value) => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`)
-    .join(' | ');
-};
-
 export const pgJsonEncode = (value: string | JsonValue): string => JSON.stringify(value);
 export const pgJsonDecode = (wire: string | JsonValue): JsonValue =>
   typeof wire === 'string' ? JSON.parse(wire) : wire;

package/src/core/codec-ids.ts

@@ -8,7 +8,6 @@ export {
 } from '@prisma-next/sql-relational-core/ast';
 export const PG_TEXT_CODEC_ID = 'pg/text@1' as const;
 export const PG_TEXT_ARRAY_CODEC_ID = 'pg/text-array@1' as const;
-export const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;
 export const PG_CHAR_CODEC_ID = 'pg/char@1' as const;
 export const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;
 export const PG_INT_CODEC_ID = 'pg/int@1' as const;
@@ -30,3 +29,4 @@ export const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;
 export const PG_JSON_CODEC_ID = 'pg/json@1' as const;
 export const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;
 export const PG_BYTEA_CODEC_ID = 'pg/bytea@1' as const;
+export const PG_UUID_CODEC_ID = 'pg/uuid@1' as const;

package/src/core/codec-type-map.ts

@@ -21,7 +21,6 @@ import {
   pgBoolDescriptor,
   pgByteaDescriptor,
   pgCharDescriptor,
-  pgEnumDescriptor,
   pgFloat4Descriptor,
   pgFloat8Descriptor,
   pgFloatDescriptor,
@@ -38,6 +37,7 @@ import {
   pgTimestampDescriptor,
   pgTimestamptzDescriptor,
   pgTimetzDescriptor,
+  pgUuidDescriptor,
   pgVarbitDescriptor,
   pgVarcharDescriptor,
 } from './codecs';
@@ -68,8 +68,8 @@ export const codecDescriptorMap = {
   bit: pgBitDescriptor,
   'bit varying': pgVarbitDescriptor,
   bytea: pgByteaDescriptor,
+  uuid: pgUuidDescriptor,
   interval: pgIntervalDescriptor,
-  enum: pgEnumDescriptor,
   json: pgJsonDescriptor,
   jsonb: pgJsonbDescriptor,
 } as const;