@rebasepro/server-postgres 0.22.0 → 0.24.0

package/dist/schema/plan/diff-plan.d.ts

@@ -102,7 +102,7 @@ export interface DiffOptions {
     constraints?: ConstraintPolicy;
 }
 export interface EnsureAction {
-    kind: "create-enum" | "create-table" | "add-column" | "add-constraint" | "rename-column" | "create-extension" | "create-function" | "create-index" | "comment-column" | "add-enum-value" | "set-not-null" | "drop-not-null" | "set-default" | "create-trigger";
+    kind: "create-enum" | "create-table" | "enable-rls" | "add-column" | "add-constraint" | "rename-column" | "create-extension" | "create-function" | "create-index" | "comment-column" | "add-enum-value" | "set-not-null" | "drop-not-null" | "set-default" | "create-trigger";
     /** Qualified target, for logging: `public.posts` or `public.posts.title`. */
     target: string;
     sql: string;
@@ -120,11 +120,12 @@ export interface OrphanedRequiredColumn {
 export interface WithheldConstraint {
     /** `schema.table.column`. */
     target: string;
-    kind: "not-null";
+    kind: "not-null" | "unique";
     /**
      * Why, in a sentence that names the obstacle rather than the rule. The
      * reader is looking at a column that is nullable when they asked for
-     * required, and needs to know what to do about it.
+     * required, or accepts duplicates when they asked for unique, and needs to
+     * know what to do about it.
      */
     reason: string;
     /** What would make it applicable. */

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

@@ -12,7 +12,7 @@
  * imported would not be comparable with itself.
  *
  * It **throws** rather than guessing. A configuration no renderer can honour —
- * an empty enum, two `isId` properties, `isId: "cuid"`, an unknown
+ * an empty enum, `isId: "cuid"`, a foreign key into a composite key, an unknown
  * `columnType`, a relation to a collection that is not in the bundle, a
  * `search` block on a collection Postgres does not store — used to fail
  * differently in each of the three emitters, or not at all, and the failure
@@ -55,11 +55,27 @@ export declare const defaultBelongsToOnDelete: (required: boolean | undefined) =
  * The type a column pointing at this collection's primary key must have — a
  * junction endpoint, a `belongsTo` foreign key, a `reference`.
  *
- * One function because it was three: the ladder was spelled inline in
- * `generatePostgresDdl`, again in `planJunctionTables` and a third time in the
- * Drizzle generator.
+ * The key's own column type, from the same functions that typed the key: a
+ * foreign key only holds between compatible types, so any second reading of
+ * the key is a constraint waiting to fail. This used to look at the id
+ * strategy alone, so `id: { isId: true, columnType: "uuid" }` was referenced by
+ * TEXT columns (42804 — the constraint was never created) and a `bigint` key by
+ * INTEGER ones, which overflow at 2^31.
+ *
+ * One exception: a `serial` key owns a sequence, and a column pointing at it is
+ * the plain integer of the same width — `SERIAL` there would give every
+ * referencing column a sequence of its own.
+ *
+ * @param via the link asking, named if the collection's key is composite and so
+ *   cannot be pointed at — see `getPrimaryKeyProp`.
+ */
+export declare const primaryKeyPgType: (collection: CollectionConfig, via: string) => PgType;
+/**
+ * The DEFAULT of the implicit `id TEXT PRIMARY KEY` a collection that declares
+ * no key gets: a uuid, as text. The same generator `isId: "uuid"` uses, cast to
+ * the column the key has always been.
  */
-export declare const primaryKeyPgType: (collection: CollectionConfig) => PgType;
+export declare const IMPLICIT_ID_DEFAULT = "gen_random_uuid()::text";
 /**
  * The Postgres type a property's column has.
  *
@@ -72,12 +88,11 @@ export declare const columnPgType: (propName: string, prop: Property, collection
 /**
  * One security rule, compiled to the clauses a policy is made of.
  *
- * The desugaring (`access` / `ownerField` / `roles` / structured condition /
- * raw SQL → `PolicyExpression`) and the SQL compilation are `@rebasepro/common`'s,
- * which is what the client-side evaluator uses too — so the UI, the DDL and the
- * database agree about who can read a row. What lives here is only the shape:
- * which operations a rule expands to, which clauses each operation takes, and
- * the deny-all fallback for a clause that compiled to nothing.
+ * The compilation is `compileRulePolicies` in `@rebasepro/common`, which the
+ * Studio's RLS editor also compares the live database against — so the UI, the
+ * DDL and the database agree about who can read a row. What this adds is only
+ * the planner's bookkeeping: which rule a policy came from, and whether Rebase
+ * injected it.
  */
 export declare const compileSecurityRule: (collection: CollectionConfig, rule: SecurityRule, resolveCollection: ResolveCollection, injected: boolean, ruleKey?: string) => PolicyPlan[];
 export declare function planSchema(allCollections: CollectionConfig[], options?: PlanOptions): SchemaPlan;

package/dist/schema/plan/render-ddl.d.ts

@@ -25,6 +25,12 @@ export declare const renderPgType: (type: PgType) => string;
  * DEFAULT, which is why it is rendered here and not in the DEFAULT slot.
  */
 export declare const renderColumnDefinition: (column: ColumnPlan) => string;
+/**
+ * `PRIMARY KEY ("a", "b")`, the clause a composite key takes inside a
+ * `CREATE TABLE`. Shared by `schema.sql` and boot-ensure's `CREATE TABLE`, so
+ * the two cannot list the columns differently.
+ */
+export declare const renderPrimaryKeyConstraint: (table: Pick<TablePlan, "primaryKey">) => string;
 /**
  * One policy as its `DROP` / `CREATE` pair — each a complete statement.
  *

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;
@@ -288,7 +295,12 @@ export interface EnumPlan {
     schema: string;
     /** Type name, unqualified: `<table>_<column>`. A frozen derived name. */
     name: string;
-    /** `schema.name` — the key `readExistingSchema` returns. */
+    /**
+     * `schema.name`, with the name cut to the 63 bytes Postgres keeps — the key
+     * `readExistingSchema` returns. `name` itself is emitted in full, and
+     * Postgres truncates it the same way; comparing the full name against the
+     * catalogue found a long one missing on every boot.
+     */
     qualified: string;
     /**
      * The schema the collection *declared*, before the `public` fallback.
@@ -321,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[];
@@ -350,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 {
     /**
@@ -408,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