@rebasepro/server-postgresql 0.4.0 → 0.6.0

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

@@ -3,6 +3,7 @@ import { getPrimaryKeys } from "../services/entity-helpers";
 import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 import { createHash } from "crypto";
+import { logger } from "@rebasepro/server-core";
 // --- Helper Functions ---
 
 /**
@@ -41,6 +42,31 @@ type: "string",
 isUuid: isUuid ?? false };
 };
 
+/**
+ * Given a raw DB column name (e.g. "client_id"), find the Drizzle property key
+ * on the collection that maps to that column. A property matches if:
+ *   (a) it has an explicit `columnName` equal to the given column, OR
+ *   (b) its snake_case form equals the given column.
+ *
+ * Returns the property key (the Drizzle object key) if found, or the original
+ * column name as a fallback.
+ */
+const resolvePropertyKeyForColumn = (collection: EntityCollection, column: string): string => {
+    if (!collection.properties) return column;
+    for (const [propKey, prop] of Object.entries(collection.properties)) {
+        const p = prop as Property;
+        // Explicit columnName match
+        if ("columnName" in p && typeof (p as unknown as Record<string, unknown>).columnName === "string") {
+            if ((p as unknown as Record<string, unknown>).columnName === column) return propKey;
+        }
+        // Convention match: snake_case(propKey) === column
+        if (toSnakeCase(propKey) === column) return propKey;
+        // Exact match (propKey is already the column name)
+        if (propKey === column) return propKey;
+    }
+    return column;
+};
+
 const isNumericId = (collection: EntityCollection): boolean => {
     return getPrimaryKeyProp(collection).type === "number";
 };
@@ -143,7 +169,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             }
             // autoValue: database-level default for initial value on INSERT
             if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
-                columnDefinition += `.default(sql\`now()\`)`;
+                columnDefinition += ".default(sql`now()`)";
             }
             break;
         }
@@ -206,7 +232,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
 
             // The localKey property is the source of truth for the FK column name.
             if (!relation.localKey) {
-                console.warn(`Could not generate column for owning relation '${relation.relationName}' on '${collection.name}': 'localKey' is not defined.`);
+                logger.warn(`Could not generate column for owning relation '${relation.relationName}' on '${collection.name}': 'localKey' is not defined.`);
                 return null;
             }
 
@@ -296,7 +322,7 @@ const resolveRawSql = (expression: string): string => {
  */
 const wrapWithRoleCheck = (clause: string, roles: string[]): string => {
     const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
-    const roleCondition = `string_to_array(auth.roles(), ',') @> ${rolesArrayString}`;
+    const roleCondition = `string_to_array(auth.roles(), ',') && ${rolesArrayString}`;
     return `sql\`(${unwrapSql(clause)}) AND (${roleCondition})\``;
 };
 
@@ -410,13 +436,13 @@ const generateSinglePolicyCode = (collection: EntityCollection, rule: SecurityRu
         } else if (needsUsing) {
             // Roles-only rule (e.g. { operation: "select", roles: ["admin"] })
             const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
-            usingClause = `sql\`string_to_array(auth.roles(), ',') @> ${rolesArrayString}\``;
+            usingClause = `sql\`string_to_array(auth.roles(), ',') && ${rolesArrayString}\``;
         }
         if (withCheckClause) {
             withCheckClause = wrapWithRoleCheck(withCheckClause, roles);
         } else if (needsWithCheck) {
             const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
-            withCheckClause = `sql\`string_to_array(auth.roles(), ',') @> ${rolesArrayString}\``;
+            withCheckClause = `sql\`string_to_array(auth.roles(), ',') && ${rolesArrayString}\``;
         }
     }
 
@@ -466,15 +492,22 @@ const computeSharedRelationName = (
 
     // --- owning one (belongs-to) ---
     if (rel.direction === "owning" && rel.cardinality === "one" && rel.localKey) {
-        return `${getTableName(sourceCollection)}_${rel.localKey}`;
+        // Normalise the localKey to the actual Drizzle property name so that
+        // the owning side produces the same relation name as the inverse side
+        // (which resolves foreignKeyOnTarget via the same helper).
+        const normalisedKey = resolvePropertyKeyForColumn(sourceCollection, rel.localKey);
+        return `${getTableName(sourceCollection)}_${normalisedKey}`;
     }
 
     // --- inverse many (one-to-many has-many) ---
     if (rel.direction === "inverse" && rel.cardinality === "many" && rel.foreignKeyOnTarget) {
-        // The owning table is the *target*, the FK column is foreignKeyOnTarget
+        // The owning table is the *target*, the FK column is foreignKeyOnTarget.
+        // Resolve to the Drizzle property key on the target so it matches the
+        // owning side's normalised localKey.
         try {
             const targetCollection = rel.target();
-            return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+            const normalisedFK = resolvePropertyKeyForColumn(targetCollection, rel.foreignKeyOnTarget);
+            return `${getTableName(targetCollection)}_${normalisedFK}`;
         } catch {
             return fallback;
         }
@@ -483,10 +516,11 @@ const computeSharedRelationName = (
     // --- inverse one (one-to-one inverse) ---
     if (rel.direction === "inverse" && rel.cardinality === "one") {
         if (rel.foreignKeyOnTarget) {
-            // FK lives on the target table
+            // FK lives on the target table — resolve to Drizzle property key
             try {
                 const targetCollection = rel.target();
-                return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+                const normalisedFK = resolvePropertyKeyForColumn(targetCollection, rel.foreignKeyOnTarget);
+                return `${getTableName(targetCollection)}_${normalisedFK}`;
             } catch {
                 return fallback;
             }
@@ -521,7 +555,6 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
     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")
@@ -812,23 +845,23 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                                     const junctionTableVar = getTableVarName(correspondingRelation.through.table);
                                     tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
                                 } else {
-                                    console.warn(`Could not find corresponding owning many-to-many relation for inverse relation '${relationKey}' on '${collection.name}'`);
+                                    logger.warn(`Could not find corresponding owning many-to-many relation for inverse relation '${relationKey}' on '${collection.name}'`);
                                 }
                             } catch (e) {
-                                console.warn(`Could not resolve inverse many-to-many relation '${relationKey}':`, e);
+                                logger.warn(`Could not resolve inverse many-to-many relation '${relationKey}'`, { error: e });
                             }
                         }
                         // joinPath relations don't generate Drizzle relations - they use existing user tables
                     }
                 } catch (e) {
-                    console.warn(`Could not generate relation ${relationKey} for ${collection.name}:`, e);
+                    logger.warn(`Could not generate relation ${relationKey} for ${collection.name}`, { error: 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) {
@@ -837,11 +870,16 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                             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    })`);
+                                    // Resolve foreignKeyOnTarget to the Drizzle property key
+                                    // on THIS collection (the owning table). The raw FK column
+                                    // name (e.g. "client_id") may differ from the property key
+                                    // (e.g. "clientId") when `columnName` is set.
+                                    const drizzleFieldKey = resolvePropertyKeyForColumn(collection, otherRel.foreignKeyOnTarget);
+                                    const synthKey = `_synth_${otherTableVar}_${drizzleFieldKey}`;
+                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${drizzleFieldKey}],\n        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
                                     emittedRelationNames.add(deduplicationKey);
                                 }
                             }

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

@@ -5,6 +5,7 @@ import { pathToFileURL } from "url";
 import chokidar from "chokidar";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { EntityCollection } from "@rebasepro/types";
+import { logger } from "@rebasepro/server-core";
 
 
 // --- Helper Functions ---
@@ -48,7 +49,7 @@ const formatTerminalText = (text: string, options: {
 const runGeneration = async (collectionsFilePath?: string, outputPath?: string) => {
     try {
         if (!collectionsFilePath) {
-            console.error("Error: No collections file path provided. Skipping schema generation.");
+            logger.error("Error: No collections file path provided. Skipping schema generation.");
             return;
         }
 
@@ -74,7 +75,7 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
                         }
                     } catch (err: unknown) {
                         const message = err instanceof Error ? err.message : String(err);
-                        console.error(`Error loading ${file}:`, message);
+                        logger.error(`Error loading ${file}`, { detail: message });
                     }
                 }
             }
@@ -91,7 +92,6 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
         }
 
 
-
         // Sort collections by slug alphabetically to ensure deterministic schema generation
         collections.sort((a, b) => a.slug.localeCompare(b.slug));
 
@@ -101,20 +101,20 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             const outputDir = path.dirname(outputPath);
             await fsPromises.mkdir(outputDir, { recursive: true });
             await fsPromises.writeFile(outputPath, schemaContent);
-            console.log("✅ Drizzle schema generated successfully at", outputPath);
+            logger.info("✅ Drizzle schema generated successfully at", { detail: outputPath });
         } else {
-            console.log("✅ Drizzle schema generated successfully.");
-            console.log(schemaContent);
+            logger.info("✅ Drizzle schema generated successfully.");
+            logger.info(String(schemaContent));
         }
 
-        console.log(`You can now run ${formatTerminalText("rebase db generate", {
+        logger.info(`You can now run ${formatTerminalText("rebase db generate", {
             bold: true,
             backgroundColor: "blue",
             textColor: "black"
         })} to generate the SQL migration files.`);
 
     } catch (error) {
-        console.error("Error generating schema:", error);
+        logger.error("Error generating schema", { error: error });
     }
 };
 
@@ -128,7 +128,7 @@ const main = () => {
     const watch = process.argv.includes("--watch");
 
     if (!collectionsFilePath) {
-        console.log("Usage: ts-node generate-drizzle-schema.ts <path-to-collections-file> [--output <path-to-output-file>] [--watch]");
+        logger.info("Usage: ts-node generate-drizzle-schema.ts <path-to-collections-file> [--output <path-to-output-file>] [--watch]");
         return;
     }
 
@@ -136,14 +136,14 @@ const main = () => {
     const resolvedOutputPath = outputPath ? path.resolve(process.cwd(), outputPath) : undefined;
 
     if (watch) {
-        console.log(`Watching for changes in ${resolvedPath}...`);
+        logger.info(`Watching for changes in ${resolvedPath}...`);
         const watcher = chokidar.watch(resolvedPath, {
             persistent: true,
             ignoreInitial: false
         });
 
         watcher.on("all", (event, filePath) => {
-            console.log(`[${event}] ${filePath}. Regenerating schema...`);
+            logger.info(`[${event}] ${filePath}. Regenerating schema...`);
             runGeneration(resolvedPath, resolvedOutputPath);
         });
     } else {

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

@@ -45,15 +45,15 @@ export function inferPropertyFromData(
             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            }`);
+                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            }`);
+                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            }`);
+            extraLines.push("            ui: {\n                currency: true\n            }");
         }
     }
 
@@ -94,7 +94,7 @@ export function inferPropertyFromData(
             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> = {};
@@ -115,7 +115,7 @@ export function inferPropertyFromData(
                         }
                     }
                 }
-                
+
                 const keys = Object.keys(schema).filter(k => schema[k] !== "mixed");
                 if (keys.length > 0) {
                     const props = keys.map(k => {
@@ -123,10 +123,10 @@ export function inferPropertyFromData(
                     }).join(",");
                     extraLines.push(`            properties: {${props}\n            }`);
                 } else {
-                    extraLines.push(`            keyValue: true`);
+                    extraLines.push("            keyValue: true");
                 }
             } else {
-                extraLines.push(`            keyValue: true`);
+                extraLines.push("            keyValue: true");
             }
         }
     }
@@ -134,7 +134,7 @@ export function inferPropertyFromData(
     // ── String Analysis ──────────────────────────────────────────────────
     if (currentPropType === "string") {
         // Date/Time Strings
-        if (validValues.every(v => typeof v === 'string' && ISO_8601_REGEX.test(v))) {
+        if (validValues.every(v => typeof v === "string" && ISO_8601_REGEX.test(v))) {
             result.propType = "date";
             return result;
         }
@@ -148,7 +148,7 @@ export function inferPropertyFromData(
                 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");
@@ -161,18 +161,18 @@ export function inferPropertyFromData(
         }
 
         // 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));
+        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"`);
+            if (isPk) extraLines.push("            isId: \"uuid\"");
         } else if (allCuid) {
-            if (isPk) extraLines.push(`            isId: "cuid"`);
+            if (isPk) extraLines.push("            isId: \"cuid\"");
         }
 
         // Color Codes
-        const allColors = validValues.every(v => typeof v === 'string' && COLOR_HEX_REGEX.test(v));
+        const allColors = validValues.every(v => typeof v === "string" && COLOR_HEX_REGEX.test(v));
         if (allColors) {
-            extraLines.push(`            ui: {\n                color: true\n            }`);
+            extraLines.push("            ui: {\n                color: true\n            }");
         }
 
         // Text Lengths, Multiline & Markdown
@@ -190,9 +190,9 @@ export function inferPropertyFromData(
         }
 
         if (hasMarkdown) {
-            extraLines.push(`            multiline: true,\n            markdown: true`);
+            extraLines.push("            multiline: true,\n            markdown: true");
         } else if (hasNewlines || maxLength > 100) {
-            extraLines.push(`            multiline: true`);
+            extraLines.push("            multiline: true");
         }
 
         if (maxLength > 0 && maxLength < 10000) { // arbitrary cap to avoid huge limits
@@ -208,26 +208,26 @@ export function inferPropertyFromData(
         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://")));
+        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));
+            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("            ui: {\n                url: \"image\"\n            }");
             } else {
-                extraLines.push(`            ui: {\n                url: true\n            }`);
+                extraLines.push("            ui: {\n                url: true\n            }");
             }
         } else {
-            const hasFileExtension = validValues.some(v => typeof v === 'string' && v.match(/\.[a-zA-Z0-9]+$/));
+            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('/');
+                const lastSlash = firstVal.lastIndexOf("/");
                 const 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            }`);
+                    extraLines.push("            ui: {\n                url: \"image\"\n            }");
                 } else {
-                    extraLines.push(`            ui: {\n                url: true\n            }`);
+                    extraLines.push("            ui: {\n                url: true\n            }");
                 }
             }
         }

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

@@ -63,7 +63,7 @@ const IRREGULAR_SINGULARS: Record<string, string> = {
     data: "datum",
     media: "medium",
     criteria: "criterion",
-    phenomena: "phenomenon",
+    phenomena: "phenomenon"
 };
 
 /** Words ending in 's' that are already singular. */
@@ -73,7 +73,7 @@ const UNCOUNTABLE = new Set([
     "synopsis", "parenthesis", "hypothesis", "emphasis",
     "news", "series", "species", "means", "athletics",
     "economics", "electronics", "mathematics", "physics",
-    "politics", "statistics",
+    "politics", "statistics"
 ]);
 
 export function singularize(word: string): string {
@@ -165,10 +165,10 @@ export function mapPgType(dataType: string): string {
 
     // Numeric types
     if (
-        dt.includes("int") ||        // integer, smallint, bigint
+        dt.includes("int") || // integer, smallint, bigint
         dt.includes("numeric") ||
         dt.includes("decimal") ||
-        dt.includes("serial") ||     // serial, bigserial
+        dt.includes("serial") || // serial, bigserial
         dt === "real" ||
         dt === "float4" ||
         dt === "float8" ||
@@ -281,7 +281,7 @@ export interface PropertyOrderingContext {
 const IDENTITY_EXACT: Record<string, number> = {
     id: 0,
     uuid: 1,
-    _id: 2,
+    _id: 2
 };
 
 // — Tier 1: Title / Name — the "display column" (10–19) ———————————————
@@ -293,7 +293,7 @@ const TITLE_EXACT: Record<string, number> = {
     displayname: 13,
     headline: 14,
     subject: 15,
-    heading: 16,
+    heading: 16
 };
 
 // — Tier 2: Human identity fields (20–29) —————————————————————————————
@@ -313,7 +313,7 @@ const HUMAN_IDENTITY_EXACT: Record<string, number> = {
     email_address: 26,
     phone: 27,
     phone_number: 27,
-    mobile: 27,
+    mobile: 27
 };
 
 // — Tier 3: Core descriptors (30–39) ——————————————————————————————————
@@ -333,7 +333,7 @@ const DESCRIPTOR_EXACT: Record<string, number> = {
     priority: 39,
     order: 39,
     sort_order: 39,
-    position: 39,
+    position: 39
 };
 
 // — Tier 12: System timestamps (120–129) ——————————————————————————————
@@ -348,7 +348,7 @@ const SYSTEM_TIMESTAMP_EXACT: Record<string, number> = {
     last_modified: 122,
     deleted_at: 123,
     deletedat: 123,
-    archived_at: 124,
+    archived_at: 124
 };
 
 // — Pattern-based rules for partial matches ———————————————————————————
@@ -370,7 +370,7 @@ const JSON_MAP_NAMES = new Set(["metadata", "meta", "config", "configuration", "
  */
 export function computePropertyPriority(
     columnName: string,
-    ctx: PropertyOrderingContext,
+    ctx: PropertyOrderingContext
 ): number {
     // Normalize camelCase/PascalCase to snake_case, then lowercase
     const col = columnName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
@@ -521,7 +521,7 @@ export function generateCollectionFile(
     joinTables: Set<string>,
     tablesMap: Map<string, TableMeta>,
     enumMap: Map<string, string[]>,
-    sampleData?: Record<string, unknown>[],
+    sampleData?: Record<string, unknown>[]
 ): string {
     const collectionName = humanize(tableName);
     const singular = singularize(collectionName);
@@ -529,8 +529,8 @@ export function generateCollectionFile(
 
     const imports = new Set<string>(['import { PostgresCollection } from "@rebasepro/types";']);
 
-    let propsOutput = ``;
-    let relationsOutput = ``;
+    let propsOutput = "";
+    let relationsOutput = "";
     const orderEntries: PropertyOrderEntry[] = [];
     const propertyBlocks = new Map<string, string>();
     let columnIndex = 0;
@@ -559,7 +559,7 @@ export function generateCollectionFile(
         // ── Data Inference Engine ────────────────────────────────────────────
         let finalPropType = propType;
         let inferenceExtra = "";
-        
+
         if (!isEnumColumn && sampleData && sampleData.length > 0) {
             const values = sampleData.map(r => r[col.column_name]);
             const inferred = inferPropertyFromData(col.column_name, col.data_type, propType, values, meta.pks.includes(col.column_name));
@@ -578,11 +578,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            ui: {\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            ui: {\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            ui: {\n                readOnly: true\n            },";
             }
         }
 
@@ -602,7 +602,7 @@ export function generateCollectionFile(
             }
             extra += `\n            of: { name: "${humanize(col.column_name)} Item", type: "${innerType}" },`;
         } else if (finalPropType === "map" && !inferenceExtra.includes("keyValue: true") && !inferenceExtra.includes("properties: {")) {
-            extra += `\n            keyValue: true,`;
+            extra += "\n            keyValue: true,";
         }
 
         // String sub-type heuristics (Fallback if not handled by inference or enum)
@@ -613,16 +613,16 @@ 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            ui: {\n                url: true\n            },";
             } else if (colNameLower === "description" || colNameLower === "summary" || colNameLower === "excerpt") {
-                extra += `\n            multiline: true,`;
+                extra += "\n            multiline: true,";
             } else if (colNameLower === "content" || colNameLower === "body") {
-                extra += `\n            multiline: true,\n            markdown: true,`;
+                extra += "\n            multiline: true,\n            markdown: true,";
             } else if (col.data_type === "text") {
-                extra += `\n            multiline: true,`;
+                extra += "\n            multiline: true,";
             }
         }
-        
+
         // Append inference results
         if (inferenceExtra) {
             extra += inferenceExtra;
@@ -634,11 +634,11 @@ export function generateCollectionFile(
             if (isCompositePk) {
                 extra += `\n            // Part of composite primary key (${meta.pks.join(", ")})`;
             } else if (finalPropType === "number" && !inferenceExtra.includes("isId:")) {
-                extra += `\n            isId: "increment",`;
+                extra += "\n            isId: \"increment\",";
             } else if (col.data_type.toLowerCase() === "uuid" && !inferenceExtra.includes("isId:")) {
-                extra += `\n            isId: "uuid",`;
+                extra += "\n            isId: \"uuid\",";
             } else if (!inferenceExtra.includes("isId:")) {
-                extra += `\n            isId: "uuid", // Verify if this is a UUID or CUID`;
+                extra += "\n            isId: \"uuid\", // Verify if this is a UUID or CUID";
             }
         }
 
@@ -651,7 +651,7 @@ export function generateCollectionFile(
             if (extra.includes("validation: {")) {
                 extra = extra.replace("validation: {", "validation: {\n                required: true,");
             } else {
-                extra += `\n            validation: {\n                required: true\n            },`;
+                extra += "\n            validation: {\n                required: true\n            },";
             }
         }
 
@@ -665,8 +665,8 @@ export function generateCollectionFile(
                 isEnum: isEnumColumn,
                 isStorage: extra.includes("storage: {") || inferenceExtra.includes("storage: {"),
                 pgDataType: col.data_type,
-                originalIndex: currentIndex,
-            },
+                originalIndex: currentIndex
+            }
         });
 
         propertyBlocks.set(col.column_name, `
@@ -696,8 +696,8 @@ export function generateCollectionFile(
                     isEnum: false,
                     isStorage: false,
                     pgDataType: "",
-                    originalIndex: columnIndex++,
-                },
+                    originalIndex: columnIndex++
+                }
             });
 
             const targetCollectionCamel = toCollectionVarName(targetTableName);
@@ -794,7 +794,7 @@ export function generateCollectionFile(
             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.`;
+                throughCode = "\n            // Make sure the target collection configures the 'through' property.";
             }
 
             relationsOutput += `
@@ -860,10 +860,10 @@ export function mergeIndexContent(existingContent: string, newFileNames: string[
         [...existingContent.matchAll(/import\s+([a-zA-Z0-9_]+)\s+from\s+"\.\/([^"]+)"/g)].map((m) => m[2])
     );
     const sorted = [...newFileNames].sort();
-    
+
     let newImports = "";
     let newElements = "";
-    
+
     for (const f of sorted) {
         if (!existingImports.has(f)) {
             const varName = toCollectionVarName(f);
@@ -871,9 +871,9 @@ export function mergeIndexContent(existingContent: string, newFileNames: string[
             newElements += `    ${varName},\n`;
         }
     }
-    
+
     if (!newImports) return existingContent;
-    
+
     // Simple injection logic:
     // Add new imports below the last import or at the top
     const importRegex = /import\s+.*?;/g;
@@ -882,7 +882,7 @@ export function mergeIndexContent(existingContent: string, newFileNames: string[
     while ((match = importRegex.exec(existingContent)) !== null) {
         lastImportMatch = match;
     }
-    
+
     let contentWithImports = existingContent;
     if (lastImportMatch) {
         const pos = lastImportMatch.index + lastImportMatch[0].length;
@@ -890,7 +890,7 @@ export function mergeIndexContent(existingContent: string, newFileNames: string[
     } else {
         contentWithImports = newImports + "\n" + existingContent;
     }
-    
+
     // Inject into the `collections = [...]` array
     const arrayRegex = /export\s+const\s+collections\s*=\s*\[([\s\S]*?)\];/;
     return contentWithImports.replace(arrayRegex, (fullMatch, arrayContent) => {