@rebasepro/server-postgres 0.11.0 → 0.11.1-canary.g8caabf3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgres",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.11.1-canary.g8caabf3",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -47,11 +47,11 @@
     "execa": "^9.6.1",
     "pg": "^8.21.0",
     "ws": "^8.21.0",
-    "@rebasepro/codegen": "0.11.0",
-    "@rebasepro/common": "0.11.0",
-    "@rebasepro/utils": "0.11.0",
-    "@rebasepro/types": "0.11.0",
-    "@rebasepro/server": "0.11.0"
+    "@rebasepro/common": "0.11.1-canary.g8caabf3",
+    "@rebasepro/codegen": "0.11.1-canary.g8caabf3",
+    "@rebasepro/utils": "0.11.1-canary.g8caabf3",
+    "@rebasepro/server": "0.11.1-canary.g8caabf3",
+    "@rebasepro/types": "0.11.1-canary.g8caabf3"
   },
   "devDependencies": {
     "@hono/node-server": "^2.0.11",

package/src/PostgresBootstrapper.ts

@@ -112,10 +112,10 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
         async initializeDriver(config: unknown): Promise<InitializedDriver> {
             // config is passed from coordinator, we merge it with our internal pgConfig if needed
             // Currently config from init.ts is `{ collections, collectionRegistry, mode }`
-            const { collections, collectionRegistry, mode, baas } = config as {
+            const { collections, collectionRegistry, introspectCollections, baas } = config as {
                 collections?: CollectionConfig[];
                 collectionRegistry?: unknown;
-                mode?: "cms" | "baas";
+                introspectCollections?: boolean;
                 baas?: { unprotectedTables?: "exclude" | "serve" };
             };
             // Secure by default: a table with no RLS is not served.
@@ -126,13 +126,13 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                 ? (connection as Record<string, unknown>).$client
                 : connection) as import("pg").Pool;
 
-            // ── BaaS mode: derive the schema from the database ───────────────
+            // ── No declared collections: derive the schema from the database ──
             // No collection files and no generated drizzle schema exist, so read
             // the live database and build both from what is actually there.
             let introspectedCollections: CollectionConfig[] | undefined;
             let introspectedTables: Record<string, PgTable> | undefined;
             let introspectedRelations: Record<string, Relations> | undefined;
-            if (mode === "baas" && (!collections || collections.length === 0)) {
+            if (introspectCollections && (!collections || collections.length === 0)) {
                 const pgSchemaName = pgConfig.introspectionSchema ?? "public";
                 const schema = await introspectSchema(rawClient, pgSchemaName);
 

package/src/collections/buildRegistry.ts

@@ -9,7 +9,7 @@ import { assertRelationsResolve } from "./validate-relations";
 /**
  * Everything a registry is built from: the collections, and the drizzle schema
  * they are backed by. In BaaS mode all of it is introspected from the live
- * database; in CMS mode it comes from the config and the generated schema.
+ * database; when collections are declared it comes from the config and the generated schema.
  */
 export interface RegistrySchema {
     collections?: CollectionConfig[];

package/src/schema/dynamic-tables.ts

@@ -1,7 +1,7 @@
 /**
  * Build drizzle tables at runtime from an introspected schema.
  *
- * CMS mode gets its drizzle tables from a generated `schema.generated.ts` that
+ * A project with declared collections gets its drizzle tables from a generated `schema.generated.ts` that
  * the developer commits. BaaS mode has no such file — it points at a database
  * and serves it — so the equivalent table objects are constructed here from
  * `information_schema` metadata.

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

@@ -708,9 +708,17 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                     emittedRelationNames.add(deduplicationKey);
 
                     switch (rel.kind) {
-                        case "belongsTo":
-                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${rel.localKey}],\n        references: [${targetTableVar}.${getPrimaryKeyName(target)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                        case "belongsTo": {
+                            // `localKey` is a COLUMN name; the generated Drizzle
+                            // object is keyed by PROPERTY. They differ whenever
+                            // the property is camelCase — `user_id` is exposed
+                            // as `userId` — and emitting the column produces a
+                            // 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    })`);
                             break;
+                        }
 
                         case "hasOne":
                             // The foreign key lives on the TARGET table. Drizzle pairs

package/src/schema/introspect-runtime.ts

@@ -7,7 +7,7 @@
  * single config file.
  *
  * Distinct from `introspect-db.ts`, which runs the same queries but emits
- * TypeScript *source* for a developer to edit and commit (CMS mode). The two
+ * TypeScript *source* for a developer to edit and commit (declared collections). The two
  * share the mapping helpers in `introspect-db-logic.ts` so a table is described
  * the same way whether it was generated or introspected.
  */

package/src/services/FetchService.ts

@@ -85,7 +85,7 @@ export class FetchService {
      * Converts collection relations to a Drizzle-compatible `with` object.
      *
      * When `include` is provided, only those relations are loaded.
-     * When `include` is absent, ALL relations are loaded (CMS path).
+     * When `include` is absent, ALL relations are loaded (the admin path).
      *
      * Automatically detects many-to-many junction tables and nests
      * the target relation so actual row data is returned.

package/src/utils/drizzle-conditions.ts

@@ -99,7 +99,24 @@ export class DrizzleConditionBuilder {
                 // Correlated, not joined: a join through a junction multiplies
                 // the target rows by the number of matching links and silently
                 // breaks `limit`/`offset`.
-                return sql`EXISTS (SELECT 1 FROM ${junctionTable} WHERE ${targetCol} = ${targetIdColumn} AND ${sourceCol} = ${parentId})`;
+                //
+                // The junction is aliased and referenced by identifier, never as a
+                // Drizzle column. A column object carries no table qualifier of its
+                // own — it is rendered against whatever the surrounding builder
+                // thinks the current table is — so inside `db.query.findMany`, which
+                // aliases the root table, `${sourceCol}` came out qualified with the
+                // *target's* alias: `podcast.podcast_id`, a column that does not
+                // exist. That aborts the transaction, and the fallback read then
+                // fails on the poisoned transaction rather than on anything to do
+                // with the relation. Only `targetIdColumn` stays a column object,
+                // because that one *must* bind to the outer row to correlate.
+                //
+                // Aliasing also disambiguates a self-referential many-to-many, where
+                // the junction and the target are the same table.
+                const junctionAlias = "__rel_m2m";
+                const junctionRef = (column: AnyPgColumn) =>
+                    sql`${sql.identifier(junctionAlias)}.${sql.identifier(column.name)}`;
+                return sql`EXISTS (SELECT 1 FROM ${junctionTable} AS ${sql.identifier(junctionAlias)} WHERE ${junctionRef(targetCol)} = ${targetIdColumn} AND ${junctionRef(sourceCol)} = ${parentId})`;
             }
 
             case "hasOne":