@rebasepro/server-core 0.7.0 → 0.9.0

package/jest.config.cjs

@@ -1,19 +0,0 @@
-/** @type {import("ts-jest").JestConfigWithTsJest} */
-module.exports = {
-    preset: "ts-jest",
-    testEnvironment: "node",
-    // This pattern tells Jest to look for .test.ts files
-    testMatch: [
-        "**/__tests__/**/*.test.ts",
-        "**/src/**/*.test.ts",
-        "**/test/**/*.test.ts"
-    ],
-    // This helps Jest resolve monorepo packages
-    moduleNameMapper: {
-        "^@rebasepro/client$": "<rootDir>/../client/src/index.ts",
-        "^@rebasepro/common$": "<rootDir>/../common/src/index.ts",
-        "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
-        "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts",
-        "^(\\.{1,2}/.*)\\.js$": "$1"
-    }
-};

package/src/api/ast-schema-editor.ts

@@ -1,289 +0,0 @@
-import { Project, SyntaxKind, ObjectLiteralExpression, ObjectLiteralElementLike, PropertyAssignment, VariableDeclaration, IndentationText } from "ts-morph";
-import * as path from "path";
-import * as fs from "fs";
-
-export class AstSchemaEditor {
-    private project: Project;
-    private collectionsDir: string;
-
-    constructor(collectionsDir: string) {
-        this.project = new Project({
-            manipulationSettings: {
-                indentationText: IndentationText.FourSpaces
-            }
-        });
-        if (fs.existsSync(collectionsDir)) {
-            this.project.addSourceFilesAtPaths(`${collectionsDir}/**/*.ts`);
-        }
-        this.collectionsDir = path.resolve(collectionsDir);
-    }
-
-    /**
-     * Sanitize collectionId to prevent path traversal attacks.
-     * Only allows alphanumeric characters, underscores, and hyphens.
-     */
-    private sanitizeCollectionId(collectionId: string): string {
-        const sanitized = collectionId.replace(/[^a-zA-Z0-9_-]/g, "");
-        if (!sanitized || sanitized !== collectionId) {
-            throw new Error(`Invalid collection ID: "${collectionId}". Only alphanumeric characters, underscores, and hyphens are allowed.`);
-        }
-        return sanitized;
-    }
-
-    /**
-     * Resolve a file path and ensure it falls within the collectionsDir.
-     */
-    private safePath(filename: string): string {
-        const resolved = path.resolve(this.collectionsDir, filename);
-        if (!resolved.startsWith(this.collectionsDir + path.sep) && resolved !== this.collectionsDir) {
-            throw new Error("Path traversal detected: resolved path is outside the collections directory.");
-        }
-        return resolved;
-    }
-
-    private getCollectionFile(collectionId: string) {
-        const safeId = this.sanitizeCollectionId(collectionId);
-        const filePath = this.safePath(`${safeId}.ts`);
-        let file = this.project.getSourceFile(filePath);
-        if (!file && fs.existsSync(filePath)) {
-            this.project.addSourceFilesAtPaths(`${this.collectionsDir}/**/*.ts`);
-            file = this.project.getSourceFile(filePath);
-        }
-        return file;
-    }
-
-    private getCollectionObject(collectionId: string): ObjectLiteralExpression | null {
-        const file = this.getCollectionFile(collectionId);
-        if (!file) return null;
-
-        const defaultExport = file.getDefaultExportSymbol();
-        if (defaultExport) {
-            const declaration = defaultExport.getDeclarations()[0];
-            if (declaration && declaration.getKind() === SyntaxKind.ExportAssignment) {
-                const expr = declaration.asKind(SyntaxKind.ExportAssignment)?.getExpression();
-                if (expr && expr.getKind() === SyntaxKind.Identifier) {
-                    const varName = expr.getText();
-                    const varDecl = file.getVariableDeclaration(varName);
-                    return varDecl?.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression) || null;
-                }
-            }
-        }
-        // Fallback: Just get the first exported VariableDeclaration with an ObjectLiteral
-        const varDecls = file.getVariableDeclarations();
-        for (const varDecl of varDecls) {
-            const init = varDecl.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
-            if (init) return init;
-        }
-        return null;
-    }
-
-    private convertJsonToAstString(obj: unknown, indentLevel = 0, oldAstNode?: ObjectLiteralExpression): string {
-        // Base TS-morph parses arrays as 2 levels deep from the property key:
-        // PropertiesObject = level 1, PropertyConfig = level 2.
-        // We calibrate the spacing multiples to keep the items flush with standard TS format.
-        const indentStr = "    ";
-        const indent = indentStr.repeat(indentLevel);
-        const innerIndent = indentStr.repeat(indentLevel + 1);
-
-        if (obj === null || obj === undefined) {
-            return "undefined";
-        }
-        if (typeof obj === "string") {
-            return JSON.stringify(obj);
-        }
-        if (typeof obj === "number" || typeof obj === "boolean") {
-            return String(obj);
-        }
-        if (Array.isArray(obj)) {
-            if (obj.length === 0) return "[]";
-            const items = obj.map(item => this.convertJsonToAstString(item, indentLevel + 1));
-            return `[\n${innerIndent}${items.join(`,\n${innerIndent}`)}\n${indent}]`;
-        }
-        if (typeof obj === "object") {
-            const record = obj as Record<string, unknown>;
-            const keys = Object.keys(record);
-
-            // Collect preserved AST properties
-            const preservedProps: string[] = [];
-            if (oldAstNode) {
-                const oldProps = oldAstNode.getProperties();
-                for (const oldProp of oldProps) {
-                    if (oldProp.isKind(SyntaxKind.PropertyAssignment)) {
-                        const nameNode = oldProp.getNameNode();
-                        let name = nameNode.getText();
-                        if (name.startsWith('"') && name.endsWith('"')) name = name.slice(1, -1);
-                        if (name.startsWith("'") && name.endsWith("'")) name = name.slice(1, -1);
-
-                        // If the JSON object doesn't have this key, check if we should preserve it
-                        if (!(name in record)) {
-                            const init = oldProp.getInitializer();
-                            if (init) {
-                                const kind = init.getKind();
-                                const isCode = kind === SyntaxKind.ArrowFunction ||
-                                    kind === SyntaxKind.FunctionExpression ||
-                                    kind === SyntaxKind.Identifier ||
-                                    kind === SyntaxKind.CallExpression ||
-                                    kind === SyntaxKind.JsxElement;
-
-                                if (isCode || name === "target" || name === "callbacks" || name === "permissions" || name === "securityRules") {
-                                    // Preserve this property exactly as it was
-                                    const keyStr = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
-                                    preservedProps.push(`${keyStr}: ${init.getText()}`);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (keys.length === 0 && preservedProps.length === 0) return "{}";
-
-            const props = keys.map(key => {
-                const keyStr = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
-
-                // If the value is an object, pass the old AST node to recurse
-                let childAstNode: ObjectLiteralExpression | undefined;
-                if (oldAstNode && typeof record[key] === "object" && record[key] !== null && !Array.isArray(record[key])) {
-                    const oldProp = oldAstNode.getProperty(
-                        (p: ObjectLiteralElementLike) => "getName" in p && typeof (p as PropertyAssignment).getName === "function" && ((p as PropertyAssignment).getName() === key || (p as PropertyAssignment).getName() === `"${key}"` || (p as PropertyAssignment).getName() === `'${key}'`)
-                    );
-                    if (oldProp && oldProp.isKind(SyntaxKind.PropertyAssignment)) {
-                        childAstNode = oldProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
-                    }
-                }
-
-                return `${keyStr}: ${this.convertJsonToAstString(record[key], indentLevel + 1, childAstNode)}`;
-            });
-
-            const allProps = [...props, ...preservedProps];
-            return `{\n${innerIndent}${allProps.join(`,\n${innerIndent}`)}\n${indent}}`;
-        }
-        return "undefined";
-    }
-
-    public async saveProperty(collectionId: string, propertyKey: string, propertyConfig: Record<string, unknown>) {
-        const collectionObj = this.getCollectionObject(collectionId);
-        if (!collectionObj) throw new Error(`Collection ${collectionId} not found in ATS workspace.`);
-
-        let propertiesProp = collectionObj.getProperty("properties") as PropertyAssignment;
-        if (!propertiesProp) {
-            propertiesProp = collectionObj.addPropertyAssignment({
-                name: "properties",
-                initializer: "{}"
-            });
-        }
-
-        const propsObj = propertiesProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
-        if (propsObj) {
-            const existingProp = propsObj.getProperty(
-                (p: ObjectLiteralElementLike) => "getName" in p && typeof (p as PropertyAssignment).getName === "function" && ((p as PropertyAssignment).getName() === propertyKey || (p as PropertyAssignment).getName() === `"${propertyKey}"`)
-            );
-
-            let oldPropAstNode: ObjectLiteralExpression | undefined;
-            if (existingProp && existingProp.isKind(SyntaxKind.PropertyAssignment)) {
-                oldPropAstNode = existingProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
-            }
-
-            const newInitializer = this.convertJsonToAstString(propertyConfig, 2, oldPropAstNode);
-
-            if (existingProp) {
-                if (existingProp.isKind(SyntaxKind.PropertyAssignment)) {
-                    existingProp.setInitializer(newInitializer);
-                }
-            } else {
-                propsObj.addPropertyAssignment({
-                    name: /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(propertyKey) ? propertyKey : JSON.stringify(propertyKey),
-                    initializer: newInitializer
-                });
-            }
-
-            const file = this.getCollectionFile(collectionId);
-            if (file) {
-                file.formatText();
-            }
-            await this.project.save();
-        }
-    }
-
-    public async deleteProperty(collectionId: string, propertyKey: string) {
-        const collectionObj = this.getCollectionObject(collectionId);
-        if (!collectionObj) return;
-
-        const propertiesProp = collectionObj.getProperty("properties") as PropertyAssignment;
-        if (propertiesProp) {
-            const propsObj = propertiesProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
-            if (propsObj) {
-                const existingProp = propsObj.getProperty(
-                    (p: ObjectLiteralElementLike) => "getName" in p && typeof (p as PropertyAssignment).getName === "function" && ((p as PropertyAssignment).getName() === propertyKey || (p as PropertyAssignment).getName() === `"${propertyKey}"`)
-                );
-                if (existingProp) {
-                    existingProp.remove();
-                    const file = this.getCollectionFile(collectionId);
-                    if (file) {
-                        file.formatText();
-                    }
-                    await this.project.save();
-                }
-            }
-        }
-    }
-
-    public async saveCollection(collectionId: string, collectionData: Record<string, unknown>) {
-        let file = this.getCollectionFile(collectionId);
-        const collectionObj = this.getCollectionObject(collectionId);
-
-        if (!file || !collectionObj) {
-            // Create a new file
-            const safeId = this.sanitizeCollectionId(collectionId);
-            const newFilePath = this.safePath(`${safeId}.ts`);
-            file = this.project.createSourceFile(newFilePath, `import { EntityCollection } from "@rebasepro/types";\n\nconst ${safeId}Collection: EntityCollection = ${this.convertJsonToAstString(collectionData)};\n\nexport default ${safeId}Collection;\n`, { overwrite: true });
-        } else {
-            // Update root level properties gracefully
-
-            // Force delete securityRules if empty or undefined to handle Formex / serialization stripping
-            if (!("securityRules" in collectionData) || collectionData.securityRules === undefined || (Array.isArray(collectionData.securityRules) && collectionData.securityRules.length === 0)) {
-                const srProp = collectionObj.getProperty("securityRules");
-                if (srProp) {
-                    srProp.remove();
-                }
-
-                // If it was in collectionData as an empty array, delete it so the loop below doesn't add it back as "[]"
-                // Actually, if it's "[]", omitting it entirely from the TS file achieves the same logical effect (no RLS rules)
-                // and correctly triggers "unmapped policies" if the DB still has them.
-                delete collectionData["securityRules"];
-            }
-
-            for (const key of Object.keys(collectionData)) {
-                if (key === "relations") continue; // Kept via other AST functions or handled separately.
-
-                const prop = collectionObj.getProperty(key) as PropertyAssignment;
-
-                let oldAstNode: ObjectLiteralExpression | undefined;
-                if (prop && prop.isKind(SyntaxKind.PropertyAssignment)) {
-                    oldAstNode = prop.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
-                }
-
-                const newInit = this.convertJsonToAstString(collectionData[key], 1, oldAstNode);
-                if (prop) {
-                    prop.setInitializer(newInit);
-                } else {
-                    collectionObj.addPropertyAssignment({
-                        name: key,
-                        initializer: newInit
-                    });
-                }
-            }
-        }
-        if (file) {
-            file.formatText();
-        }
-        await this.project.save();
-    }
-
-    public async deleteCollection(collectionId: string) {
-        const file = this.getCollectionFile(collectionId);
-        if (file) {
-            file.deleteImmediatelySync();
-        }
-    }
-}

package/src/api/collections_for_test/callbacks_test_collection.ts

@@ -1,61 +0,0 @@
-import { EntityCollection, EntityBeforeSaveProps, EntityAfterSaveProps, EntityAfterSaveErrorProps, EntityAfterReadProps, EntityBeforeDeleteProps, EntityAfterDeleteProps, PostgresCollection } from "@rebasepro/types";
-import { logger } from "../../utils/logger";
-
-export const callbacksTestCollection: PostgresCollection = {
-    name: "Callback Tests",
-    slug: "callback_tests",
-    table: "callback_tests",
-    description: "A collection to test backend callbacks",
-    properties: {
-        name: {
-            name: "Name",
-            validation: { required: true },
-            type: "string"
-        },
-        hasSaveSuccessTriggered: {
-            name: "Save Success Triggered",
-            type: "boolean"
-        },
-        hasPreSaveTriggered: {
-            name: "Pre Save Triggered",
-            type: "boolean"
-        },
-        hasFetchTriggered: {
-            name: "Fetch Triggered",
-            type: "boolean"
-        }
-    },
-    callbacks: {
-        beforeSave: (props: EntityBeforeSaveProps) => {
-            logger.info("🔥 [BACKEND_CALLBACK] beforeSave Triggered!", { detail: props });
-            return {
-                ...props.values,
-                hasPreSaveTriggered: true,
-                name: props.values.name + " (PreSaved)" // Modifying value before save
-            };
-        },
-        afterSave: (props: EntityAfterSaveProps) => {
-            logger.info("🔥 [BACKEND_CALLBACK] afterSave Triggered!", { detail: props });
-            // This usually triggers other side effects (emails, notifications), log for now
-        },
-        afterSaveError: (props: EntityAfterSaveErrorProps) => {
-            logger.error("🔥 [BACKEND_CALLBACK] afterSaveError Triggered!", { detail: props });
-        },
-        afterRead: (props: EntityAfterReadProps) => {
-            logger.info("🔥 [BACKEND_CALLBACK] afterRead Triggered!", { detail: props });
-            return {
-                ...props.entity,
-                values: {
-                    ...props.entity.values,
-                    hasFetchTriggered: true
-                }
-            };
-        },
-        beforeDelete: (props: EntityBeforeDeleteProps) => {
-            logger.info("🔥 [BACKEND_CALLBACK] beforeDelete Triggered!", { detail: props });
-        },
-        afterDelete: (props: EntityAfterDeleteProps) => {
-            logger.info("🔥 [BACKEND_CALLBACK] afterDelete Triggered!", { detail: props });
-        }
-    }
-};

package/src/api/errors.ts

@@ -1,278 +0,0 @@
-import type { ErrorHandler } from "hono";
-import type { ContentfulStatusCode } from "hono/utils/http-status";
-import type { HonoEnv } from "./types";
-import { logger } from "../utils/logger";
-
-/** Tracks whether we've already shown the doctor hint (once per process). */
-let _schemaDriftHinted = false;
-
-/** Shape of Postgres / network errors with diagnostic codes */
-interface PgLikeError {
-    code?: string;
-    address?: string;
-    port?: number;
-    message?: string;
-    table?: string;
-    column?: string;
-    schema?: string;
-}
-
-/**
- * Extract the missing table or column name from a PG error.
- * PG 42P01 messages look like: 'relation "my_table" does not exist'
- * PG 42703 messages look like: 'column "my_col" does not exist' or 'column my_table.my_col does not exist'
- */
-function extractMissingIdentifier(pgMessage?: string): string | null {
-    if (!pgMessage) return null;
-    // Match quoted identifier: relation "xxx" / column "xxx"
-    const quoted = pgMessage.match(/(?:relation|column|table)\s+"([^"]+)"/i);
-    if (quoted) return quoted[1];
-    // Match unquoted: column table.col does not exist
-    const unquoted = pgMessage.match(/(?:relation|column|table)\s+([\w.]+)\s+does not exist/i);
-    if (unquoted) return unquoted[1];
-    return null;
-}
-
-/**
- * Standardized API error class.
- * Throw this from any route handler — the errorHandler middleware
- * will format it into `{ error: { message, code, details? } }`.
- */
-export class ApiError extends Error {
-    public readonly statusCode: number;
-    public readonly code: string;
-    public readonly details?: unknown;
-
-    constructor(statusCode: number, code: string, message: string, details?: unknown) {
-        super(message);
-        this.name = "ApiError";
-        this.statusCode = statusCode;
-        this.code = code;
-        this.details = details;
-    }
-
-    // ── Factory methods ──────────────────────────────────────────────
-
-    static badRequest(message: string, code = "BAD_REQUEST", details?: unknown): ApiError {
-        return new ApiError(400, code, message, details);
-    }
-
-    static unauthorized(message: string, code = "UNAUTHORIZED"): ApiError {
-        return new ApiError(401, code, message);
-    }
-
-    static forbidden(message: string, code = "FORBIDDEN"): ApiError {
-        return new ApiError(403, code, message);
-    }
-
-    static notFound(message: string, code = "NOT_FOUND"): ApiError {
-        return new ApiError(404, code, message);
-    }
-
-    static conflict(message: string, code = "CONFLICT"): ApiError {
-        return new ApiError(409, code, message);
-    }
-
-    static internal(message: string, code = "INTERNAL_ERROR"): ApiError {
-        return new ApiError(500, code, message);
-    }
-
-    static serviceUnavailable(message: string, code = "SERVICE_UNAVAILABLE"): ApiError {
-        return new ApiError(503, code, message);
-    }
-}
-
-/**
- * Canonical error response shape:
- * `{ error: { message: string, code: string, details?: unknown } }`
- */
-export interface ErrorResponse {
-    error: {
-        message: string;
-        code: string;
-        details?: unknown;
-        /** Request correlation ID for tracing (echoes X-Request-ID). */
-        requestId?: string;
-    };
-}
-
-/**
- * General shape of errors that flow through the API error handler.
- * Extends Error with optional HTTP status, error code, and details.
- */
-export interface RebaseApiError extends Error {
-    statusCode?: number;
-    code?: string;
-    details?: unknown;
-}
-
-/**
- * Type guard for errors that carry optional API metadata (statusCode, code, details).
- * Returns true for any Error instance — the optional properties are then
- * checked via normal property access.
- */
-export function isRebaseApiError(error: unknown): error is RebaseApiError {
-    return error instanceof Error;
-}
-
-/**
- * Hono error-handling middleware (`app.onError`).
- * Converts any error into the canonical `{ error: { message, code } }` shape.
- */
-export const errorHandler: ErrorHandler<HonoEnv> = (err, c) => {
-    // Typecast custom error properties
-    const error: RebaseApiError = err;
-    const reqId = typeof c.get === "function" ? c.get("requestId") : undefined;
-
-    if (error instanceof ApiError || error.name === "ApiError") {
-        // Operational errors — log at warn level
-        logger.warn(
-            `⚠️ [API] ${c.req.method} ${c.req.path} → ${error.statusCode} ${error.code}: ${error.message}` +
-            (reqId ? ` [${reqId}]` : "")
-        );
-        return c.json({
-            error: {
-                message: error.message,
-                code: error.code || "INTERNAL_ERROR",
-                ...(error.details !== undefined && { details: error.details }),
-                ...(reqId && { requestId: reqId })
-            }
-        } satisfies ErrorResponse, (error.statusCode || 500) as ContentfulStatusCode);
-    }
-
-    const statusCode = error.statusCode || codeToStatus(error.code) || 500;
-    let code = error.code || "INTERNAL_ERROR";
-
-    // Handle DB connection and specific system errors for better logging
-    let logMessage = error.message;
-
-    // Resolve the actual cause — Node's net module wraps dual-stack failures
-    // in an AggregateError whose inner errors carry the real address/port.
-    let resolvedCause: PgLikeError | undefined;
-    if (error.cause && typeof error.cause === "object" && error.cause !== null && "code" in error.cause) {
-        const cause = error.cause as PgLikeError & { errors?: PgLikeError[] };
-        if (cause.code === "ECONNREFUSED" && !cause.address && Array.isArray(cause.errors)) {
-            // AggregateError — pick the first inner error that has address info
-            resolvedCause = cause.errors.find(e => e.address) || cause;
-        } else {
-            resolvedCause = cause;
-        }
-    }
-
-    if (resolvedCause) {
-        const cause = resolvedCause;
-        if (cause.code === "ENETUNREACH") {
-            logMessage = `Network unreachable. Cannot connect to database at ${cause.address}:${cause.port}.`;
-        } else if (cause.code === "ECONNREFUSED") {
-            logMessage = `Connection refused to database at ${cause.address}:${cause.port}. Is PostgreSQL running?`;
-        } else if (cause.code === "42703" || cause.code === "42P01") {
-            code = "SCHEMA_DRIFT";
-            const issue = cause.code === "42703" ? "column" : "table";
-            const identifier = cause.table || cause.column || extractMissingIdentifier(cause.message) || "unknown";
-            logMessage = `Schema drift: ${issue} "${identifier}" does not exist in the database. Run \`pnpm db:push\` to sync your schema, or \`pnpm db:migrate\` to apply pending migrations.`;
-        }
-    } else if ("code" in error && error.code === "ENETUNREACH") {
-         const netErr = error as PgLikeError;
-         logMessage = `Network unreachable. Cannot connect to service at ${netErr.address}:${netErr.port}.`;
-    } else if ("code" in error && (error.code === "42703" || error.code === "42P01")) {
-        code = "SCHEMA_DRIFT";
-        const issue = error.code === "42703" ? "column" : "table";
-        const pgErr = error as PgLikeError;
-        const identifier = pgErr.table || pgErr.column || extractMissingIdentifier(error.message) || "unknown";
-        logMessage = `Schema drift: ${issue} "${identifier}" does not exist in the database. Run \`pnpm db:push\` to sync your schema, or \`pnpm db:migrate\` to apply pending migrations.`;
-    }
-
-    const causePg = (error.cause && typeof error.cause === "object") ? (error.cause as PgLikeError) : undefined;
-    const pgErrorCode = causePg?.code || error.code;
-    const isDbSchemaMismatch = code === "SCHEMA_DRIFT" || pgErrorCode === "42703" || pgErrorCode === "42P01";
-
-    if (isDbSchemaMismatch) {
-        // Database schema mismatch is logged as a warning instead of a fatal error
-        logger.warn(
-            `⚠️ [API] ${c.req.method} ${c.req.path} → ${statusCode} ${code}: ${logMessage}` +
-            (reqId ? ` [${reqId}]` : "")
-        );
-        // In dev mode, show a one-time hint to run `rebase doctor`
-        if (!_schemaDriftHinted && process.env.NODE_ENV !== "production") {
-            _schemaDriftHinted = true;
-            logger.warn([
-                "",
-                "┌──────────────────────────────────────────────────────────────┐",
-                "│  💡 TIP: Run `rebase doctor` for full schema diagnostics    │",
-                "│                                                             │",
-                "│  Quick fixes:                                               │",
-                "│    pnpm db:push      sync schema to database (dev)          │",
-                "│    pnpm db:migrate   generate + apply migration (prod)      │",
-                "│    rebase doctor     full 3-way drift report                │",
-                "└──────────────────────────────────────────────────────────────┘",
-                ""
-            ].join("\n"));
-        }
-    } else {
-        // Unexpected errors — log at error level
-        logger.error(
-            `❌ [API] ${c.req.method} ${c.req.path} → ${statusCode} ${code}: ${logMessage}` +
-            (reqId ? ` [${reqId}]` : "")
-        );
-    }
-
-    // Suppress the huge stack trace for known DB errors (it's noisy and leaks SQL)
-    const suppressStack = isDbSchemaMismatch || (statusCode < 500 && code === "BAD_REQUEST");
-    if (!suppressStack) {
-        logger.error(String(error.stack || error));
-    }
-
-    // Sanitize the message for the client to prevent leaking sensitive details
-    // like SQL queries or internal IP addresses.
-    let clientMessage = "An unexpected error occurred";
-    if (statusCode < 500 && error.message) {
-        // If it's a 4xx error (e.g. from validation), it's generally safe to send the message
-        clientMessage = error.message;
-    } else if (error instanceof ApiError || error.name === "ApiError") {
-        // We already handled ApiError above, but just in case
-        clientMessage = error.message;
-    } else if (code === "SCHEMA_DRIFT") {
-        const pgErr = causePg || (error as PgLikeError);
-        const issue = (pgErr.code === "42703" || pgErrorCode === "42703") ? "column" : "table";
-        const identifier = pgErr.table || pgErr.column || extractMissingIdentifier(pgErr.message || error.message) || "unknown";
-        clientMessage = `Schema drift: ${issue} "${identifier}" does not exist. Run \`pnpm db:push\` to sync your schema.`;
-    } else if (code === "INTERNAL_ERROR") {
-        clientMessage = "Internal Server Error";
-    }
-
-    return c.json({
-        error: {
-            message: clientMessage,
-            code,
-            ...(error.details !== undefined && { details: error.details }),
-            ...(reqId && { requestId: reqId })
-        }
-    } satisfies ErrorResponse, statusCode as ContentfulStatusCode);
-};
-
-/**
- * Map known error codes to HTTP status codes.
- */
-function codeToStatus(code?: string): number | undefined {
-    if (!code) return undefined;
-    const map: Record<string, number> = {
-        BAD_REQUEST: 400,
-        INVALID_INPUT: 400,
-        WEAK_PASSWORD: 400,
-        UNAUTHORIZED: 401,
-        INVALID_CREDENTIALS: 401,
-        INVALID_TOKEN: 401,
-        FORBIDDEN: 403,
-        NOT_FOUND: 404,
-        CONFLICT: 409,
-        EMAIL_EXISTS: 409,
-        ROLE_EXISTS: 409,
-        SCHEMA_DRIFT: 500,
-        INTERNAL_ERROR: 500,
-        NOT_CONFIGURED: 503,
-        SERVICE_UNAVAILABLE: 503
-    };
-    return map[code];
-}
-
-