@rebasepro/server-postgres 0.13.1-canary.g18cfeb7 → 0.13.1-canary.g249daa1

package/src/cli.ts

@@ -12,6 +12,10 @@ import {
     getTableIncludes,
     getDevDatabaseUrl,
     ensureDevDatabaseExists,
+    applySearchDdl,
+    getSearchExcludes,
+    readSearchDdl,
+    seedDevDatabaseSearchHelpers,
     getTableExcludes,
     ExcludeIntrospectionError,
     promptConfirm
@@ -70,6 +74,13 @@ export async function runPluginCommand(args: string[]) {
     }
 }
 
+/** The migration files on disk, sorted, or none if the directory is absent. */
+function listMigrationFiles(): string[] {
+    const dir = path.resolve(process.cwd(), "drizzle", "migrations");
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir).filter(f => f.endsWith(".sql")).sort();
+}
+
 async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
     const VALID_ACTIONS = ["push", "generate", "migrate", "branch", "backup", "restore", "backups"];
     if (!subcommand || !VALID_ACTIONS.includes(subcommand)) {
@@ -116,7 +127,9 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
         logger.info(chalk.gray("  Step 2/2: Generating SQL migration files with Atlas..."));
         logger.info("");
         const migrationName = argsList._[0] || "migration";
+        const migrationsBefore = listMigrationFiles();
         await runAtlas("migrate", ["diff", migrationName, "--dir", "file://drizzle/migrations", "--to", "file://drizzle/schema.sql"], collectionsPath);
+        const wroteNewMigration = listMigrationFiles().length > migrationsBefore.length;
         
         // Post-process the newest migration file
         try {
@@ -137,6 +150,33 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
                         /CREATE SCHEMA (?!IF NOT EXISTS)("[^"]+");/g,
                         "CREATE SCHEMA IF NOT EXISTS $1;"
                     );
+                    // Atlas never writes the search objects into a migration —
+                    // it is not shown them — so a migration replayed against a
+                    // fresh database would build every table except the part
+                    // that makes search work. Appending, because these are
+                    // `ALTER TABLE ... ADD COLUMN` over the tables the
+                    // migration just created.
+                    //
+                    // Only into a migration Atlas just wrote. The file picked
+                    // here is simply the newest one, which when there was no
+                    // diff is a migration that has already run in production:
+                    // editing it changes a hash Atlas has recorded, and the
+                    // appended SQL would never be applied anywhere.
+                    const searchContent = readSearchDdl();
+                    if (searchContent && wroteNewMigration) {
+                        migrationContent = `${migrationContent}\n\n${searchContent}`;
+                        logger.info(chalk.gray("  ✓ Appended search DDL to the migration"));
+                    } else if (searchContent) {
+                        // Reachable whenever a `search` block is the *only*
+                        // thing that changed: Atlas cannot see one, so it finds
+                        // nothing to diff and writes no file.
+                        logger.info(chalk.gray(
+                            "  ℹ Search DDL not written to a migration — this change produced none.\n" +
+                            "    It is applied by `rebase db push`, and at boot by the schema ensure.\n" +
+                            "    For a migration-only deployment, add drizzle/search.sql to a migration by hand."
+                        ));
+                    }
+
                     fs.writeFileSync(newestMigrationFile, migrationContent, "utf-8");
 
                     // Append RLS policies, preceded by the RLS bootstrap so the
@@ -234,6 +274,10 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
             
             if (databaseUrl) {
                 await ensureAuthTables(databaseUrl, collectionsPath);
+                // After the tables exist and before the policies: the search
+                // column is `ALTER TABLE ... ADD COLUMN`, and a policy may
+                // reference the table it is added to.
+                await applySearchDdl(databaseUrl);
                 await applyPolicies(databaseUrl);
                 await reconcilePolicies(databaseUrl, collectionsPath);
                 await ensureRlsUserRole(databaseUrl);
@@ -759,6 +803,9 @@ async function runAtlas(
 
     const devDatabaseUrl = getDevDatabaseUrl(databaseUrl);
     await ensureDevDatabaseExists(databaseUrl, devDatabaseUrl);
+    if (collectionsPath) {
+        await seedDevDatabaseSearchHelpers(devDatabaseUrl, collectionsPath);
+    }
 
     // Atlas speaks libpq, which rejects the `sslmode=no-verify` that
     // node-postgres accepts — see `forLibpq`. Rewritten only for the argv, so
@@ -785,6 +832,16 @@ async function runAtlas(
         }
     }
 
+    // Search objects are Rebase's, not Atlas's — on both paths. `schema apply`
+    // would drop them as absent from the desired state; `migrate diff` would
+    // write that same drop into the next migration file, where it would sit
+    // waiting to be applied later.
+    if (collectionsPath && (args.includes("apply") || args.includes("diff"))) {
+        for (const exc of await getSearchExcludes(collectionsPath)) {
+            atlasArgs.push("--exclude", exc);
+        }
+    }
+
     if (domain === "schema" && args.includes("apply") && collectionsPath) {
         // Fail CLOSED: the exclude list is the only thing shielding
         // non-collection tables from the auto-approved apply. If we can't

package/src/data-transformer.ts

@@ -685,6 +685,15 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
  *                       from the result (used by `normalizeDbValues` where
  *                       Drizzle's relational API already hydrates them).
  */
+/**
+ * Keys a query computes and attaches to a row, rather than reads from a column.
+ *
+ * An explicit set rather than a `_` prefix rule: a user's column may perfectly
+ * well be called `_internal`, and passing it through here would put a value on
+ * the row that no property describes and nothing downstream knows how to type.
+ */
+const QUERY_METADATA_KEYS = new Set(["_score", "_distance", "_matches"]);
+
 function normalizeScalarValues<M extends Record<string, unknown>>(
     data: M,
     properties: Properties,
@@ -709,6 +718,15 @@ function normalizeScalarValues<M extends Record<string, unknown>>(
             continue;
         }
 
+        // Query-computed metadata, which by definition is not a column and so
+        // has no property to be found. Dropped here until now — which meant
+        // `_distance` was computed for every vector search on this path and
+        // then discarded before the caller ever saw it.
+        if (QUERY_METADATA_KEYS.has(key)) {
+            result[key] = value;
+            continue;
+        }
+
         const property = properties[key as keyof M] as Property;
         if (!property) continue; // Skip DB columns not defined in properties
 

package/src/schema/ensure-collection-tables.ts

@@ -28,6 +28,16 @@
 import { type CollectionConfig, type Property, isPostgresCollectionConfig } from "@rebasepro/types";
 import { getTableName, relationalCollections } from "@rebasepro/common";
 import { logger } from "@rebasepro/server";
+import {
+    assertSearchIsPostgresOnly,
+    buildSearchColumnSpec,
+    searchExtensionStatements,
+    searchHelperFunctions,
+    searchIndexStatements,
+    SEARCH_TEXT_FN,
+    SEARCH_UNACCENT_FN,
+    type SearchColumnSpec
+} from "./search-column";
 import {
     getSqlColumnType,
     resolveColumnName,
@@ -83,7 +93,8 @@ export interface ExistingSchema {
 }
 
 export interface EnsureAction {
-    kind: "create-enum" | "create-table" | "add-column" | "add-constraint" | "rename-column";
+    kind: "create-enum" | "create-table" | "add-column" | "add-constraint" | "rename-column"
+        | "create-extension" | "create-function" | "create-index";
     /** Qualified target, for logging: `public.posts` or `public.posts.title`. */
     target: string;
     sql: string;
@@ -181,6 +192,10 @@ export function planCollectionSchemaEnsure(
     // Firestore collection is not a harmless extra: the app keeps reading
     // documents from Firestore while an empty table with the same name accretes
     // policies and shows up in every drift report.
+    // Before the filter, deliberately: a `search` block on a collection this
+    // engine does not store would otherwise be dropped here without a word.
+    assertSearchIsPostgresOnly(allCollections);
+
     const collections = relationalCollections(allCollections);
     const actions: EnsureAction[] = [];
     const plannedEnums = new Set<string>();
@@ -200,6 +215,34 @@ export function planCollectionSchemaEnsure(
         }
     }
 
+    // 1b. Search support, for collections that declared a `search` block.
+    //
+    //     Before the tables, because a generated column's expression is
+    //     resolved when the column is created: a table whose search column
+    //     calls `rebase_search_text` cannot be added before that function
+    //     exists. Both forms are idempotent, so a boot against a database that
+    //     already has them plans nothing.
+    const searchSpecs = collections
+        .map(c => buildSearchColumnSpec(c))
+        .filter((spec): spec is SearchColumnSpec => spec !== undefined);
+
+    const plannedExtensions = new Set<string>();
+    for (const spec of searchSpecs) {
+        for (const statement of searchExtensionStatements(spec)) {
+            if (plannedExtensions.has(statement)) continue;
+            plannedExtensions.add(statement);
+            actions.push({ kind: "create-extension", target: statement.replace(/^CREATE EXTENSION IF NOT EXISTS |;$/g, ""), sql: statement });
+        }
+    }
+    const plannedFunctions = new Set<string>();
+    for (const spec of searchSpecs) {
+        for (const statement of searchHelperFunctions(spec)) {
+            if (plannedFunctions.has(statement)) continue;
+            plannedFunctions.add(statement);
+            actions.push({ kind: "create-function", target: statement.includes("unaccent") ? SEARCH_UNACCENT_FN : SEARCH_TEXT_FN, sql: statement });
+        }
+    }
+
     // 2. Missing tables. Only the identity column is created here; every other
     //    column is added by step 3, so a new table and an existing table that
     //    gained a field travel the exact same code path. One way to build a
@@ -375,6 +418,22 @@ export function planCollectionSchemaEnsure(
         }
     }
 
+    // 3aa. The generated search columns.
+    //
+    //      Adding a STORED generated column rewrites the table, which on a large
+    //      one is not free — but it is the same additive shape as every other
+    //      column here, and the alternative (leaving it out until someone runs a
+    //      migration) is a declared `search` block that silently does nothing.
+    for (const spec of searchSpecs) {
+        const key = `${spec.schema}.${spec.table}`;
+        addColumn(key, spec.schema, spec.table, spec.column,
+            `tsvector GENERATED ALWAYS AS (${spec.expression}) STORED`);
+        if (spec.fuzzy) {
+            addColumn(key, spec.schema, spec.table, spec.fuzzy.column,
+                `text GENERATED ALWAYS AS (${spec.fuzzy.expression}) STORED`);
+        }
+    }
+
     // 3b. A junction that already existed, but is short a column. One created
     //     above already carries both — unlike a collection table, whose CREATE
     //     declares only the identity column — so re-listing them would log two
@@ -422,6 +481,23 @@ export function planCollectionSchemaEnsure(
         });
     }
 
+    // 5. Search indexes, after everything — the column has to exist, and this is
+    //    the one step that runs against a populated table for real work.
+    //
+    //    CONCURRENTLY: a plain CREATE INDEX takes a lock that blocks writes for
+    //    the duration of the build, which on a live table is an outage. Each
+    //    statement here is issued on its own, outside any transaction, which is
+    //    the condition CONCURRENTLY requires.
+    for (const spec of searchSpecs) {
+        for (const statement of searchIndexStatements(spec)) {
+            actions.push({
+                kind: "create-index",
+                target: `${spec.schema}.${spec.table}`,
+                sql: statement.replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS")
+            });
+        }
+    }
+
     return { actions, statements: actions.map(a => a.sql), legacyForeignKeys };
 }
 

package/src/schema/generate-drizzle-schema-logic.ts

@@ -1,5 +1,6 @@
 import { CollectionConfig, NumberProperty, Property, ResolvedRelation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty, isManyToMany, type ResolvedManyToMany, type ResolvedBelongsTo, type ResolvedForeignKeyOnTarget, hasForeignKeyOnTarget } from "@rebasepro/types";
 import { getPrimaryKeys } from "../services/collection-helpers";
+import { buildSearchColumnSpec } from "./search-column";
 import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength, relationalCollections } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 import { logger } from "@rebasepro/server";
@@ -479,11 +480,15 @@ export const generateSchema = async (allCollections: CollectionConfig[], stripPo
         )
     );
 
+    // drizzle ships no `tsvector` builder, so an opted-in search column reaches
+    // the schema the same way `bytea` does — through `customType`.
+    const hasSearch = collections.some(c => buildSearchColumnSpec(c) !== undefined);
+
     // Always import pgPolicy and sql — RLS is enabled on every table (secure by default)
     const pgCoreImports = ["primaryKey", "pgTable", "integer", "varchar", "text", "char", "boolean", "timestamp", "date", "time", "jsonb", "json", "pgEnum", "numeric", "real", "doublePrecision", "bigint", "serial", "bigserial", "pgPolicy"];
     if (hasUuid) pgCoreImports.push("uuid");
     if (hasVector) pgCoreImports.push("vector");
-    if (hasBinary) pgCoreImports.push("customType");
+    if (hasBinary || hasSearch) pgCoreImports.push("customType");
 
     const uniqueSchemas = Array.from(new Set(
         collections.map(c => isPostgresCollectionConfig(c) ? c.schema : undefined).filter(Boolean)
@@ -632,6 +637,25 @@ export const generateSchema = async (allCollections: CollectionConfig[], stripPo
 
             });
 
+            // The opt-in search column. Declared with its real generation
+            // expression rather than as a bare custom type: `schema.generated.ts`
+            // is what a developer running drizzle-kit themselves diffs against,
+            // and a column declared without its expression reads to drizzle-kit
+            // as one it should alter.
+            const searchSpec = buildSearchColumnSpec(collection);
+            if (searchSpec) {
+                columns.add(
+                    `    ${searchSpec.column}: customType({ dataType() { return 'tsvector'; } })("${searchSpec.column}")` +
+                    `.generatedAlwaysAs(sql\`${searchSpec.expression}\`)`
+                );
+                if (searchSpec.fuzzy) {
+                    columns.add(
+                        `    ${searchSpec.fuzzy.column}: text("${searchSpec.fuzzy.column}")` +
+                        `.generatedAlwaysAs(sql\`${searchSpec.fuzzy.expression}\`)`
+                    );
+                }
+            }
+
             // Backwards compatibility: if no id/primary key column is found in properties, but `id` wasn't explicitly provided
             // We should generate a basic id column if one was completely omitted.
             const hasIdColumn = Array.from(columns).some(col => col.includes(".primaryKey()"));

package/src/schema/generate-postgres-ddl-logic.ts

@@ -1,7 +1,18 @@
 import { CollectionConfig, NumberProperty, Property, ResolvedRelation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty, isManyToMany, type ResolvedManyToMany, type ResolvedBelongsTo } from "@rebasepro/types";
 import { getEnumVarName, getTableName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, getInjectedSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength, relationalCollections } from "@rebasepro/common";
-import { toSnakeCase, getPolicyNamesForRule, generateForeignKeyName, legacyForeignKeyName } from "@rebasepro/utils";
+import { toSnakeCase, getPolicyNamesForRule, generateForeignKeyName, legacyForeignKeyName, toPostgresIdentifier } from "@rebasepro/utils";
 import { AUTH_USERS_COLUMNS, authUsersColumnDefinition, authUsersColumnSql, isAuthCollection } from "./auth-users-columns";
+import {
+    buildSearchColumnSpec,
+    searchColumnDefinition,
+    fuzzyColumnDefinition,
+    searchIndexStatements,
+    searchHelperFunctions,
+    searchExtensionStatements,
+    searchColumnNames,
+    searchIndexNames,
+    type SearchColumnSpec
+} from "./search-column";
 import { REBASE_SCHEMA } from "@rebasepro/types";
 
 // --- Helper Functions ---
@@ -237,9 +248,122 @@ export const getSqlColumnType = (propName: string, prop: Property, collection: C
     }
 };
 
+/**
+ * Everything a `search` block needs, as a file Rebase applies itself.
+ *
+ * Search is the one part of the schema Atlas does not own. Two independent
+ * reasons, and either alone would be enough:
+ *
+ * 1. Its free tier refuses to *parse* a desired-state file that so much as
+ *    contains a function — "functions and procedures are available to
+ *    logged-in users only". A generated `tsvector` column cannot avoid one:
+ *    `unaccent` is STABLE and jsonb flattening needs a set-returning function,
+ *    so both have to be wrapped in an IMMUTABLE helper to be legal in a
+ *    generated column at all.
+ * 2. Even with the file accepted, Atlas *wipes* the dev database it diffs
+ *    against, so a helper seeded there beforehand is gone by the time the plan
+ *    is analysed. There is no hook to reinstate it.
+ *
+ * So the column, its index and its helpers are excluded from Atlas's view
+ * (`searchExcludePatterns`) and applied from here — the same arrangement the
+ * RLS policies already use, and for the same underlying reason.
+ *
+ * Ordered as it must run: extensions, then helpers, then the column whose
+ * expression calls them, then the index over that column. Every statement is
+ * `IF NOT EXISTS` / `OR REPLACE`, because this is replayed on every push and
+ * appended to migrations that run against databases at any stage of their
+ * life. Empty when nothing opted in — the caller writes no file then.
+ *
+ * The leading half — extensions and helpers, without the table-shaped
+ * statements — is available on its own as {@link searchPrerequisiteStatements},
+ * for the dev database Atlas analyses plans against. That database has none of
+ * the project's tables, so it wants the functions and nothing else.
+ */
+export const searchPrerequisiteStatements = (allCollections: CollectionConfig[]): string[] => {
+    const specs = relationalCollections(allCollections)
+        .map(c => buildSearchColumnSpec(c))
+        .filter((s): s is SearchColumnSpec => s !== undefined);
+    if (specs.length === 0) return [];
+    return [
+        ...new Set(specs.flatMap(searchExtensionStatements)),
+        ...new Set(specs.flatMap(searchHelperFunctions))
+    ];
+};
+
+export const generatePostgresSearchDdl = (allCollections: CollectionConfig[]): string => {
+    const collections = relationalCollections(allCollections);
+    const specs = collections
+        .map(c => buildSearchColumnSpec(c))
+        .filter((s): s is SearchColumnSpec => s !== undefined);
+    if (specs.length === 0) return "";
+
+    const extensions = Array.from(new Set(specs.flatMap(searchExtensionStatements)));
+    const helpers = Array.from(new Set(specs.flatMap(searchHelperFunctions)));
+
+    let ddl = "-- This file is auto-generated by the Rebase DDL generator. Do not edit manually.\n";
+    ddl += "--\n";
+    ddl += "-- Full-text search for the collections declaring a `search` block.\n";
+    ddl += "-- Applied by Rebase, not by Atlas — see generatePostgresSearchDdl.\n\n";
+
+    extensions.forEach(s => { ddl += `${s}\n`; });
+    if (extensions.length > 0) ddl += "\n";
+    helpers.forEach(s => { ddl += `${s}\n\n`; });
+
+    for (const collection of collections) {
+        const spec = buildSearchColumnSpec(collection);
+        if (!spec) continue;
+        const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
+        const table = `"${schema}"."${getTableName(collection)}"`;
+
+        // ADD COLUMN IF NOT EXISTS rather than the inline definition the
+        // CREATE TABLE would use: by the time this runs the table exists,
+        // whether Atlas just created it or it has been live for a year.
+        ddl += `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${searchColumnDefinition(spec)};\n`;
+        const fuzzyDef = fuzzyColumnDefinition(spec);
+        if (fuzzyDef) ddl += `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${fuzzyDef};\n`;
+        searchIndexStatements(spec).forEach(s => { ddl += `${s}\n`; });
+        ddl += "\n";
+    }
+
+    return ddl;
+};
+
+/**
+ * Glob patterns telling Atlas to leave the search column and its index alone.
+ *
+ * Without these, a desired state that omits search reads to Atlas as an
+ * instruction to drop the column — taking the index and the whole search
+ * feature with it on the next push.
+ *
+ * Fully qualified, `schema.table.object`, matching the include list. The
+ * two-part form is what Atlas wants when the connection URL scopes it to one
+ * schema and is *silently ignored* otherwise: it reads `posts.search_vector`
+ * as a table named `search_vector` in a schema named `posts`, matches nothing,
+ * and reports no error for the pattern that never fired.
+ */
+export const searchExcludePatterns = (allCollections: CollectionConfig[]): string[] => {
+    const patterns: string[] = [];
+    for (const collection of relationalCollections(allCollections)) {
+        const spec = buildSearchColumnSpec(collection);
+        if (!spec) continue;
+        const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
+        const table = getTableName(collection);
+        for (const name of searchColumnNames(collection)) {
+            patterns.push(`${schema}.${table}.${name}`);
+        }
+        for (const index of searchIndexNames(spec)) {
+            patterns.push(`${schema}.${table}.${index}`);
+        }
+    }
+    return patterns;
+};
+
 export const generatePostgresDdl = async (
     allCollections: CollectionConfig[],
-    options: { includePolicies?: boolean } = { includePolicies: true }
+    options: { includePolicies?: boolean; includeSearch?: boolean } = {
+        includePolicies: true,
+        includeSearch: true
+    }
 ): Promise<string> => {
     // Only the collections this engine stores. See `relationalCollections`.
     const collections = relationalCollections(allCollections);
@@ -263,6 +387,32 @@ export const generatePostgresDdl = async (
     });
     if (uniqueSchemas.length > 0) ddl += "\n";
 
+    // 1b. Search support, for collections that opted in.
+    //
+    // Extensions and helper functions come before every CREATE TABLE because a
+    // generated column's expression is resolved at creation time: a table whose
+    // search column calls `rebase_search_text` cannot be created before that
+    // function exists. Both are `IF NOT EXISTS` / `OR REPLACE`, so a file
+    // replayed against a live database is a no-op here.
+    const searchSpecs = collections
+        .map(c => buildSearchColumnSpec(c))
+        .filter((s): s is SearchColumnSpec => s !== undefined);
+
+    if (searchSpecs.length > 0) {
+        if (options.includeSearch === false) {
+            // Everything search-related lives in `search.sql` — see
+            // `generatePostgresSearchDdl` for why Atlas is not shown any of it.
+            ddl += "-- Full-text search support lives in `search.sql`, applied separately.\n\n";
+        } else {
+            const extensions = Array.from(new Set(searchSpecs.flatMap(searchExtensionStatements)));
+            const helpers = Array.from(new Set(searchSpecs.flatMap(searchHelperFunctions)));
+            ddl += "-- Full-text search support (collections declaring a `search` block)\n";
+            extensions.forEach(s => { ddl += `${s}\n`; });
+            if (extensions.length > 0) ddl += "\n";
+            helpers.forEach(s => { ddl += `${s}\n\n`; });
+        }
+    }
+
     // 2. Generate Enums
     //
     // The enum type name is derived from table + column, so two collections
@@ -330,6 +480,9 @@ export const generatePostgresDdl = async (
 
     // 3. Generate tables
     const fkStatements: string[] = [];
+    // Indexes follow the tables for the same reason the FK constraints do: the
+    // table has to exist first.
+    const indexStatements: string[] = [];
     // Policies are emitted after every CREATE TABLE, like the FK constraints:
     // a policy may reference other tables (a junction's derived policies always
     // reference both endpoints; `policy.existsIn` references a join table), and
@@ -526,6 +679,19 @@ export const generatePostgresDdl = async (
                 }
             }
 
+            // ── The opt-in search column ─────────────────────────────────────
+            // Last, so it reads as what it is: derived from the columns above
+            // it. Postgres recomputes it on every write of a source column and
+            // rejects any attempt to write it directly, which is the property
+            // that makes it impossible for the index to drift from the row.
+            const searchSpec = options.includeSearch === false ? undefined : buildSearchColumnSpec(collection);
+            if (searchSpec) {
+                columns.push(`  ${searchColumnDefinition(searchSpec)}`);
+                const fuzzyDef = fuzzyColumnDefinition(searchSpec);
+                if (fuzzyDef) columns.push(`  ${fuzzyDef}`);
+                indexStatements.push(...searchIndexStatements(searchSpec));
+            }
+
             // Backwards compatibility: add default id primary key if missing
             const hasPk = columns.some(c => c.includes("PRIMARY KEY"));
             if (!hasPk) {
@@ -559,6 +725,11 @@ export const generatePostgresDdl = async (
         ddl += fkStatements.join("\n") + "\n\n";
     }
 
+    if (indexStatements.length > 0) {
+        ddl += "-- Indexes\n";
+        ddl += indexStatements.join("\n") + "\n\n";
+    }
+
     if (policyStatements.length > 0) {
         ddl += "-- Row Level Security Policies\n";
         ddl += policyStatements.join("");
@@ -642,13 +813,9 @@ const bareTableName = (name: string): string => (name.includes(".") ? name.split
  * Byte length, not string length: NAMEDATALEN is 64 bytes, and a multi-byte
  * character straddling the boundary would be cut mid-sequence by `slice(0, 63)`.
  */
-const toPostgresIdentifier = (name: string): string => {
-    const bytes = Buffer.from(name, "utf8");
-    if (bytes.byteLength <= 63) return name;
-    // `toString` on a slice that ends mid-character yields U+FFFD; dropping it
-    // lands on the last whole character that fits, which is what Postgres does.
-    return bytes.subarray(0, 63).toString("utf8").replace(/�+$/, "");
-};
+// Moved to `@rebasepro/utils` so the search-column builder derives index names
+// under the same 63-byte rule this file derives constraint names under. Two
+// copies of a truncation rule is two rules the moment one of them is edited.
 
 const foreignKeyPlan = (
     args: Omit<ForeignKeyPlan, "constraintName" | "sql"> & { onDelete: string; onUpdate?: string }

package/src/schema/generate-postgres-ddl.ts

@@ -3,7 +3,11 @@ import * as fs from "fs";
 import path from "path";
 import { pathToFileURL } from "url";
 import chokidar from "chokidar";
-import { generatePostgresDdl, generatePostgresPoliciesDdl } from "./generate-postgres-ddl-logic";
+import {
+    generatePostgresDdl,
+    generatePostgresPoliciesDdl,
+    generatePostgresSearchDdl
+} from "./generate-postgres-ddl-logic";
 import { CollectionConfig } from "@rebasepro/types";
 import { logger, loadCollectionsFromDirectory } from "@rebasepro/server";
 
@@ -29,8 +33,16 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
         // Sort collections by slug alphabetically to ensure deterministic DDL generation
         collections.sort((a, b) => a.slug.localeCompare(b.slug));
 
-        const ddlContent = await generatePostgresDdl(collections, { includePolicies: false });
+        // `schema.sql` is Atlas's desired state, and it carries neither the RLS
+        // policies nor the search apparatus: Atlas manages neither, and in the
+        // search case cannot. Both are written beside it and applied by the CLI
+        // in their own right.
+        const ddlContent = await generatePostgresDdl(collections, {
+            includePolicies: false,
+            includeSearch: false
+        });
         const policiesContent = generatePostgresPoliciesDdl(collections);
+        const searchContent = generatePostgresSearchDdl(collections);
 
         if (outputPath) {
             const outputDir = path.dirname(outputPath);
@@ -41,6 +53,17 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             const policiesPath = path.join(outputDir, "policies.sql");
             await fsPromises.writeFile(policiesPath, policiesContent);
             logger.info(`✅ PostgreSQL Policies DDL generated successfully at ${policiesPath}`);
+
+            // Removed when the last `search` block goes: the CLI applies this
+            // file whenever it exists, and a stale one would keep re-creating
+            // functions for collections that no longer want them.
+            const searchPath = path.join(outputDir, "search.sql");
+            if (searchContent) {
+                await fsPromises.writeFile(searchPath, searchContent);
+                logger.info(`✅ PostgreSQL search DDL generated successfully at ${searchPath}`);
+            } else if (fs.existsSync(searchPath)) {
+                await fsPromises.rm(searchPath);
+            }
         } else {
             logger.info("✅ PostgreSQL DDL generated successfully.");
             logger.info(String(ddlContent));