@rebasepro/server-postgres 0.23.0 → 0.24.0

package/dist/schema/plan/types.d.ts

@@ -200,6 +200,13 @@ export interface ColumnPlan {
     column: string;
     type: PgType;
     nullable: boolean;
+    /**
+     * This column alone is the table's primary key, declared inline on it.
+     *
+     * `false` for a column of a composite key: several inline `PRIMARY KEY`
+     * clauses would be several primary keys, so a composite key is one table
+     * constraint over {@link TablePlan.primaryKey} instead.
+     */
     primaryKey: boolean;
     unique: boolean;
     default?: ColumnDefault;
@@ -326,7 +333,13 @@ export interface TablePlan {
      */
     declaringSlugs?: string[];
     columns: ColumnPlan[];
-    /** Column names, in order. One entry for a collection, two for a junction. */
+    /**
+     * The primary key's column names, in key order.
+     *
+     * One entry is a key declared inline on its column ({@link ColumnPlan.primaryKey}).
+     * Several — a junction's two endpoints, or a collection marking several
+     * properties `isId` — are rendered as one `PRIMARY KEY (a, b)` constraint.
+     */
     primaryKey: string[];
     /** The declared `indexes:` block, with its frozen names. */
     indexes: CollectionIndexSpec[];
@@ -355,23 +368,35 @@ export interface TablePlan {
  * pair them; the rule that derives it is `sharedRelationName`, which both sides
  * compute independently from the table that owns the column.
  */
-export interface RelationPlan {
+export type RelationPlan = OneRelationPlan | ManyRelationPlan;
+interface RelationPlanBase {
     /** The Drizzle table variable this entry belongs to. */
     tableVar: string;
     /** The key in the relations object. */
     key: string;
-    kind: "one" | "many";
     targetVar: string;
-    /**
-     * Absent only for a `hasOne` inverse, which is the documented FK-less form:
-     * `one(target)` with no config. `one(target, { relationName })` is not a
-     * `RelationConfig` (TS2345) and throws at runtime besides.
-     */
-    relationName?: string;
+    relationName: string;
+}
+/**
+ * A `one()`. Every one names its join — Drizzle has no `one()` paired by
+ * `relationName` alone, and one paired by table is ambiguous as soon as two
+ * links join the same pair of tables.
+ */
+export interface OneRelationPlan extends RelationPlanBase {
+    kind: "one";
     /** Property keys on this table. */
-    fields?: string[];
+    fields: string[];
     /** Property keys on the target table. */
-    references?: string[];
+    references: string[];
+    /**
+     * Set on a `hasOne`, whose `fields` are this table's own key: the target
+     * row may not exist although every column in `fields` is NOT NULL, which
+     * is what Drizzle reads a `one()`'s nullability from.
+     */
+    nullable?: true;
+}
+export interface ManyRelationPlan extends RelationPlanBase {
+    kind: "many";
 }
 export interface PlanOptions {
     /**
@@ -413,3 +438,4 @@ export interface SchemaPlan {
     collections: CollectionConfig[];
     options: PlanOptions;
 }
+export {};

package/dist/search-column-BM-GV6vH.js

@@ -0,0 +1,442 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_MODE, DEFAULT_SEARCH_WEIGHT, isPostgresCollectionConfig } from "@rebasepro/types";
+import { getTableName } from "@rebasepro/common";
+import { toPostgresIdentifier, toSnakeCase } from "@rebasepro/utils";
+import { createHash } from "node:crypto";
+//#region src/schema/search-column.ts
+/**
+* The one place a collection's `search` block becomes SQL.
+*
+* Four things describe a Postgres table in this codebase — the DDL generator,
+* the Drizzle schema generator, the runtime table builder for BaaS mode, and
+* the boot-time schema ensure — and each of them has, at some point, described
+* a column differently from the others. The `varchar(255)` note in
+* `generate-postgres-ddl-logic` is one such scar: the same property produced a
+* capped column down one path and an uncapped one down the other, and nothing
+* failed until a user hit the cap.
+*
+* So the search column is not implemented four times. It is computed once,
+* here, and every generator renders the same {@link SearchColumnSpec}. There is
+* a test asserting exactly that (`search-column-contract.test.ts`); the point of
+* this module is that the test has something to assert *about*.
+*
+* ## Why the expressions look the way they do
+*
+* A `GENERATED ALWAYS AS … STORED` expression must be strictly IMMUTABLE, and
+* Postgres is stricter here than intuition. Verified against PostgreSQL 18:
+*
+* | expression                              | immutable |
+* |-----------------------------------------|-----------|
+* | `to_tsvector('spanish', col)`           | yes       |
+* | `to_tsvector(col)` (1-arg)              | **no** — depends on `default_text_search_config` |
+* | `array_to_string(col, ' ')`             | **no**    |
+* | `col::text` on `text[]`                 | **no**    |
+* | `to_jsonb(col)`                         | **no**    |
+* | `unaccent(col)`                         | **no** — dictionary lookup is STABLE |
+* | `jsonb_to_tsvector('spanish', j, '["string"]')` | yes |
+* | `setweight(...) || setweight(...)`      | yes       |
+*
+* Three of the four things a real search column needs are therefore unavailable
+* directly, which is why {@link searchHelperFunctions} exists: each wraps a
+* stable built-in in an SQL function declared IMMUTABLE. That declaration is a
+* promise, and it is a true one for these three — array joining, JSON string
+* extraction and accent folding are all deterministic for a given input; the
+* built-ins are marked stable only because they must account for element types
+* and dictionaries in general.
+*
+* The alternative was to skip `unaccent` and text arrays entirely. That is not
+* a real option in an accented language: Postgres stems `auditoría` to
+* `auditor` and `auditoria` to `auditori` — *different lexemes* — so a query
+* typed without accents misses every row that carries them.
+*/
+/** Schema-qualified so a collection outside `public` still resolves them. */
+var HELPER_SCHEMA = "public";
+/**
+* Names of the helper functions. Frozen: they are recorded in the stored
+* generation expression of every search column ever created, so renaming one
+* orphans every table that already has a search column.
+*/
+var SEARCH_TEXT_FN = `${HELPER_SCHEMA}.rebase_search_text`;
+var SEARCH_UNACCENT_FN = `${HELPER_SCHEMA}.rebase_search_unaccent`;
+/** Raised when a `search` block names something that cannot be searched. */
+var SearchConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SearchConfigError";
+	}
+};
+/** The `search` block of a collection, or undefined when it has none. */
+var getSearchConfig = (collection) => isPostgresCollectionConfig(collection) ? collection.search : void 0;
+/**
+* Refuse a `search` block on a collection this engine does not store.
+*
+* The type only permits one on a `PostgresCollectionConfig`, so TypeScript
+* already stops the ordinary case. This catches the rest — a JS config, a cast,
+* a collection whose `engine` was changed after the block was written — because
+* the alternative is the exact failure the block exists to prevent: a developer
+* who declared what to index, saw no error, and got the substring fallback.
+*
+* Called with *every* collection, before the Postgres ones are filtered out.
+*/
+var assertSearchIsPostgresOnly = (collections) => {
+	for (const collection of collections) {
+		if (isPostgresCollectionConfig(collection)) continue;
+		if (!collection.search) continue;
+		const engine = collection.engine ?? "non-postgres";
+		throw new SearchConfigError(`${collection.slug}.search: full-text search is a Postgres feature, and this collection is served by \`${engine}\`. Remove the block — it would otherwise look configured while \`.search()\` kept using the default substring match.`);
+	}
+};
+var columnNameOf = (propName, prop) => prop && "columnName" in prop && typeof prop.columnName === "string" ? prop.columnName : toSnakeCase(propName);
+/**
+* Classify a property for search purposes.
+*
+* Deliberately narrower than the schema plan's `PgType`: search only cares
+* whether a value reaches text, and the mapping from property to *physical*
+* type is asserted against the plan in the contract test rather than duplicated
+* here.
+*
+* Returns null for anything that is not text-bearing, which the caller turns
+* into a boot error naming the property.
+*/
+var classify = (prop) => {
+	switch (prop.type) {
+		case "string": {
+			const sp = prop;
+			if (sp.enum) return {
+				kind: "text",
+				reason: "enum"
+			};
+			if (sp.isId === "uuid" || sp.columnType === "uuid") return {
+				kind: "text",
+				reason: "uuid"
+			};
+			return { kind: "text" };
+		}
+		case "map":
+			if (prop.columnType === "json") return {
+				kind: "jsonb",
+				reason: "json"
+			};
+			return { kind: "jsonb" };
+		case "array": {
+			const ap = prop;
+			let colType = ap.columnType;
+			if (!colType && ap.of && !Array.isArray(ap.of)) {
+				const of = ap.of;
+				if (of.type === "string") colType = "text[]";
+				else if (of.type === "number") colType = of.validation?.integer ? "integer[]" : "numeric[]";
+				else if (of.type === "boolean") colType = "boolean[]";
+			}
+			if (colType === "text[]") return { kind: "text_array" };
+			if (colType === "json") return {
+				kind: "jsonb",
+				reason: "json"
+			};
+			if (colType === "integer[]" || colType === "boolean[]" || colType === "numeric[]") return {
+				kind: "text_array",
+				reason: "non_text_array"
+			};
+			return { kind: "jsonb" };
+		}
+		default: return null;
+	}
+};
+var normalize = (inner, unaccent) => unaccent ? `${SEARCH_UNACCENT_FN}(${inner})` : inner;
+/** SQL reading one field as plain text, before normalization. */
+var rawTextSql = (field) => {
+	const col = `"${field.column}"`;
+	if (field.kind === "text") return `coalesce(${col}, '')`;
+	if (field.kind === "text_array") return `${SEARCH_TEXT_FN}(coalesce(${col}, '{}'::text[]))`;
+	return `${SEARCH_TEXT_FN}(coalesce(${field.jsonPath.length === 0 ? col : field.jsonPath.length === 1 ? `${col} -> ${quote(field.jsonPath[0])}` : `${col} #> ${quote(`{${field.jsonPath.join(",")}}`)}`}, '{}'::jsonb))`;
+};
+var quote = (v) => `'${v.replace(/'/g, "''")}'`;
+/**
+* Resolve and validate one declared field path.
+*
+* A path that does not resolve throws. The whole point of an explicit block is
+* that the author knows what is indexed; a silently dropped field would make it
+* a guess again, and the failure — a search that returns nothing for content
+* that is plainly in the row — is invisible from the outside.
+*/
+var resolveField = (entry, collection, cfg) => {
+	const path = typeof entry === "string" ? entry : entry.path;
+	const weight = (typeof entry === "string" ? void 0 : entry.weight) ?? DEFAULT_SEARCH_WEIGHT;
+	const where = `${collection.slug}.search`;
+	if (!path || typeof path !== "string") throw new SearchConfigError(`${where}: every entry in \`fields\` needs a property path.`);
+	const [head, ...rest] = path.split(".");
+	const prop = collection.properties?.[head];
+	if (!prop) throw new SearchConfigError(`${where}: "${path}" starts at property "${head}", which this collection does not declare. Known properties: ${Object.keys(collection.properties ?? {}).join(", ")}.`);
+	const classified = classify(prop);
+	if (!classified) throw new SearchConfigError(`${where}: "${path}" is a \`${prop.type}\` property, which holds no text to search. Searchable kinds are \`string\`, \`string[]\` and \`map\` (or a path inside one).`);
+	if (classified.reason === "enum") throw new SearchConfigError(`${where}: "${path}" is an enum. Enums are a fixed vocabulary — filter on them with \`where\` instead, which is exact and uses an index.`);
+	if (classified.reason === "uuid") throw new SearchConfigError(`${where}: "${path}" is a UUID column. Look it up by id rather than searching it.`);
+	if (classified.reason === "json") throw new SearchConfigError(`${where}: "${path}" is a \`json\` column, and the cast from \`json\` to \`jsonb\` is not immutable, so it cannot feed a generated column. Declare the property as \`jsonb\` (the default) to search it.`);
+	if (classified.reason === "non_text_array") throw new SearchConfigError(`${where}: "${path}" is an array of numbers or booleans. Only \`string[]\` carries text to search.`);
+	if (rest.length > 0 && classified.kind !== "jsonb") throw new SearchConfigError(`${where}: "${path}" addresses a path inside "${head}", but "${head}" is a \`${prop.type}\` property, not a \`map\`. Only map properties have paths inside them.`);
+	const column = columnNameOf(head, prop);
+	const raw = rawTextSql({
+		column,
+		jsonPath: rest,
+		kind: classified.kind
+	});
+	const textSql = normalize(raw, cfg.unaccent === true);
+	const language = cfg.language ?? DEFAULT_SEARCH_LANGUAGE;
+	return {
+		path,
+		column,
+		jsonPath: rest,
+		kind: classified.kind,
+		weight,
+		sql: `setweight(to_tsvector(${quote(language)}, ${textSql}), ${quote(weight)})`,
+		textSql,
+		foldedTextSql: normalize(raw, true)
+	};
+};
+/**
+* Build the full spec for a collection, or undefined when it has not opted in.
+*
+* Throws {@link SearchConfigError} on a config that cannot be honoured. Callers
+* at boot surface that as a startup failure — a search block that half-works is
+* worse than one that refuses.
+*/
+var buildSearchColumnSpec = (collection) => {
+	const cfg = getSearchConfig(collection);
+	if (!cfg) return void 0;
+	if (!Array.isArray(cfg.fields) || cfg.fields.length === 0) throw new SearchConfigError(`${collection.slug}.search: \`fields\` is empty. Name the properties to index, or remove the \`search\` block to keep the default ILIKE behaviour.`);
+	const table = getTableName(collection);
+	const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
+	const column = cfg.column ?? DEFAULT_SEARCH_COLUMN;
+	if (collection.properties?.[column]) throw new SearchConfigError(`${collection.slug}.search: the generated column "${column}" collides with a declared property of the same name. Set \`search.column\` to something else.`);
+	const fields = cfg.fields.map((entry) => resolveField(entry, collection, cfg));
+	const seen = /* @__PURE__ */ new Set();
+	for (const f of fields) {
+		if (seen.has(f.path)) throw new SearchConfigError(`${collection.slug}.search: "${f.path}" is listed twice.`);
+		seen.add(f.path);
+	}
+	const mode = cfg.mode ?? DEFAULT_SEARCH_MODE;
+	const extensions = [];
+	if (cfg.unaccent || mode === "hybrid") extensions.push("unaccent");
+	if (cfg.fuzzy) extensions.push("pg_trgm");
+	const spec = {
+		schema,
+		table,
+		column,
+		language: cfg.language ?? DEFAULT_SEARCH_LANGUAGE,
+		unaccent: cfg.unaccent === true,
+		mode,
+		fields,
+		expression: fields.map((f) => f.sql).join(" || "),
+		indexName: toPostgresIdentifier(`${table}_${column}_gin`),
+		extensions
+	};
+	if (cfg.fuzzy) {
+		const fuzzyColumn = `${column}_text`;
+		if (collection.properties?.[fuzzyColumn]) throw new SearchConfigError(`${collection.slug}.search: \`fuzzy\` needs the column "${fuzzyColumn}", which collides with a declared property. Set \`search.column\` to something else.`);
+		spec.fuzzy = {
+			column: fuzzyColumn,
+			expression: fields.map((f) => f.textSql).join(" || ' ' || "),
+			indexName: toPostgresIdentifier(`${table}_${fuzzyColumn}_trgm`),
+			threshold: cfg.fuzzyThreshold ?? DEFAULT_FUZZY_THRESHOLD
+		};
+	}
+	return spec;
+};
+/**
+* The IMMUTABLE wrappers the generated expressions call.
+*
+* `CREATE OR REPLACE` so a boot against an existing database is a no-op rather
+* than an error, and idempotent for the same reason every other boot-time DDL
+* statement here is.
+*
+* The bodies are stable built-ins wrapped in an immutable promise — see the
+* module comment for why that promise is sound. `STRICT` matters: it makes NULL
+* in mean NULL out without executing the body, which is what the `coalesce` at
+* each call site then absorbs.
+*/
+var searchHelperFunctions = (spec) => {
+	const statements = [`CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(text[]) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT array_to_string($1, ' ') $$;`, `CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(jsonb) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT coalesce(string_agg(v, ' '), '')\n       FROM jsonb_array_elements_text(jsonb_path_query_array($1, 'strict $.**?(@.type() == "string")')) AS v $$;`];
+	if (spec.unaccent || spec.mode === "hybrid") statements.push(`CREATE OR REPLACE FUNCTION ${SEARCH_UNACCENT_FN}(text) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT ${HELPER_SCHEMA}.unaccent('${HELPER_SCHEMA}.unaccent'::regdictionary, $1) $$;`);
+	return statements;
+};
+/**
+* `CREATE EXTENSION` statements the spec's expressions depend on.
+*
+* `WITH SCHEMA public` is load-bearing, not tidiness. An unqualified
+* `CREATE EXTENSION` installs into the first schema on `search_path`, which
+* defaults to `"$user", public` — and the scaffold's database role is named
+* `rebase`, the same as the schema the generator creates one statement earlier.
+* So the moment that schema exists, `CREATE EXTENSION unaccent` puts the
+* dictionary in `rebase`, and every reference to `public.unaccent` below fails
+* with "text search dictionary does not exist". Observed, not theorised.
+*/
+var searchExtensionStatements = (spec) => spec.extensions.map((e) => `CREATE EXTENSION IF NOT EXISTS ${e} WITH SCHEMA ${HELPER_SCHEMA};`);
+/**
+* Everything after the column name — the type and the generation expression.
+*
+* Split out because four emitters need it and only two of them have a place to
+* put the name: `CREATE TABLE` and `ADD COLUMN` write `"col" <this>`, while the
+* schema plan carries it as the column's SQL definition and the boot-time
+* rebuild statement interpolates it on its own.
+*/
+var searchColumnTypeSql = (expression, kind) => `${kind} GENERATED ALWAYS AS (${expression}) STORED`;
+/** The column definition as it appears inside `CREATE TABLE`. */
+var searchColumnDefinition = (spec) => `"${spec.column}" ${searchColumnTypeSql(spec.expression, "tsvector")}`;
+/** The fuzzy column definition, when the spec asks for one. */
+var fuzzyColumnDefinition = (spec) => spec.fuzzy ? `"${spec.fuzzy.column}" ${searchColumnTypeSql(spec.fuzzy.expression, "text")}` : void 0;
+/**
+* Index statements for the spec.
+*
+* `CONCURRENTLY` is deliberately *not* used here. This form is emitted into a
+* SQL file replayed as one unit — a migration, or `search.sql` — where a
+* concurrent build is not allowed. The boot-time ensure path runs statement by
+* statement against tables that are live and populated, and uses the
+* concurrent form instead; see `ensureSearchColumns`.
+*/
+var searchIndexStatements = (spec) => {
+	const statements = [`CREATE INDEX IF NOT EXISTS "${spec.indexName}" ON "${spec.schema}"."${spec.table}" USING GIN ("${spec.column}");`];
+	if (spec.fuzzy) statements.push(`CREATE INDEX IF NOT EXISTS "${spec.fuzzy.indexName}" ON "${spec.schema}"."${spec.table}" USING GIN ("${spec.fuzzy.column}" ${HELPER_SCHEMA}.gin_trgm_ops);`);
+	return statements;
+};
+/**
+* Marker on the comment of every generated search column this module creates.
+*
+* Versioned because the fingerprint below is only comparable against itself: a
+* future change to how it is computed has to read as "not stamped by this
+* version" rather than as drift on every existing column.
+*/
+var SEARCH_STAMP_PREFIX = "rebase:search:v1:";
+/**
+* A stable fingerprint of one generated column's expression.
+*
+* Why a stamp rather than reading the expression back: Postgres stores a
+* generated column's expression *parsed*, and hands it back deparsed — casts
+* made explicit, identifiers requoted, schema qualifications added or dropped
+* according to `search_path`. Comparing that text to the text we generated
+* would report drift on wording, and this comparison decides whether a boot
+* refuses, so a false positive is an outage. The stamp is written by the same
+* code that writes the column, so equality means what it says.
+*/
+var searchExpressionFingerprint = (expression) => `${SEARCH_STAMP_PREFIX}${createHash("sha256").update(expression).digest("hex").slice(0, 16)}`;
+/**
+* The stamps for a spec's generated columns — one per column, never shared.
+*
+* Per column on purpose: turning `fuzzy` on adds a second column and changes
+* nothing about the first, and a spec-wide fingerprint would report the
+* untouched `tsvector` column as drifted and refuse a boot over a change that
+* is purely additive.
+*/
+var searchColumnStamps = (spec) => {
+	const stamp = (column, expression) => {
+		const fingerprint = searchExpressionFingerprint(expression);
+		return {
+			column,
+			expression,
+			fingerprint,
+			sql: `COMMENT ON COLUMN "${spec.schema}"."${spec.table}"."${column}" IS ${quote(fingerprint)};`
+		};
+	};
+	const stamps = [stamp(spec.column, spec.expression)];
+	if (spec.fuzzy) stamps.push(stamp(spec.fuzzy.column, spec.fuzzy.expression));
+	return stamps;
+};
+/**
+* The same drift check as the boot ensure, for the SQL file.
+*
+* Needed because {@link searchColumnStamps} would otherwise *launder* drift on
+* the migration path: `ADD COLUMN IF NOT EXISTS` does nothing to a column that
+* exists, so a re-generated `search.sql` would stamp a stale column with the
+* new block's fingerprint and the next boot would find them in agreement.
+* Guarding first means the file refuses instead — `rebase db push` is attended,
+* and the operator reading the failure is the person who changed the block.
+*/
+var searchStampGuards = (spec) => searchColumnStamps(spec).map((stamp) => {
+	const relation = quote(`"${spec.schema}"."${spec.table}"`);
+	return `DO $rebase_search$
+DECLARE recorded text;
+BEGIN
+    SELECT col_description(a.attrelid, a.attnum) INTO recorded
+    FROM pg_attribute a
+    WHERE a.attrelid = ${relation}::regclass AND a.attname = ${quote(stamp.column)} AND NOT a.attisdropped;
+    IF recorded LIKE ${quote(`${SEARCH_STAMP_PREFIX}%`)} AND recorded <> ${quote(stamp.fingerprint)} THEN
+        RAISE EXCEPTION 'Rebase: the search block for ${spec.schema}.${spec.table} changed after the generated column "${stamp.column}" was built (recorded %, expected ${stamp.fingerprint}). Postgres cannot alter a generated expression in place. Drop the column and re-apply this file — it rewrites the table and rebuilds the index: ALTER TABLE ${relation.slice(1, -1)} DROP COLUMN "${stamp.column}";', recorded;
+    END IF;
+END
+$rebase_search$;`;
+});
+/**
+* The index names the spec creates.
+*
+* Needed by name, not just by statement, so Atlas can be told to exclude them
+* from its diff — see `searchExcludePatterns`.
+*/
+var searchIndexNames = (spec) => spec.fuzzy ? [spec.indexName, spec.fuzzy.indexName] : [spec.indexName];
+/**
+* The generated column names a collection's search block adds, if any.
+*
+* These are physical columns on the table, so `SELECT *` returns them. They are
+* an index in column form — a list of lexeme positions, or a concatenation of
+* every searchable field on the row — and nothing outside the query planner has
+* any use for them. Left in, every list response carries a second, larger copy
+* of the row's text.
+*/
+var searchColumnNames = (collection) => {
+	let spec;
+	try {
+		spec = buildSearchColumnSpec(collection);
+	} catch {
+		return [];
+	}
+	if (!spec) return [];
+	return spec.fuzzy ? [spec.column, spec.fuzzy.column] : [spec.column];
+};
+/**
+* True for a column whose type only ever holds a search index.
+*
+* Independent of any collection config on purpose: an introspected database
+* (BaaS mode) can carry a `tsvector` column this framework never created —
+* Pagila's `film.fulltext` is the canonical one — and it should not be returned
+* to callers either. `isDerivedIndexColumn` already keeps such a column out of
+* the *properties*; this keeps it out of the *rows*.
+*/
+var isSearchIndexColumn = (column) => {
+	const sqlType = typeof column?.getSQLType === "function" ? column.getSQLType().toLowerCase() : "";
+	return sqlType === "tsvector" || sqlType === "tsquery";
+};
+/**
+* A drizzle select projection over `table` with the search columns dropped.
+*
+* Returns undefined when nothing needs dropping, so the common case keeps using
+* a plain `select()` and this stays invisible in the generated SQL.
+*/
+var visibleColumnProjection = (tableColumns, collection) => {
+	const excluded = excludedColumnNames(tableColumns, collection);
+	if (!tableColumns || excluded.length === 0) return void 0;
+	const projection = {};
+	for (const [name, column] of Object.entries(tableColumns)) if (!excluded.includes(name)) projection[name] = column;
+	return projection;
+};
+/** The same exclusion as a drizzle `db.query` `columns` denylist. */
+var hiddenColumnsOption = (tableColumns, collection) => {
+	const excluded = excludedColumnNames(tableColumns, collection);
+	if (excluded.length === 0) return void 0;
+	return Object.fromEntries(excluded.map((name) => [name, false]));
+};
+/**
+* The columns to keep out of a response, by name.
+*
+* `tableColumns` is whatever `getTableColumns` returned, which is `undefined`
+* for anything that is not a real drizzle table — a stub in a test, a derived
+* or nested path with no table behind it. Nothing to exclude is the right
+* answer there, and it has to be an answer rather than a throw: this runs on
+* the read path of every collection, opted in or not.
+*/
+var excludedColumnNames = (tableColumns, collection) => {
+	if (!tableColumns || typeof tableColumns !== "object") return [];
+	const byName = new Set(collection ? searchColumnNames(collection) : []);
+	return Object.keys(tableColumns).filter((name) => byName.has(name) || isSearchIndexColumn(tableColumns[name]));
+};
+//#endregion
+export { visibleColumnProjection as _, buildSearchColumnSpec as a, searchColumnDefinition as c, searchColumnTypeSql as d, searchExtensionStatements as f, searchStampGuards as g, searchIndexStatements as h, assertSearchIsPostgresOnly as i, searchColumnNames as l, searchIndexNames as m, SEARCH_TEXT_FN as n, fuzzyColumnDefinition as o, searchHelperFunctions as p, SEARCH_UNACCENT_FN as r, hiddenColumnsOption as s, SEARCH_STAMP_PREFIX as t, searchColumnStamps as u };
+
+//# sourceMappingURL=search-column-BM-GV6vH.js.map

package/dist/search-column-BM-GV6vH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-column-BM-GV6vH.js","names":[],"sources":["../src/schema/search-column.ts"],"sourcesContent":["/**\n * The one place a collection's `search` block becomes SQL.\n *\n * Four things describe a Postgres table in this codebase — the DDL generator,\n * the Drizzle schema generator, the runtime table builder for BaaS mode, and\n * the boot-time schema ensure — and each of them has, at some point, described\n * a column differently from the others. The `varchar(255)` note in\n * `generate-postgres-ddl-logic` is one such scar: the same property produced a\n * capped column down one path and an uncapped one down the other, and nothing\n * failed until a user hit the cap.\n *\n * So the search column is not implemented four times. It is computed once,\n * here, and every generator renders the same {@link SearchColumnSpec}. There is\n * a test asserting exactly that (`search-column-contract.test.ts`); the point of\n * this module is that the test has something to assert *about*.\n *\n * ## Why the expressions look the way they do\n *\n * A `GENERATED ALWAYS AS … STORED` expression must be strictly IMMUTABLE, and\n * Postgres is stricter here than intuition. Verified against PostgreSQL 18:\n *\n * | expression                              | immutable |\n * |-----------------------------------------|-----------|\n * | `to_tsvector('spanish', col)`           | yes       |\n * | `to_tsvector(col)` (1-arg)              | **no** — depends on `default_text_search_config` |\n * | `array_to_string(col, ' ')`             | **no**    |\n * | `col::text` on `text[]`                 | **no**    |\n * | `to_jsonb(col)`                         | **no**    |\n * | `unaccent(col)`                         | **no** — dictionary lookup is STABLE |\n * | `jsonb_to_tsvector('spanish', j, '[\"string\"]')` | yes |\n * | `setweight(...) || setweight(...)`      | yes       |\n *\n * Three of the four things a real search column needs are therefore unavailable\n * directly, which is why {@link searchHelperFunctions} exists: each wraps a\n * stable built-in in an SQL function declared IMMUTABLE. That declaration is a\n * promise, and it is a true one for these three — array joining, JSON string\n * extraction and accent folding are all deterministic for a given input; the\n * built-ins are marked stable only because they must account for element types\n * and dictionaries in general.\n *\n * The alternative was to skip `unaccent` and text arrays entirely. That is not\n * a real option in an accented language: Postgres stems `auditoría` to\n * `auditor` and `auditoria` to `auditori` — *different lexemes* — so a query\n * typed without accents misses every row that carries them.\n */\nimport {\n    CollectionConfig,\n    Property,\n    StringProperty,\n    ArrayProperty,\n    MapProperty,\n    SearchConfig,\n    SearchField,\n    SearchMode,\n    SearchWeight,\n    isPostgresCollectionConfig,\n    DEFAULT_SEARCH_COLUMN,\n    DEFAULT_SEARCH_MODE,\n    DEFAULT_SEARCH_LANGUAGE,\n    DEFAULT_SEARCH_WEIGHT,\n    DEFAULT_FUZZY_THRESHOLD\n} from \"@rebasepro/types\";\nimport { createHash } from \"node:crypto\";\nimport { getTableName } from \"@rebasepro/common\";\nimport { toSnakeCase, toPostgresIdentifier } from \"@rebasepro/utils\";\n\n/** Schema-qualified so a collection outside `public` still resolves them. */\nconst HELPER_SCHEMA = \"public\";\n\n/**\n * Names of the helper functions. Frozen: they are recorded in the stored\n * generation expression of every search column ever created, so renaming one\n * orphans every table that already has a search column.\n */\nexport const SEARCH_TEXT_FN = `${HELPER_SCHEMA}.rebase_search_text`;\nexport const SEARCH_UNACCENT_FN = `${HELPER_SCHEMA}.rebase_search_unaccent`;\n\n/** How a declared path reaches text, which decides the SQL that extracts it. */\ntype FieldKind = \"text\" | \"text_array\" | \"jsonb\";\n\n/** One resolved field: where it lives, how to read it, what it is worth. */\nexport interface ResolvedSearchField {\n    /** The path exactly as the author wrote it, for error messages. */\n    path: string;\n    /** The physical column the path starts at. */\n    column: string;\n    /** Dotted remainder addressed inside a JSONB column, if any. */\n    jsonPath: string[];\n    kind: FieldKind;\n    weight: SearchWeight;\n    /** The `setweight(to_tsvector(…), 'X')` term this field contributes. */\n    sql: string;\n    /** The plain-text term this field contributes, for the fuzzy column. */\n    textSql: string;\n    /**\n     * The same text with accents folded **unconditionally**, for the substring\n     * half of {@link SearchMode} `\"hybrid\"`.\n     *\n     * Separate from {@link textSql} rather than replacing it, and that\n     * separation is the whole migration story for `mode`. `textSql` feeds the\n     * *stored* generated columns, so changing it changes their generation\n     * expression, which changes the fingerprint, which makes the next boot\n     * refuse (see `searchStampGuards`). This one is only ever interpolated into\n     * a WHERE clause, so a collection can switch to `\"hybrid\"` — and gain\n     * accent folding on the substring half — without rebuilding a column or\n     * taking an ACCESS EXCLUSIVE lock.\n     */\n    foldedTextSql: string;\n}\n\n/** Everything the generators need to render one collection's search column. */\nexport interface SearchColumnSpec {\n    schema: string;\n    table: string;\n    /** The generated `tsvector` column. */\n    column: string;\n    language: string;\n    unaccent: boolean;\n    /**\n     * How the query side matches. Deliberately absent from\n     * {@link SearchColumnSpec.expression} and from every fingerprint: it\n     * describes the WHERE clause, not the column.\n     */\n    mode: SearchMode;\n    fields: ResolvedSearchField[];\n    /** Body of `GENERATED ALWAYS AS ( … ) STORED` for the tsvector column. */\n    expression: string;\n    indexName: string;\n    /** Extensions that must exist before the column can be created. */\n    extensions: string[];\n    fuzzy?: {\n        column: string;\n        expression: string;\n        indexName: string;\n        threshold: number;\n    };\n}\n\n/** Raised when a `search` block names something that cannot be searched. */\nexport class SearchConfigError extends Error {\n    constructor(message: string) {\n        super(message);\n        this.name = \"SearchConfigError\";\n    }\n}\n\n/** The `search` block of a collection, or undefined when it has none. */\nexport const getSearchConfig = (collection: CollectionConfig): SearchConfig | undefined =>\n    isPostgresCollectionConfig(collection) ? collection.search : undefined;\n\n/**\n * Refuse a `search` block on a collection this engine does not store.\n *\n * The type only permits one on a `PostgresCollectionConfig`, so TypeScript\n * already stops the ordinary case. This catches the rest — a JS config, a cast,\n * a collection whose `engine` was changed after the block was written — because\n * the alternative is the exact failure the block exists to prevent: a developer\n * who declared what to index, saw no error, and got the substring fallback.\n *\n * Called with *every* collection, before the Postgres ones are filtered out.\n */\nexport const assertSearchIsPostgresOnly = (collections: CollectionConfig[]): void => {\n    for (const collection of collections) {\n        if (isPostgresCollectionConfig(collection)) continue;\n        if (!(collection as { search?: unknown }).search) continue;\n        const engine = (collection as { engine?: string }).engine ?? \"non-postgres\";\n        throw new SearchConfigError(\n            `${collection.slug}.search: full-text search is a Postgres feature, and this collection is served by \\`${engine}\\`. ` +\n            \"Remove the block — it would otherwise look configured while `.search()` kept using the default substring match.\"\n        );\n    }\n};\n\nconst columnNameOf = (propName: string, prop?: Property | null): string =>\n    prop && \"columnName\" in prop && typeof prop.columnName === \"string\" ? prop.columnName : toSnakeCase(propName);\n\n/**\n * Classify a property for search purposes.\n *\n * Deliberately narrower than the schema plan's `PgType`: search only cares\n * whether a value reaches text, and the mapping from property to *physical*\n * type is asserted against the plan in the contract test rather than duplicated\n * here.\n *\n * Returns null for anything that is not text-bearing, which the caller turns\n * into a boot error naming the property.\n */\nconst classify = (prop: Property): { kind: FieldKind; reason?: string } | null => {\n    switch (prop.type) {\n        case \"string\": {\n            const sp = prop as StringProperty;\n            if (sp.enum) {\n                return { kind: \"text\", reason: \"enum\" };\n            }\n            if (sp.isId === \"uuid\" || sp.columnType === \"uuid\") {\n                return { kind: \"text\", reason: \"uuid\" };\n            }\n            return { kind: \"text\" };\n        }\n        case \"map\": {\n            const mp = prop as MapProperty;\n            // A `json` column is not `jsonb`, and the cast between them is not\n            // immutable. Declaring `columnType: \"json\"` puts the value out of\n            // reach of a generated column.\n            if (mp.columnType === \"json\") return { kind: \"jsonb\", reason: \"json\" };\n            return { kind: \"jsonb\" };\n        }\n        case \"array\": {\n            const ap = prop as ArrayProperty;\n            let colType = ap.columnType;\n            if (!colType && ap.of && !Array.isArray(ap.of)) {\n                const of = ap.of as Property;\n                if (of.type === \"string\") colType = \"text[]\";\n                else if (of.type === \"number\") colType = of.validation?.integer ? \"integer[]\" : \"numeric[]\";\n                else if (of.type === \"boolean\") colType = \"boolean[]\";\n            }\n            if (colType === \"text[]\") return { kind: \"text_array\" };\n            if (colType === \"json\") return { kind: \"jsonb\", reason: \"json\" };\n            if (colType === \"integer[]\" || colType === \"boolean[]\" || colType === \"numeric[]\") {\n                return { kind: \"text_array\", reason: \"non_text_array\" };\n            }\n            // Everything else lands in JSONB, which the JSON extractor handles.\n            return { kind: \"jsonb\" };\n        }\n        default:\n            return null;\n    }\n};\n\nconst normalize = (inner: string, unaccent: boolean): string =>\n    unaccent ? `${SEARCH_UNACCENT_FN}(${inner})` : inner;\n\n/** SQL reading one field as plain text, before normalization. */\nconst rawTextSql = (field: { column: string; jsonPath: string[]; kind: FieldKind }): string => {\n    const col = `\"${field.column}\"`;\n    if (field.kind === \"text\") return `coalesce(${col}, '')`;\n    if (field.kind === \"text_array\") return `${SEARCH_TEXT_FN}(coalesce(${col}, '{}'::text[]))`;\n    // JSONB, optionally addressed at a path inside the document.\n    const target = field.jsonPath.length === 0\n        ? col\n        : field.jsonPath.length === 1\n            ? `${col} -> ${quote(field.jsonPath[0])}`\n            : `${col} #> ${quote(`{${field.jsonPath.join(\",\")}}`)}`;\n    return `${SEARCH_TEXT_FN}(coalesce(${target}, '{}'::jsonb))`;\n};\n\nconst quote = (v: string): string => `'${v.replace(/'/g, \"''\")}'`;\n\n/**\n * Resolve and validate one declared field path.\n *\n * A path that does not resolve throws. The whole point of an explicit block is\n * that the author knows what is indexed; a silently dropped field would make it\n * a guess again, and the failure — a search that returns nothing for content\n * that is plainly in the row — is invisible from the outside.\n */\nconst resolveField = (\n    entry: string | SearchField,\n    collection: CollectionConfig,\n    cfg: SearchConfig\n): ResolvedSearchField => {\n    const path = typeof entry === \"string\" ? entry : entry.path;\n    const weight = (typeof entry === \"string\" ? undefined : entry.weight) ?? DEFAULT_SEARCH_WEIGHT;\n    const where = `${collection.slug}.search`;\n\n    if (!path || typeof path !== \"string\") {\n        throw new SearchConfigError(`${where}: every entry in \\`fields\\` needs a property path.`);\n    }\n\n    const [head, ...rest] = path.split(\".\");\n    const prop = collection.properties?.[head] as Property | undefined;\n    if (!prop) {\n        const known = Object.keys(collection.properties ?? {}).join(\", \");\n        throw new SearchConfigError(\n            `${where}: \"${path}\" starts at property \"${head}\", which this collection does not declare. Known properties: ${known}.`\n        );\n    }\n\n    const classified = classify(prop);\n    if (!classified) {\n        throw new SearchConfigError(\n            `${where}: \"${path}\" is a \\`${prop.type}\\` property, which holds no text to search. ` +\n            `Searchable kinds are \\`string\\`, \\`string[]\\` and \\`map\\` (or a path inside one).`\n        );\n    }\n    if (classified.reason === \"enum\") {\n        throw new SearchConfigError(\n            `${where}: \"${path}\" is an enum. Enums are a fixed vocabulary — filter on them with \\`where\\` instead, which is exact and uses an index.`\n        );\n    }\n    if (classified.reason === \"uuid\") {\n        throw new SearchConfigError(\n            `${where}: \"${path}\" is a UUID column. Look it up by id rather than searching it.`\n        );\n    }\n    if (classified.reason === \"json\") {\n        throw new SearchConfigError(\n            `${where}: \"${path}\" is a \\`json\\` column, and the cast from \\`json\\` to \\`jsonb\\` is not immutable, so it cannot feed a generated column. Declare the property as \\`jsonb\\` (the default) to search it.`\n        );\n    }\n    if (classified.reason === \"non_text_array\") {\n        throw new SearchConfigError(\n            `${where}: \"${path}\" is an array of numbers or booleans. Only \\`string[]\\` carries text to search.`\n        );\n    }\n\n    if (rest.length > 0 && classified.kind !== \"jsonb\") {\n        throw new SearchConfigError(\n            `${where}: \"${path}\" addresses a path inside \"${head}\", but \"${head}\" is a \\`${prop.type}\\` property, not a \\`map\\`. Only map properties have paths inside them.`\n        );\n    }\n\n    const column = columnNameOf(head, prop);\n    const field = { column, jsonPath: rest, kind: classified.kind };\n    const raw = rawTextSql(field);\n    const textSql = normalize(raw, cfg.unaccent === true);\n    const language = cfg.language ?? DEFAULT_SEARCH_LANGUAGE;\n\n    return {\n        path,\n        column,\n        jsonPath: rest,\n        kind: classified.kind,\n        weight,\n        sql: `setweight(to_tsvector(${quote(language)}, ${textSql}), ${quote(weight)})`,\n        textSql,\n        foldedTextSql: normalize(raw, true)\n    };\n};\n\n/**\n * Build the full spec for a collection, or undefined when it has not opted in.\n *\n * Throws {@link SearchConfigError} on a config that cannot be honoured. Callers\n * at boot surface that as a startup failure — a search block that half-works is\n * worse than one that refuses.\n */\nexport const buildSearchColumnSpec = (collection: CollectionConfig): SearchColumnSpec | undefined => {\n    const cfg = getSearchConfig(collection);\n    if (!cfg) return undefined;\n\n    if (!Array.isArray(cfg.fields) || cfg.fields.length === 0) {\n        throw new SearchConfigError(\n            `${collection.slug}.search: \\`fields\\` is empty. Name the properties to index, or remove the \\`search\\` block to keep the default ILIKE behaviour.`\n        );\n    }\n\n    const table = getTableName(collection);\n    const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : \"public\";\n    const column = cfg.column ?? DEFAULT_SEARCH_COLUMN;\n\n    if (collection.properties?.[column]) {\n        throw new SearchConfigError(\n            `${collection.slug}.search: the generated column \"${column}\" collides with a declared property of the same name. Set \\`search.column\\` to something else.`\n        );\n    }\n\n    const fields = cfg.fields.map(entry => resolveField(entry, collection, cfg));\n\n    const seen = new Set<string>();\n    for (const f of fields) {\n        if (seen.has(f.path)) {\n            throw new SearchConfigError(`${collection.slug}.search: \"${f.path}\" is listed twice.`);\n        }\n        seen.add(f.path);\n    }\n\n    const mode = cfg.mode ?? DEFAULT_SEARCH_MODE;\n\n    const extensions: string[] = [];\n    // `hybrid` folds accents on its substring half whatever `unaccent` says, so\n    // it needs the dictionary and the helper even on a block that never asked\n    // for folding in the stored column. Both statements are idempotent, which\n    // is what keeps turning the mode on out of the column-rebuild business.\n    if (cfg.unaccent || mode === \"hybrid\") extensions.push(\"unaccent\");\n    if (cfg.fuzzy) extensions.push(\"pg_trgm\");\n\n    const spec: SearchColumnSpec = {\n        schema,\n        table,\n        column,\n        language: cfg.language ?? DEFAULT_SEARCH_LANGUAGE,\n        unaccent: cfg.unaccent === true,\n        mode,\n        fields,\n        expression: fields.map(f => f.sql).join(\" || \"),\n        indexName: toPostgresIdentifier(`${table}_${column}_gin`),\n        extensions\n    };\n\n    if (cfg.fuzzy) {\n        const fuzzyColumn = `${column}_text`;\n        if (collection.properties?.[fuzzyColumn]) {\n            throw new SearchConfigError(\n                `${collection.slug}.search: \\`fuzzy\\` needs the column \"${fuzzyColumn}\", which collides with a declared property. Set \\`search.column\\` to something else.`\n            );\n        }\n        spec.fuzzy = {\n            column: fuzzyColumn,\n            // Concatenated with spaces so a trigram never spans two fields.\n            expression: fields.map(f => f.textSql).join(\" || ' ' || \"),\n            indexName: toPostgresIdentifier(`${table}_${fuzzyColumn}_trgm`),\n            threshold: cfg.fuzzyThreshold ?? DEFAULT_FUZZY_THRESHOLD\n        };\n    }\n\n    return spec;\n};\n\n/**\n * The IMMUTABLE wrappers the generated expressions call.\n *\n * `CREATE OR REPLACE` so a boot against an existing database is a no-op rather\n * than an error, and idempotent for the same reason every other boot-time DDL\n * statement here is.\n *\n * The bodies are stable built-ins wrapped in an immutable promise — see the\n * module comment for why that promise is sound. `STRICT` matters: it makes NULL\n * in mean NULL out without executing the body, which is what the `coalesce` at\n * each call site then absorbs.\n */\nexport const searchHelperFunctions = (spec: SearchColumnSpec): string[] => {\n    const statements: string[] = [\n        // text[] → \" \"-joined text.\n        `CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(text[]) RETURNS text\\n` +\n        `    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\\n` +\n        `    $$ SELECT array_to_string($1, ' ') $$;`,\n        // jsonb → every string value at or below the node, space-joined. Keys\n        // are not values: indexing them would make `certifications` itself a\n        // search term on every row that has the field at all.\n        `CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(jsonb) RETURNS text\\n` +\n        `    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\\n` +\n        `    $$ SELECT coalesce(string_agg(v, ' '), '')\\n` +\n        `       FROM jsonb_array_elements_text(jsonb_path_query_array($1, 'strict $.**?(@.type() == \"string\")')) AS v $$;`\n    ];\n    if (spec.unaccent || spec.mode === \"hybrid\") {\n        // The two-argument form with an explicit dictionary is the one that can\n        // honestly be called immutable: the single-argument form resolves the\n        // dictionary through the current search_path at call time.\n        statements.push(\n            `CREATE OR REPLACE FUNCTION ${SEARCH_UNACCENT_FN}(text) RETURNS text\\n` +\n            `    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\\n` +\n            `    $$ SELECT ${HELPER_SCHEMA}.unaccent('${HELPER_SCHEMA}.unaccent'::regdictionary, $1) $$;`\n        );\n    }\n    return statements;\n};\n\n/**\n * `CREATE EXTENSION` statements the spec's expressions depend on.\n *\n * `WITH SCHEMA public` is load-bearing, not tidiness. An unqualified\n * `CREATE EXTENSION` installs into the first schema on `search_path`, which\n * defaults to `\"$user\", public` — and the scaffold's database role is named\n * `rebase`, the same as the schema the generator creates one statement earlier.\n * So the moment that schema exists, `CREATE EXTENSION unaccent` puts the\n * dictionary in `rebase`, and every reference to `public.unaccent` below fails\n * with \"text search dictionary does not exist\". Observed, not theorised.\n */\nexport const searchExtensionStatements = (spec: SearchColumnSpec): string[] =>\n    spec.extensions.map(e => `CREATE EXTENSION IF NOT EXISTS ${e} WITH SCHEMA ${HELPER_SCHEMA};`);\n\n/**\n * Everything after the column name — the type and the generation expression.\n *\n * Split out because four emitters need it and only two of them have a place to\n * put the name: `CREATE TABLE` and `ADD COLUMN` write `\"col\" <this>`, while the\n * schema plan carries it as the column's SQL definition and the boot-time\n * rebuild statement interpolates it on its own.\n */\nexport const searchColumnTypeSql = (expression: string, kind: \"tsvector\" | \"text\"): string =>\n    `${kind} GENERATED ALWAYS AS (${expression}) STORED`;\n\n/** The column definition as it appears inside `CREATE TABLE`. */\nexport const searchColumnDefinition = (spec: SearchColumnSpec): string =>\n    `\"${spec.column}\" ${searchColumnTypeSql(spec.expression, \"tsvector\")}`;\n\n/** The fuzzy column definition, when the spec asks for one. */\nexport const fuzzyColumnDefinition = (spec: SearchColumnSpec): string | undefined =>\n    spec.fuzzy ? `\"${spec.fuzzy.column}\" ${searchColumnTypeSql(spec.fuzzy.expression, \"text\")}` : undefined;\n\n/**\n * Index statements for the spec.\n *\n * `CONCURRENTLY` is deliberately *not* used here. This form is emitted into a\n * SQL file replayed as one unit — a migration, or `search.sql` — where a\n * concurrent build is not allowed. The boot-time ensure path runs statement by\n * statement against tables that are live and populated, and uses the\n * concurrent form instead; see `ensureSearchColumns`.\n */\nexport const searchIndexStatements = (spec: SearchColumnSpec): string[] => {\n    const statements = [\n        `CREATE INDEX IF NOT EXISTS \"${spec.indexName}\" ON \"${spec.schema}\".\"${spec.table}\" USING GIN (\"${spec.column}\");`\n    ];\n    if (spec.fuzzy) {\n        statements.push(\n            // The operator class is resolved through `search_path` like any\n            // other object, so it is qualified for the same reason the\n            // extension is installed explicitly.\n            `CREATE INDEX IF NOT EXISTS \"${spec.fuzzy.indexName}\" ON \"${spec.schema}\".\"${spec.table}\" USING GIN (\"${spec.fuzzy.column}\" ${HELPER_SCHEMA}.gin_trgm_ops);`\n        );\n    }\n    return statements;\n};\n\n// ── Telling a changed `search` block from an unchanged one ──────────────────\n\n/**\n * Marker on the comment of every generated search column this module creates.\n *\n * Versioned because the fingerprint below is only comparable against itself: a\n * future change to how it is computed has to read as \"not stamped by this\n * version\" rather than as drift on every existing column.\n */\nexport const SEARCH_STAMP_PREFIX = \"rebase:search:v1:\";\n\n/**\n * A stable fingerprint of one generated column's expression.\n *\n * Why a stamp rather than reading the expression back: Postgres stores a\n * generated column's expression *parsed*, and hands it back deparsed — casts\n * made explicit, identifiers requoted, schema qualifications added or dropped\n * according to `search_path`. Comparing that text to the text we generated\n * would report drift on wording, and this comparison decides whether a boot\n * refuses, so a false positive is an outage. The stamp is written by the same\n * code that writes the column, so equality means what it says.\n */\nexport const searchExpressionFingerprint = (expression: string): string =>\n    `${SEARCH_STAMP_PREFIX}${createHash(\"sha256\").update(expression).digest(\"hex\").slice(0, 16)}`;\n\n/** One generated column, with the fingerprint that identifies its expression. */\nexport interface SearchColumnStamp {\n    column: string;\n    /** The expression the column is generated from. */\n    expression: string;\n    fingerprint: string;\n    /** `COMMENT ON COLUMN …`, which is where the fingerprint is recorded. */\n    sql: string;\n}\n\n/**\n * The stamps for a spec's generated columns — one per column, never shared.\n *\n * Per column on purpose: turning `fuzzy` on adds a second column and changes\n * nothing about the first, and a spec-wide fingerprint would report the\n * untouched `tsvector` column as drifted and refuse a boot over a change that\n * is purely additive.\n */\nexport const searchColumnStamps = (spec: SearchColumnSpec): SearchColumnStamp[] => {\n    const stamp = (column: string, expression: string): SearchColumnStamp => {\n        const fingerprint = searchExpressionFingerprint(expression);\n        return {\n            column,\n            expression,\n            fingerprint,\n            sql: `COMMENT ON COLUMN \"${spec.schema}\".\"${spec.table}\".\"${column}\" IS ${quote(fingerprint)};`\n        };\n    };\n    const stamps = [stamp(spec.column, spec.expression)];\n    if (spec.fuzzy) stamps.push(stamp(spec.fuzzy.column, spec.fuzzy.expression));\n    return stamps;\n};\n\n/**\n * The same drift check as the boot ensure, for the SQL file.\n *\n * Needed because {@link searchColumnStamps} would otherwise *launder* drift on\n * the migration path: `ADD COLUMN IF NOT EXISTS` does nothing to a column that\n * exists, so a re-generated `search.sql` would stamp a stale column with the\n * new block's fingerprint and the next boot would find them in agreement.\n * Guarding first means the file refuses instead — `rebase db push` is attended,\n * and the operator reading the failure is the person who changed the block.\n */\nexport const searchStampGuards = (spec: SearchColumnSpec): string[] =>\n    searchColumnStamps(spec).map(stamp => {\n        const relation = quote(`\"${spec.schema}\".\"${spec.table}\"`);\n        return `DO $rebase_search$\nDECLARE recorded text;\nBEGIN\n    SELECT col_description(a.attrelid, a.attnum) INTO recorded\n    FROM pg_attribute a\n    WHERE a.attrelid = ${relation}::regclass AND a.attname = ${quote(stamp.column)} AND NOT a.attisdropped;\n    IF recorded LIKE ${quote(`${SEARCH_STAMP_PREFIX}%`)} AND recorded <> ${quote(stamp.fingerprint)} THEN\n        RAISE EXCEPTION 'Rebase: the search block for ${spec.schema}.${spec.table} changed after the generated column \"${stamp.column}\" was built (recorded %, expected ${stamp.fingerprint}). Postgres cannot alter a generated expression in place. Drop the column and re-apply this file — it rewrites the table and rebuilds the index: ALTER TABLE ${relation.slice(1, -1)} DROP COLUMN \"${stamp.column}\";', recorded;\n    END IF;\nEND\n$rebase_search$;`;\n    });\n\n/**\n * The index names the spec creates.\n *\n * Needed by name, not just by statement, so Atlas can be told to exclude them\n * from its diff — see `searchExcludePatterns`.\n */\nexport const searchIndexNames = (spec: SearchColumnSpec): string[] =>\n    spec.fuzzy ? [spec.indexName, spec.fuzzy.indexName] : [spec.indexName];\n\n// ── Keeping the generated columns out of responses ──────────────────────────\n\n/**\n * The generated column names a collection's search block adds, if any.\n *\n * These are physical columns on the table, so `SELECT *` returns them. They are\n * an index in column form — a list of lexeme positions, or a concatenation of\n * every searchable field on the row — and nothing outside the query planner has\n * any use for them. Left in, every list response carries a second, larger copy\n * of the row's text.\n */\nexport const searchColumnNames = (collection: CollectionConfig): string[] => {\n    let spec: SearchColumnSpec | undefined;\n    try {\n        spec = buildSearchColumnSpec(collection);\n    } catch {\n        // A malformed block is reported at boot, loudly. A read is the wrong\n        // place to raise it a second time, and returning the row without the\n        // exclusion would be worse than returning it with.\n        return [];\n    }\n    if (!spec) return [];\n    return spec.fuzzy ? [spec.column, spec.fuzzy.column] : [spec.column];\n};\n\n/**\n * True for a column whose type only ever holds a search index.\n *\n * Independent of any collection config on purpose: an introspected database\n * (BaaS mode) can carry a `tsvector` column this framework never created —\n * Pagila's `film.fulltext` is the canonical one — and it should not be returned\n * to callers either. `isDerivedIndexColumn` already keeps such a column out of\n * the *properties*; this keeps it out of the *rows*.\n */\nexport const isSearchIndexColumn = (column: { getSQLType?: () => string }): boolean => {\n    const sqlType = typeof column?.getSQLType === \"function\" ? column.getSQLType().toLowerCase() : \"\";\n    return sqlType === \"tsvector\" || sqlType === \"tsquery\";\n};\n\n/**\n * A drizzle select projection over `table` with the search columns dropped.\n *\n * Returns undefined when nothing needs dropping, so the common case keeps using\n * a plain `select()` and this stays invisible in the generated SQL.\n */\nexport const visibleColumnProjection = (\n    tableColumns: Record<string, { getSQLType?: () => string }> | undefined,\n    collection?: CollectionConfig\n): Record<string, unknown> | undefined => {\n    const excluded = excludedColumnNames(tableColumns, collection);\n    if (!tableColumns || excluded.length === 0) return undefined;\n    const projection: Record<string, unknown> = {};\n    for (const [name, column] of Object.entries(tableColumns)) {\n        if (!excluded.includes(name)) projection[name] = column;\n    }\n    return projection;\n};\n\n/** The same exclusion as a drizzle `db.query` `columns` denylist. */\nexport const hiddenColumnsOption = (\n    tableColumns: Record<string, { getSQLType?: () => string }> | undefined,\n    collection?: CollectionConfig\n): Record<string, false> | undefined => {\n    const excluded = excludedColumnNames(tableColumns, collection);\n    if (excluded.length === 0) return undefined;\n    return Object.fromEntries(excluded.map(name => [name, false as const]));\n};\n\n/**\n * The columns to keep out of a response, by name.\n *\n * `tableColumns` is whatever `getTableColumns` returned, which is `undefined`\n * for anything that is not a real drizzle table — a stub in a test, a derived\n * or nested path with no table behind it. Nothing to exclude is the right\n * answer there, and it has to be an answer rather than a throw: this runs on\n * the read path of every collection, opted in or not.\n */\nconst excludedColumnNames = (\n    tableColumns: Record<string, { getSQLType?: () => string }> | undefined,\n    collection?: CollectionConfig\n): string[] => {\n    if (!tableColumns || typeof tableColumns !== \"object\") return [];\n    const byName = new Set(collection ? searchColumnNames(collection) : []);\n    return Object.keys(tableColumns).filter(\n        name => byName.has(name) || isSearchIndexColumn(tableColumns[name])\n    );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,IAAM,gBAAgB;;;;;;AAOtB,IAAa,iBAAiB,GAAG,cAAc;AAC/C,IAAa,qBAAqB,GAAG,cAAc;;AAgEnD,IAAa,oBAAb,cAAuC,MAAM;CACzC,YAAY,SAAiB;EACzB,MAAM,OAAO;EACb,KAAK,OAAO;CAChB;AACJ;;AAGA,IAAa,mBAAmB,eAC5B,2BAA2B,UAAU,IAAI,WAAW,SAAS,KAAA;;;;;;;;;;;;AAajE,IAAa,8BAA8B,gBAA0C;CACjF,KAAK,MAAM,cAAc,aAAa;EAClC,IAAI,2BAA2B,UAAU,GAAG;EAC5C,IAAI,CAAE,WAAoC,QAAQ;EAClD,MAAM,SAAU,WAAmC,UAAU;EAC7D,MAAM,IAAI,kBACN,GAAG,WAAW,KAAK,sFAAsF,OAAO,sHAEpH;CACJ;AACJ;AAEA,IAAM,gBAAgB,UAAkB,SACpC,QAAQ,gBAAgB,QAAQ,OAAO,KAAK,eAAe,WAAW,KAAK,aAAa,YAAY,QAAQ;;;;;;;;;;;;AAahH,IAAM,YAAY,SAAgE;CAC9E,QAAQ,KAAK,MAAb;EACI,KAAK,UAAU;GACX,MAAM,KAAK;GACX,IAAI,GAAG,MACH,OAAO;IAAE,MAAM;IAAQ,QAAQ;GAAO;GAE1C,IAAI,GAAG,SAAS,UAAU,GAAG,eAAe,QACxC,OAAO;IAAE,MAAM;IAAQ,QAAQ;GAAO;GAE1C,OAAO,EAAE,MAAM,OAAO;EAC1B;EACA,KAAK;GAKD,IAAI,KAAG,eAAe,QAAQ,OAAO;IAAE,MAAM;IAAS,QAAQ;GAAO;GACrE,OAAO,EAAE,MAAM,QAAQ;EAE3B,KAAK,SAAS;GACV,MAAM,KAAK;GACX,IAAI,UAAU,GAAG;GACjB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,GAAG;IAC5C,MAAM,KAAK,GAAG;IACd,IAAI,GAAG,SAAS,UAAU,UAAU;SAC/B,IAAI,GAAG,SAAS,UAAU,UAAU,GAAG,YAAY,UAAU,cAAc;SAC3E,IAAI,GAAG,SAAS,WAAW,UAAU;GAC9C;GACA,IAAI,YAAY,UAAU,OAAO,EAAE,MAAM,aAAa;GACtD,IAAI,YAAY,QAAQ,OAAO;IAAE,MAAM;IAAS,QAAQ;GAAO;GAC/D,IAAI,YAAY,eAAe,YAAY,eAAe,YAAY,aAClE,OAAO;IAAE,MAAM;IAAc,QAAQ;GAAiB;GAG1D,OAAO,EAAE,MAAM,QAAQ;EAC3B;EACA,SACI,OAAO;CACf;AACJ;AAEA,IAAM,aAAa,OAAe,aAC9B,WAAW,GAAG,mBAAmB,GAAG,MAAM,KAAK;;AAGnD,IAAM,cAAc,UAA2E;CAC3F,MAAM,MAAM,IAAI,MAAM,OAAO;CAC7B,IAAI,MAAM,SAAS,QAAQ,OAAO,YAAY,IAAI;CAClD,IAAI,MAAM,SAAS,cAAc,OAAO,GAAG,eAAe,YAAY,IAAI;CAO1E,OAAO,GAAG,eAAe,YALV,MAAM,SAAS,WAAW,IACnC,MACA,MAAM,SAAS,WAAW,IACtB,GAAG,IAAI,MAAM,MAAM,MAAM,SAAS,EAAE,MACpC,GAAG,IAAI,MAAM,MAAM,IAAI,MAAM,SAAS,KAAK,GAAG,EAAE,EAAE,IAChB;AAChD;AAEA,IAAM,SAAS,MAAsB,IAAI,EAAE,QAAQ,MAAM,IAAI,EAAE;;;;;;;;;AAU/D,IAAM,gBACF,OACA,YACA,QACsB;CACtB,MAAM,OAAO,OAAO,UAAU,WAAW,QAAQ,MAAM;CACvD,MAAM,UAAU,OAAO,UAAU,WAAW,KAAA,IAAY,MAAM,WAAW;CACzE,MAAM,QAAQ,GAAG,WAAW,KAAK;CAEjC,IAAI,CAAC,QAAQ,OAAO,SAAS,UACzB,MAAM,IAAI,kBAAkB,GAAG,MAAM,mDAAmD;CAG5F,MAAM,CAAC,MAAM,GAAG,QAAQ,KAAK,MAAM,GAAG;CACtC,MAAM,OAAO,WAAW,aAAa;CACrC,IAAI,CAAC,MAED,MAAM,IAAI,kBACN,GAAG,MAAM,KAAK,KAAK,wBAAwB,KAAK,+DAFtC,OAAO,KAAK,WAAW,cAAc,CAAC,CAAC,CAAC,CAAC,KAAK,IAEuD,EAAM,EACzH;CAGJ,MAAM,aAAa,SAAS,IAAI;CAChC,IAAI,CAAC,YACD,MAAM,IAAI,kBACN,GAAG,MAAM,KAAK,KAAK,WAAW,KAAK,KAAK,8HAE5C;CAEJ,IAAI,WAAW,WAAW,QACtB,MAAM,IAAI,kBACN,GAAG,MAAM,KAAK,KAAK,sHACvB;CAEJ,IAAI,WAAW,WAAW,QACtB,MAAM,IAAI,kBACN,GAAG,MAAM,KAAK,KAAK,+DACvB;CAEJ,IAAI,WAAW,WAAW,QACtB,MAAM,IAAI,kBACN,GAAG,MAAM,KAAK,KAAK,sLACvB;CAEJ,IAAI,WAAW,WAAW,kBACtB,MAAM,IAAI,kBACN,GAAG,MAAM,KAAK,KAAK,gFACvB;CAGJ,IAAI,KAAK,SAAS,KAAK,WAAW,SAAS,SACvC,MAAM,IAAI,kBACN,GAAG,MAAM,KAAK,KAAK,6BAA6B,KAAK,UAAU,KAAK,WAAW,KAAK,KAAK,wEAC7F;CAGJ,MAAM,SAAS,aAAa,MAAM,IAAI;CAEtC,MAAM,MAAM,WAAW;EADP;EAAQ,UAAU;EAAM,MAAM,WAAW;CAClC,CAAK;CAC5B,MAAM,UAAU,UAAU,KAAK,IAAI,aAAa,IAAI;CACpD,MAAM,WAAW,IAAI,YAAY;CAEjC,OAAO;EACH;EACA;EACA,UAAU;EACV,MAAM,WAAW;EACjB;EACA,KAAK,yBAAyB,MAAM,QAAQ,EAAE,IAAI,QAAQ,KAAK,MAAM,MAAM,EAAE;EAC7E;EACA,eAAe,UAAU,KAAK,IAAI;CACtC;AACJ;;;;;;;;AASA,IAAa,yBAAyB,eAA+D;CACjG,MAAM,MAAM,gBAAgB,UAAU;CACtC,IAAI,CAAC,KAAK,OAAO,KAAA;CAEjB,IAAI,CAAC,MAAM,QAAQ,IAAI,MAAM,KAAK,IAAI,OAAO,WAAW,GACpD,MAAM,IAAI,kBACN,GAAG,WAAW,KAAK,gIACvB;CAGJ,MAAM,QAAQ,aAAa,UAAU;CACrC,MAAM,SAAS,2BAA2B,UAAU,KAAK,WAAW,SAAS,WAAW,SAAS;CACjG,MAAM,SAAS,IAAI,UAAU;CAE7B,IAAI,WAAW,aAAa,SACxB,MAAM,IAAI,kBACN,GAAG,WAAW,KAAK,iCAAiC,OAAO,+FAC/D;CAGJ,MAAM,SAAS,IAAI,OAAO,KAAI,UAAS,aAAa,OAAO,YAAY,GAAG,CAAC;CAE3E,MAAM,uBAAO,IAAI,IAAY;CAC7B,KAAK,MAAM,KAAK,QAAQ;EACpB,IAAI,KAAK,IAAI,EAAE,IAAI,GACf,MAAM,IAAI,kBAAkB,GAAG,WAAW,KAAK,YAAY,EAAE,KAAK,mBAAmB;EAEzF,KAAK,IAAI,EAAE,IAAI;CACnB;CAEA,MAAM,OAAO,IAAI,QAAQ;CAEzB,MAAM,aAAuB,CAAC;CAK9B,IAAI,IAAI,YAAY,SAAS,UAAU,WAAW,KAAK,UAAU;CACjE,IAAI,IAAI,OAAO,WAAW,KAAK,SAAS;CAExC,MAAM,OAAyB;EAC3B;EACA;EACA;EACA,UAAU,IAAI,YAAY;EAC1B,UAAU,IAAI,aAAa;EAC3B;EACA;EACA,YAAY,OAAO,KAAI,MAAK,EAAE,GAAG,CAAC,CAAC,KAAK,MAAM;EAC9C,WAAW,qBAAqB,GAAG,MAAM,GAAG,OAAO,KAAK;EACxD;CACJ;CAEA,IAAI,IAAI,OAAO;EACX,MAAM,cAAc,GAAG,OAAO;EAC9B,IAAI,WAAW,aAAa,cACxB,MAAM,IAAI,kBACN,GAAG,WAAW,KAAK,uCAAuC,YAAY,qFAC1E;EAEJ,KAAK,QAAQ;GACT,QAAQ;GAER,YAAY,OAAO,KAAI,MAAK,EAAE,OAAO,CAAC,CAAC,KAAK,aAAa;GACzD,WAAW,qBAAqB,GAAG,MAAM,GAAG,YAAY,MAAM;GAC9D,WAAW,IAAI,kBAAkB;EACrC;CACJ;CAEA,OAAO;AACX;;;;;;;;;;;;;AAcA,IAAa,yBAAyB,SAAqC;CACvE,MAAM,aAAuB,CAEzB,8BAA8B,eAAe,wHAM7C,8BAA8B,eAAe,2OAIjD;CACA,IAAI,KAAK,YAAY,KAAK,SAAS,UAI/B,WAAW,KACP,8BAA8B,mBAAmB,yFAEhC,cAAc,aAAa,cAAc,mCAC9D;CAEJ,OAAO;AACX;;;;;;;;;;;;AAaA,IAAa,6BAA6B,SACtC,KAAK,WAAW,KAAI,MAAK,kCAAkC,EAAE,eAAe,cAAc,EAAE;;;;;;;;;AAUhG,IAAa,uBAAuB,YAAoB,SACpD,GAAG,KAAK,wBAAwB,WAAW;;AAG/C,IAAa,0BAA0B,SACnC,IAAI,KAAK,OAAO,IAAI,oBAAoB,KAAK,YAAY,UAAU;;AAGvE,IAAa,yBAAyB,SAClC,KAAK,QAAQ,IAAI,KAAK,MAAM,OAAO,IAAI,oBAAoB,KAAK,MAAM,YAAY,MAAM,MAAM,KAAA;;;;;;;;;;AAWlG,IAAa,yBAAyB,SAAqC;CACvE,MAAM,aAAa,CACf,+BAA+B,KAAK,UAAU,QAAQ,KAAK,OAAO,KAAK,KAAK,MAAM,gBAAgB,KAAK,OAAO,IAClH;CACA,IAAI,KAAK,OACL,WAAW,KAIP,+BAA+B,KAAK,MAAM,UAAU,QAAQ,KAAK,OAAO,KAAK,KAAK,MAAM,gBAAgB,KAAK,MAAM,OAAO,IAAI,cAAc,gBAChJ;CAEJ,OAAO;AACX;;;;;;;;AAWA,IAAa,sBAAsB;;;;;;;;;;;;AAanC,IAAa,+BAA+B,eACxC,GAAG,sBAAsB,WAAW,QAAQ,CAAC,CAAC,OAAO,UAAU,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;;;;;;;;;AAoB9F,IAAa,sBAAsB,SAAgD;CAC/E,MAAM,SAAS,QAAgB,eAA0C;EACrE,MAAM,cAAc,4BAA4B,UAAU;EAC1D,OAAO;GACH;GACA;GACA;GACA,KAAK,sBAAsB,KAAK,OAAO,KAAK,KAAK,MAAM,KAAK,OAAO,OAAO,MAAM,WAAW,EAAE;EACjG;CACJ;CACA,MAAM,SAAS,CAAC,MAAM,KAAK,QAAQ,KAAK,UAAU,CAAC;CACnD,IAAI,KAAK,OAAO,OAAO,KAAK,MAAM,KAAK,MAAM,QAAQ,KAAK,MAAM,UAAU,CAAC;CAC3E,OAAO;AACX;;;;;;;;;;;AAYA,IAAa,qBAAqB,SAC9B,mBAAmB,IAAI,CAAC,CAAC,KAAI,UAAS;CAClC,MAAM,WAAW,MAAM,IAAI,KAAK,OAAO,KAAK,KAAK,MAAM,EAAE;CACzD,OAAO;;;;;yBAKU,SAAS,6BAA6B,MAAM,MAAM,MAAM,EAAE;uBAC5D,MAAM,GAAG,oBAAoB,EAAE,EAAE,mBAAmB,MAAM,MAAM,WAAW,EAAE;wDAC5C,KAAK,OAAO,GAAG,KAAK,MAAM,uCAAuC,MAAM,OAAO,oCAAoC,MAAM,YAAY,+JAA+J,SAAS,MAAM,GAAG,EAAE,EAAE,gBAAgB,MAAM,OAAO;;;;AAI1Y,CAAC;;;;;;;AAQL,IAAa,oBAAoB,SAC7B,KAAK,QAAQ,CAAC,KAAK,WAAW,KAAK,MAAM,SAAS,IAAI,CAAC,KAAK,SAAS;;;;;;;;;;AAazE,IAAa,qBAAqB,eAA2C;CACzE,IAAI;CACJ,IAAI;EACA,OAAO,sBAAsB,UAAU;CAC3C,QAAQ;EAIJ,OAAO,CAAC;CACZ;CACA,IAAI,CAAC,MAAM,OAAO,CAAC;CACnB,OAAO,KAAK,QAAQ,CAAC,KAAK,QAAQ,KAAK,MAAM,MAAM,IAAI,CAAC,KAAK,MAAM;AACvE;;;;;;;;;;AAWA,IAAa,uBAAuB,WAAmD;CACnF,MAAM,UAAU,OAAO,QAAQ,eAAe,aAAa,OAAO,WAAW,CAAC,CAAC,YAAY,IAAI;CAC/F,OAAO,YAAY,cAAc,YAAY;AACjD;;;;;;;AAQA,IAAa,2BACT,cACA,eACsC;CACtC,MAAM,WAAW,oBAAoB,cAAc,UAAU;CAC7D,IAAI,CAAC,gBAAgB,SAAS,WAAW,GAAG,OAAO,KAAA;CACnD,MAAM,aAAsC,CAAC;CAC7C,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,YAAY,GACpD,IAAI,CAAC,SAAS,SAAS,IAAI,GAAG,WAAW,QAAQ;CAErD,OAAO;AACX;;AAGA,IAAa,uBACT,cACA,eACoC;CACpC,MAAM,WAAW,oBAAoB,cAAc,UAAU;CAC7D,IAAI,SAAS,WAAW,GAAG,OAAO,KAAA;CAClC,OAAO,OAAO,YAAY,SAAS,KAAI,SAAQ,CAAC,MAAM,KAAc,CAAC,CAAC;AAC1E;;;;;;;;;;AAWA,IAAM,uBACF,cACA,eACW;CACX,IAAI,CAAC,gBAAgB,OAAO,iBAAiB,UAAU,OAAO,CAAC;CAC/D,MAAM,SAAS,IAAI,IAAI,aAAa,kBAAkB,UAAU,IAAI,CAAC,CAAC;CACtE,OAAO,OAAO,KAAK,YAAY,CAAC,CAAC,QAC7B,SAAQ,OAAO,IAAI,IAAI,KAAK,oBAAoB,aAAa,KAAK,CACtE;AACJ"}

package/dist/security/policy-drift.d.ts

@@ -10,7 +10,7 @@
  * table is indistinguishable from a table with no data.
  *
  * Expected policies are parsed from `generatePostgresPoliciesDdl`, the same
- * function `db push` uses to write `drizzle/policies.sql`, so this compares
+ * function `db push` uses to write `.rebase/sql/policies.sql`, so this compares
  * against exactly what would be applied rather than a reimplementation.
  */
 import { type CollectionConfig } from "@rebasepro/types";

package/dist/security/rls-enforcement.d.ts

@@ -115,6 +115,13 @@ export interface AuthContext {
      */
     claims?: Record<string, unknown>;
 }
+/**
+ * Take every privilege the user role holds on one table back — what a table
+ * gets when RLS cannot be switched on for it, so it is unreachable rather than
+ * unprotected. Quoted exactly: a mixed-case adopted table (`"User"`) folded to
+ * lower case names a table that does not exist.
+ */
+export declare const revokeUserRoleSql: (schema: string, table: string) => string;
 /**
  * Warn when the connection role shares its name with an existing schema.
  *