@rebasepro/server-postgresql 0.5.0 → 0.6.0

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) => {

package/src/schema/introspect-db.ts

@@ -18,8 +18,9 @@ import {
     generateCollectionFile,
     generateIndexContent,
     mergeIndexContent,
-    safeHostFromUrl,
+    safeHostFromUrl
 } from "./introspect-db-logic";
+import { logger } from "@rebasepro/server-core";
 
 async function main() {
     const args = arg(
@@ -31,15 +32,15 @@ async function main() {
             "--data-inference": Boolean,
             "-o": "--output",
             "-c": "--collections",
-            "-f": "--force",
+            "-f": "--force"
         },
         { permissive: true }
     );
 
     const cwd = process.cwd();
     const isBackendDir = path.basename(cwd) === "backend";
-    const defaultOutDir = isBackendDir 
-        ? path.resolve(cwd, "..", "config", "collections") 
+    const defaultOutDir = isBackendDir
+        ? path.resolve(cwd, "..", "config", "collections")
         : path.resolve(cwd, "config", "collections");
 
     const outDir = args["--output"] || args["--collections"] || defaultOutDir;
@@ -67,7 +68,7 @@ async function main() {
 
     const databaseUrl = process.env.DATABASE_URL || process.env.ADMIN_CONNECTION_STRING;
     if (!databaseUrl) {
-        console.error(chalk.red("✗ DATABASE_URL is not set. Make sure your .env file is configured."));
+        logger.error(chalk.red("✗ DATABASE_URL is not set. Make sure your .env file is configured."));
         process.exit(1);
     }
 
@@ -76,15 +77,15 @@ async function main() {
     try {
         await client.connect();
     } catch (err) {
-        console.error(chalk.red(`✗ Failed to connect to database: ${err instanceof Error ? err.message : String(err)}`));
-        console.error(chalk.gray("  Check your DATABASE_URL and ensure the database is reachable."));
+        logger.error(chalk.red(`✗ Failed to connect to database: ${err instanceof Error ? err.message : String(err)}`));
+        logger.error(chalk.gray("  Check your DATABASE_URL and ensure the database is reachable."));
         process.exit(1);
     }
 
     // Log the host portion safely — handle URLs without "@"
     const hostPart = safeHostFromUrl(databaseUrl);
-    console.log(chalk.gray(`Connected to database: ${hostPart}`));
-    console.log(chalk.gray(`Introspecting schema '${pgSchema}'...`));
+    logger.info(chalk.gray(`Connected to database: ${hostPart}`));
+    logger.info(chalk.gray(`Introspecting schema '${pgSchema}'...`));
 
     try {
         // 1. Get Tables
@@ -162,7 +163,7 @@ async function main() {
         const tablesMap = buildTablesMap(tables, columns, pks, fks);
         const joinTables = identifyJoinTables(tablesMap);
 
-        console.log(chalk.blue(`Found ${tablesMap.size} tables (including ${joinTables.size} detected join tables).`));
+        logger.info(chalk.blue(`Found ${tablesMap.size} tables (including ${joinTables.size} detected join tables).`));
 
         let runDataInference = false;
         if (args["--data-inference"] !== undefined) {
@@ -173,12 +174,12 @@ async function main() {
                 output: process.stdout
             });
             const answer = await new Promise<string>((resolve) => rl.question(chalk.yellow("? Do you want to run comprehensive data inference on sampled rows to auto-detect types, formats, constraints, and UI configurations? (y/N) "), resolve));
-            runDataInference = answer.trim().toLowerCase() === 'y';
+            runDataInference = answer.trim().toLowerCase() === "y";
             rl.close();
         }
 
         if (runDataInference) {
-            console.log(chalk.gray(`Sampling database rows for data inference...`));
+            logger.info(chalk.gray("Sampling database rows for data inference..."));
         }
 
         // Generate Collections
@@ -186,11 +187,11 @@ async function main() {
         const skippedFiles: string[] = [];
 
         const tablesToProcess = Array.from(tablesMap.entries()).filter(([tableName]) => !joinTables.has(tableName));
-        
+
         const BATCH_SIZE = 10;
         for (let i = 0; i < tablesToProcess.length; i += BATCH_SIZE) {
             const batch = tablesToProcess.slice(i, i + BATCH_SIZE);
-            
+
             await Promise.all(batch.map(async ([tableName, meta]) => {
                 // ── File overwrite protection ──────────────────────────────
                 const filePath = path.join(outDir, `${tableName}.ts`);
@@ -205,7 +206,7 @@ async function main() {
                         const { rows } = await client.query(`SELECT * FROM "${pgSchema}"."${tableName}" LIMIT 100`);
                         sampleData = rows;
                     } catch (err) {
-                        console.error(chalk.yellow(`⚠ Failed to sample data for table ${tableName}: ${err instanceof Error ? err.message : String(err)}`));
+                        logger.error(chalk.yellow(`⚠ Failed to sample data for table ${tableName}: ${err instanceof Error ? err.message : String(err)}`));
                     }
                 }
 
@@ -216,12 +217,12 @@ async function main() {
                     joinTables,
                     tablesMap,
                     enumMap,
-                    sampleData,
+                    sampleData
                 );
 
                 fs.writeFileSync(filePath, fileContent, "utf-8");
                 generatedFiles.push(tableName);
-                console.log(chalk.green(`  ✓ ${filePath}`));
+                logger.info(chalk.green(`  ✓ ${filePath}`));
             }));
         }
 
@@ -238,21 +239,21 @@ async function main() {
                 const indexContent = generateIndexContent(generatedFiles);
                 fs.writeFileSync(indexPath, indexContent, "utf-8");
             }
-            console.log(chalk.green(`  ✓ ${indexPath}`));
+            logger.info(chalk.green(`  ✓ ${indexPath}`));
         }
 
-        console.log("");
+        logger.info("");
         if (skippedFiles.length > 0) {
-            console.log(chalk.yellow(`⚠ Skipped ${skippedFiles.length} existing file(s): ${skippedFiles.join(", ")}`));
-            console.log(chalk.gray(`  Use --force to overwrite existing files.`));
-            console.log("");
+            logger.info(chalk.yellow(`⚠ Skipped ${skippedFiles.length} existing file(s): ${skippedFiles.join(", ")}`));
+            logger.info(chalk.gray("  Use --force to overwrite existing files."));
+            logger.info("");
         }
-        console.log(chalk.bold.green(`✓ Introspected ${tablesMap.size} tables — generated ${generatedFiles.length} collection(s).`));
-        console.log(chalk.gray(`  Review the generated files in ${outDir} and customize properties as needed.`));
-        console.log("");
+        logger.info(chalk.bold.green(`✓ Introspected ${tablesMap.size} tables — generated ${generatedFiles.length} collection(s).`));
+        logger.info(chalk.gray(`  Review the generated files in ${outDir} and customize properties as needed.`));
+        logger.info("");
 
     } catch (e) {
-        console.error(chalk.red(`✗ Error introspecting database: ${e instanceof Error ? e.message : String(e)}`));
+        logger.error(chalk.red(`✗ Error introspecting database: ${e instanceof Error ? e.message : String(e)}`));
         process.exit(1);
     } finally {
         await client.end();
@@ -260,6 +261,6 @@ async function main() {
 }
 
 main().catch((err) => {
-    console.error(err);
+    logger.error(String(err));
     process.exit(1);
 });