@rebasepro/server-postgresql 0.4.0 → 0.6.0

package/src/data-transformer.ts

@@ -6,6 +6,7 @@ import { getTableName, resolveCollectionRelations, findRelation, createRelationR
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "./utils/drizzle-conditions";
 import { getPrimaryKeys, buildCompositeId } from "./services/entity-helpers";
+import { logger } from "@rebasepro/server-core";
 
 /**
  * Data transformation utilities for converting between frontend and database formats.
@@ -90,7 +91,9 @@ export function serializeDataToServer<M extends Record<string, unknown>>(
     collection?: EntityCollection,
     registry?: PostgresCollectionRegistry
 ): SerializedEntityData {
-    if (!entity || !properties) return { scalarData: entity ?? {}, inverseRelationUpdates: [], joinPathRelationUpdates: [] };
+    if (!entity || !properties) return { scalarData: entity ?? {},
+inverseRelationUpdates: [],
+joinPathRelationUpdates: [] };
 
     const result: Record<string, unknown> = {};
 
@@ -128,7 +131,6 @@ export function serializeDataToServer<M extends Record<string, unknown>>(
         }
 
 
-
         // Handle relation properties specially
         if (property.type === "relation" && collection) {
             const relation = findRelation(resolvedRelations, key);
@@ -272,41 +274,19 @@ export function serializePropertyToServer(value: unknown, property: Property): u
             return value;
         }
 
-        case "binary":
-            if (typeof value === "string") {
-                if (value.startsWith("data:application/octet-stream;base64,")) {
-                    const base64Data = value.split(",")[1];
-                    if (base64Data) {
-                        return Buffer.from(base64Data, "base64");
-                    }
-                }
-            }
-            if (Buffer.isBuffer(value)) {
-                return value;
-            }
+        case "binary": {
+            const decoded = tryDecodeBase64DataUrl(value);
+            if (decoded) return decoded;
+            if (Buffer.isBuffer(value)) return value;
             return value;
+        }
 
         case "string":
-            if (typeof value === "string") {
-                if (value.startsWith("data:application/octet-stream;base64,")) {
-                    const base64Data = value.split(",")[1];
-                    if (base64Data) {
-                        return Buffer.from(base64Data, "base64");
-                    }
-                }
-            }
-            return value;
-
-        default:
-            if (typeof value === "string") {
-                if (value.startsWith("data:application/octet-stream;base64,")) {
-                    const base64Data = value.split(",")[1];
-                    if (base64Data) {
-                        return Buffer.from(base64Data, "base64");
-                    }
-                }
-            }
+        default: {
+            const decoded = tryDecodeBase64DataUrl(value);
+            if (decoded) return decoded;
             return value;
+        }
     }
 }
 
@@ -342,7 +322,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             const targetCollection = relation.target();
                             result[propKey] = createRelationRef(fkValue.toString(), targetCollection.slug);
                         } catch (e) {
-                            console.warn(`Could not resolve target collection for relation property: ${propKey}`, e);
+                            logger.warn(`Could not resolve target collection for relation property: ${propKey}`, { error: e });
                         }
                     }
                 } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget && db && registry) {
@@ -372,7 +352,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                                     } else {
                                         // One-to-many: return array of relation objects
                                         const targetPks = getPrimaryKeys(targetCollection, registry!);
-                                        result[propKey] = relatedEntities.map((entity: Record<string, unknown>) => 
+                                        result[propKey] = relatedEntities.map((entity: Record<string, unknown>) =>
                                             createRelationRef(buildCompositeId(entity, targetPks), targetCollection.slug)
                                         );
                                     }
@@ -380,7 +360,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             }
                         }
                     } catch (e) {
-                        console.warn(`Could not resolve inverse relation property: ${propKey}`, e);
+                        logger.warn(`Could not resolve inverse relation property: ${propKey}`, { error: e });
                     }
                 } else if (relation.direction === "inverse" && relation.joinPath && db && registry) {
                     // Join path relation: Multi-hop relation using joins
@@ -393,7 +373,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             // Build the join query following the join path
                             const sourceTable = registry.getTable(getTableName(collection));
                             if (!sourceTable) {
-                                console.warn(`Source table not found for collection: ${collection.slug}`);
+                                logger.warn(`Source table not found for collection: ${collection.slug}`);
                                 continue;
                             }
 
@@ -404,7 +384,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             for (const join of relation.joinPath) {
                                 const joinTable = registry.getTable(join.table);
                                 if (!joinTable) {
-                                    console.warn(`Join table not found: ${join.table}`);
+                                    logger.warn(`Join table not found: ${join.table}`);
                                     break;
                                 }
 
@@ -422,7 +402,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                                 const toCol = joinTable[toColName as keyof typeof joinTable] as AnyPgColumn;
 
                                 if (!fromCol || !toCol) {
-                                    console.warn(`Join columns not found: ${fromColumn} -> ${toColumn}`);
+                                    logger.warn(`Join columns not found: ${fromColumn} -> ${toColumn}`);
                                     break;
                                 }
 
@@ -436,7 +416,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                                 query = query.where(eq(sourceIdField, currentEntityId)) as typeof query;
                             } else {
                                 // For composite keys, we would need to map the split parts. For now log a warning.
-                                console.warn(`Join path resolution for composite primary keys is not yet fully supported: ${collection.slug}`);
+                                logger.warn(`Join path resolution for composite primary keys is not yet fully supported: ${collection.slug}`);
                             }
 
                             // Build additional conditions array
@@ -475,7 +455,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             }
                         }
                     } catch (e) {
-                        console.warn(`Could not resolve join path relation property: ${propKey}`, e);
+                        logger.warn(`Could not resolve join path relation property: ${propKey}`, { error: e });
                     }
                 }
             }
@@ -486,24 +466,53 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
 }
 
 /**
- * Parse a single property value from database format to frontend format
+ * Try to decode a `data:application/octet-stream;base64,...` data URL string
+ * into a Buffer. Returns null if the value is not a matching data URL.
  */
-export function parsePropertyFromServer(value: unknown, property: Property, collection: EntityCollection, propertyKey?: string): unknown {
-    if (value === null || value === undefined) {
-        return value;
+function tryDecodeBase64DataUrl(value: unknown): Buffer | null {
+    if (typeof value !== "string") return null;
+    if (!value.startsWith("data:application/octet-stream;base64,")) return null;
+    const base64Data = value.split(",")[1];
+    return base64Data ? Buffer.from(base64Data, "base64") : null;
+}
+
+/**
+ * Try to resolve an unknown value into a Buffer.
+ * Handles native Buffers and `{ type: "Buffer", data: number[] }` objects (from JSON deserialization).
+ * Returns null if the value is not a buffer.
+ */
+function tryResolveBuffer(value: unknown): Buffer | null {
+    if (Buffer.isBuffer(value)) return value;
+    if (typeof value === "object" && value !== null) {
+        const rawVal = value as Record<string, unknown>;
+        if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
+            return Buffer.from(rawVal.data as number[]);
+        }
     }
+    return null;
+}
+
+/**
+ * Convert a Buffer to a UTF-8 string if all bytes are printable ASCII,
+ * otherwise return a base64 data URL.
+ */
+function bufferToStringOrBase64(buf: Buffer): string {
+    for (let i = 0; i < buf.length; i++) {
+        const b = buf[i];
+        // Allow standard printable ASCII + common whitespace (\r, \n, \t)
+        if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+            return `data:application/octet-stream;base64,${buf.toString("base64")}`;
+        }
+    }
+    return buf.toString("utf8");
+}
+
+export function parsePropertyFromServer(value: unknown, property: Property, collection: EntityCollection, propertyKey?: string): unknown {
+    if (value === null || value === undefined) return value;
 
     switch (property.type) {
         case "binary": {
-            let buf: Buffer | null = null;
-            if (Buffer.isBuffer(value)) {
-                buf = value;
-            } else if (typeof value === "object" && value !== null) {
-                const rawVal = value as Record<string, unknown>;
-                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
-                    buf = Buffer.from(rawVal.data as number[]);
-                }
-            }
+            const buf = tryResolveBuffer(value);
             if (buf) {
                 return `data:application/octet-stream;base64,${buf.toString("base64")}`;
             }
@@ -512,36 +521,13 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
 
         case "string": {
             if (typeof value === "string") return value;
-            
+
             // Handle Buffer objects (e.g. from PostgreSQL bytea columns)
-            let isBuffer = false;
-            let buf: Buffer | null = null;
-            
-            if (Buffer.isBuffer(value)) {
-                isBuffer = true;
-                buf = value;
-            } else if (typeof value === "object" && value !== null) {
-                const rawVal = value as Record<string, unknown>;
-                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
-                    isBuffer = true;
-                    buf = Buffer.from(rawVal.data as number[]);
-                }
-            }
-            
-            if (isBuffer && buf) {
-                // Heuristic: if all bytes are printable ASCII, return utf8, else base64
-                let isPrintable = true;
-                for (let i = 0; i < buf.length; i++) {
-                    const b = buf[i];
-                    // Allow standard printable ASCII + common whitespace (\r, \n, \t)
-                    if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
-                        isPrintable = false;
-                        break;
-                    }
-                }
-                return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+            const buf = tryResolveBuffer(value);
+            if (buf) {
+                return bufferToStringOrBase64(buf);
             }
-            
+
             if (typeof value === "object" && value !== null) {
                 try {
                     return JSON.stringify(value);
@@ -565,7 +551,7 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
                 }
 
                 if (!relationDef) {
-                    console.warn(`Relation not defined in property for key: ${propertyKey || "unknown"}`);
+                    logger.warn(`Relation not defined in property for key: ${propertyKey || "unknown"}`);
                     return value;
                 }
 
@@ -573,7 +559,7 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
                     const targetCollection = relationDef.target();
                     return createRelationRef(value.toString(), targetCollection.slug);
                 } catch (e) {
-                    console.warn(`Could not resolve target collection for relation property: ${propertyKey || "unknown"}`, e);
+                    logger.warn(`Could not resolve target collection for relation property: ${propertyKey || "unknown"}`, { error: e });
                     return value;
                 }
             }
@@ -665,32 +651,10 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
 
         default: {
             // Fallback for buffers in case they are mapped to something other than string
-            let isBuffer = false;
-            let buf: Buffer | null = null;
-            
-            if (Buffer.isBuffer(value)) {
-                isBuffer = true;
-                buf = value;
-            } else if (typeof value === "object" && value !== null) {
-                const rawVal = value as Record<string, unknown>;
-                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
-                    isBuffer = true;
-                    buf = Buffer.from(rawVal.data as number[]);
-                }
-            }
-            
-            if (isBuffer && buf) {
-                let isPrintable = true;
-                for (let i = 0; i < buf.length; i++) {
-                    const b = buf[i];
-                    if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
-                        isPrintable = false;
-                        break;
-                    }
-                }
-                return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+            const buf = tryResolveBuffer(value);
+            if (buf) {
+                return bufferToStringOrBase64(buf);
             }
-            
             return value;
         }
     }

package/src/databasePoolManager.ts

@@ -1,6 +1,7 @@
 import { Pool } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { logger } from "@rebasepro/server-core";
 
 export class DatabasePoolManager {
     private pools: Map<string, Pool> = new Map();
@@ -18,7 +19,7 @@ export class DatabasePoolManager {
         }
     }
 
-    public getDrizzle(databaseName: string): NodePgDatabase<any> {
+    public getDrizzle(databaseName: string): NodePgDatabase<Record<string, never>> {
         const existing = this.drizzleInstances.get(databaseName);
         if (existing) {
             return existing;
@@ -47,7 +48,7 @@ export class DatabasePoolManager {
 
         // Prevent idle client errors from crashing the Node.js process
         pool.on("error", (err) => {
-            console.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, err);
+            logger.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, { error: err });
         });
 
         this.pools.set(databaseName, pool);
@@ -76,10 +77,11 @@ export class DatabasePoolManager {
     public async shutdown(): Promise<void> {
         const promises = [];
         for (const [dbName, pool] of this.pools.entries()) {
-            console.log(`[DatabasePoolManager] Shutting down pool for ${dbName}`);
+            logger.info(`[DatabasePoolManager] Shutting down pool for ${dbName}`);
             promises.push(pool.end());
         }
         await Promise.all(promises);
         this.pools.clear();
+        this.drizzleInstances.clear();
     }
 }

package/src/history/HistoryService.ts

@@ -1,5 +1,6 @@
 import { sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { logger } from "@rebasepro/server-core";
 
 export interface HistoryEntry {
     id: string;
@@ -99,10 +100,10 @@ export class HistoryService {
 
             // Non-blocking prune for this specific entity
             this.pruneEntity(tableName, entityId).catch(err =>
-                console.error("History prune failed:", err)
+                logger.error("History prune failed", { error: err })
             );
         } catch (error) {
-            console.error("Failed to record entity history:", error);
+            logger.error("Failed to record entity history", { error: error });
         }
     }
 

package/src/history/ensure-history-table.ts

@@ -1,5 +1,6 @@
 import { sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { logger } from "@rebasepro/server-core";
 
 /**
  * Auto-create the entity history table if it doesn't exist.
@@ -7,7 +8,7 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
  * pattern as `ensureAuthTablesExist`.
  */
 export async function ensureHistoryTableExists(db: NodePgDatabase): Promise<void> {
-    console.log("🔍 Checking entity history table...");
+    logger.info("🔍 Checking entity history table...");
 
     try {
         // Create the rebase schema (idempotent — may already exist from auth init)
@@ -37,9 +38,9 @@ export async function ensureHistoryTableExists(db: NodePgDatabase): Promise<void
             ON rebase.entity_history(table_name, entity_id, updated_at DESC)
         `);
 
-        console.log("✅ Entity history table ready");
+        logger.info("✅ Entity history table ready");
     } catch (error) {
-        console.error("❌ Failed to create entity history table:", error);
-        console.warn("⚠️ Continuing without creating history table.");
+        logger.error("❌ Failed to create entity history table", { error: error });
+        logger.warn("⚠️ Continuing without creating history table.");
     }
 }

package/src/schema/auth-schema.ts

@@ -4,7 +4,7 @@ import { relations } from "drizzle-orm";
 /**
  * Factory function to dynamically create the auth tables bound to the specified schema names.
  */
-export function createAuthSchema(usersSchemaName: string = "rebase") {
+export function createAuthSchema(usersSchemaName = "rebase") {
     const usersSchema = usersSchemaName === "public" ? null : pgSchema(usersSchemaName);
 
     const tableCreator = (usersSchema ? usersSchema.table.bind(usersSchema) : pgTable) as typeof pgTable;
@@ -30,7 +30,6 @@ export function createAuthSchema(usersSchemaName: string = "rebase") {
     });
 
 
-
     /**
      * Refresh tokens for long-lived sessions
      */

package/src/schema/doctor-cli.ts

@@ -7,6 +7,7 @@ import path from "path";
 import chalk from "chalk";
 import fs from "fs";
 import { runDoctor } from "./doctor";
+import { logger } from "@rebasepro/server-core";
 
 async function main() {
     const collectionsArg = process.argv.find((a) => a.startsWith("--collections="));
@@ -46,6 +47,6 @@ async function main() {
 }
 
 main().catch((err) => {
-    console.error(chalk.red("  ✗ Doctor failed:"), err instanceof Error ? err.message : String(err));
+    logger.error(chalk.red("  ✗ Doctor failed"), { error: err });
     process.exit(1);
 });

package/src/schema/doctor.ts

@@ -17,6 +17,7 @@ import { generateSchema } from "./generate-drizzle-schema-logic";
 import { generateTypedefs } from "@rebasepro/sdk-generator";
 import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
+import { logger } from "@rebasepro/server-core";
 
 /**
  * Resolve the SQL column name for a property.
@@ -149,7 +150,7 @@ export async function loadCollections(collectionsPath: string): Promise<EntityCo
                     }
                 } catch (err: unknown) {
                     const message = err instanceof Error ? err.message : String(err);
-                    console.error(chalk.yellow(`  ⚠ Could not load ${file}: ${message}`));
+                    logger.error(chalk.yellow(`  ⚠ Could not load ${file}: ${message}`));
                 }
             }
         }
@@ -244,7 +245,8 @@ export async function checkCollectionsVsSdk(
             message: `Generated SDK typedefs file does not exist at "${sdkFilePath}".`,
             fix: "Run `rebase generate-sdk`"
         });
-        return { passed: false, issues };
+        return { passed: false,
+issues };
     }
 
     try {
@@ -277,7 +279,8 @@ export async function checkCollectionsVsSdk(
         });
     }
 
-    return { passed: issues.length === 0, issues };
+    return { passed: issues.length === 0,
+issues };
 }
 
 // ── Phase 2: Collections ↔ Database ──────────────────────────────────────
@@ -326,7 +329,7 @@ export async function checkCollectionsVsDatabase(
              WHERE table_schema = ANY($1) AND table_type = 'BASE TABLE'`,
             [schemas]
         );
-        const existingTables = new Set(tablesResult.rows.map((r) => 
+        const existingTables = new Set(tablesResult.rows.map((r) =>
             r.table_schema === "public" ? r.table_name : `${r.table_schema}.${r.table_name}`
         ));
 
@@ -457,8 +460,8 @@ export async function checkCollectionsVsDatabase(
                             targetSchemaName = targetColl.schema || "public";
                         } catch { /* ignore */ }
 
-                        const hasFk = tableFks.some((fk) => 
-                            fk.column_name === fkColName && 
+                        const hasFk = tableFks.some((fk) =>
+                            fk.column_name === fkColName &&
                             fk.foreign_table_name === targetTableName &&
                             fk.foreign_table_schema === targetSchemaName
                         );
@@ -615,10 +618,10 @@ issues };
 // ── Report Rendering ─────────────────────────────────────────────────────
 
 export function renderReport(report: DoctorReport): void {
-    console.log("");
-    console.log(chalk.bold("  🩺 Rebase Schema Doctor"));
-    console.log(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
-    console.log("");
+    logger.info("");
+    logger.info(chalk.bold("  🩺 Rebase Schema Doctor"));
+    logger.info(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+    logger.info("");
 
     // Phase 1
     renderPhase(
@@ -642,7 +645,7 @@ export function renderReport(report: DoctorReport): void {
     );
 
     // Summary
-    console.log(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+    logger.info(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
     const { passed, warnings, errors } = report.summary;
 
     const parts: string[] = [];
@@ -650,50 +653,50 @@ export function renderReport(report: DoctorReport): void {
     if (warnings > 0) parts.push(chalk.yellow(`${warnings} warnings`));
     if (errors > 0) parts.push(chalk.red(`${errors} errors`));
 
-    console.log(`  Summary: ${parts.join(", ")}`);
-    console.log("");
+    logger.info(`  Summary: ${parts.join(", ")}`);
+    logger.info("");
 
     if (errors > 0) {
-        console.log(chalk.red.bold("  ✗ Schema drift detected. Run the suggested fixes above."));
+        logger.info(chalk.red.bold("  ✗ Schema drift detected. Run the suggested fixes above."));
     } else if (warnings > 0) {
-        console.log(chalk.yellow.bold("  ⚠ Minor issues detected. Consider running the suggested fixes."));
+        logger.info(chalk.yellow.bold("  ⚠ Minor issues detected. Consider running the suggested fixes."));
     } else {
-        console.log(chalk.green.bold("  ✓ All schemas are in sync!"));
+        logger.info(chalk.green.bold("  ✓ All schemas are in sync!"));
     }
-    console.log("");
+    logger.info("");
 }
 
 function renderPhase(label: string, passed: boolean, issues: DoctorIssue[]): void {
     if (passed) {
-        console.log(`  ${chalk.green("✅")} ${label}: ${chalk.green("In sync")}`);
+        logger.info(`  ${chalk.green("✅")} ${label}: ${chalk.green("In sync")}`);
     } else {
         const errorCount = issues.filter((i) => i.severity === "error").length;
         const warnCount = issues.filter((i) => i.severity === "warning").length;
         const parts: string[] = [];
         if (errorCount > 0) parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
         if (warnCount > 0) parts.push(`${warnCount} warning${warnCount > 1 ? "s" : ""}`);
-        console.log(`  ${chalk.yellow("⚠️")}  ${label}: ${chalk.yellow(parts.join(", "))}`);
+        logger.info(`  ${chalk.yellow("⚠️")}  ${label}: ${chalk.yellow(parts.join(", "))}`);
     }
-    console.log("");
+    logger.info("");
 
     for (const issue of issues) {
         const severityIcon = issue.severity === "error" ? chalk.red("✗") : chalk.yellow("⚠");
         const categoryLabel = formatCategory(issue.category);
-        console.log(`  ${chalk.gray("┌─")} ${severityIcon} ${chalk.bold(categoryLabel)} ${chalk.gray("─".repeat(Math.max(0, 42 - categoryLabel.length)))}`);
+        logger.info(`  ${chalk.gray("┌─")} ${severityIcon} ${chalk.bold(categoryLabel)} ${chalk.gray("─".repeat(Math.max(0, 42 - categoryLabel.length)))}`);
 
         if (issue.table) {
             const colPart = issue.column ? ` │ Column: ${chalk.cyan(issue.column)}` : "";
-            console.log(`  ${chalk.gray("│")} Table: ${chalk.cyan(issue.table)}${colPart}`);
+            logger.info(`  ${chalk.gray("│")} Table: ${chalk.cyan(issue.table)}${colPart}`);
         }
 
         if (issue.expected && issue.actual) {
-            console.log(`  ${chalk.gray("│")} Expected: ${chalk.green(issue.expected)} │ Actual: ${chalk.red(issue.actual)}`);
+            logger.info(`  ${chalk.gray("│")} Expected: ${chalk.green(issue.expected)} │ Actual: ${chalk.red(issue.actual)}`);
         }
 
-        console.log(`  ${chalk.gray("│")} ${issue.message}`);
-        console.log(`  ${chalk.gray("│")} Fix: ${chalk.blue(issue.fix)}`);
-        console.log(`  ${chalk.gray("└" + "─".repeat(48))}`);
-        console.log("");
+        logger.info(`  ${chalk.gray("│")} ${issue.message}`);
+        logger.info(`  ${chalk.gray("│")} Fix: ${chalk.blue(issue.fix)}`);
+        logger.info(`  ${chalk.gray("└" + "─".repeat(48))}`);
+        logger.info("");
     }
 }
 
@@ -720,33 +723,33 @@ export async function runDoctor(options: {
     sdkPath: string;
     databaseUrl?: string;
 }): Promise<DoctorReport> {
-    console.log("");
-    console.log(chalk.bold("  🩺 Loading collections..."));
+    logger.info("");
+    logger.info(chalk.bold("  🩺 Loading collections..."));
     const collections = await loadCollections(options.collectionsPath);
     if (collections.length === 0) {
-        console.error(chalk.red("  ✗ No collections found."));
+        logger.error(chalk.red("  ✗ No collections found."));
         process.exit(1);
     }
-    console.log(chalk.gray(`  Found ${collections.length} collection(s)`));
-    console.log("");
+    logger.info(chalk.gray(`  Found ${collections.length} collection(s)`));
+    logger.info("");
 
     // Phase 1: Collections ↔ Generated Schema
-    console.log(chalk.gray("  Checking Collections → Generated Schema..."));
+    logger.info(chalk.gray("  Checking Collections → Generated Schema..."));
     const collectionsToSchema = await checkCollectionsVsSchema(collections, options.schemaPath);
 
     // Phase 2: Collections ↔ Database (only if we have a DATABASE_URL)
     let schemaToDatabase: { passed: boolean; issues: DoctorIssue[] } = { passed: true,
 issues: [] };
     if (options.databaseUrl) {
-        console.log(chalk.gray("  Checking Collections → Database..."));
+        logger.info(chalk.gray("  Checking Collections → Database..."));
         schemaToDatabase = await checkCollectionsVsDatabase(collections, options.databaseUrl);
     } else {
-        console.log(chalk.yellow("  ⚠ DATABASE_URL not set — skipping database comparison."));
-        console.log(chalk.gray("    Set DATABASE_URL in your .env to enable full drift detection."));
+        logger.info(chalk.yellow("  ⚠ DATABASE_URL not set — skipping database comparison."));
+        logger.info(chalk.gray("    Set DATABASE_URL in your .env to enable full drift detection."));
     }
 
     // Phase 3: Collections ↔ SDK Types
-    console.log(chalk.gray("  Checking Collections → SDK Types..."));
+    logger.info(chalk.gray("  Checking Collections → SDK Types..."));
     const collectionsToSdk = await checkCollectionsVsSdk(collections, options.sdkPath);
 
     const allIssues = [...collectionsToSchema.issues, ...schemaToDatabase.issues, ...collectionsToSdk.issues];