@rebasepro/server-postgresql 0.4.0 → 0.6.0

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);
 });

package/src/services/BranchService.ts

@@ -18,6 +18,16 @@ const BRANCH_DB_PREFIX = "rb_";
 /** Fully-qualified metadata table in the rebase schema. */
 const BRANCHES_TABLE = "rebase.branches";
 
+/**
+ * Validate that a user-provided identifier only contains safe characters.
+ * Throws if the value contains characters outside [a-zA-Z0-9_-].
+ */
+function validateIdentifier(value: string, label: string): void {
+    if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
+        throw new Error(`Invalid ${label}: only letters, digits, underscores, and hyphens are allowed.`);
+    }
+}
+
 /**
  * Sanitize a user-provided branch name to a safe PostgreSQL identifier.
  * Only allows alphanumeric characters and underscores.
@@ -70,6 +80,10 @@ export class BranchService {
      * @param options.source  Source database to clone; defaults to the main database.
      */
     async createBranch(name: string, options?: { source?: string }): Promise<BranchInfo> {
+        if (options?.source) {
+            validateIdentifier(options.source, "source database name");
+        }
+
         const dbName = toBranchDbName(name);
         const sanitizedName = sanitizeBranchName(name);
         const sourceDb = options?.source || this.poolManager.defaultDatabaseName;

package/src/services/EntityFetchService.ts

@@ -16,6 +16,7 @@ import { RelationService } from "./RelationService";
 import { RelationalQueryBuilder } from "drizzle-orm/pg-core/query-builders/query";
 import { DrizzleClient } from "../interfaces";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { logger } from "@rebasepro/server-core";
 
 /** Type-safe accessor for Drizzle's relational query API via dynamic table name */
 type DbQueryAccessor = Record<string, RelationalQueryBuilder<any, any>> | undefined;
@@ -269,7 +270,7 @@ export class EntityFetchService {
                         );
                     }
                 } catch (e) {
-                    console.warn(`Could not resolve joinPath relation '${key}':`, e);
+                    logger.warn(`Could not resolve joinPath relation '${key}'`, { error: e });
                 }
             });
 
@@ -322,7 +323,7 @@ export class EntityFetchService {
                     }
                 }
             } catch (e) {
-                console.warn(`Could not batch resolve joinPath relation '${key}':`, e);
+                logger.warn(`Could not batch resolve joinPath relation '${key}'`, { error: e });
             }
         }
     }
@@ -400,7 +401,7 @@ export class EntityFetchService {
                     }
                 }
             } catch (e) {
-                console.warn(`Could not batch resolve joinPath relation '${key}' for REST:`, e);
+                logger.warn(`Could not batch resolve joinPath relation '${key}' for REST`, { error: e });
             }
         }
     }
@@ -625,10 +626,10 @@ export class EntityFetchService {
                 return entity;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
-                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                    logger.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
-                console.warn(`[EntityFetchService] db.query.findFirst failed for ${collectionPath}, falling back to db.select:`, e);
+                logger.warn(`[EntityFetchService] db.query.findFirst failed for ${collectionPath}, falling back to db.select`, { error: e });
             }
         }
 
@@ -675,7 +676,7 @@ export class EntityFetchService {
                                 (values as Record<string, unknown>)[key] = createRelationRef(e.id, e.path);
                             }
                         } catch (e) {
-                            console.warn(`Could not resolve one-to-one relation property: ${key}`, e);
+                            logger.warn(`Could not resolve one-to-one relation property: ${key}`, { error: e });
                         }
                     }
                 }
@@ -749,10 +750,10 @@ export class EntityFetchService {
                 return entities;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
-                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                    logger.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
-                console.warn(`[EntityFetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select:`, e);
+                logger.warn(`[EntityFetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select`, { error: e });
             }
         }
 
@@ -764,7 +765,8 @@ export class EntityFetchService {
         }
 
         let query = vectorMeta
-            ? this.db.select({ table_row: table, _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
+            ? this.db.select({ table_row: table,
+_distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             : this.db.select().from(table).$dynamic();
         const allConditions: SQL[] = [];
 
@@ -908,7 +910,7 @@ export class EntityFetchService {
                         }
                     });
                 } catch (e) {
-                    console.warn(`Could not batch load one-to-one relation property: ${key}`, e);
+                    logger.warn(`Could not batch load one-to-one relation property: ${key}`, { error: e });
                 }
             }
 
@@ -935,7 +937,7 @@ export class EntityFetchService {
                         );
                     });
                 } catch (e) {
-                    console.warn(`Could not batch load many relation property: ${key}`, e);
+                    logger.warn(`Could not batch load many relation property: ${key}`, { error: e });
                 }
             }
         }
@@ -1250,10 +1252,10 @@ export class EntityFetchService {
                 return restRows;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
-                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                    logger.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
-                console.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back:`, e);
+                logger.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back`, { error: e });
             }
         }
 
@@ -1290,7 +1292,7 @@ export class EntityFetchService {
                     }
                 }
             } catch (e) {
-                console.warn(`[include] Failed to batch load one-to-one '${key}':`, e);
+                logger.warn(`[include] Failed to batch load one-to-one '${key}'`, { error: e });
             }
         }
 
@@ -1309,7 +1311,7 @@ export class EntityFetchService {
                     }));
                 }
             } catch (e) {
-                console.warn(`[include] Failed to batch load many '${key}':`, e);
+                logger.warn(`[include] Failed to batch load many '${key}'`, { error: e });
             }
         }
 
@@ -1364,10 +1366,10 @@ export class EntityFetchService {
                 return restRow;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
-                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                    logger.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
-                console.warn(`[fetchEntityForRest] db.query.findFirst failed for ${collectionPath}, falling back:`, e);
+                logger.warn(`[fetchEntityForRest] db.query.findFirst failed for ${collectionPath}, falling back`, { error: e });
             }
         }
 
@@ -1415,7 +1417,7 @@ export class EntityFetchService {
                     }));
                 }
             } catch (e) {
-                console.warn(`[include] Failed to load relation '${key}':`, e);
+                logger.warn(`[include] Failed to load relation '${key}'`, { error: e });
             }
         }
 
@@ -1450,7 +1452,8 @@ export class EntityFetchService {
         }
 
         let query = vectorMeta
-            ? this.db.select({ table_row: table, _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
+            ? this.db.select({ table_row: table,
+_distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             : this.db.select().from(table).$dynamic();
         const allConditions: SQL[] = [];
 
@@ -1621,7 +1624,7 @@ export class EntityFetchService {
                 return flat;
             });
         } catch (e) {
-            console.warn(`[include] Drizzle relational query failed for '${collectionPath}', falling back:`, e);
+            logger.warn(`[include] Drizzle relational query failed for '${collectionPath}', falling back`, { error: e });
             return null;
         }
     }
@@ -1647,7 +1650,7 @@ export class EntityFetchService {
         const relation = resolvedRelations[relationKey];
 
         if (!relation) {
-            console.warn(`[batchFetchManyRelatedEntities] Relation '${relationKey}' not found, skipping`);
+            logger.warn(`[batchFetchManyRelatedEntities] Relation '${relationKey}' not found, skipping`);
             return new Map();
         }
 

package/src/services/EntityPersistService.ts

@@ -16,6 +16,8 @@ import { RelationService } from "./RelationService";
 import { EntityFetchService } from "./EntityFetchService";
 import { DrizzleClient } from "../interfaces";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { logger } from "@rebasepro/server-core";
+import { extractPgError, extractCauseMessage, pgErrorToFriendlyMessage } from "../utils/pg-error-utils";
 
 /**
  * Service for handling all entity write operations.
@@ -128,7 +130,7 @@ export class EntityPersistService {
                                 const targetColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(relevantJoinStep.on.to);
                                 targetColumnName = targetColumnNames[0];
                             } else {
-                                console.warn(`Could not find specific join step for target table ${targetTableName} in relation '${relationKey}'.`);
+                                logger.warn(`Could not find specific join step for target table ${targetTableName} in relation '${relationKey}'.`);
                                 const targetColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(relation.joinPath[0].on.to);
                                 targetColumnName = targetColumnNames[0];
                             }
@@ -149,7 +151,7 @@ export class EntityPersistService {
 
                         const existingValue = (effectiveValues as Record<string, unknown>)[targetColumnName];
                         if (existingValue !== undefined && existingValue !== null && existingValue !== parsedParentId) {
-                            console.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent id '${parsedParentId}'.`);
+                            logger.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent id '${parsedParentId}'.`);
                         }
                         (effectiveValues as Record<string, unknown>)[targetColumnName] = parsedParentId;
                         break;
@@ -302,139 +304,24 @@ export class EntityPersistService {
      * Translate raw PostgreSQL / Drizzle errors into user-friendly messages.
      */
     private toUserFriendlyError(error: unknown, collectionSlug: string): Error {
-        // Dig into Drizzle's wrapper to find the underlying PG error
-        const pgError = this.extractPgError(error);
+        const pgError = extractPgError(error);
 
         if (pgError) {
-            const detail = pgError.detail as string | undefined;
-            const hint = pgError.hint as string | undefined;
-            const constraint = pgError.constraint as string | undefined;
-            const column = pgError.column as string | undefined;
-            const table = pgError.table as string | undefined;
-            const dataType = pgError.dataType as string | undefined;
-            const pgMessage = pgError.message || "Unknown database error";
-
-            const suffix = hint ? ` Hint: ${hint}` : "";
-            const tableRef = table ?? collectionSlug;
-
-            switch (pgError.code) {
-                case "23503": // foreign_key_violation
-                    return new Error(
-                        detail
-                            ? `Foreign key constraint violated: ${detail}${suffix}`
-                            : `Cannot save: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`
-                    );
-                case "23505": // unique_violation
-                    return new Error(
-                        detail
-                            ? `Duplicate value: ${detail}${suffix}`
-                            : `Cannot save: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`
-                    );
-                case "23502": // not_null_violation
-                    return new Error(
-                        `Missing required field: "${column ?? "unknown"}" in "${tableRef}" cannot be empty.${suffix}`
-                    );
-                case "23514": // check_violation
-                    return new Error(
-                        `Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`
-                    );
-                case "22P02": // invalid_text_representation (e.g. invalid UUID, wrong enum value)
-                    return new Error(
-                        `Invalid data format in "${collectionSlug}": ${pgMessage}${suffix}`
-                    );
-                case "22001": // string_data_right_truncation (value too long)
-                    return new Error(
-                        `Value too long for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`
-                    );
-                case "22003": // numeric_value_out_of_range
-                    return new Error(
-                        `Numeric value out of range for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`
-                    );
-                case "42703": // undefined_column
-                    return new Error(
-                        `Unknown column in "${tableRef}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`
-                    );
-                case "42P01": // undefined_table
-                    return new Error(
-                        `Table not found for "${collectionSlug}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`
-                    );
-                default: {
-                    // Unhandled PG code — still surface the actual database message
-                    const parts = [`Database error in "${collectionSlug}" [${pgError.code}]: ${pgMessage}`];
-                    if (detail) parts.push(`Detail: ${detail}`);
-                    if (column) parts.push(`Column: ${column}`);
-                    if (dataType) parts.push(`Data type: ${dataType}`);
-                    if (constraint) parts.push(`Constraint: ${constraint}`);
-                    if (hint) parts.push(`Hint: ${hint}`);
-                    return new Error(parts.join(". "));
-                }
-            }
+            const { message } = pgErrorToFriendlyMessage(pgError, collectionSlug);
+            return new Error(message);
         }
 
         // No PG error found — try to extract a useful message from the
         // Drizzle wrapper instead of leaking the raw SQL query + params.
-        const causeMessage = this.extractCauseMessage(error);
+        const causeMessage = extractCauseMessage(error);
         if (causeMessage) {
             return new Error(`Database error in "${collectionSlug}": ${causeMessage}`);
         }
 
-        // Last resort: use the original error message but strip the SQL query
-        if (error instanceof Error) {
-            const cleaned = this.stripSqlFromMessage(error.message, collectionSlug);
-            return new Error(cleaned);
+        // Last resort: generic message, never leak raw SQL
+        if (error instanceof Error && error.message.startsWith("Failed query:")) {
+            return new Error(`Failed to save entity in "${collectionSlug}". Check server logs for details.`);
         }
         return new Error(`Database error in "${collectionSlug}": ${String(error)}`);
     }
-
-    /**
-     * Walk the error cause chain and return the deepest meaningful message.
-     */
-    private extractCauseMessage(error: unknown): string | null {
-        if (!error || typeof error !== "object") return null;
-        const err = error as Error & { cause?: unknown };
-
-        if (err.cause && typeof err.cause === "object") {
-            const deeper = this.extractCauseMessage(err.cause);
-            if (deeper) return deeper;
-            // The cause itself has a message
-            if (err.cause instanceof Error && err.cause.message) {
-                return err.cause.message;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Strip the raw SQL query from a Drizzle "Failed query: ..." message,
-     * keeping only the error description.
-     */
-    private stripSqlFromMessage(message: string, collectionSlug: string): string {
-        // Drizzle format: "Failed query: <SQL>\nparams: <params>"
-        if (message.startsWith("Failed query:")) {
-            return `Failed to save entity in "${collectionSlug}". Check server logs for details.`;
-        }
-        return message;
-    }
-
-    /**
-     * Extract the underlying PostgreSQL error from a Drizzle wrapper.
-     * Drizzle wraps PG errors in a `cause` property.
-     */
-    private extractPgError(error: unknown): (Error & { code?: string; detail?: unknown; hint?: unknown; constraint?: unknown; column?: unknown; table?: unknown; dataType?: unknown }) | null {
-        if (!error || typeof error !== "object") return null;
-
-        const err = error as Error & { code?: string; cause?: unknown; detail?: unknown };
-
-        // Check if the error itself has a PG error code
-        if (err.code && /^[0-9A-Z]{5}$/.test(err.code)) {
-            return err as Error & { code: string; detail?: unknown; hint?: unknown; constraint?: unknown; column?: unknown; table?: unknown; dataType?: unknown };
-        }
-
-        // Check the cause chain (Drizzle wraps PG errors)
-        if (err.cause && typeof err.cause === "object") {
-            return this.extractPgError(err.cause);
-        }
-
-        return null;
-    }
 }