@prisma-next/target-postgres 0.13.0-dev.34 → 0.13.0-dev.36

package/dist/types.d.mts

@@ -1,6 +1,8 @@
+import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
 import { NamespaceBase } from "@prisma-next/framework-components/ir";
-import { SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
+import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
+import { SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
 
 //#region src/core/postgres-schema.d.ts
 interface PostgresSchemaInput {
@@ -32,7 +34,7 @@ declare class PostgresSchema extends NamespaceBase {
   static unbound: PostgresUnboundSchema;
   readonly kind: 'schema';
   readonly id: string;
-  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+  readonly entries: SqlNamespaceEntries;
   constructor(input: PostgresSchemaInput);
   get table(): Readonly<Record<string, StorageTable>>;
   get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
@@ -65,6 +67,22 @@ declare class PostgresSchema extends NamespaceBase {
    * connection's `search_path` resolved at runtime.
    */
   schemaSqlExpression(): string;
+  /**
+   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+   * builder-built catalog check compares `n.nspname` / `table_schema`
+   * against. Named schemas bind the schema name as a text parameter; the
+   * unbound singleton overrides this to the opaque `current_schema()`
+   * expression so the live connection's `search_path` decides at runtime.
+   */
+  schemaFilterExpression(): CfExpr;
+  /**
+   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+   * builder-built check uses to address a user table in this namespace.
+   * Named schemas qualify (`"schema"."table"`); the unbound singleton
+   * overrides this to leave the table unqualified so `search_path`
+   * resolves it at runtime.
+   */
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
   /**
    * The bare schema name a DDL planner should target when emitting
    * statements that need to identify this namespace in the live
@@ -72,9 +90,9 @@ declare class PostgresSchema extends NamespaceBase {
    * catalog filters, planner conflict lookups). Named schemas resolve
    * to their own id. The `PostgresUnboundSchema` singleton inherits
    * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
-   * through `qualifyTableName` / `toRegclassLiteral` route through the
-   * polymorphic `PostgresUnboundSchema` overrides and produce
-   * unqualified (search-path-resolved) output automatically.
+   * through `qualifyTableName` route through the polymorphic
+   * `PostgresUnboundSchema` overrides and produce unqualified
+   * (search-path-resolved) output automatically.
    */
   ddlSchemaName(_storage: SqlStorage): string;
 }
@@ -93,9 +111,9 @@ declare class PostgresSchema extends NamespaceBase {
  * `search_path`).
  *
  * `ddlSchemaName` is inherited from `PostgresSchema` and returns
- * `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,
- * `toRegclassLiteral`) route through the polymorphic factory and
- * produce unqualified output automatically.
+ * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+ * route through the polymorphic factory and produce unqualified output
+ * automatically.
  */
 declare class PostgresUnboundSchema extends PostgresSchema {
   static readonly instance: PostgresUnboundSchema;
@@ -103,6 +121,8 @@ declare class PostgresUnboundSchema extends PostgresSchema {
   qualifier(): string;
   qualifyTable(tableName: string): string;
   schemaSqlExpression(): string;
+  schemaFilterExpression(): CfExpr;
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
 }
 /**
  * Target-supplied `Namespace` factory the Postgres target plumbs

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;UAiBiB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;;;;cAiBxC,cAAA,SAAuB,aAAA;EAjBuB;AAiB3D;;;;;;EAjB2D,OAyBlD,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;cAEvC,KAAA,EAAO,mBAAA;EAAA,IAmDf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EAAf;;;;;EASzB,SAAA;EA9EkC;;;;;;EAwFlC,YAAA,CAAa,SAAA;EA5Ec;;;;;;EAsF3B,eAAA,CAAgB,IAAA;EAjCH;;;;;;;;EA6Cb,mBAAA;EAtBa;;;;;;;;AAqCqB;AAwBpC;;EAxBE,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;;;;;;;AAuCI;AA+B9B;;;cA9Ca,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;AAAA;;;;;;;;;;;;iBA+BK,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;;;UAqBiB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;;;;cAiBxC,cAAA,SAAuB,aAAA;EAjBuB;AAiB3D;;;;;;EAjB2D,OAyBlD,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,mBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IA4Bf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EA+DQ;;;;;EAtDhD,SAAA;EA/CO;;;;;;EAyDP,YAAA,CAAa,SAAA;EAnDM;;;;;;EA6DnB,eAAA,CAAgB,IAAA;EA7BA;;;;;;;;EAyChB,mBAAA;EAWA;;;;;;;EAAA,sBAAA,IAA0B,MAAA;EA8BZ;;AAAoB;AAwBpC;;;;EA3CE,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;EA8Db;;;;;;;;;;;EA3CnC,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;AA+CoD;AAkC9E;;;;;;;;AAAuF;cAzD1E,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;EAIA,sBAAA,IAA0B,MAAA;EAI1B,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;AAAA;;;;;;;;;;;;iBAkC3C,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}

package/dist/types.mjs

@@ -1,2 +1,2 @@
-import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-CTKYiTHu.mjs";
+import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-COGZ1ark.mjs";
 export { PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.13.0-dev.34",
+  "version": "0.13.0-dev.36",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.13.0-dev.34",
-    "@prisma-next/contract": "0.13.0-dev.34",
-    "@prisma-next/errors": "0.13.0-dev.34",
-    "@prisma-next/family-sql": "0.13.0-dev.34",
-    "@prisma-next/framework-components": "0.13.0-dev.34",
-    "@prisma-next/migration-tools": "0.13.0-dev.34",
-    "@prisma-next/ts-render": "0.13.0-dev.34",
-    "@prisma-next/sql-contract": "0.13.0-dev.34",
-    "@prisma-next/sql-errors": "0.13.0-dev.34",
-    "@prisma-next/sql-operations": "0.13.0-dev.34",
-    "@prisma-next/sql-relational-core": "0.13.0-dev.34",
-    "@prisma-next/sql-schema-ir": "0.13.0-dev.34",
-    "@prisma-next/utils": "0.13.0-dev.34",
+    "@prisma-next/cli": "0.13.0-dev.36",
+    "@prisma-next/contract": "0.13.0-dev.36",
+    "@prisma-next/errors": "0.13.0-dev.36",
+    "@prisma-next/family-sql": "0.13.0-dev.36",
+    "@prisma-next/framework-components": "0.13.0-dev.36",
+    "@prisma-next/migration-tools": "0.13.0-dev.36",
+    "@prisma-next/ts-render": "0.13.0-dev.36",
+    "@prisma-next/sql-contract": "0.13.0-dev.36",
+    "@prisma-next/sql-errors": "0.13.0-dev.36",
+    "@prisma-next/sql-operations": "0.13.0-dev.36",
+    "@prisma-next/sql-relational-core": "0.13.0-dev.36",
+    "@prisma-next/sql-schema-ir": "0.13.0-dev.36",
+    "@prisma-next/utils": "0.13.0-dev.36",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0-dev.34",
-    "@prisma-next/tsconfig": "0.13.0-dev.34",
-    "@prisma-next/tsdown": "0.13.0-dev.34",
+    "@prisma-next/test-utils": "0.13.0-dev.36",
+    "@prisma-next/tsconfig": "0.13.0-dev.36",
+    "@prisma-next/tsdown": "0.13.0-dev.36",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

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(),
+  };
+}