@rebasepro/server-postgres 0.12.1-canary.gf5f1d39 → 0.13.1-canary.g18cfeb7

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

@@ -1,6 +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 { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig } from "@rebasepro/common";
+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";
 // --- Helper Functions ---
@@ -98,9 +98,13 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             } else if (stringProp.columnType === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "char") {
-                columnDefinition = `char("${colName}")`;
+                columnDefinition = `char("${colName}", { length: ${resolveStringColumnLength(stringProp)} })`;
             } else if (stringProp.columnType === "varchar") {
-                columnDefinition = `varchar("${colName}")`;
+                // 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)} })`;
             } else {
                 // `text` is the default, and the only length-unbounded choice.
                 // Ask for `varchar` explicitly if you want the length constraint.
@@ -133,6 +137,25 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             let baseType = (numProp.validation?.integer || isId) ? `integer("${colName}")` : `numeric("${colName}")`;
             if (numProp.columnType) {
                 if (numProp.columnType === "double precision") baseType = `doublePrecision("${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
+                // emitted call does not typecheck.
+                //
+                // This is why `schema.generated.ts` drifted. Regenerating it
+                // produced a file that would not compile, so the bigint lines
+                // were hand-patched — and every regeneration after that looked
+                // like a large, alarming diff nobody wanted to ship. The file
+                // then sat stale for long enough that a security fix to two RLS
+                // policies never reached production.
+                //
+                // `number` rather than `bigint`: these are counters and byte
+                // totals that every caller already treats as numbers, and
+                // 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" })`;
+                }
                 else baseType = `${numProp.columnType}("${colName}")`;
             }
 
@@ -428,7 +451,13 @@ 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.
+    const collections = relationalCollections(allCollections);
     let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
 
 
@@ -547,8 +576,15 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
         const tableVarName = getTableVarName(tableName);
         if (isJunction && relation && sourceCollection && isManyToMany(relation)) {
             const targetCollection = relation.target();
-            const schema = (isPostgresCollectionConfig(targetCollection) ? targetCollection.schema : undefined) || (isPostgresCollectionConfig(sourceCollection) ? sourceCollection.schema : undefined);
-            const tableCreator = schema ? `${schema}Schema.table` : "pgTable";
+            // Junctions live in `public`, full stop — `resolveJunctionSpecs`
+            // hardcodes that, so it is where `planJunctionTables` CREATEs them
+            // and where the derived RLS policies are applied. Inheriting the
+            // endpoint's schema here (as this used to) put the junction of any
+            // m2m onto `users` in `rebase`, while its policies were still
+            // created against `public.<junction>` — RLS enabled on one table,
+            // rows written to another. The three generators have to agree, and
+            // the other two already did.
+            const tableCreator = "pgTable";
             const baseTableName = tableName.includes(".") ? tableName.split(".").pop()! : tableName;
             const {
                 sourceColumn,
@@ -774,8 +810,14 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                                     // name (e.g. "client_id") may differ from the property key
                                     // (e.g. "clientId") when `columnName` is set.
                                     const drizzleFieldKey = resolvePropertyKeyForColumn(collection, otherRel.foreignKeyOnTarget);
+                                    // The column the far side points at: its
+                                    // primary key, unless the link names another
+                                    // one with `sourceKey`.
+                                    const referencedKey = otherRel.sourceKey
+                                        ? resolvePropertyKeyForColumn(otherCollection, otherRel.sourceKey)
+                                        : getPrimaryKeyName(otherCollection);
                                     const synthKey = `_synth_${otherTableVar}_${drizzleFieldKey}`;
-                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${drizzleFieldKey}],\n        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${drizzleFieldKey}],\n        references: [${otherTableVar}.${referencedKey}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
                                     emittedRelationNames.add(deduplicationKey);
                                 }
                             }