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

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, fieldKeyForColumn, 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;
@@ -42,29 +68,17 @@ isUuid: isUuid ?? false };
 };
 
 /**
- * Given a raw DB column name (e.g. "client_id"), find the Drizzle property key
- * on the collection that maps to that column. A property matches if:
- *   (a) it has an explicit `columnName` equal to the given column, OR
- *   (b) its snake_case form equals the given column.
+ * Given a raw DB column name (e.g. "client_id"), the Drizzle property key that
+ * maps to it.
  *
- * Returns the property key (the Drizzle object key) if found, or the original
- * column name as a fallback.
+ * One line, because the rule is shared: the Drizzle object key is the wire
+ * name, and {@link fieldKeyForColumn} is the one definition of what a column is
+ * named on the wire. This used to be a private copy that fell back to the
+ * column verbatim, which is how a derived foreign key ended up served as
+ * `author_id` beside a hand-authored `displayName`.
  */
-const resolvePropertyKeyForColumn = (collection: CollectionConfig, column: string): string => {
-    if (!collection.properties) return column;
-    for (const [propKey, prop] of Object.entries(collection.properties)) {
-        const p = prop as Property;
-        // Explicit columnName match
-        if ("columnName" in p && typeof (p as unknown as Record<string, unknown>).columnName === "string") {
-            if ((p as unknown as Record<string, unknown>).columnName === column) return propKey;
-        }
-        // Convention match: snake_case(propKey) === column
-        if (toSnakeCase(propKey) === column) return propKey;
-        // Exact match (propKey is already the column name)
-        if (propKey === column) return propKey;
-    }
-    return column;
-};
+const resolvePropertyKeyForColumn = (collection: CollectionConfig, column: string): string =>
+    fieldKeyForColumn(collection, column);
 
 const isNumericId = (collection: CollectionConfig): boolean => {
     return getPrimaryKeyProp(collection).type === "number";
@@ -82,7 +96,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 +113,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 +155,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 +175,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 +201,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 +221,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 +252,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": {
@@ -255,9 +286,14 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
                 return null;
             }
 
-            // If the localKey property is defined elsewhere in the properties, it will be handled there.
-            // This logic is for when the relation property itself defines the FK.
-            if (collection.properties[relation.localKey] && propName !== relation.localKey) {
+            // If a property of its own already declares this foreign key, that
+            // property emits the column and this relation must not emit a second
+            // key for it. Asked of the *field key*, not the column: a property
+            // declared `authorId` with `columnName: "author_id"` did not answer
+            // to `properties["author_id"]`, so both sides emitted and the table
+            // carried two Drizzle keys pointing at one column.
+            const fkFieldKey = fieldKeyForColumn(collection, relation.localKey);
+            if (collection.properties[fkFieldKey] && propName !== fkFieldKey) {
                 return null;
             }
 
@@ -282,47 +318,63 @@ 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}`;
+            // Key by the wire name, column by `localKey`. They are two different
+            // names for one thing and the generated line is where they meet:
+            // `authorId: integer("author_id")`.
+            return `    ${propKey(fkFieldKey)}: ${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 +451,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 +503,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 +536,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 +588,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 +693,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 +784,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 +792,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 +832,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 +897,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);
                                 }
                             }

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

@@ -5,7 +5,8 @@ import { pathToFileURL } from "url";
 import chokidar from "chokidar";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { CollectionConfig } from "@rebasepro/types";
-import { logger, loadCollectionsFromDirectory } from "@rebasepro/server";
+import { loadCollectionsFromDirectory } from "@rebasepro/server";
+import { out, outError } from "../cli-output";
 
 
 // --- Helper Functions ---
@@ -49,7 +50,7 @@ const formatTerminalText = (text: string, options: {
 const runGeneration = async (collectionsFilePath?: string, outputPath?: string) => {
     try {
         if (!collectionsFilePath) {
-            logger.error("Error: No collections file path provided. Skipping schema generation.");
+            outError("Error: No collections file path provided. Skipping schema generation.");
             return;
         }
 
@@ -75,20 +76,20 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             const outputDir = path.dirname(outputPath);
             await fsPromises.mkdir(outputDir, { recursive: true });
             await fsPromises.writeFile(outputPath, schemaContent);
-            logger.info(`✅ Drizzle schema generated successfully at ${outputPath}`);
+            out(`✅ Drizzle schema generated successfully at ${outputPath}`);
         } else {
-            logger.info("✅ Drizzle schema generated successfully.");
-            logger.info(String(schemaContent));
+            out("✅ Drizzle schema generated successfully.");
+            out(String(schemaContent));
         }
 
-        logger.info(`You can now run ${formatTerminalText("rebase db generate", {
+        out(`You can now run ${formatTerminalText("rebase db generate", {
             bold: true,
             backgroundColor: "blue",
             textColor: "black"
         })} to generate the SQL migration files.`);
 
     } catch (error) {
-        logger.error("Error generating schema", { error: error });
+        outError(`Error generating schema: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
     }
 };
 
@@ -102,7 +103,7 @@ const main = () => {
     const watch = process.argv.includes("--watch");
 
     if (!collectionsFilePath) {
-        logger.info("Usage: ts-node generate-drizzle-schema.ts <path-to-collections-file> [--output <path-to-output-file>] [--watch]");
+        out("Usage: ts-node generate-drizzle-schema.ts <path-to-collections-file> [--output <path-to-output-file>] [--watch]");
         return;
     }
 
@@ -110,14 +111,14 @@ const main = () => {
     const resolvedOutputPath = outputPath ? path.resolve(process.cwd(), outputPath) : undefined;
 
     if (watch) {
-        logger.info(`Watching for changes in ${resolvedPath}...`);
+        out(`Watching for changes in ${resolvedPath}...`);
         const watcher = chokidar.watch(resolvedPath, {
             persistent: true,
             ignoreInitial: false
         });
 
         watcher.on("all", (event, filePath) => {
-            logger.info(`[${event}] ${filePath}. Regenerating schema...`);
+            out(`[${event}] ${filePath}. Regenerating schema...`);
             runGeneration(resolvedPath, resolvedOutputPath);
         });
     } else {