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

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

@@ -1,4 +1,4 @@
-import { CollectionConfig, NumberProperty, Property, Relation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty } from "@rebasepro/types";
+import { CollectionConfig, NumberProperty, Property, ResolvedRelation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty, isManyToMany, type ResolvedManyToMany, type ResolvedBelongsTo } from "@rebasepro/types";
 import { getEnumVarName, getTableName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, getInjectedSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 
@@ -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;
@@ -165,28 +170,28 @@ export const getSqlColumnType = (propName: string, prop: Property, collection: C
         case "relation": {
             const refProp = prop as RelationProperty;
             const resolvedRelations = resolveCollectionRelations(collection);
-            const relation = findRelation(resolvedRelations, refProp.relationName ?? propName);
-            if (!relation || relation.direction !== "owning" || relation.cardinality !== "one") {
-                throw new Error(`Relation ${propName} is not an owning one-to-one/many-to-one relation`);
+            const relation = findRelation(resolvedRelations, refProp.relation?.relationName ?? propName);
+            if (relation?.kind !== "belongsTo") {
+                throw new Error(`Relation ${propName} does not put a column on this table (only \`belongsTo\` does)`);
             }
             let targetCollection: CollectionConfig;
             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";
     }
 };
 
@@ -233,7 +238,7 @@ export const generatePostgresDdl = async (
     const allTablesToGenerate = new Map<string, {
         collection: CollectionConfig,
         isJunction?: boolean,
-        relation?: Relation,
+        relation?: ResolvedRelation,
         sourceCollection?: CollectionConfig
     }>();
 
@@ -246,7 +251,7 @@ export const generatePostgresDdl = async (
 
         const resolvedRelations = resolveCollectionRelations(collection);
         for (const relation of Object.values(resolvedRelations)) {
-            if (relation.through) {
+            if (isManyToMany(relation)) {
                 const junctionTableName = relation.through.table;
                 if (!allTablesToGenerate.has(junctionTableName)) {
                     allTablesToGenerate.set(junctionTableName, {
@@ -279,7 +284,7 @@ export const generatePostgresDdl = async (
         const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
         const baseTableName = tableName.includes(".") ? tableName.split(".").pop()! : tableName;
 
-        if (isJunction && relation && sourceCollection && relation.through) {
+        if (isJunction && relation && sourceCollection && isManyToMany(relation)) {
             const targetCollection = relation.target();
             const sourceTable = getTableName(sourceCollection);
             const targetTable = getTableName(targetCollection);
@@ -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);
 
@@ -329,9 +336,9 @@ export const generatePostgresDdl = async (
                 if (prop.type === "relation") {
                     const refProp = prop as RelationProperty;
                     const resolvedRelations = resolveCollectionRelations(collection);
-                    const relInfo = findRelation(resolvedRelations, refProp.relationName ?? propName);
+                    const relInfo = findRelation(resolvedRelations, refProp.relation?.relationName ?? propName);
 
-                    if (!relInfo || relInfo.direction !== "owning" || relInfo.cardinality !== "one" || !relInfo.localKey) {
+                    if (relInfo?.kind !== "belongsTo") {
                         return;
                     }
 
@@ -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            },";
             }
         }
 
@@ -700,11 +700,12 @@ export function generateCollectionFile(
         ${relName}: {
             name: "${relHumanName}",
             type: "relation",
-            target: () => ${targetCollectionCamel},
-            cardinality: "one",
-            direction: "owning",
-            localKey: "${fk.column_name}",
             // mapped from foreign key: ${fk.column_name} -> ${targetTableName}(${fk.foreign_column_name})
+            relation: {
+                kind: "belongsTo",
+                target: () => ${targetCollectionCamel},
+                localKey: "${fk.column_name}"
+            }
         },`);
         }
     }
@@ -718,15 +719,12 @@ export function generateCollectionFile(
         const targetCollectionCamel = toCollectionVarName(sourceTableName);
         imports.add(`import ${targetCollectionCamel} from "./${sourceTableName}";`);
 
-        const inverseRelName = fk.column_name.replace(/_id$/, "");
-
         relationsOutput += `
         {
+            kind: "hasMany",
             relationName: "${sourceTableName}",
             target: () => ${targetCollectionCamel},
-            cardinality: "many",
-            direction: "inverse",
-            inverseRelationName: "${inverseRelName}",
+            // the ${sourceTableName}.${fk.column_name} FK points back here
             foreignKeyOnTarget: "${fk.column_name}"
         },`;
     }
@@ -755,10 +753,9 @@ export function generateCollectionFile(
 
             relationsOutput += `
         {
+            kind: "manyToMany",
             relationName: "${relPropName}",
             target: () => ${tableName}Collection,
-            cardinality: "many",
-            direction: "owning",
             through: {
                 table: "${jt}",
                 sourceColumn: "${thisFk.column_name}",
@@ -776,24 +773,23 @@ export function generateCollectionFile(
             const targetCollectionCamel = toCollectionVarName(targetTableName);
             imports.add(`import ${targetCollectionCamel} from "./${targetTableName}";`);
 
-            // Determine direction (alphabetically first table is owning)
-            const direction = tableName < targetTableName ? "owning" : "inverse";
-
+            // Both sides of a many-to-many are `manyToMany`. There is no owning
+            // and inverse side to pick between any more, so this no longer
+            // guesses one from table-name ordering and no longer emits a
+            // half-configured relation on the losing side with a comment asking
+            // the reader to finish it by hand. Introspection already knows both
+            // junction columns; each side just names them from its own end.
             const thisFk = joinFks.find((fk) => fk.foreign_table_name === tableName);
 
-            let throughCode = "";
-            if (direction === "owning" && thisFk) {
-                throughCode = `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            },`;
-            } else if (direction === "inverse") {
-                throughCode = "\n            // Make sure the target collection configures the 'through' property.";
-            }
+            const throughCode = thisFk
+                ? `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            }`
+                : "";
 
             relationsOutput += `
         {
+            kind: "manyToMany",
             relationName: "${targetTableName}",
-            target: () => ${targetCollectionCamel},
-            cardinality: "many",
-            direction: "${direction}",${throughCode}
+            target: () => ${targetCollectionCamel},${throughCode}
         },`;
         }
     }