@rebasepro/server-postgres 0.13.0 → 0.13.1-canary.g06dbe5b

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

@@ -1,6 +1,7 @@
 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 { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength } from "@rebasepro/common";
+import { buildSearchColumnSpec } from "./search-column";
+import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength, relationalCollections, sortCollectionsBySlug } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 import { logger } from "@rebasepro/server";
 // --- Helper Functions ---
@@ -10,6 +11,31 @@ import { logger } from "@rebasepro/server";
  * Uses the explicit `columnName` when set (e.g. from introspection),
  * falling back to `toSnakeCase(propName)` for manually-authored collections.
  */
+const JS_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+/**
+ * A string literal for the generated schema file.
+ *
+ * Column names, table names and enum values are all written into this file as
+ * literals, and none of them is constrained to be quote-free: a Postgres
+ * identifier only has to be quoted, and `O'Brien` is an ordinary enum value.
+ * Interpolating them raw ended the literal early — for enum values, inside
+ * single quotes, where an apostrophe is not an edge case.
+ */
+const quote = (value: string): string => JSON.stringify(value);
+
+/** An object key: verbatim when it is an identifier, quoted otherwise. */
+const propKey = (name: string): string => (JS_IDENTIFIER.test(name) ? name : quote(name));
+
+/**
+ * A property access on a generated table variable.
+ *
+ * `users.full name` is not an expression; `users["full name"]` is, and Drizzle
+ * treats the two identically.
+ */
+const member = (object: string, key: string): string =>
+    (JS_IDENTIFIER.test(key) ? `${object}.${key}` : `${object}[${quote(key)}]`);
+
 const resolveColumnName = (propName: string, prop?: Property | null): string => {
     if (prop && "columnName" in prop && typeof prop.columnName === "string") {
         return prop.columnName;
@@ -82,7 +108,14 @@ const isIdProperty = (propName: string, prop: Property, collection: CollectionCo
     return !hasExplicitId && propName === "id";
 };
 
-const getDrizzleColumn = (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]): string | null => {
+/**
+ * The Drizzle column declaration a property compiles to, or `null` when the
+ * property puts no column on *this* table (an inverse relation, whose column
+ * lives on the target). Exported so it can be checked against its DDL twin
+ * `getSqlColumnType` directly — the two disagreeing is what left `geopoint`
+ * with a database column and no Drizzle key.
+ */
+export const getDrizzleColumn = (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]): string | null => {
 
     const colName = resolveColumnName(propName, prop);
     let columnDefinition: string;
@@ -92,23 +125,23 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const stringProp = prop as unknown as StringProperty;
             if (stringProp.enum) {
                 const enumName = getEnumVarName(getTableName(collection), propName);
-                columnDefinition = `${enumName}("${colName}")`;
+                columnDefinition = `${enumName}(${quote(colName)})`;
             } else if ("isId" in stringProp && stringProp.isId === "uuid") {
-                columnDefinition = `uuid("${colName}")`;
+                columnDefinition = `uuid(${quote(colName)})`;
             } else if (stringProp.columnType === "uuid") {
-                columnDefinition = `uuid("${colName}")`;
+                columnDefinition = `uuid(${quote(colName)})`;
             } else if (stringProp.columnType === "char") {
-                columnDefinition = `char("${colName}", { length: ${resolveStringColumnLength(stringProp)} })`;
+                columnDefinition = `char(${quote(colName)}, { length: ${resolveStringColumnLength(stringProp)} })`;
             } else if (stringProp.columnType === "varchar") {
                 // The length is not optional decoration: `varchar("col")` with
                 // no length is an UNBOUNDED varchar in Postgres, which is what
                 // this emitted while the DDL generator emitted VARCHAR(255) for
                 // the very same property.
-                columnDefinition = `varchar("${colName}", { length: ${resolveStringColumnLength(stringProp)} })`;
+                columnDefinition = `varchar(${quote(colName)}, { length: ${resolveStringColumnLength(stringProp)} })`;
             } else {
                 // `text` is the default, and the only length-unbounded choice.
                 // Ask for `varchar` explicitly if you want the length constraint.
-                columnDefinition = `text("${colName}")`;
+                columnDefinition = `text(${quote(colName)})`;
             }
             if (isIdProperty(propName, prop, collection)) {
                 columnDefinition += ".primaryKey()";
@@ -134,9 +167,9 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const numProp = prop as unknown as NumberProperty;
             const isId = isIdProperty(propName, prop, collection);
 
-            let baseType = (numProp.validation?.integer || isId) ? `integer("${colName}")` : `numeric("${colName}")`;
+            let baseType = (numProp.validation?.integer || isId) ? `integer(${quote(colName)})` : `numeric(${quote(colName)})`;
             if (numProp.columnType) {
-                if (numProp.columnType === "double precision") baseType = `doublePrecision("${colName}")`;
+                if (numProp.columnType === "double precision") baseType = `doublePrecision(${quote(colName)})`;
                 // `bigint` and `bigserial` are the only pg-core builders that
                 // *require* a config argument: without `mode`, drizzle cannot
                 // know whether to hand back a `number` or a `bigint`, and the
@@ -154,9 +187,9 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
                 // switching the runtime type would be a breaking change to
                 // every consumer of the generated schema.
                 else if (numProp.columnType === "bigint" || numProp.columnType === "bigserial") {
-                    baseType = `${numProp.columnType}("${colName}", { mode: "number" })`;
+                    baseType = `${numProp.columnType}(${quote(colName)}, { mode: "number" })`;
                 }
-                else baseType = `${numProp.columnType}("${colName}")`;
+                else baseType = `${numProp.columnType}(${quote(colName)})`;
             }
 
             if ("isId" in numProp && numProp.isId === "increment") {
@@ -180,16 +213,16 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             break;
         }
         case "boolean":
-            columnDefinition = `boolean("${colName}")`;
+            columnDefinition = `boolean(${quote(colName)})`;
             break;
         case "date": {
             const dateProp = prop as DateProperty;
             if (dateProp.columnType === "date") {
-                columnDefinition = `date("${colName}", { mode: 'string' })`;
+                columnDefinition = `date(${quote(colName)}, { mode: 'string' })`;
             } else if (dateProp.columnType === "time") {
-                columnDefinition = `time("${colName}")`;
+                columnDefinition = `time(${quote(colName)})`;
             } else {
-                columnDefinition = `timestamp("${colName}", { withTimezone: true, mode: 'string' })`;
+                columnDefinition = `timestamp(${quote(colName)}, { withTimezone: true, mode: 'string' })`;
             }
             // autoValue: database-level default for initial value on INSERT
             if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
@@ -200,12 +233,22 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
         case "map": {
             const mapProp = prop as MapProperty;
             if (mapProp.columnType === "json") {
-                columnDefinition = `json("${colName}")`;
+                columnDefinition = `json(${quote(colName)})`;
             } else {
-                columnDefinition = `jsonb("${colName}")`;
+                columnDefinition = `jsonb(${quote(colName)})`;
             }
             break;
         }
+        case "geopoint": {
+            // `{ latitude, longitude }`, which is what the OpenAPI schema, the
+            // generated TS type and the admin's field binding all describe.
+            // This arm did not exist: `geopoint` fell to `default: return null`
+            // and the caller dropped the column, so the DDL generator created a
+            // column the Drizzle table had no key for — and every write to it
+            // was silently discarded with a 201.
+            columnDefinition = `jsonb(${quote(colName)})`;
+            break;
+        }
         case "array": {
             const arrayProp = prop as ArrayProperty;
             let colType = arrayProp.columnType;
@@ -221,27 +264,27 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             }
 
             if (colType === "json") {
-                columnDefinition = `json("${colName}")`;
+                columnDefinition = `json(${quote(colName)})`;
             } else if (colType === "text[]") {
-                columnDefinition = `text("${colName}").array()`;
+                columnDefinition = `text(${quote(colName)}).array()`;
             } else if (colType === "integer[]") {
-                columnDefinition = `integer("${colName}").array()`;
+                columnDefinition = `integer(${quote(colName)}).array()`;
             } else if (colType === "boolean[]") {
-                columnDefinition = `boolean("${colName}").array()`;
+                columnDefinition = `boolean(${quote(colName)}).array()`;
             } else if (colType === "numeric[]") {
-                columnDefinition = `numeric("${colName}").array()`;
+                columnDefinition = `numeric(${quote(colName)}).array()`;
             } else {
-                columnDefinition = `jsonb("${colName}")`;
+                columnDefinition = `jsonb(${quote(colName)})`;
             }
             break;
         }
         case "vector": {
             const vp = prop as VectorProperty;
-            columnDefinition = `vector("${colName}", { dimensions: ${vp.dimensions} })`;
+            columnDefinition = `vector(${quote(colName)}, { dimensions: ${vp.dimensions} })`;
             break;
         }
         case "binary": {
-            columnDefinition = `customType({ dataType() { return 'bytea'; } })("${colName}")`;
+            columnDefinition = `customType({ dataType() { return 'bytea'; } })(${quote(colName)})`;
             break;
         }
         case "relation": {
@@ -282,47 +325,60 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const refOptionsParts = [onUpdate, onDelete].filter(Boolean);
             const refOptions = refOptionsParts.length > 0 ? `{ ${refOptionsParts.join(", ")} }` : "";
 
-            let columnDef = `${baseColumn}.references(() => ${targetTableVar}.${targetIdField}${refOptions ? `, ${refOptions}` : ""})`;
+            let columnDef = `${baseColumn}.references(() => ${member(targetTableVar, targetIdField)}${refOptions ? `, ${refOptions}` : ""})`;
 
             if (required) {
                 columnDef += ".notNull()";
             }
 
-            return `    ${relation.localKey}: ${columnDef}`;
+            return `    ${propKey(relation.localKey)}: ${columnDef}`;
         }
         case "reference": {
             const refProp = prop as ReferenceProperty;
             const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
             if (!targetCollection) {
-                columnDefinition = `text("${colName}")`;
+                columnDefinition = `text(${quote(colName)})`;
                 break;
             }
 
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const targetIdField = pkProp.name;
-            const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : (pkProp.isUuid ? `uuid("${colName}")` : `text("${colName}")`);
+            const baseColumn = pkProp.type === "number" ? `integer(${quote(colName)})` : (pkProp.isUuid ? `uuid(${quote(colName)})` : `text(${quote(colName)})`);
 
             const required = prop.validation?.required;
             const onDelete = required ? "cascade" : "set null";
             const refOptions = `{ onDelete: "${onDelete}" }`;
 
-            columnDefinition = `${baseColumn}.references(() => ${targetTableVar}.${targetIdField}, ${refOptions})`;
+            columnDefinition = `${baseColumn}.references(() => ${member(targetTableVar, targetIdField)}, ${refOptions})`;
             if (required) {
                 columnDefinition += ".notNull()";
             }
             // Skip the standard notNull() handling below because we did it here with references
-            return `    ${propName}: ${columnDefinition}`;
+            return `    ${propKey(propName)}: ${columnDefinition}`;
         }
         default:
-            return null;
+            // Not `return null`. A `null` here means "this property puts no
+            // column on this table", which is true of an inverse relation and
+            // false of everything else — and the caller cannot tell the two
+            // apart, so a type this switch simply forgot produced a table
+            // missing a column while the DDL generator happily created one.
+            // That is how `geopoint` stayed unpersistable: writes to it were
+            // dropped before the SQL was built, forever, with a 201. A property
+            // type nobody mapped is a generator bug, and it says so here rather
+            // than at some caller's next INSERT.
+            throw new Error(
+                `No Postgres column mapping for property '${propName}' of type ` +
+                `'${(prop as Property).type}' in collection '${collection.slug}'. ` +
+                "Add a case to `getDrizzleColumn` (and to `getSqlColumnType`, which must agree)."
+            );
     }
 
     if (prop.validation?.required) {
         columnDefinition += ".notNull()";
     }
 
-    return `    ${propName}: ${columnDefinition}`;
+    return `    ${propKey(propName)}: ${columnDefinition}`;
 };
 
 /**
@@ -399,7 +455,7 @@ const generateSinglePolicyCode = (collection: CollectionConfig, rule: SecurityRu
     if (usingClause) parts.push(`using: ${usingClause}`);
     if (withCheckClause) parts.push(`withCheck: ${withCheckClause}`);
 
-    return `    pgPolicy("${policyName}", { ${parts.join(", ")} }),\n`;
+    return `    pgPolicy(${quote(policyName)}, { ${parts.join(", ")} }),\n`;
 };
 
 /**
@@ -451,7 +507,18 @@ const computeSharedRelationName = (
 };
 
 // --- Main Schema Generation Logic ---
-export const generateSchema = async (collections: CollectionConfig[], stripPolicies = false): Promise<string> => {
+export const generateSchema = async (allCollections: CollectionConfig[], stripPolicies = false): Promise<string> => {
+    // A Firestore or MongoDB collection has no table to generate, and generating
+    // one for it is not merely wasted output: `db push` would create it, and
+    // `rebase doctor` would then report the store the collection actually reads
+    // from as drift. Non-SQL collections leave the toolchain here, once, rather
+    // than being filtered again in each stage below.
+    //
+    // Sorted here rather than in the writer: the output is order-dependent and
+    // `rebase doctor` regenerates it in memory to diff against the file on
+    // disk. With the sort in the writer only, a project whose file order
+    // differed from its slug order was reported stale forever.
+    const collections = sortCollectionsBySlug(relationalCollections(allCollections));
     let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
 
 
@@ -473,11 +540,15 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
         )
     );
 
+    // 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)
@@ -521,7 +592,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                     )
                     : Object.keys(prop.enum);
                 if (values.length > 0) {
-                    schemaContent += `export const ${enumVarName} = pgEnum(\"${enumDbName}\", [${values.map(v => `'${v}'`).join(", ")}]);\n`;
+                    schemaContent += `export const ${enumVarName} = pgEnum(${quote(enumDbName)}, [${values.map(v => quote(v)).join(", ")}]);\n`;
                     if (!exportedEnumVars.includes(enumVarName)) exportedEnumVars.push(enumVarName);
                 }
             }
@@ -626,6 +697,25 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
 
             });
 
+            // 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()"));
@@ -698,7 +788,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                 }
 
                 // Source side one(): pairs with owning table's many(junctionTable, { relationName })
-                tableRelations.push(`    "${relation.through.sourceColumn}": one(${sourceTableVar}, {\n        fields: [${tableVarName}.${relation.through.sourceColumn}],\n        references: [${sourceTableVar}.${sourceId}],\n        relationName: \"${owningRelationName}\"\n    })`);
+                tableRelations.push(`    ${quote(relation.through.sourceColumn)}: one(${sourceTableVar}, {\n        fields: [${member(tableVarName, relation.through.sourceColumn)}],\n        references: [${member(sourceTableVar, sourceId)}],\n        relationName: ${quote(owningRelationName)}\n    })`);
 
                 // Target side one(): pairs with inverse table's many(junctionTable, { relationName })
                 // Always emit a relationName to avoid collisions with the source-side's owningRelationName.
@@ -706,7 +796,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                 const targetRelationName = inverseRelationName
                     ? inverseRelationName
                     : `${tableName}_${relation.through.targetColumn}`;
-                tableRelations.push(`    "${relation.through.targetColumn}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${relation.through.targetColumn}],\n        references: [${targetTableVar}.${targetId}],\n        relationName: "${targetRelationName}"\n    })`);
+                tableRelations.push(`    ${quote(relation.through.targetColumn)}: one(${targetTableVar}, {\n        fields: [${member(tableVarName, relation.through.targetColumn)}],\n        references: [${member(targetTableVar, targetId)}],\n        relationName: ${quote(targetRelationName)}\n    })`);
             }
         } else {
             const resolvedRelations = resolveCollectionRelations(collection);
@@ -746,7 +836,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                             // schema that does not compile. The three other
                             // emission sites normalise; this one did not.
                             const localFieldKey = resolvePropertyKeyForColumn(collection, rel.localKey);
-                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${localFieldKey}],\n        references: [${targetTableVar}.${getPrimaryKeyName(target)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                            tableRelations.push(`    ${quote(relationKey)}: one(${targetTableVar}, {\n        fields: [${member(tableVarName, localFieldKey)}],\n        references: [${member(targetTableVar, getPrimaryKeyName(target))}],\n        relationName: ${quote(drizzleRelationName)}\n    })`);
                             break;
                         }
 
@@ -811,7 +901,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                                         ? resolvePropertyKeyForColumn(otherCollection, otherRel.sourceKey)
                                         : getPrimaryKeyName(otherCollection);
                                     const synthKey = `_synth_${otherTableVar}_${drizzleFieldKey}`;
-                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${drizzleFieldKey}],\n        references: [${otherTableVar}.${referencedKey}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                                    tableRelations.push(`    ${quote(synthKey)}: one(${otherTableVar}, {\n        fields: [${member(tableVarName, drizzleFieldKey)}],\n        references: [${member(otherTableVar, referencedKey)}],\n        relationName: ${quote(drizzleRelationName)}\n    })`);
                                     emittedRelationNames.add(deduplicationKey);
                                 }
                             }