@rebasepro/server-postgresql 0.5.0 → 0.6.0

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,18 +16,8 @@ import { RelationService } from "./RelationService";
 import { EntityFetchService } from "./EntityFetchService";
 import { DrizzleClient } from "../interfaces";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-
-/** Shape of PostgreSQL errors with diagnostic metadata. */
-interface PostgresError extends Error {
-    code?: string;
-    detail?: string;
-    hint?: string;
-    constraint?: string;
-    column?: string;
-    table?: string;
-    dataType?: string;
-    cause?: unknown;
-}
+import { logger } from "@rebasepro/server-core";
+import { extractPgError, extractCauseMessage, pgErrorToFriendlyMessage } from "../utils/pg-error-utils";
 
 /**
  * Service for handling all entity write operations.
@@ -140,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];
                             }
@@ -161,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;
@@ -314,144 +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;
-        if (!(error instanceof Error)) return null;
-
-        if (error.cause && typeof error.cause === "object") {
-            const deeper = this.extractCauseMessage(error.cause);
-            if (deeper) return deeper;
-            // The cause itself has a message
-            if (error.cause instanceof Error && error.cause.message) {
-                return error.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): PostgresError | null {
-        if (!error || typeof error !== "object") return null;
-        if (!(error instanceof Error)) {
-            // Check non-Error objects for a cause chain (Drizzle sometimes wraps oddly)
-            if ("cause" in error && (error as Record<string, unknown>).cause && typeof (error as Record<string, unknown>).cause === "object") {
-                return this.extractPgError((error as Record<string, unknown>).cause);
-            }
-            return null;
-        }
-
-        // Check if the error itself has a PG error code
-        if ("code" in error && typeof (error as PostgresError).code === "string" && /^[0-9A-Z]{5}$/.test((error as PostgresError).code!)) {
-            return error as PostgresError;
-        }
-
-        // Check the cause chain (Drizzle wraps PG errors)
-        if (error.cause && typeof error.cause === "object") {
-            return this.extractPgError(error.cause);
-        }
-
-        return null;
-    }
 }