@rebasepro/server-postgresql 0.0.1-canary.dbf160a → 0.0.1-canary.e17585f

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

@@ -5,6 +5,18 @@ import { toSnakeCase } from "@rebasepro/utils";
 import { createHash } from "crypto";
 // --- Helper Functions ---
 
+/**
+ * Resolve the SQL column name for a property.
+ * Uses the explicit `columnName` when set (e.g. from introspection),
+ * falling back to `toSnakeCase(propName)` for manually-authored collections.
+ */
+const resolveColumnName = (propName: string, prop?: Property | null): string => {
+    if (prop && "columnName" in prop && typeof prop.columnName === "string") {
+        return prop.columnName;
+    }
+    return toSnakeCase(propName);
+};
+
 const getPrimaryKeyProp = (collection: EntityCollection): { name: string, type: "string" | "number", isUuid: boolean } => {
     if (collection.properties) {
         const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in (prop as object) && Boolean((prop as unknown as Record<string, unknown>).isId));
@@ -46,7 +58,7 @@ const isIdProperty = (propName: string, prop: Property, collection: EntityCollec
 };
 
 const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCollection, collections: EntityCollection[]): string | null => {
-    const colName = toSnakeCase(propName);
+    const colName = resolveColumnName(propName, prop);
     let columnDefinition: string;
 
     switch (prop.type) {
@@ -126,6 +138,10 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             } else {
                 columnDefinition = `timestamp("${colName}", { withTimezone: true, mode: 'string' })`;
             }
+            // autoValue: database-level default for initial value on INSERT
+            if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
+                columnDefinition += `.default(sql\`now()\`)`;
+            }
             break;
         }
         case "map":
@@ -167,7 +183,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
                 return null; // Cannot resolve target
             }
 
-            const fkColumnName = toSnakeCase(relation.localKey);
+            const fkColumnName = relation.localKey;
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetIdField = pkProp.name;
@@ -461,6 +477,8 @@ const computeSharedRelationName = (
 export const generateSchema = async (collections: EntityCollection[], stripPolicies = false): Promise<string> => {
     let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
 
+
+
     const hasUuid = collections.some(c =>
         c.properties && Object.values(c.properties).some(
             (p: Property) => p.type === "string" && ((p as unknown as Record<string, unknown>).autoValue === "uuid" || (p as unknown as Record<string, unknown>).isId === "uuid")
@@ -496,7 +514,7 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
         Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
             if (("enum" in prop) && (prop.type === "string" || prop.type === "number") && prop.enum) {
                 const enumVarName = getEnumVarName(collectionPath, propName);
-                const enumDbName = `${collectionPath}_${toSnakeCase(propName)}`;
+                const enumDbName = `${collectionPath}_${resolveColumnName(propName, prop)}`;
                 const values = Array.isArray(prop.enum)
                     ? prop.enum.map(v => String(v.id ?? v))
                     : Object.keys(prop.enum);
@@ -560,8 +578,8 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
             const targetId = getPrimaryKeyName(targetCollection);
 
             schemaContent += `export const ${tableVarName} = pgTable(\"${tableName}\", {\n`;
-            schemaContent += `    ${sourceColumn}: ${sourceColType}(\"${toSnakeCase(sourceColumn)}\").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),\n`;
-            schemaContent += `    ${targetColumn}: ${targetColType}(\"${toSnakeCase(targetColumn)}\").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),\n`;
+            schemaContent += `    ${sourceColumn}: ${sourceColType}(\"${sourceColumn}\").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),\n`;
+            schemaContent += `    ${targetColumn}: ${targetColType}(\"${targetColumn}\").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),\n`;
             schemaContent += "}, (table) => ({\n";
             schemaContent += `    pk: primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] })\n`;
             schemaContent += "}));\n\n";
@@ -571,6 +589,7 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
             Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
                 const columnString = getDrizzleColumn(propName, prop as Property, collection, collections);
                 if (columnString) columns.add(columnString);
+
             });
 
             // Backwards compatibility: if no id/primary key column is found in properties, but `id` wasn't explicitly provided
@@ -682,31 +701,13 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                     if (rel.cardinality === "one") {
                         if (rel.direction === "owning" && rel.localKey) {
                             tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${rel.localKey}],\n        references: [${targetTableVar}.${getPrimaryKeyName(target)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
-                        } else if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
-                            const sourceIdField = getPrimaryKeyName(collection);
-                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${sourceIdField}],\n        references: [${targetTableVar}.${rel.foreignKeyOnTarget}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
-                        } else if (rel.direction === "inverse" && !rel.foreignKeyOnTarget) {
-                            // Handle inverse one-to-one relations where the FK is on the target table
-                            // but foreignKeyOnTarget is not explicitly specified
-                            // In this case, we need to find the corresponding owning relation on the target
-                            try {
-                                const targetCollection = rel.target();
-                                const targetResolvedRelations = resolveCollectionRelations(targetCollection);
-
-                                // Find the owning relation on the target that points back to this collection
-                                const correspondingRelation = Object.values(targetResolvedRelations).find(targetRel =>
-                                    targetRel.direction === "owning" &&
-                                    targetRel.cardinality === "one" &&
-                                    targetRel.target().slug === collection.slug
-                                );
-
-                                if (correspondingRelation && correspondingRelation.localKey) {
-                                    const sourceIdField = getPrimaryKeyName(collection);
-                                    tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${sourceIdField}],\n        references: [${targetTableVar}.${correspondingRelation.localKey}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
-                                }
-                            } catch (e) {
-                                console.warn(`Could not resolve inverse one-to-one relation '${relationKey}':`, e);
-                            }
+                        } else if (rel.direction === "inverse") {
+                            // Inverse one-to-one: the FK lives on the TARGET table, not here.
+                            // Drizzle pairs inverse relations via `relationName` alone — specifying
+                            // `fields`/`references` on the inverse side is invalid and causes
+                            // `normalizeRelation` to crash with "Cannot read properties of
+                            // undefined (reading 'referencedTable')".
+                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        relationName: \"${drizzleRelationName}\"\n    })`);
                         }
                     } else if (rel.cardinality === "many") {
                         if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
@@ -746,6 +747,33 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                     console.warn(`Could not generate relation ${relationKey} for ${collection.name}:`, e);
                 }
             }
+
+            // Synthesize missing reciprocal relations
+            for (const otherCollection of collections) {
+                if (otherCollection.slug === collection.slug) continue;
+                
+                const otherRelations = resolveCollectionRelations(otherCollection);
+                for (const [otherKey, otherRel] of Object.entries(otherRelations)) {
+                    if (otherRel.direction === "inverse" && otherRel.foreignKeyOnTarget) {
+                        try {
+                            const otherTarget = otherRel.target();
+                            if (otherTarget.slug === collection.slug) {
+                                const drizzleRelationName = computeSharedRelationName(otherRel, otherCollection, collections);
+                                const deduplicationKey = `${drizzleRelationName}::owning`;
+                                
+                                if (!emittedRelationNames.has(deduplicationKey)) {
+                                    const otherTableVar = getTableVarName(getTableName(otherCollection));
+                                    const synthKey = `_synth_${otherTableVar}_${otherRel.foreignKeyOnTarget}`;
+                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${otherRel.foreignKeyOnTarget}],\n        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                                    emittedRelationNames.add(deduplicationKey);
+                                }
+                            }
+                        } catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+            }
         }
 
         if (tableRelations.length > 0) {
@@ -763,3 +791,4 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
 
     return schemaContent;
 };
+

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

@@ -0,0 +1,238 @@
+import { humanize } from "./introspect-db-logic";
+
+export interface InferenceResult {
+    propType?: string; // If the inference changes the base type
+    extra?: string; // String to append to the property definition
+}
+
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const CUID_REGEX = /^c[^\s-]{7,}$/i; // Basic CUID check
+const COLOR_HEX_REGEX = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+
+export function inferPropertyFromData(
+    columnName: string,
+    pgDataType: string,
+    currentPropType: string,
+    sampleValues: unknown[],
+    isPk: boolean
+): InferenceResult {
+    let result: InferenceResult = {};
+    let extraLines: string[] = [];
+
+    // Filter out null/undefined for analysis
+    const validValues = sampleValues.filter(v => v !== null && v !== undefined && v !== "");
+
+    if (validValues.length === 0) {
+        return result; // Not enough data
+    }
+
+    const colNameLower = columnName.toLowerCase();
+
+    // ── Number Analysis ──────────────────────────────────────────────────
+    if (currentPropType === "number") {
+        // Boolean stored as int
+        const allZeroOrOne = validValues.every(v => v === 0 || v === 1 || v === "0" || v === "1");
+        if (allZeroOrOne) {
+            result.propType = "boolean";
+            return result; // Don't do min/max if boolean
+        }
+
+        // Min / Max constraints
+        const numValues = validValues.map(v => Number(v)).filter(v => !isNaN(v));
+        if (numValues.length === validValues.length) {
+            const min = Math.min(...numValues);
+            const max = Math.max(...numValues);
+            // Example heuristic: percentages
+            if (min >= 0 && max <= 100 && (colNameLower.includes("percent") || colNameLower.includes("rate") || colNameLower.includes("score"))) {
+                extraLines.push(`            validation: {\n                min: 0,\n                max: 100\n            }`);
+            } else if (min >= 0 && (colNameLower.includes("count") || colNameLower.includes("total") || colNameLower.includes("amount"))) {
+                extraLines.push(`            validation: {\n                min: 0\n            }`);
+            }
+        }
+
+        // Currency
+        if (colNameLower.includes("price") || colNameLower.includes("cost") || colNameLower.includes("amount") || colNameLower.includes("fee") || pgDataType === "money") {
+            extraLines.push(`            ui: {\n                currency: true\n            }`);
+        }
+    }
+
+    // ── JSON / JSONB Analysis ────────────────────────────────────────────
+    if (currentPropType === "map" || pgDataType.includes("json")) {
+        // PostGres jsonb can be object or array
+        let allArrays = true;
+        let allObjects = true;
+
+        for (const v of validValues) {
+            let parsed = v;
+            if (typeof v === "string") {
+                try { parsed = JSON.parse(v); } catch (e) { allArrays = false; allObjects = false; break; }
+            }
+            if (Array.isArray(parsed)) {
+                allObjects = false;
+            } else if (typeof parsed === "object" && parsed !== null) {
+                allArrays = false;
+            } else {
+                allArrays = false;
+                allObjects = false;
+            }
+        }
+
+        if (allArrays && !allObjects) {
+            result.propType = "array";
+            // Infer inner type
+            let allNumbers = true;
+            let allStrings = true;
+            for (const v of validValues) {
+                let parsed = typeof v === "string" ? JSON.parse(v) : v;
+                for (const item of parsed) {
+                    if (typeof item !== "number") allNumbers = false;
+                    if (typeof item !== "string") allStrings = false;
+                }
+            }
+            const innerType = allNumbers ? "number" : allStrings ? "string" : "map";
+            extraLines.push(`            of: { name: "${humanize(columnName)} Item", type: "${innerType}" }`);
+        } else {
+            result.propType = "map";
+            
+            // Infer inner schema
+            if (allObjects && validValues.length > 0) {
+                const schema: Record<string, string> = {};
+                for (const v of validValues) {
+                    let parsed = typeof v === "string" ? JSON.parse(v) : v;
+                    for (const [k, val] of Object.entries(parsed)) {
+                        if (val === null || val === undefined) continue;
+                        const type = typeof val;
+                        if (type === "string" || type === "number" || type === "boolean") {
+                            if (!schema[k]) schema[k] = type;
+                            else if (schema[k] !== type) schema[k] = "mixed";
+                        } else if (Array.isArray(val)) {
+                            if (!schema[k]) schema[k] = "array";
+                            else if (schema[k] !== "array") schema[k] = "mixed";
+                        } else if (type === "object") {
+                            if (!schema[k]) schema[k] = "map";
+                            else if (schema[k] !== "map") schema[k] = "mixed";
+                        }
+                    }
+                }
+                
+                const keys = Object.keys(schema).filter(k => schema[k] !== "mixed");
+                if (keys.length > 0) {
+                    const props = keys.map(k => {
+                        return `\n                ${k}: { name: "${humanize(k)}", type: "${schema[k]}" }`;
+                    }).join(",");
+                    extraLines.push(`            properties: {${props}\n            }`);
+                } else {
+                    extraLines.push(`            keyValue: true`);
+                }
+            } else {
+                extraLines.push(`            keyValue: true`);
+            }
+        }
+    }
+
+    // ── String Analysis ──────────────────────────────────────────────────
+    if (currentPropType === "string") {
+        // Date/Time Strings
+        if (validValues.every(v => typeof v === 'string' && ISO_8601_REGEX.test(v))) {
+            result.propType = "date";
+            return result;
+        }
+
+        // Implicit Enums
+        const uniqueValues = new Set(validValues);
+        // Determine the maximum length among unique values
+        let maxEnumLength = 0;
+        for (const v of uniqueValues) {
+            if (typeof v === "string" && v.length > maxEnumLength) {
+                maxEnumLength = v.length;
+            }
+        }
+        
+        // Ensure no empty string, max length makes sense, and fewer unique values than total values (unless small total)
+        if (uniqueValues.size > 0 && uniqueValues.size <= 5 && maxEnumLength <= 50 && validValues.length > uniqueValues.size && !uniqueValues.has("")) {
+            const isLikelyId = isPk || colNameLower.endsWith("_id");
+            if (!isLikelyId) {
+                const enumEntries = Array.from(uniqueValues).map(v => `{ id: ${JSON.stringify(v)}, label: ${JSON.stringify(humanize(v as string))} }`).join(", ");
+                extraLines.push(`            enum: [${enumEntries}]`);
+                result.extra = extraLines.length > 0 ? "\n" + extraLines.join(",\n") + "," : "";
+                return result; // Skip other string checks if it's an enum
+            }
+        }
+
+        // UUID / CUID Detection
+        const allUuid = validValues.every(v => typeof v === 'string' && UUID_REGEX.test(v));
+        const allCuid = validValues.every(v => typeof v === 'string' && CUID_REGEX.test(v));
+        if (allUuid) {
+            if (isPk) extraLines.push(`            isId: "uuid"`);
+        } else if (allCuid) {
+            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            }`);
+        }
+
+        // Text Lengths, Multiline & Markdown
+        let maxLength = 0;
+        let hasNewlines = false;
+        let hasMarkdown = false;
+        for (const v of validValues) {
+            if (typeof v === "string") {
+                if (v.length > maxLength) maxLength = v.length;
+                if (v.includes("\n")) hasNewlines = true;
+                if (/^#{1,6}\s+.+/m.test(v) || /\*\*.+\*\*/.test(v) || /\[.+\]\(.+\)/.test(v) || /^\s*[-*]\s+.+/m.test(v)) {
+                    hasMarkdown = true;
+                }
+            }
+        }
+
+        if (hasMarkdown) {
+            extraLines.push(`            multiline: true,\n            markdown: true`);
+        } else if (hasNewlines || maxLength > 100) {
+            extraLines.push(`            multiline: true`);
+        }
+
+        if (maxLength > 0 && maxLength < 10000) { // arbitrary cap to avoid huge limits
+            // Pad the max length slightly for the constraint
+            const paddedMax = Math.ceil((maxLength * 1.5) / 10) * 10;
+            // Only add length constraint if it seems like a bounded string, not a long text
+            if (paddedMax < 255) {
+                extraLines.push(`            validation: {\n                max: ${paddedMax}\n            }`);
+            }
+        }
+
+        // Storage & Media (Extracted from old logic)
+        const isUrl = colNameLower.endsWith("_url") || colNameLower.endsWith("_uri") || colNameLower.endsWith("_link");
+        const isMedia = colNameLower.includes("image") || colNameLower.includes("avatar") || colNameLower.includes("photo") || colNameLower.includes("logo") || colNameLower.includes("cover");
+
+        const allAbsoluteUrls = validValues.every(v => typeof v === 'string' && (v.startsWith("http://") || v.startsWith("https://")));
+        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            }`);
+            } else {
+                extraLines.push(`            ui: {\n                url: true\n            }`);
+            }
+        } else {
+            const hasFileExtension = validValues.some(v => typeof v === 'string' && v.match(/\.[a-zA-Z0-9]+$/));
+            if (hasFileExtension) {
+                const firstVal = validValues[0] as string;
+                const lastSlash = firstVal.lastIndexOf('/');
+                let inferredStoragePath = lastSlash > 0 ? firstVal.substring(0, lastSlash) : "files";
+                extraLines.push(`            storage: {\n                storagePath: "${inferredStoragePath}"\n            }`);
+            } else if (isUrl) {
+                if (isMedia) {
+                    extraLines.push(`            ui: {\n                url: "image"\n            }`);
+                } else {
+                    extraLines.push(`            ui: {\n                url: true\n            }`);
+                }
+            }
+        }
+    }
+
+    result.extra = extraLines.length > 0 ? "\n" + extraLines.join(",\n") + "," : "";
+    return result;
+}