okmodel 0.2.1 → 0.3.0

package/dist/dialects/pg/role/check.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Role checks for `okm doctor` and apply preflight.
+ *
+ * Both run before any catalog statement. `connect()` does not call them.
+ */
+import type { DriverPool } from "../../../contracts/driver.js";
+import type { CatalogObject } from "../../../contracts/catalog/types.js";
+import type { RolesInput } from "./index.js";
+/** A pool or a reserved connection. Both can run one statement. */
+type Runner = Pick<DriverPool, "execute">;
+/**
+ * Checks named roles, `CREATEROLE`, and the application role's privileges.
+ *
+ * A missing external role is reported. A managed role that is absent is not:
+ * the plan creates it. OKM1825 is raised only when the object exists and the
+ * privilege is missing.
+ *
+ * @param runner - Database connection
+ * @param roles - `defineConfig({ roles })`
+ * @param objects - Catalog, including grants
+ */
+export declare function assertRoleHealth(runner: Runner, roles: RolesInput, objects: readonly CatalogObject[]): Promise<void>;
+/**
+ * Refuses to apply role changes when the acting role lacks `CREATEROLE`.
+ *
+ * @param runner - Database connection
+ * @param role - The role that will run `CREATE ROLE` or `ALTER ROLE`
+ */
+export declare function assertCreateRole(runner: Runner, role: string): Promise<void>;
+/**
+ * Reads `current_user`.
+ *
+ * @param runner - Database connection
+ * @returns The role this session is acting as
+ */
+export declare function currentUser(runner: Runner): Promise<string>;
+/**
+ * Reports whether `pg_roles` has the name.
+ *
+ * @param runner - Database connection
+ * @param name - Role name
+ * @returns `true` when the role exists
+ */
+export declare function roleExists(runner: Runner, name: string): Promise<boolean>;
+export {};

package/dist/dialects/pg/role/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `roles: { migration, app }`.
+ *
+ * The object contributes role, grant, and default-privilege records. `schema()`
+ * does not import this module. Tooling calls {@link attachRoles} when the
+ * config names roles.
+ */
+import type { Catalog, CatalogObject } from "../../../contracts/catalog/types.js";
+/** A role the plan creates and alters. It is never dropped. */
+export type ManagedRole = {
+    readonly name: string;
+    /** `LOGIN` when true. The default is `NOLOGIN`. */
+    readonly login?: boolean;
+    /** `INHERIT` when not `false`. */
+    readonly inherit?: boolean;
+};
+/**
+ * Roles named by `defineConfig`.
+ *
+ * A string is external: it must already exist. A name listed in `managed` is
+ * created when `pg_roles` does not have it.
+ */
+export type RolesInput = {
+    /** Role that runs migrations. */
+    readonly migration: string;
+    /** Role the application connects as. */
+    readonly app: string;
+    /** Roles this catalog creates and alters. */
+    readonly managed?: readonly ManagedRole[];
+};
+/**
+ * Adds role, grant, and default-privilege objects to a catalog.
+ *
+ * Grants and default privileges are for {@link RolesInput.app} on every
+ * managed table, view, materialized view, sequence, and function. Fine-grained
+ * grants are not accepted here.
+ *
+ * @param source - Catalog from `schema()`
+ * @param input - Migration role, application role, and managed roles
+ * @returns A catalog that includes those objects
+ */
+export declare function attachRoles(source: Catalog, input: RolesInput): Catalog;
+/**
+ * Catalog records for one `roles` configuration.
+ *
+ * @param input - Migration role, application role, and managed roles
+ * @param built - Objects already in the catalog
+ * @returns Role, grant, and default-privilege records
+ */
+export declare function contributeRoles(input: RolesInput, built: readonly CatalogObject[]): readonly CatalogObject[];

package/dist/dialects/pg/role/sql.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SQL for roles, grants, and default privileges.
+ *
+ * The plan calls these. `SET ROLE` is not one of them: the runner issues it
+ * once, outside the plan (D119).
+ */
+import type { CatalogObject } from "../../../contracts/catalog/types.js";
+/** Statements the planner inserts around the rest of the catalog. */
+export type PrivilegeSql = {
+    /** Revokes, run while the objects still exist. */
+    readonly revoke: readonly string[];
+    /** Role creates, role alters, and default privileges. Before new tables. */
+    readonly prepare: readonly string[];
+    /** Grants on objects that exist, or that this plan creates first. */
+    readonly grant: readonly string[];
+};
+/**
+ * Diffs role, grant, and default-privilege objects into SQL.
+ *
+ * A role is created only when it is managed and absent. It is altered only
+ * when both sides are managed. It is never dropped. Grants and default
+ * privileges are revoked and granted. None of the statements use
+ * `IF NOT EXISTS`.
+ *
+ * @param before - Previous catalog objects
+ * @param after - Next catalog objects
+ * @param schema - Concrete schema name
+ * @returns Statements in three groups
+ */
+export declare function privilegeSql(before: readonly CatalogObject[], after: readonly CatalogObject[], schema: string): PrivilegeSql;
+/**
+ * Role name in `create role`, when the statement is one.
+ *
+ * @param sql - One plan statement
+ * @returns The role, or `undefined` when the statement is not `CREATE ROLE`
+ */
+export declare function createdRoleName(sql: string): string | undefined;
+/**
+ * Reports whether a statement creates or alters a role.
+ *
+ * @param sql - One plan statement
+ * @returns `true` for `CREATE ROLE` and `ALTER ROLE`
+ */
+export declare function changesRole(sql: string): boolean;

package/dist/dialects/pg/table.d.ts

@@ -28,6 +28,13 @@ export type IndexCall = {
      * Absent on an ordinary index.
      */
     readonly predicate?: string;
+    /**
+     * Raw index tail an extension may set on the call.
+     *
+     * A `using …` tail is the extension's index method. The core factory does
+     * not read it. `compileIndexes` copies the field onto the catalog index.
+     */
+    readonly expression?: string;
     /**
      * Marks the index unique.
      *

package/dist/dialects/pg/tenancy.d.ts

@@ -81,6 +81,15 @@ export type ColumnTenancy = {
      * @param ctx - Names, scope, and the table map
      */
     hook(target: Record<string, unknown>, ctx: SchemaHookCtx): void;
+    /**
+     * Treats a view that exposes the tenant key as tenant-scoped.
+     *
+     * The predicate then applies to reads of that view. A view that does not
+     * expose the key is refused earlier (OKM1820) unless it is `global`.
+     *
+     * @param name - Client name of the view
+     */
+    scopeView(name: string): void;
     missing(table: string): never;
 };
 /**

package/dist/dialects/pg/view/client.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Read model and client hook for a declared view.
+ *
+ * `schema()` calls `install` and the client calls `hook`. Neither path is
+ * imported by a featureless app. Writes are not copied onto the handle.
+ */
+import type { ColumnTenancy } from "../tenancy.js";
+import type { SchemaHook, TableModel } from "../model.js";
+import { type AnyTable } from "../table.js";
+/** What `schema()` passes when it binds a view. */
+export type ViewInstall = (model: {
+    [name: string]: TableModel;
+}, tenancy: ColumnTenancy | undefined, tables: readonly AnyTable[], casing: "snake" | undefined, scoped: Set<string>) => void;
+/**
+ * Client name, read model, and the hook that moves the handle under `views`.
+ *
+ * @param name - SQL name of the view
+ * @param columns - Declared output columns
+ * @param query - Author SQL
+ * @param tenancy - `global("reason")`, when the view opts out
+ * @returns Methods stored on the declaration
+ */
+export declare function viewClient(name: string, columns: readonly {
+    readonly name: string;
+    readonly type: string;
+}[], query: string, tenancy: unknown): {
+    readonly field: string;
+    readonly install: ViewInstall;
+    readonly hook: SchemaHook;
+};

package/dist/dialects/pg/view/depend.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Column dependencies of a view, read from `pg_depend`.
+ *
+ * Postgres records them on the view's rewrite rule. The edge is column
+ * granularity when that column is a catalog object.
+ */
+import type { CatalogObject, Namespace, ObjectIdentity } from "../../../contracts/catalog/types.js";
+/**
+ * Reads a query cell as text.
+ *
+ * @param value - A driver cell
+ * @returns The string, or empty when the cell is not a scalar
+ */
+export declare function cellText(value: unknown): string;
+/**
+ * `pg_depend` rows for views and materialized views in one schema.
+ *
+ * `$1` is the concrete schema name. `refobjsubid > 0` keeps column edges.
+ */
+export declare const VIEW_DEPENDENCIES = "\n  select v.relname as view, t.relname as table, a.attname as column\n  from pg_depend d\n  join pg_rewrite r on r.oid = d.objid and d.classid = 'pg_rewrite'::regclass\n  join pg_class v on v.oid = r.ev_class\n  join pg_class t on t.oid = d.refobjid and d.refclassid = 'pg_class'::regclass\n  join pg_attribute a on a.attrelid = t.oid and a.attnum = d.refobjsubid\n  join pg_namespace n on n.oid = v.relnamespace\n  where n.nspname = $1\n    and v.relkind in ('v', 'm')\n    and d.refobjsubid > 0\n    and v.oid <> t.oid\n    and t.relkind in ('r', 'p', 'v', 'm')\n";
+/**
+ * Turns dependency rows into edges that exist in `objects`.
+ *
+ * A table column becomes a column edge. A view that is itself a catalog
+ * object becomes an object edge. Anything else is omitted: the catalog
+ * refuses an edge whose target is missing.
+ *
+ * @param rows - Rows from {@link VIEW_DEPENDENCIES}
+ * @param namespace - Logical namespace stored on the edges
+ * @param objects - Catalog the edges must point into
+ * @returns Edges keyed by view name
+ */
+export declare function viewDependencyEdges(rows: readonly Readonly<Record<string, unknown>>[], namespace: Namespace, objects: readonly CatalogObject[]): Map<string, ObjectIdentity[]>;
+/** Logical public namespace. Tests and the default schema use it. */
+export declare const PUBLIC: Namespace;

package/dist/dialects/pg/view/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * `okmodel/view`.
+ *
+ * `view()` and `materializedView()` return objects that produce their own
+ * catalog records. `schema()` only asks each declared object for those records.
+ * DDL, diffing, and scratch verification stay out of this module's callers
+ * until a plan or a check loads them.
+ */
+import type { CatalogObject } from "../../../contracts/catalog/types.js";
+import type { SchemaHook } from "../model.js";
+import type { SqlText } from "../table.js";
+import { type ViewInstall } from "./client.js";
+/** One declared output column. `type` is the Postgres type name. */
+export type ViewColumnInput = {
+    readonly name: string;
+    readonly type: string;
+};
+/** Options for {@link view}. */
+export type ViewOptions = {
+    readonly columns: readonly ViewColumnInput[];
+    readonly query: SqlText | string;
+    /** Schema. The default is `public`. */
+    readonly schema?: string;
+    /**
+     * Opts the view out of tenancy.
+     *
+     * A view that reads a tenant table and does not expose the tenant key is
+     * OKM1820 unless this is `global("reason")`.
+     */
+    readonly tenancy?: unknown;
+};
+/**
+ * One declared view.
+ *
+ * `contribute` builds the catalog record. Column dependencies are filled
+ * from `pg_depend` by scratch verification, not at this call.
+ */
+export type ViewDeclaration = {
+    readonly name: string;
+    readonly schema: string;
+    /**
+     * Catalog record for this declaration.
+     *
+     * @param peers - The `schema({ views })` list
+     * @param built - Objects the schema has already staged
+     * @returns The view record
+     */
+    contribute(peers: unknown, built: unknown): readonly CatalogObject[];
+    /** Publishes the read model. `schema()` calls it. */
+    install: ViewInstall;
+    /** Moves the read handle under `db.views`. */
+    hook: SchemaHook;
+};
+/** One index owned by a materialized view. */
+export type MaterializedViewIndexInput = {
+    readonly name?: string;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+};
+/** Options for {@link materializedView}. */
+export type MaterializedViewOptions = ViewOptions & {
+    readonly indexes?: readonly MaterializedViewIndexInput[];
+    /**
+     * Populate mode.
+     *
+     * `"concurrently"` plans `REFRESH MATERIALIZED VIEW CONCURRENTLY` and
+     * requires a unique index (OKM1822). Omitted still populates, without
+     * `CONCURRENTLY`.
+     */
+    readonly refresh?: "concurrently";
+};
+/**
+ * One declared materialized view.
+ *
+ * Identity is `(namespace, name)`. Indexes are separate catalog objects.
+ */
+export type MaterializedViewDeclaration = {
+    readonly name: string;
+    readonly schema: string;
+    /**
+     * Catalog records for this declaration.
+     *
+     * @param peers - The `schema({ views })` list
+     * @param built - Objects the schema has already staged
+     * @returns The materialized view and its indexes
+     */
+    contribute(peers: unknown, built: unknown): readonly CatalogObject[];
+    /** Publishes the read model. `schema()` calls it. */
+    install: ViewInstall;
+    /** Moves the read handle under `db.views`. */
+    hook: SchemaHook;
+};
+/**
+ * Declares a view as SQL with output columns.
+ *
+ * The query is stored as written. A scratch database reads `pg_depend` and
+ * `pg_get_viewdef` before a plan treats the body as canonical.
+ *
+ * @param name - View name
+ * @param options - Columns and query
+ * @returns The definition object `schema({ views })` stores
+ */
+export declare function view(name: string, options: ViewOptions): ViewDeclaration;
+/**
+ * Declares a materialized view.
+ *
+ * Creation is `WITH NO DATA`. Populate is a later plan step. `refresh:
+ * "concurrently"` without a unique index is OKM1822.
+ *
+ * @param name - Materialized view name
+ * @param options - Columns, query, indexes, and refresh mode
+ * @returns The definition object `schema({ views })` stores
+ */
+export declare function materializedView(name: string, options: MaterializedViewOptions): MaterializedViewDeclaration;

package/dist/dialects/pg/view/index.js

@@ -0,0 +1,289 @@
+import {
+  viewObject,
+  materializedViewObject,
+  materializedViewIndex
+} from "../../../shared/y005b761.js";
+import {
+  encodeUuid,
+  decodeUuid
+} from "../../../shared/dyj86cmj.js";
+import {
+  snakeCase
+} from "../../../shared/6w5j844a.js";
+import {
+  encodeText,
+  decodeText
+} from "../../../shared/4m9fn52z.js";
+import {
+  staticNamespace2
+} from "../../../shared/t4tbsy9h.js";
+import {
+  OkmError2
+} from "../../../shared/52szzakm.js";
+
+// src/dialects/pg/view/client.ts
+function viewClient(name, columns, query, tenancy) {
+  const field = camelCase(name);
+  const marked = readGlobal(name, tenancy);
+  return {
+    field,
+    install(model, scope, tables, casing, scoped) {
+      if (Object.hasOwn(model, field)) {
+        throw new OkmError2("OKM1023", `View ${name} uses the client name ${field}.`, {
+          fix: { summary: "Give the view a name that no table uses." }
+        });
+      }
+      const exposes = exposesKey(columns, scope);
+      if (scope !== undefined && readsTenant(query, tables, casing, scoped)) {
+        if (!exposes && marked === undefined) {
+          throw new OkmError2("OKM1820", `View ${name} reads a tenant table and does not expose ${scope.key}.`, {
+            fix: {
+              summary: "Expose the tenant key so the predicate can be applied, or declare global(reason)."
+            }
+          });
+        }
+        if (exposes) {
+          scope.scopeView(field);
+          scoped.add(name);
+        }
+      }
+      model[field] = {
+        name: field,
+        sql: name,
+        primary: [],
+        uniques: [],
+        columns: columnModels(columns, scope),
+        relations: []
+      };
+    },
+    hook(target, ctx) {
+      publish(field, target, ctx);
+    }
+  };
+}
+function publish(field, target, ctx) {
+  if (ctx.tables === undefined || ctx.table !== undefined)
+    return;
+  const handle = ctx.tables[field];
+  if (typeof handle !== "object" || handle === null)
+    return;
+  const source = handle;
+  const views = target.views;
+  const map = typeof views === "object" && views !== null ? views : {};
+  map[field] = {
+    find: source.find,
+    one: source.one,
+    count: source.count,
+    exists: source.exists
+  };
+  target.views = map;
+  delete ctx.tables[field];
+  delete target[field];
+}
+function columnModels(columns, tenancy) {
+  const seen = new Set;
+  const models = [];
+  for (const column of columns) {
+    const field = fieldName(column.name, tenancy);
+    if (seen.has(field)) {
+      throw new OkmError2("OKM1020", `View column ${column.name} repeats ${field}.`, {
+        fix: { summary: "Declare each output column once." }
+      });
+    }
+    seen.add(field);
+    const uuid = column.type.toLowerCase() === "uuid";
+    const key = tenancy !== undefined && field === tenancy.key;
+    models.push({
+      field,
+      sql: column.name,
+      dataType: column.type,
+      encode: uuid ? (value) => encodeUuid(textValue(value)) : (value) => encodeText(textValue(value)),
+      decode: uuid ? decodeUuid : decodeText,
+      hidden: false,
+      sensitive: false,
+      guarded: key,
+      writable: false,
+      guardUpdate: false
+    });
+  }
+  return models;
+}
+function exposesKey(columns, tenancy) {
+  if (tenancy === undefined)
+    return false;
+  return columns.some((column) => fieldName(column.name, tenancy) === tenancy.key);
+}
+function readsTenant(query, tables, casing, scoped) {
+  for (const name of scoped) {
+    if (mentions(query, name))
+      return true;
+  }
+  for (const table of tables) {
+    const mark = table.options?.tenancy;
+    if (isGlobalMark(mark))
+      continue;
+    const sql = casing === "snake" ? snakeCase(table.name) : table.name;
+    if (mentions(query, sql) || mentions(query, table.name))
+      return true;
+  }
+  return false;
+}
+function readGlobal(name, tenancy) {
+  if (tenancy === undefined)
+    return;
+  if (!isGlobalMark(tenancy)) {
+    throw new OkmError2("OKM1020", `View ${name} tenancy must be global("reason").`, {
+      fix: { summary: 'Pass global("reason") from okmodel/tenancy, or omit tenancy.' }
+    });
+  }
+  return tenancy.reason;
+}
+function isGlobalMark(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return record.kind === "global" && typeof record.reason === "string" && record.reason.trim().length > 0;
+}
+function fieldName(column, tenancy) {
+  const field = camelCase(column);
+  if (tenancy !== undefined && (column === tenancy.key || field === tenancy.key))
+    return tenancy.key;
+  return field;
+}
+function camelCase(name) {
+  let out = "";
+  let upper = false;
+  for (const char of name) {
+    if (char === "_") {
+      upper = out.length > 0;
+      continue;
+    }
+    out += upper ? char.toUpperCase() : char;
+    upper = false;
+  }
+  return out;
+}
+function mentions(query, name) {
+  let pattern = '(^|[^A-Za-z0-9_])"?';
+  for (const char of name) {
+    if ("\\^$[]().*+?|{}".includes(char))
+      pattern += "\\";
+    pattern += char;
+  }
+  pattern += '"?(?![A-Za-z0-9_])';
+  return new RegExp(pattern).test(query);
+}
+function textValue(value) {
+  if (typeof value !== "string") {
+    throw new OkmError2("OKM1121", "A view column value must be text.", {
+      fix: { summary: "Pass a string." }
+    });
+  }
+  return value;
+}
+
+// src/dialects/pg/view/index.ts
+function view(name, options) {
+  const schema = options.schema ?? "public";
+  const columns = options.columns.map((column) => ({ name: column.name, dataType: column.type }));
+  const query = bodyText(options.query);
+  const bound = viewClient(name, options.columns, query, options.tenancy);
+  return {
+    name,
+    schema,
+    install: bound.install,
+    hook: bound.hook,
+    contribute(peers, built) {
+      assertPeers(peers);
+      assertNoTable(built, name);
+      const provenance = { origin: "file", name };
+      return [
+        viewObject({
+          namespace: staticNamespace2(schema),
+          name,
+          columns,
+          query,
+          provenance
+        })
+      ];
+    }
+  };
+}
+function materializedView(name, options) {
+  const schema = options.schema ?? "public";
+  const columns = options.columns.map((column) => ({ name: column.name, dataType: column.type }));
+  const query = bodyText(options.query);
+  const bound = viewClient(name, options.columns, query, options.tenancy);
+  const indexes = options.indexes ?? [];
+  if (options.refresh === "concurrently" && !indexes.some((index) => index.unique === true)) {
+    throw new OkmError2("OKM1822", `Materialized view ${name} refreshes concurrently and has no unique index.`, { fix: { summary: "Add a unique index, or refresh without CONCURRENTLY." } });
+  }
+  const columnNames = new Set(columns.map((column) => column.name));
+  for (const index of indexes) {
+    for (const column of index.columns) {
+      if (!columnNames.has(column)) {
+        throw new OkmError2("OKM1020", `Index on ${name} names column ${column}, which the materialized view does not have.`, { fix: { summary: "Name a column of the materialized view." } });
+      }
+    }
+  }
+  return {
+    name,
+    schema,
+    install: bound.install,
+    hook: bound.hook,
+    contribute(peers, built) {
+      assertPeers(peers);
+      assertNoTable(built, name);
+      const namespace = staticNamespace2(schema);
+      const provenance = { origin: "file", name };
+      const parent = { namespace, name };
+      return [
+        materializedViewObject({
+          namespace,
+          name,
+          columns,
+          query,
+          provenance,
+          ...options.refresh === "concurrently" ? { refresh: "concurrently" } : {}
+        }),
+        ...indexes.map((index) => materializedViewIndex({
+          parent,
+          ...index.name !== undefined ? { name: index.name } : {},
+          columns: index.columns,
+          ...index.unique === true ? { unique: true } : {},
+          provenance
+        }))
+      ];
+    }
+  };
+}
+function bodyText(body) {
+  return typeof body === "string" ? body : body.text;
+}
+function assertPeers(peers) {
+  if (!Array.isArray(peers)) {
+    throw new OkmError2("OKM1020", "schema({ views }) must be a list.", {
+      fix: { summary: "Pass an array to schema({ views })." }
+    });
+  }
+}
+function assertNoTable(built, name) {
+  if (!Array.isArray(built))
+    return;
+  for (const object of built) {
+    if (!isRecord(object) || object.kind !== "table" || !isRecord(object.identity))
+      continue;
+    if (object.identity.name === name) {
+      throw new OkmError2("OKM1023", `View ${name} uses the name of a table.`, {
+        fix: { summary: "Give the view a name that no table uses." }
+      });
+    }
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export {
+  materializedView,
+  view
+};

package/dist/dialects/pg/view/scratch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Verifies declared views on a scratch schema.
+ *
+ * Tables from the catalog are created there, then each view. `pg_get_viewdef`
+ * replaces the author query and `pg_depend` supplies column edges (D117).
+ * The scratch schema is dropped before this returns. Plans never use it.
+ */
+import type { Catalog } from "../../../contracts/catalog/types.js";
+import type { CatalogQuery } from "../introspect.js";
+/**
+ * Reads dependencies and reprints for every view in `source`.
+ *
+ * The returned catalog matches what introspection prints for those views
+ * when the same query is applied. A declared column list that disagrees
+ * with the database is OKM1020.
+ *
+ * @param runner - Database connection. Statements share its session
+ * @param source - Catalog whose views are still author SQL
+ * @returns A catalog whose views carry the reprint and `pg_depend` edges
+ */
+export declare function sealViews(runner: CatalogQuery, source: Catalog): Promise<Catalog>;

package/dist/dialects/pg/where.d.ts

@@ -5,11 +5,11 @@
  * `where` without importing the client types. `runtime/types.ts` re-exports
  * the two names callers use.
  */
-import type { Between, Compare, Containment, Eq, HasAnyKey, HasKey, InList, Matches, Not, NotIn, Overlaps, Path, Pattern, RawPattern } from "./operators.js";
+import type { Between, Compare, Containment, Eq, HasAnyKey, HasKey, InList, Matches, Trigram, Not, NotIn, Overlaps, Path, Pattern, RawPattern } from "./operators.js";
 import type { Range } from "./range.js";
 export type IsObject<V> = V extends object ? V extends readonly unknown[] ? false : null extends V ? false : true : false;
 /** Text patterns, including substring `contains`. `matches` is for tsvector, which is also `string`. */
-type TextOps = Pattern<"startsWith"> | Pattern<"contains"> | Pattern<"endsWith"> | RawPattern<"like"> | RawPattern<"ilike"> | Matches;
+type TextOps = Pattern<"startsWith"> | Pattern<"contains"> | Pattern<"endsWith"> | RawPattern<"like"> | RawPattern<"ilike"> | Matches | Trigram<"similar"> | Trigram<"wordSimilar">;
 /** Array, jsonb, or range containment, plus overlap where that operator fits. */
 type StructuredOps<V> = Containment<"contains" | "containedBy", V> | Overlaps<V>;
 /** A JSON fragment. Containment matches part of a document, not the whole column type. */