@rebasepro/server-postgres 0.10.1-canary.d8d45b2 → 0.10.1-canary.ed8caed

package/dist/utils/drizzle-conditions.d.ts

@@ -18,6 +18,47 @@ export interface DrizzleDynamicQuery {
  * const builder: ConditionBuilderStatic<SQL> = DrizzleConditionBuilder;
  */
 export declare class DrizzleConditionBuilder {
+    /**
+     * Express "reachable from this parent through this relation" as a plain
+     * `WHERE` condition on the target table.
+     *
+     * This is the primitive that lets a relation be a *filter* rather than an
+     * addressing scheme. A nested listing used to be served by its own query
+     * builder — `fetchEntitiesUsingJoins`, which grew joins the root pipeline
+     * did not have and lost the options the root pipeline did have (offset,
+     * filter, orderBy, include). Reduced to a condition, the same listing runs
+     * through the ordinary collection query, so it inherits all of them and
+     * there is one read path instead of two.
+     *
+     * The shapes:
+     *   - inverse FK  → `target.<fk> = :parentId`, a column comparison.
+     *   - `through`   → `EXISTS (SELECT 1 FROM junction …)`, correlated on the
+     *                   target's key, so the junction never multiplies rows the
+     *                   way an `INNER JOIN` would.
+     *   - `joinPath`  → the same `EXISTS`, with the path's steps joined inside
+     *                   it and the final step correlating to the outer row.
+     */
+    static buildRelationScopeCondition(relation: Relation, 
+    /**
+     * Lazy: only `joinPath` and `localKey` relations need the parent's own
+     * table. An inverse foreign key and a junction are both expressible
+     * from the parent's *id* alone, and requiring the table for them would
+     * make a child listing fail on a parent whose table isn't registered.
+     */
+    parent: () => {
+        table: PgTable<any>;
+        idColumn: AnyPgColumn;
+    }, parentId: string | number, targetTable: PgTable<any>, targetIdColumn: AnyPgColumn, registry: PostgresCollectionRegistry): SQL;
+    /**
+     * `EXISTS` for an explicit `joinPath`.
+     *
+     * The path is declared source → target. The subquery replays every step but
+     * the last from inside, and turns the last one into the correlation with the
+     * outer target row — so the target table is never named twice and needs no
+     * alias. Each intermediate table is aliased positionally, which keeps a path
+     * that revisits a table (a self-referencing many-to-many) unambiguous.
+     */
+    private static buildJoinPathScopeCondition;
     /**
      * Build filter conditions from FilterValues
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgres",
   "type": "module",
-  "version": "0.10.1-canary.d8d45b2",
+  "version": "0.10.1-canary.ed8caed",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -47,21 +47,20 @@
     "execa": "^9.6.1",
     "pg": "^8.21.0",
     "ws": "^8.21.0",
-    "@rebasepro/codegen": "0.10.1-canary.d8d45b2",
-    "@rebasepro/server": "0.10.1-canary.d8d45b2",
-    "@rebasepro/utils": "0.10.1-canary.d8d45b2",
-    "@rebasepro/common": "0.10.1-canary.d8d45b2",
-    "@rebasepro/types": "0.10.1-canary.d8d45b2"
+    "@rebasepro/codegen": "0.10.1-canary.ed8caed",
+    "@rebasepro/common": "0.10.1-canary.ed8caed",
+    "@rebasepro/server": "0.10.1-canary.ed8caed",
+    "@rebasepro/types": "0.10.1-canary.ed8caed",
+    "@rebasepro/utils": "0.10.1-canary.ed8caed"
   },
   "devDependencies": {
-    "@hono/node-server": "^2.0.9",
+    "@hono/node-server": "^2.0.11",
     "@jest/globals": "^30.4.1",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.9.3",
     "@types/pg": "^8.20.0",
     "@types/ws": "^8.18.1",
-    "@vitejs/plugin-react": "^6.0.2",
-    "hono": "^4.12.25",
+    "hono": "^4.12.27",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11",
     "typescript": "^6.0.3",

package/src/schema/doctor.ts

@@ -62,12 +62,10 @@ export function getExpectedColumnType(prop: Property): string | null {
             if (sp.enum) return "USER-DEFINED"; // pgEnum → USER-DEFINED in information_schema
             if ("isId" in sp && sp.isId === "uuid") return "uuid";
             if (sp.columnType === "uuid") return "uuid";
-            // A markdown/multiline string compiles to `text`, not varchar — the
-            // generator treats those UI hints as column-type signals, so the
-            // expectation here must too or every such column reads as drift.
-            if (sp.columnType === "text" || sp.ui?.markdown || sp.ui?.multiline) return "text";
             if (sp.columnType === "char") return "character";
-            return "character varying";
+            if (sp.columnType === "varchar") return "character varying";
+            // `text` is the default — see generate-postgres-ddl-logic.
+            return "text";
         }
         case "number": {
             const np = prop as NumberProperty;
@@ -122,7 +120,9 @@ export function getExpectedColumnType(prop: Property): string | null {
         case "relation":
             return null; // FK columns are derived from the relation, not from the property
         case "reference":
-            return "character varying"; // References default to varchar FK
+            // A reference FK follows the key it points at, and a string key is
+            // `text` — see generate-postgres-ddl-logic.
+            return "text";
         case "vector":
             return "USER-DEFINED";
         case "binary":

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

@@ -97,12 +97,14 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
                 columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
-            } else if (stringProp.columnType === "text" || stringProp.ui?.markdown || stringProp.ui?.multiline) {
-                columnDefinition = `text("${colName}")`;
             } else if (stringProp.columnType === "char") {
                 columnDefinition = `char("${colName}")`;
-            } else {
+            } else if (stringProp.columnType === "varchar") {
                 columnDefinition = `varchar("${colName}")`;
+            } else {
+                // `text` is the default, and the only length-unbounded choice.
+                // Ask for `varchar` explicitly if you want the length constraint.
+                columnDefinition = `text("${colName}")`;
             }
             if (isIdProperty(propName, prop, collection)) {
                 columnDefinition += ".primaryKey()";
@@ -252,7 +254,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetIdField = pkProp.name;
-            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `varchar("${fkColumnName}")`);
+            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `text("${fkColumnName}")`);
 
             const onUpdate = relation.onUpdate ? `onUpdate: "${relation.onUpdate}"` : "";
             const required = prop.validation?.required;
@@ -274,14 +276,14 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const refProp = prop as ReferenceProperty;
             const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
             if (!targetCollection) {
-                columnDefinition = `varchar("${colName}")`;
+                columnDefinition = `text("${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}")` : `varchar("${colName}")`);
+            const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : (pkProp.isUuid ? `uuid("${colName}")` : `text("${colName}")`);
 
             const required = prop.validation?.required;
             const onDelete = required ? "cascade" : "set null";
@@ -597,8 +599,10 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
             const onDelete = relation.onDelete ?? "cascade";
             const refOptions = `{ onDelete: \"${onDelete}\" }`;
 
-            const sourceColType = isNumericId(sourceCollection) ? "integer" : (getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "varchar");
-            const targetColType = isNumericId(targetCollection) ? "integer" : (getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "varchar");
+            // `text`, matching the string default: a junction column must have the
+            // same type as the primary key it references.
+            const sourceColType = isNumericId(sourceCollection) ? "integer" : (getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "text");
+            const targetColType = isNumericId(targetCollection) ? "integer" : (getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "text");
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
@@ -637,7 +641,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
             // We should generate a basic id column if one was completely omitted.
             const hasIdColumn = Array.from(columns).some(col => col.includes(".primaryKey()"));
             if (!hasIdColumn) {
-                columns.add("    id: varchar(\"id\").primaryKey()");
+                columns.add("    id: text(\"id\").primaryKey()");
             }
 
             schemaContent += `${Array.from(columns).join(",\n")}`;

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

@@ -103,13 +103,18 @@ export const getSqlColumnType = (propName: string, prop: Property, collection: C
             if (stringProp.isId === "uuid" || stringProp.columnType === "uuid") {
                 return "UUID";
             }
-            if (stringProp.columnType === "text" || stringProp.ui?.markdown || stringProp.ui?.multiline) {
-                return "TEXT";
-            }
             if (stringProp.columnType === "char") {
                 return "CHAR(255)";
             }
-            return "VARCHAR(255)";
+            if (stringProp.columnType === "varchar") {
+                return "VARCHAR(255)";
+            }
+            // `text` is the default. The two generators disagreed here before:
+            // this one emitted VARCHAR(255) while the drizzle path emitted a bare
+            // `varchar()`, which Postgres treats as unbounded — so the same
+            // property produced a capped column down one path and an uncapped one
+            // down the other.
+            return "TEXT";
         }
         case "number": {
             const numProp = prop as NumberProperty;
@@ -173,20 +178,20 @@ export const getSqlColumnType = (propName: string, prop: Property, collection: C
             try {
                 targetCollection = relation.target();
             } catch {
-                return "VARCHAR(255)";
+                return "TEXT";
             }
             const pkProp = getPrimaryKeyProp(targetCollection);
-            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "VARCHAR(255)");
+            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "TEXT");
         }
         case "reference": {
             const refProp = prop as ReferenceProperty;
             const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
-            if (!targetCollection) return "VARCHAR(255)";
+            if (!targetCollection) return "TEXT";
             const pkProp = getPrimaryKeyProp(targetCollection);
-            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "VARCHAR(255)");
+            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "TEXT");
         }
         default:
-            return "VARCHAR(255)";
+            return "TEXT";
     }
 };
 
@@ -287,8 +292,10 @@ export const generatePostgresDdl = async (
             const targetSchema = isPostgresCollectionConfig(targetCollection) && targetCollection.schema ? targetCollection.schema : "public";
             const { sourceColumn, targetColumn } = relation.through;
 
-            const sourceColType = isNumericId(sourceCollection) ? "INTEGER" : (getPrimaryKeyProp(sourceCollection).isUuid ? "UUID" : "VARCHAR(255)");
-            const targetColType = isNumericId(targetCollection) ? "INTEGER" : (getPrimaryKeyProp(targetCollection).isUuid ? "UUID" : "VARCHAR(255)");
+            // TEXT, matching the string default: a junction column has to have the
+            // same type as the primary key it references.
+            const sourceColType = isNumericId(sourceCollection) ? "INTEGER" : (getPrimaryKeyProp(sourceCollection).isUuid ? "UUID" : "TEXT");
+            const targetColType = isNumericId(targetCollection) ? "INTEGER" : (getPrimaryKeyProp(targetCollection).isUuid ? "UUID" : "TEXT");
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
@@ -424,7 +431,7 @@ export const generatePostgresDdl = async (
             // Backwards compatibility: add default id primary key if missing
             const hasPk = columns.some(c => c.includes("PRIMARY KEY"));
             if (!hasPk) {
-                columns.unshift('  "id" VARCHAR(255) PRIMARY KEY');
+                columns.unshift('  "id" TEXT PRIMARY KEY');
             }
 
             ddl += columns.join(",\n");

package/src/schema/introspect-db-inference.ts

@@ -51,10 +51,11 @@ export function inferPropertyFromData(
             }
         }
 
-        // Currency
-        if (colNameLower.includes("price") || colNameLower.includes("cost") || colNameLower.includes("amount") || colNameLower.includes("fee") || pgDataType === "money") {
-            extraLines.push("            ui: {\n                currency: true\n            }");
-        }
+        // No currency heuristic. `admin.currency` was never a declared option and
+        // nothing reads it, so a column called `price` got a block of config that did
+        // nothing — invisible because this generator emits *source text*, which no
+        // typechecker ever saw. Reinstate it by adding `currency` to
+        // AdminNumberOptions first, and something that renders it.
     }
 
     // ── JSON / JSONB Analysis ────────────────────────────────────────────
@@ -169,11 +170,10 @@ export function inferPropertyFromData(
             if (isPk) extraLines.push("            isId: \"cuid\"");
         }
 
-        // Color Codes
-        const allColors = validValues.every(v => typeof v === "string" && COLOR_HEX_REGEX.test(v));
-        if (allColors) {
-            extraLines.push("            ui: {\n                color: true\n            }");
-        }
+        // No colour heuristic. `admin.color` was never a declared option and nothing
+        // reads it — the same dead branch `currency` was. This generator emits *source
+        // text*, so no typechecker ever saw either. Reinstate by adding the option and
+        // something that renders it first.
 
         // Text Lengths, Multiline & Markdown
         let maxLength = 0;
@@ -212,9 +212,9 @@ export function inferPropertyFromData(
         if (allAbsoluteUrls) {
             const isImage = validValues.some(v => typeof v === "string" && v.match(/\.(jpeg|jpg|gif|png|webp|svg)/i));
             if (isImage || isMedia) {
-                extraLines.push("            ui: {\n                url: \"image\"\n            }");
+                extraLines.push("            url: true,\n            admin: {\n                urlPreview: \"image\"\n            }");
             } else {
-                extraLines.push("            ui: {\n                url: true\n            }");
+                extraLines.push("            url: true");
             }
         } else {
             const hasFileExtension = validValues.some(v => typeof v === "string" && v.match(/\.[a-zA-Z0-9]+$/));
@@ -225,9 +225,9 @@ export function inferPropertyFromData(
                 extraLines.push(`            storage: {\n                storagePath: "${inferredStoragePath}"\n            }`);
             } else if (isUrl) {
                 if (isMedia) {
-                    extraLines.push("            ui: {\n                url: \"image\"\n            }");
+                    extraLines.push("            url: true,\n            admin: {\n                urlPreview: \"image\"\n            }");
                 } else {
-                    extraLines.push("            ui: {\n                url: true\n            }");
+                    extraLines.push("            url: true");
                 }
             }
         }

package/src/schema/introspect-db-logic.ts

@@ -569,11 +569,11 @@ export function generateCollectionFile(
         // Date auto-value heuristics
         if (finalPropType === "date") {
             if (colNameLower === "created_at" || colNameLower === "createdat") {
-                extra += "\n            autoValue: \"on_create\",\n            ui: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
+                extra += "\n            autoValue: \"on_create\",\n            admin: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
             } else if (colNameLower === "updated_at" || colNameLower === "updatedat") {
-                extra += "\n            autoValue: \"on_update\",\n            ui: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
+                extra += "\n            autoValue: \"on_update\",\n            admin: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
             } else if (col.column_default && (col.column_default.includes("now()") || col.column_default.includes("CURRENT_TIMESTAMP"))) {
-                extra += "\n            autoValue: \"on_create\",\n            ui: {\n                readOnly: true\n            },";
+                extra += "\n            autoValue: \"on_create\",\n            admin: {\n                readOnly: true\n            },";
             }
         }
 
@@ -604,13 +604,13 @@ export function generateCollectionFile(
             if (isMedia) {
                 extra += `\n            storage: {\n                storagePath: "${tableName}/${col.column_name}"\n            },`;
             } else if (isUrl) {
-                extra += "\n            ui: {\n                url: true\n            },";
+                extra += "\n            url: true,";
             } else if (colNameLower === "description" || colNameLower === "summary" || colNameLower === "excerpt") {
-                extra += "\n            multiline: true,";
+                extra += "\n            admin: {\n                multiline: true\n            },";
             } else if (colNameLower === "content" || colNameLower === "body") {
                 extra += "\n            multiline: true,\n            markdown: true,";
             } else if (col.data_type === "text") {
-                extra += "\n            multiline: true,";
+                extra += "\n            admin: {\n                multiline: true\n            },";
             }
         }