@rebasepro/server-core 0.2.5 → 0.4.0

package/src/api/rest/query-parser.ts

@@ -1,4 +1,4 @@
-import type { VectorSearchParams } from "@rebasepro/types";
+import type { VectorSearchParams, LogicalCondition, FilterCondition } from "@rebasepro/types";
 import { QueryOptions } from "../types";
 
 /**
@@ -20,6 +20,86 @@ export function mapOperator(op: string): string | null {
     }
 }
 
+function getLastValue(val: unknown): unknown {
+    if (Array.isArray(val)) {
+        return val[val.length - 1];
+    }
+    return val;
+}
+
+export function parseLogicalString(str: string): FilterCondition | LogicalCondition {
+    str = str.trim();
+    if (str.startsWith("or(") && str.endsWith(")")) {
+        const inner = str.slice(3, -1);
+        return { type: "or", conditions: parseLogicalList(inner) };
+    }
+    if (str.startsWith("and(") && str.endsWith(")")) {
+        const inner = str.slice(4, -1);
+        return { type: "and", conditions: parseLogicalList(inner) };
+    }
+    
+    // It's a leaf condition: field.op.val
+    const firstDot = str.indexOf(".");
+    if (firstDot === -1) {
+        return { column: str, operator: "==", value: true };
+    }
+    const field = str.substring(0, firstDot);
+    const rest = str.substring(firstDot + 1);
+    const secondDot = rest.indexOf(".");
+    let op = "eq";
+    let valStr = rest;
+    if (secondDot !== -1) {
+        op = rest.substring(0, secondDot);
+        valStr = rest.substring(secondDot + 1);
+    } else {
+        op = "eq";
+        valStr = rest;
+    }
+    
+    const rebaseOp = (mapOperator(op) || "==") as FilterCondition["operator"];
+    let parsedVal: unknown = valStr;
+    if (valStr === "true") parsedVal = true;
+    else if (valStr === "false") parsedVal = false;
+    else if (valStr === "null") parsedVal = null;
+    else if (!isNaN(Number(valStr)) && valStr.trim() !== "") parsedVal = Number(valStr);
+    else if (valStr.startsWith("(")) {
+        const arrayContent = valStr.endsWith(")") ? valStr.slice(1, -1) : valStr.slice(1);
+        parsedVal = arrayContent.split(",").map(v => {
+            const trimmed = v.trim();
+            if (!isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
+            if (trimmed === "true") return true;
+            if (trimmed === "false") return false;
+            if (trimmed === "null") return null;
+            return trimmed;
+        });
+    }
+    
+    return { column: field, operator: rebaseOp, value: parsedVal };
+}
+
+function parseLogicalList(str: string): (FilterCondition | LogicalCondition)[] {
+    const list: (FilterCondition | LogicalCondition)[] = [];
+    let depth = 0;
+    let current = "";
+    
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (char === "(") depth++;
+        if (char === ")") depth--;
+        
+        if (char === "," && depth === 0) {
+            list.push(parseLogicalString(current));
+            current = "";
+        } else {
+            current += char;
+        }
+    }
+    if (current) {
+        list.push(parseLogicalString(current));
+    }
+    return list;
+}
+
 /**
  * Parse query parameters into QueryOptions
  */
@@ -27,10 +107,15 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     const options: QueryOptions = {};
 
     // Pagination
-    if (query.limit) options.limit = parseInt(String(query.limit));
-    if (query.offset) options.offset = parseInt(String(query.offset));
-    if (query.page) {
-        const page = parseInt(String(query.page));
+    const limitVal = getLastValue(query.limit);
+    if (limitVal) options.limit = parseInt(String(limitVal));
+    
+    const offsetVal = getLastValue(query.offset);
+    if (offsetVal) options.offset = parseInt(String(offsetVal));
+    
+    const pageVal = getLastValue(query.page);
+    if (pageVal) {
+        const page = parseInt(String(pageVal));
         const limit = options.limit || 20;
         options.offset = (page - 1) * limit;
     }
@@ -38,59 +123,88 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     // Filtering
     options.where = {};
 
+    // Handle logical conditions
+    const orVal = getLastValue(query.or);
+    const andVal = getLastValue(query.and);
+    if (orVal) {
+        let orStr = String(orVal).trim();
+        if (orStr.startsWith("(") && orStr.endsWith(")")) {
+            orStr = orStr.slice(1, -1);
+        }
+        options.logical = {
+            type: "or",
+            conditions: parseLogicalList(orStr)
+        };
+    } else if (andVal) {
+        let andStr = String(andVal).trim();
+        if (andStr.startsWith("(") && andStr.endsWith(")")) {
+            andStr = andStr.slice(1, -1);
+        }
+        options.logical = {
+            type: "and",
+            conditions: parseLogicalList(andStr)
+        };
+    }
 
     // PostgREST-style filtering: ?field=op.value
-    const reservedQueryKeys = ["limit", "offset", "page", "orderBy", "include", "fields", "searchString", "vector_search", "vector", "vector_distance", "vector_threshold"];
+    const reservedQueryKeys = ["limit", "offset", "page", "orderBy", "include", "fields", "searchString", "vector_search", "vector", "vector_distance", "vector_threshold", "or", "and"];
     for (const [key, rawValue] of Object.entries(query)) {
         if (reservedQueryKeys.includes(key)) continue;
 
-        const value = Array.isArray(rawValue) ? rawValue[rawValue.length - 1] : rawValue;
-
-        if (typeof value === "string") {
-            const parts = value.split(".");
-            if (parts.length >= 2) {
-                const op = parts[0];
-                const val = parts.slice(1).join(".");
-                const rebaseOp = mapOperator(op);
-
-                if (rebaseOp) {
-                    let parsedVal: string | number | boolean | null | (string | number | boolean | null)[] = val;
-                    // Attempt to parse primitive types or arrays
-                    if (val === "true") parsedVal = true;
-                    else if (val === "false") parsedVal = false;
-                    else if (val === "null") parsedVal = null;
-                    else if (!isNaN(Number(val)) && val.trim() !== "") parsedVal = Number(val);
-                    else if (val.startsWith("(")) {
-                        // Array for 'in' or 'not-in' ops (e.g. (1,2,3) or (a,b,c))
-                        const arrayContent = val.endsWith(")") ? val.slice(1, -1) : val.slice(1);
-                        parsedVal = arrayContent.split(",").map(v => {
-                            const trimmed = v.trim();
-                            if (!isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
-                            if (trimmed === "true") return true;
-                            if (trimmed === "false") return false;
-                            if (trimmed === "null") return null;
-                            return trimmed;
-                        });
-                    }
+        const rawValues = Array.isArray(rawValue) ? rawValue : [rawValue];
+        const conditions: [string, unknown][] = [];
+
+        for (const value of rawValues) {
+            if (typeof value === "string") {
+                const parts = value.split(".");
+                if (parts.length >= 2) {
+                    const op = parts[0];
+                    const val = parts.slice(1).join(".");
+                    const rebaseOp = mapOperator(op);
 
-                    options.where[key] = [rebaseOp, parsedVal];
+                    if (rebaseOp) {
+                        let parsedVal: string | number | boolean | null | (string | number | boolean | null)[] = val;
+                        // Attempt to parse primitive types or arrays
+                        if (val === "true") parsedVal = true;
+                        else if (val === "false") parsedVal = false;
+                        else if (val === "null") parsedVal = null;
+                        else if (!isNaN(Number(val)) && val.trim() !== "") parsedVal = Number(val);
+                        else if (val.startsWith("(")) {
+                            // Array for 'in' or 'not-in' ops (e.g. (1,2,3) or (a,b,c))
+                            const arrayContent = val.endsWith(")") ? val.slice(1, -1) : val.slice(1);
+                            parsedVal = arrayContent.split(",").map(v => {
+                                const trimmed = v.trim();
+                                if (!isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
+                                if (trimmed === "true") return true;
+                                if (trimmed === "false") return false;
+                                if (trimmed === "null") return null;
+                                return trimmed;
+                            });
+                        }
+
+                        conditions.push([rebaseOp, parsedVal]);
+                    } else {
+                        // Fallback: assume implicit eq if the dot wasn't an operator (e.g. email or float)
+                        let parsedVal: string | number | boolean | null = value;
+                        if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
+                        conditions.push(["==", parsedVal]);
+                    }
                 } else {
-                    // Fallback: assume implicit eq if the dot wasn't an operator (e.g. email or float)
+                    // Implicit eq
                     let parsedVal: string | number | boolean | null = value;
-                    if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
-                    options.where[key] = ["==", parsedVal];
+                    if (value === "true") parsedVal = true;
+                    else if (value === "false") parsedVal = false;
+                    else if (value === "null") parsedVal = null;
+                    else if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
+
+                    conditions.push(["==", parsedVal]);
                 }
-            } else {
-                // Implicit eq
-                let parsedVal: string | number | boolean | null = value;
-                if (value === "true") parsedVal = true;
-                else if (value === "false") parsedVal = false;
-                else if (value === "null") parsedVal = null;
-                else if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
-
-                options.where[key] = ["==", parsedVal];
             }
         }
+
+        if (conditions.length > 0) {
+            options.where[key] = conditions.length === 1 ? conditions[0] : conditions;
+        }
     }
 
     if (Object.keys(options.where).length === 0) {
@@ -98,15 +212,16 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     }
 
     // Sorting
-    if (query.orderBy) {
+    const orderByVal = getLastValue(query.orderBy);
+    if (orderByVal) {
         try {
-            options.orderBy = typeof query.orderBy === "string"
-                ? JSON.parse(query.orderBy)
-                : query.orderBy;
+            options.orderBy = typeof orderByVal === "string"
+                ? JSON.parse(orderByVal)
+                : orderByVal;
         } catch {
             // Try simple format: "field:direction"
-            if (typeof query.orderBy === "string") {
-                const [field, direction] = query.orderBy.split(":");
+            if (typeof orderByVal === "string") {
+                const [field, direction] = orderByVal.split(":");
                 const dir = (direction === "desc" ? "desc" : "asc") as "asc" | "desc";
                 options.orderBy = [
                     {
@@ -119,8 +234,9 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     }
 
     // Relation includes
-    if (query.include) {
-        const includeStr = String(query.include).trim();
+    const includeVal = getLastValue(query.include);
+    if (includeVal) {
+        const includeStr = String(includeVal).trim();
         if (includeStr === "*") {
             options.include = ["*"];
         } else {
@@ -129,14 +245,17 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     }
 
     // Field selection
-    if (query.fields) {
-        const fieldsStr = String(query.fields).trim();
+    const fieldsVal = getLastValue(query.fields);
+    if (fieldsVal) {
+        const fieldsStr = String(fieldsVal).trim();
         options.fields = fieldsStr.split(",").map(s => s.trim()).filter(Boolean);
     }
 
     // Vector similarity search
-    if (query.vector_search && query.vector) {
-        const vectorStr = String(query.vector);
+    const vectorSearchVal = getLastValue(query.vector_search);
+    const vectorVal = getLastValue(query.vector);
+    if (vectorSearchVal && vectorVal) {
+        const vectorStr = String(vectorVal);
         let queryVector: number[];
         try {
             queryVector = JSON.parse(vectorStr) as number[];
@@ -147,19 +266,21 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
             throw new Error("Invalid vector format. Expected JSON array of numbers, e.g. [0.1,0.2,0.3]");
         }
 
-        const distanceParam = query.vector_distance ? String(query.vector_distance) : "cosine";
+        const distanceParamVal = getLastValue(query.vector_distance);
+        const distanceParam = distanceParamVal ? String(distanceParamVal) : "cosine";
         if (distanceParam !== "cosine" && distanceParam !== "l2" && distanceParam !== "inner_product") {
             throw new Error(`Invalid vector_distance: ${distanceParam}. Expected: cosine, l2, or inner_product`);
         }
 
         const vectorSearch: VectorSearchParams = {
-            property: String(query.vector_search),
+            property: String(vectorSearchVal),
             vector: queryVector,
             distance: distanceParam,
         };
 
-        if (query.vector_threshold) {
-            const threshold = parseFloat(String(query.vector_threshold));
+        const thresholdVal = getLastValue(query.vector_threshold);
+        if (thresholdVal) {
+            const threshold = parseFloat(String(thresholdVal));
             if (isNaN(threshold)) {
                 throw new Error("Invalid vector_threshold. Expected a number.");
             }

package/src/api/types.ts

@@ -1,4 +1,4 @@
-import { EntityCollection, VectorSearchParams } from "@rebasepro/types";
+import { EntityCollection, VectorSearchParams, LogicalCondition } from "@rebasepro/types";
 import { AuthResult } from "../auth/middleware";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { DataDriver } from "@rebasepro/types";
@@ -77,6 +77,7 @@ export interface QueryOptions {
     limit?: number;
     offset?: number;
     where?: Record<string, unknown>;
+    logical?: LogicalCondition;
     orderBy?: Array<{ field: string; direction: "asc" | "desc" }>;
     include?: string[];
     /** Columns to return in the response (field-level selection) */

package/src/email/smtp-email-service.ts

@@ -1,6 +1,18 @@
 import { createTransport, Transporter } from "nodemailer";
 import { EmailService, EmailSendOptions, EmailConfig } from "./types";
 
+/**
+ * Safely parse a hostname from a URL string
+ */
+function getHostname(urlStr: string): string | undefined {
+    try {
+        const url = new URL(urlStr.includes("://") ? urlStr : `https://${urlStr}`);
+        return url.hostname;
+    } catch {
+        return undefined;
+    }
+}
+
 /**
  * SMTP Email Service implementation using Nodemailer
  */
@@ -12,7 +24,26 @@ export class SMTPEmailService implements EmailService {
         this.config = config;
 
         if (config.smtp) {
+            let smtpName = config.smtp.name;
+            if (!smtpName) {
+                const urlsToTry = [
+                    process.env.FRONTEND_URL,
+                    config.resetPasswordUrl,
+                    config.verifyEmailUrl
+                ];
+                for (const urlStr of urlsToTry) {
+                    if (urlStr) {
+                        const hostname = getHostname(urlStr);
+                        if (hostname) {
+                            smtpName = hostname;
+                            break;
+                        }
+                    }
+                }
+            }
+
             this.transporter = createTransport({
+                name: smtpName,
                 host: config.smtp.host,
                 port: config.smtp.port,
                 secure: config.smtp.secure ?? (config.smtp.port === 465),

package/src/email/types.ts

@@ -22,6 +22,7 @@ export interface SMTPConfig {
         user: string;
         pass: string;
     };
+    name?: string;
 }
 
 /**

package/src/init.ts

@@ -1,7 +1,21 @@
-import { DataDriver, EntityCollection, BackendBootstrapper, BootstrappedAuth, RealtimeProvider, HealthCheckResult, InitializedDriver, isSQLAdmin, BackendHooks, AuthAdapter, DatabaseAdapter } from "@rebasepro/types";
+import {
+    AuthAdapter,
+    BackendBootstrapper,
+    BackendHooks,
+    BootstrappedAuth,
+    DatabaseAdapter,
+    DataDriver,
+    EntityCollection,
+    HealthCheckResult,
+    InitializedDriver,
+    isPostgresCollection,
+    isSQLAdmin,
+    RealtimeProvider,
+    SecurityRule
+} from "@rebasepro/types";
 import { BackendCollectionRegistry } from "./collections/BackendCollectionRegistry";
 import { loadCollectionsFromDirectory } from "./collections/loader";
-import { DriverRegistry, DEFAULT_DRIVER_ID, DefaultDriverRegistry } from "./services/driver-registry";
+import { DEFAULT_DRIVER_ID, DefaultDriverRegistry, DriverRegistry } from "./services/driver-registry";
 import { Server } from "http";
 
 import { RestApiGenerator } from "./api/rest/api-generator";
@@ -16,22 +30,46 @@ import { HonoEnv } from "./api/types";
 import { configureLogLevel } from "./utils/logging";
 import { logger } from "./utils/logger";
 import { requestLogger } from "./utils/request-logger";
-import { createAdminRoutes, createAuthRoutes, requireAuth, requireAdmin, configureJwt } from "./auth";
-import { createStorageController, createStorageRoutes, DEFAULT_STORAGE_ID, DefaultStorageRegistry, BackendStorageConfig, StorageController, StorageRegistry } from "./storage";
+import { configureJwt, requireAdmin, requireAuth } from "./auth";
+import {
+    BackendStorageConfig,
+    createStorageController,
+    createStorageRoutes,
+    DEFAULT_STORAGE_ID,
+    DefaultStorageRegistry,
+    StorageController,
+    StorageRegistry
+} from "./storage";
+import type { ApiKeyStore } from "./auth/api-keys/api-key-store";
 import { createApiKeyStore } from "./auth/api-keys/api-key-store";
 import { createApiKeyRoutes } from "./auth/api-keys/api-key-routes";
-import type { ApiKeyStore } from "./auth/api-keys/api-key-store";
 import { createApiKeyRateLimiter } from "./auth/rate-limiter";
 import { createRebaseClient } from "@rebasepro/client";
-import { defaultUsersCollection } from "@rebasepro/common";
+
 import { createHistoryRoutes } from "./history";
-import { EmailConfig, createEmailService } from "./email";
 import type { EmailService } from "./email";
+import { createEmailService, EmailConfig } from "./email";
 import type { OAuthProvider } from "./auth/interfaces";
 import type { AuthHooks } from "./auth/auth-hooks";
 import { _initRebase } from "./singleton";
 
 export interface RebaseAuthConfig {
+    /**
+     * The collection that represents auth users.
+     *
+     * When provided, this collection's underlying database table is used
+     * for all auth operations (login, registration, password reset, etc.).
+     *
+     * Import the built-in default:
+     * ```ts
+     * import { defaultUsersCollection } from "@rebasepro/common";
+     * auth: { collection: defaultUsersCollection, jwtSecret: "..." }
+     * ```
+     *
+     * Or pass your own collection with the required auth fields
+     * (email, passwordHash, displayName, etc.).
+     */
+    collection?: EntityCollection;
     jwtSecret?: string;
     accessExpiresIn?: string;
     refreshExpiresIn?: string;
@@ -84,6 +122,7 @@ export interface RebaseAuthConfig {
      * ```
      */
     hooks?: AuthHooks;
+
     [key: string]: unknown;
 }
 
@@ -136,6 +175,20 @@ export interface RebaseBackendConfig {
      */
     storage?: BackendStorageConfig | StorageController | Record<string, BackendStorageConfig | StorageController>;
     history?: unknown;
+    /**
+     * Default security rules applied to any collection that does not define
+     * its own `securityRules`. Opt-in — if not set, collections without
+     * explicit rules remain unrestricted (beyond `requireAuth`).
+     *
+     * @example
+     * ```ts
+     * defaultSecurityRules: [
+     *     { operation: "select", access: "public" },
+     *     { operations: ["insert", "update", "delete"], roles: ["admin"] }
+     * ]
+     * ```
+     */
+    defaultSecurityRules?: SecurityRule[];
     enableSwagger?: boolean;
     functionsDir?: string;
     cronsDir?: string;
@@ -219,11 +272,13 @@ export interface RebaseBackendInstance {
     storageController?: StorageController;
     collectionRegistry: BackendCollectionRegistry;
     cronScheduler?: import("./cron").CronScheduler;
+
     /**
      * Deep health check that verifies database connectivity.
      * Returns latency and component status.
      */
     healthCheck(): Promise<HealthCheckResult>;
+
     /**
      * Graceful shutdown helper for the BaaS instance.
      * Stops the cron scheduler and closes the HTTP server, allowing
@@ -289,15 +344,20 @@ async function _initializeRebaseBackend(config: RebaseBackendConfig): Promise<Re
     let activeCollections = config.collections || [];
     if (config.collectionsDir && activeCollections.length === 0) {
         activeCollections = await loadCollectionsFromDirectory(config.collectionsDir);
-        logger.info("Auto-discovered collections", { count: activeCollections.length,
-dir: config.collectionsDir });
+        logger.info("Auto-discovered collections", {
+            count: activeCollections.length,
+            dir: config.collectionsDir
+        });
     }
 
-    if (config.auth) {
-        // Prepend defaultUsersCollection if not overridden by the developer's collections
-        activeCollections = Array.from(
-            new Map([defaultUsersCollection, ...activeCollections].map(c => [c.slug, c])).values()
-        );
+    // Apply default security rules to collections that don't define their own
+    if (config.defaultSecurityRules?.length) {
+        for (const collection of activeCollections) {
+            if (isPostgresCollection(collection) && (!collection.securityRules || collection.securityRules.length === 0)) {
+                collection.securityRules = config.defaultSecurityRules;
+            }
+        }
+        logger.info("Default security rules applied to collections without explicit rules");
     }
 
     const realtimeServices: Record<string, RealtimeProvider> = {};
@@ -341,8 +401,10 @@ dir: config.collectionsDir });
             defaultDriverId = b.id || bootstrapper.type;
         }
 
-        const driverResult = await bootstrapper.initializeDriver({ collections: activeCollections,
-collectionRegistry });
+        const driverResult = await bootstrapper.initializeDriver({
+            collections: activeCollections,
+            collectionRegistry
+        });
         delegates[b.id || bootstrapper.type] = driverResult.driver;
 
         if ((b.id || bootstrapper.type) === defaultDriverId || !defaultDriverResult) {
@@ -362,7 +424,9 @@ collectionRegistry });
     if (!defaultDriver || !defaultDriverResult) {
         throw new Error("Default driver not initialized by bootstrappers");
     }
-    const defaultBootstrapper = bootstrappers.find(b => (b as BackendBootstrapper & { id?: string }).id === defaultDriverId || b.type === defaultDriverId) || bootstrappers[0];
+    const defaultBootstrapper = bootstrappers.find(b => (b as BackendBootstrapper & {
+        id?: string
+    }).id === defaultDriverId || b.type === defaultDriverId) || bootstrappers[0];
     const defaultRealtimeService = defaultDriverResult.realtimeProvider;
 
     // 2. Initialize Auth & History via the default driver's bootstrapper
@@ -527,7 +591,10 @@ collectionRegistry });
 
             if (safeAuthConfig.linkedin?.clientId && safeAuthConfig.linkedin?.clientSecret) {
                 const { createLinkedinProvider } = await import("./auth");
-                oauthProviders.push(createLinkedinProvider(safeAuthConfig.linkedin as { clientId: string; clientSecret: string }));
+                oauthProviders.push(createLinkedinProvider(safeAuthConfig.linkedin as {
+                    clientId: string;
+                    clientSecret: string
+                }));
             }
 
             if (safeAuthConfig.github?.clientId && safeAuthConfig.github?.clientSecret) {
@@ -797,6 +864,18 @@ collectionRegistry });
     if (emailService) {
         Object.assign(serverClient, { email: emailService });
         logger.info("Email service attached to singleton", { configured: emailService.isConfigured() });
+
+        if (emailService.isConfigured() && typeof emailService.verifyConnection === "function") {
+            emailService.verifyConnection().then((success) => {
+                if (!success) {
+                    logger.warn("Warning: SMTP connection verification failed. Email delivery may fail.");
+                } else {
+                    logger.info("SMTP connection verified successfully.");
+                }
+            }).catch((err) => {
+                logger.warn("Warning: SMTP connection verification failed. Email delivery may fail.", { error: err });
+            });
+        }
     }
 
     // Attach raw SQL capability when the driver supports it (Postgres, MySQL).
@@ -860,8 +939,10 @@ collectionRegistry });
             const fnRoutes = createFunctionRoutes(loadedFunctions);
             functionsRouter.route("/", fnRoutes);
             config.app.route(`${basePath}/functions`, functionsRouter);
-            logger.info("Mounted custom functions", { count: loadedFunctions.length,
-path: `${basePath}/functions` });
+            logger.info("Mounted custom functions", {
+                count: loadedFunctions.length,
+                path: `${basePath}/functions`
+            });
         }
     }
 
@@ -910,13 +991,19 @@ path: `${basePath}/functions` });
             // Start the scheduler
             cronScheduler.start();
 
-            logger.info("Mounted cron jobs", { count: loadedCronJobs.length,
-path: `${basePath}/cron` });
+            logger.info("Mounted cron jobs", {
+                count: loadedCronJobs.length,
+                path: `${basePath}/cron`
+            });
         }
     }
 
-    if ((defaultBootstrapper as BackendBootstrapper & { initializeWebsockets?: (...args: unknown[]) => unknown }).initializeWebsockets) {
-        await (defaultBootstrapper as BackendBootstrapper & { initializeWebsockets: (...args: unknown[]) => unknown }).initializeWebsockets(config.server, defaultRealtimeService, defaultDriver, config.auth, authAdapter);
+    if ((defaultBootstrapper as BackendBootstrapper & {
+        initializeWebsockets?: (...args: unknown[]) => unknown
+    }).initializeWebsockets) {
+        await (defaultBootstrapper as BackendBootstrapper & {
+            initializeWebsockets: (...args: unknown[]) => unknown
+        }).initializeWebsockets(config.server, defaultRealtimeService, defaultDriver, config.auth, authAdapter);
     }
 
     logger.info("Rebase Backend Initialized");
@@ -931,12 +1018,16 @@ path: `${basePath}/cron` });
                 await admin.executeSql("SELECT 1");
             } else {
                 // Fallback: try a lightweight fetch to confirm driver is responsive
-                await defaultDriver.fetchCollection({ path: "__health_check_nonexistent__",
-limit: 1 });
+                await defaultDriver.fetchCollection({
+                    path: "__health_check_nonexistent__",
+                    limit: 1
+                });
             }
             const latencyMs = Math.round(performance.now() - start);
-            return { healthy: true,
-latencyMs };
+            return {
+                healthy: true,
+                latencyMs
+            };
         } catch (error: unknown) {
             const latencyMs = Math.round(performance.now() - start);
             logger.error("Health check failed", {
@@ -970,7 +1061,10 @@ latencyMs };
                 //    timer callbacks don't fire against a closed pool.
                 for (const [key, rt] of Object.entries(realtimeServices)) {
                     try {
-                        const rtWithLifecycle = rt as RealtimeProvider & { destroy?: () => Promise<void>; stopListening?: () => Promise<void> };
+                        const rtWithLifecycle = rt as RealtimeProvider & {
+                            destroy?: () => Promise<void>;
+                            stopListening?: () => Promise<void>
+                        };
                         if (typeof rtWithLifecycle.destroy === "function") {
                             await rtWithLifecycle.destroy();
                             logger.info(`Realtime service "${key}" destroyed`);