local-lite 0.0.3 → 0.0.4

package/dist/adapters/remote/supabase.d.ts

@@ -1,6 +1,6 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
 import { RemoteDBAdapter } from './index.js';
-import { DeltaChanges, SyncOperation } from '../../core/types.js';
+import { DeltaChanges, PushResult, SyncOperation } from '../../core/types.js';
 import { SyncLogger, CustomLogger, LogLevel } from '../../utils/logger.js';
 export interface SupabaseAdapterOptions {
     /**
@@ -13,6 +13,12 @@ export interface SupabaseAdapterOptions {
      * Default: 'updated_at'
      */
     updatedAtColumn?: string;
+    /**
+     * Optional subset of tables to which dynamic `syncScope` filters should apply.
+     * If provided, scope filters (like `business_id`) will only be attached to queries for these tables.
+     * Tables not in this list (e.g. 'businesses', 'profiles') will be fetched without the scope filter.
+     */
+    scopedTables?: string[];
     /**
      * Primary key column name on Postgres tables.
      * Default: 'id'
@@ -55,10 +61,18 @@ export interface SupabaseAdapterOptions {
      * Minimum log level. Default: 'info'
      */
     logLevel?: LogLevel;
+    /**
+     * Maximum records pulled per page from Supabase. Default: 1000
+     */
+    fetchLimit?: number;
 }
+export type AnySupabaseClient = SupabaseClient<any, any, any> | any;
+export type SupabaseClientResolver = AnySupabaseClient | (() => AnySupabaseClient | null | undefined) | null | undefined;
 export declare class SupabaseRemoteAdapter implements RemoteDBAdapter {
-    private client;
+    private clientResolver?;
+    private activeLiveCallback?;
     private tables;
+    private scopedTables?;
     private updatedAtColumn;
     private primaryKey;
     private deletedColumn;
@@ -67,8 +81,22 @@ export declare class SupabaseRemoteAdapter implements RemoteDBAdapter {
     private schema;
     private channelName;
     private activeChannel?;
+    private fetchLimit;
     logger: SyncLogger;
-    constructor(client: SupabaseClient, options?: SupabaseAdapterOptions);
+    constructor(clientOrOptions?: SupabaseClientResolver | SupabaseAdapterOptions, maybeOptions?: SupabaseAdapterOptions);
+    /**
+     * Resolves the active Supabase client instance dynamically.
+     */
+    getClient(): AnySupabaseClient;
+    /**
+     * Property getter for backwards-compatibility.
+     */
+    get client(): AnySupabaseClient;
+    /**
+     * Dynamically sets or updates the Supabase client or getter function.
+     * Automatically cleans up the previous realtime channel and re-subscribes if active.
+     */
+    setClient(client: SupabaseClientResolver): void;
     /**
      * Set or update tracked tables dynamically.
      */
@@ -76,12 +104,12 @@ export declare class SupabaseRemoteAdapter implements RemoteDBAdapter {
     /**
      * Pushes outbox operations to Supabase.
      */
-    pushChanges(operations: SyncOperation[]): Promise<boolean>;
+    pushChanges(operations: SyncOperation[]): Promise<boolean | PushResult>;
     /**
      * Fetches delta changes from Supabase since a given timestamp.
      * Reads updated records and checks `deleted: true` to propagate soft deletes.
      */
-    fetchChanges(sinceTimestamp: number): Promise<DeltaChanges>;
+    fetchChanges(sinceTimestamp: number, scope?: Record<string, any>): Promise<DeltaChanges>;
     /**
      * Helper to determine if a record represents a soft delete.
      */
@@ -89,7 +117,7 @@ export declare class SupabaseRemoteAdapter implements RemoteDBAdapter {
     /**
      * Subscribes to live realtime postgres_changes from Supabase.
      */
-    subscribeToLiveChanges(callback: (changes: DeltaChanges) => void): void;
+    subscribeToLiveChanges(callback: (changes: DeltaChanges) => void): (() => void) | void;
     /**
      * Clean up active realtime channels.
      */

package/dist/adapters/remote/supabase.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SupabaseRemoteAdapter = void 0;
 const logger_js_1 = require("../../utils/logger.js");
 class SupabaseRemoteAdapter {
-    client;
+    clientResolver;
+    activeLiveCallback;
     tables;
+    scopedTables;
     updatedAtColumn;
     primaryKey;
     deletedColumn;
@@ -13,10 +15,27 @@ class SupabaseRemoteAdapter {
     schema;
     channelName;
     activeChannel;
+    fetchLimit;
     logger;
-    constructor(client, options = {}) {
-        this.client = client;
+    constructor(clientOrOptions, maybeOptions = {}) {
+        let client;
+        let options;
+        // Allow new SupabaseRemoteAdapter(options) shorthand when no client is passed initially
+        if (clientOrOptions &&
+            typeof clientOrOptions === 'object' &&
+            !('channel' in clientOrOptions) &&
+            !('from' in clientOrOptions) &&
+            !('auth' in clientOrOptions)) {
+            client = null;
+            options = clientOrOptions;
+        }
+        else {
+            client = clientOrOptions;
+            options = maybeOptions;
+        }
+        this.clientResolver = client;
         this.tables = options.tables ?? [];
+        this.scopedTables = options.scopedTables;
         this.updatedAtColumn = options.updatedAtColumn ?? 'updated_at';
         this.primaryKey = options.primaryKey ?? 'id';
         this.deletedColumn = options.deletedColumn ?? options.deletedAtColumn ?? 'deleted';
@@ -24,17 +43,46 @@ class SupabaseRemoteAdapter {
         this.pushRpcName = options.pushRpcName;
         this.schema = options.schema ?? 'public';
         this.channelName = options.channelName ?? 'local_first_sync';
-        if (options.logger instanceof logger_js_1.SyncLogger) {
-            this.logger = options.logger;
-        }
-        else if (typeof options.logger === 'boolean') {
-            this.logger = new logger_js_1.SyncLogger({ enabled: options.logger, level: options.logLevel });
+        this.fetchLimit = options.fetchLimit ?? 1000;
+        this.logger = (0, logger_js_1.createSyncLogger)(options.logger, options.logLevel);
+    }
+    /**
+     * Resolves the active Supabase client instance dynamically.
+     */
+    getClient() {
+        if (typeof this.clientResolver === 'function') {
+            try {
+                return this.clientResolver() ?? null;
+            }
+            catch {
+                return null;
+            }
         }
-        else if (options.logger && typeof options.logger === 'object') {
-            this.logger = new logger_js_1.SyncLogger({ customLogger: options.logger, level: options.logLevel });
+        return this.clientResolver ?? null;
+    }
+    /**
+     * Property getter for backwards-compatibility.
+     */
+    get client() {
+        return this.getClient();
+    }
+    /**
+     * Dynamically sets or updates the Supabase client or getter function.
+     * Automatically cleans up the previous realtime channel and re-subscribes if active.
+     */
+    setClient(client) {
+        const previousClient = this.getClient();
+        this.clientResolver = client;
+        const newClient = this.getClient();
+        if (this.activeChannel && previousClient?.removeChannel && previousClient !== newClient) {
+            try {
+                previousClient.removeChannel(this.activeChannel);
+            }
+            catch { }
+            this.activeChannel = undefined;
         }
-        else {
-            this.logger = options.logLevel ? new logger_js_1.SyncLogger({ level: options.logLevel }) : logger_js_1.defaultLogger;
+        if (this.activeLiveCallback && newClient && typeof newClient.channel === 'function') {
+            this.subscribeToLiveChanges(this.activeLiveCallback);
         }
     }
     /**
@@ -50,9 +98,14 @@ class SupabaseRemoteAdapter {
         if (!operations || operations.length === 0) {
             return true;
         }
+        const client = this.getClient();
+        if (!client) {
+            this.logger.debug('Supabase client is not available; skipping remote push.');
+            return false;
+        }
         // 1. If custom RPC is configured, perform atomic batch RPC
         if (this.pushRpcName) {
-            const { error } = await this.client.rpc(this.pushRpcName, {
+            const { error } = await client.rpc(this.pushRpcName, {
                 operations: operations.map((op) => ({
                     id: op.id,
                     table_name: op.tableName,
@@ -68,28 +121,129 @@ class SupabaseRemoteAdapter {
             }
             return true;
         }
-        // 2. Direct table operations
-        for (const op of operations) {
-            try {
-                if (op.operation === 'DELETE') {
-                    // Soft delete: sets deleted = true and stamps updated_at
+        // 2. Direct table operations with consecutive batching and per-operation tracking
+        const successfulIds = [];
+        const failedIds = [];
+        const errors = {};
+        let i = 0;
+        while (i < operations.length) {
+            const op = operations[i];
+            // Batch consecutive INSERTs for the same table
+            if (op.operation === 'INSERT') {
+                const batch = [];
+                while (i < operations.length &&
+                    operations[i].operation === 'INSERT' &&
+                    operations[i].tableName === op.tableName) {
+                    batch.push(operations[i]);
+                    i++;
+                }
+                const buildRowData = (item) => {
+                    const row = {
+                        ...(item.payload || {}),
+                        [this.primaryKey]: item.rowId,
+                        [this.deletedColumn]: false,
+                    };
+                    if (this.updatedAtColumn && !row[this.updatedAtColumn]) {
+                        row[this.updatedAtColumn] = new Date(item.timestamp).toISOString();
+                    }
+                    return row;
+                };
+                if (batch.length === 1) {
+                    try {
+                        const rowData = buildRowData(batch[0]);
+                        const { error } = await client.from(op.tableName).upsert(rowData);
+                        if (error) {
+                            const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'INSERT' });
+                            this.logger.error(msg);
+                            failedIds.push(batch[0].id);
+                            errors[batch[0].id] = msg;
+                        }
+                        else {
+                            successfulIds.push(batch[0].id);
+                        }
+                    }
+                    catch (err) {
+                        const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'INSERT' });
+                        this.logger.error(msg);
+                        failedIds.push(batch[0].id);
+                        errors[batch[0].id] = msg;
+                    }
+                }
+                else {
+                    // Bulk upsert for multiple consecutive inserts
+                    const retryIndividually = async () => {
+                        for (const item of batch) {
+                            try {
+                                const singleRow = buildRowData(item);
+                                const { error: singleErr } = await client.from(op.tableName).upsert(singleRow);
+                                if (singleErr) {
+                                    const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'INSERT' });
+                                    failedIds.push(item.id);
+                                    errors[item.id] = msg;
+                                }
+                                else {
+                                    successfulIds.push(item.id);
+                                }
+                            }
+                            catch (singleErr) {
+                                const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'INSERT' });
+                                failedIds.push(item.id);
+                                errors[item.id] = msg;
+                            }
+                        }
+                    };
+                    try {
+                        const rows = batch.map(buildRowData);
+                        const { error } = await client.from(op.tableName).upsert(rows);
+                        if (!error) {
+                            for (const item of batch)
+                                successfulIds.push(item.id);
+                        }
+                        else {
+                            await retryIndividually();
+                        }
+                    }
+                    catch {
+                        await retryIndividually();
+                    }
+                }
+                continue;
+            }
+            // Handle DELETE
+            if (op.operation === 'DELETE') {
+                try {
                     const patch = {
                         [this.deletedColumn]: this.deletedValue,
                     };
                     if (this.updatedAtColumn) {
                         patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
                     }
-                    const { error } = await this.client
+                    const { error } = await client
                         .from(op.tableName)
                         .update(patch)
                         .eq(this.primaryKey, op.rowId);
                     if (error) {
-                        this.logger.error((0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'DELETE' }));
-                        return false;
+                        const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'DELETE' });
+                        this.logger.error(msg);
+                        failedIds.push(op.id);
+                        errors[op.id] = msg;
                     }
+                    else {
+                        successfulIds.push(op.id);
+                    }
+                }
+                catch (err) {
+                    const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'DELETE' });
+                    this.logger.error(msg);
+                    failedIds.push(op.id);
+                    errors[op.id] = msg;
                 }
-                else if (op.operation === 'UPDATE') {
-                    // Partial UPDATE on existing record: only updates the modified columns to respect NOT NULL constraints
+                i++;
+                continue;
+            }
+            // Handle UPDATE
+            if (op.operation === 'UPDATE') {
+                try {
                     const patch = {
                         ...(op.payload || {}),
                         [this.deletedColumn]: false,
@@ -97,91 +251,130 @@ class SupabaseRemoteAdapter {
                     if (this.updatedAtColumn) {
                         patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
                     }
-                    const { error, data } = await this.client
+                    const { error, data } = await client
                         .from(op.tableName)
                         .update(patch)
                         .eq(this.primaryKey, op.rowId)
                         .select(this.primaryKey);
                     if (error) {
-                        this.logger.error((0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'UPDATE' }));
-                        return false;
+                        const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'UPDATE' });
+                        this.logger.error(msg);
+                        failedIds.push(op.id);
+                        errors[op.id] = msg;
                     }
-                    // If row did not exist remotely (e.g. created & modified offline), fallback to upsert
-                    if (!data || data.length === 0) {
+                    else if (!data || data.length === 0) {
+                        // If row did not exist remotely, fallback to upsert
                         const rowData = {
                             ...patch,
                             [this.primaryKey]: op.rowId,
                         };
-                        const { error: upsertErr } = await this.client
-                            .from(op.tableName)
-                            .upsert(rowData);
+                        const { error: upsertErr } = await client.from(op.tableName).upsert(rowData);
                         if (upsertErr) {
-                            this.logger.error((0, logger_js_1.formatSupabaseError)(upsertErr, { table: op.tableName, operation: 'UPSERT_FALLBACK' }));
-                            return false;
+                            const msg = (0, logger_js_1.formatSupabaseError)(upsertErr, { table: op.tableName, operation: 'UPSERT_FALLBACK' });
+                            this.logger.error(msg);
+                            failedIds.push(op.id);
+                            errors[op.id] = msg;
+                        }
+                        else {
+                            successfulIds.push(op.id);
                         }
                     }
-                }
-                else {
-                    // INSERT -> upsert into table with deleted: false
-                    const rowData = {
-                        ...(op.payload || {}),
-                        [this.primaryKey]: op.rowId,
-                        [this.deletedColumn]: false,
-                    };
-                    if (this.updatedAtColumn && !rowData[this.updatedAtColumn]) {
-                        rowData[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
-                    }
-                    const { error } = await this.client
-                        .from(op.tableName)
-                        .upsert(rowData);
-                    if (error) {
-                        this.logger.error((0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'INSERT' }));
-                        return false;
+                    else {
+                        successfulIds.push(op.id);
                     }
                 }
+                catch (err) {
+                    const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'UPDATE' });
+                    this.logger.error(msg);
+                    failedIds.push(op.id);
+                    errors[op.id] = msg;
+                }
+                i++;
+                continue;
             }
-            catch (err) {
-                this.logger.error((0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: op.operation }));
-                return false;
-            }
+            i++;
+        }
+        if (failedIds.length === 0) {
+            return true;
         }
-        return true;
+        return {
+            success: false,
+            successfulIds,
+            failedIds,
+            errors,
+        };
     }
     /**
      * Fetches delta changes from Supabase since a given timestamp.
      * Reads updated records and checks `deleted: true` to propagate soft deletes.
      */
-    async fetchChanges(sinceTimestamp) {
+    async fetchChanges(sinceTimestamp, scope) {
+        const client = this.getClient();
+        if (!client) {
+            this.logger.debug('Supabase client is not available; skipping fetchChanges.');
+            return {
+                timestamp: sinceTimestamp,
+                changes: [],
+            };
+        }
         const changes = [];
         const sinceIso = sinceTimestamp > 0 ? new Date(sinceTimestamp).toISOString() : null;
         let maxServerTimestamp = sinceTimestamp;
-        for (const table of this.tables) {
-            try {
-                let query = this.client
-                    .from(table)
-                    .select('*');
-                if (sinceIso) {
-                    query = query.gt(this.updatedAtColumn, sinceIso);
+        const fetchTableDeltas = async (table) => {
+            const isTableScoped = !this.scopedTables || this.scopedTables.includes(table);
+            const tableChanges = [];
+            let hasMore = true;
+            let currentSinceIso = sinceIso;
+            while (hasMore) {
+                let query = client.from(table).select('*');
+                if (isTableScoped && scope && typeof scope === 'object') {
+                    for (const [col, val] of Object.entries(scope)) {
+                        if (val !== undefined && val !== null && typeof query.eq === 'function') {
+                            query = query.eq(col, val);
+                        }
+                    }
+                }
+                if (currentSinceIso) {
+                    query = query.gt(this.updatedAtColumn, currentSinceIso);
                 }
                 if (typeof query.order === 'function') {
                     query = query.order(this.updatedAtColumn, { ascending: true });
                 }
-                const { data, error } = await query;
+                if (typeof query.limit === 'function') {
+                    query = query.limit(this.fetchLimit);
+                }
+                let { data, error } = await query;
+                // If PostgreSQL returns 42703 (undefined column) because a scoped column does not exist on this table,
+                // gracefully fallback to querying without the scope filter so synchronization doesn't halt.
+                if (error &&
+                    (error.code === '42703' || String(error.message || '').includes('does not exist')) &&
+                    isTableScoped) {
+                    this.logger.debug(`[local-lite] Column in scope does not exist on table "${table}". Retrying without scope filter.`);
+                    let fallbackQuery = client.from(table).select('*');
+                    if (currentSinceIso) {
+                        fallbackQuery = fallbackQuery.gt(this.updatedAtColumn, currentSinceIso);
+                    }
+                    if (typeof fallbackQuery.order === 'function') {
+                        fallbackQuery = fallbackQuery.order(this.updatedAtColumn, { ascending: true });
+                    }
+                    if (typeof fallbackQuery.limit === 'function') {
+                        fallbackQuery = fallbackQuery.limit(this.fetchLimit);
+                    }
+                    const fallbackResult = await fallbackQuery;
+                    data = fallbackResult.data;
+                    error = fallbackResult.error;
+                }
                 if (error) {
-                    this.logger.error((0, logger_js_1.formatSupabaseError)(error, { table, operation: 'PULL' }));
-                    continue;
+                    throw error;
                 }
-                if (data && Array.isArray(data)) {
+                if (data && Array.isArray(data) && data.length > 0) {
                     for (const row of data) {
                         const isSoftDeleted = this.isSoftDeleted(row);
                         const operation = isSoftDeleted ? 'DELETE' : 'UPDATE';
                         const rowTime = row[this.updatedAtColumn]
                             ? new Date(row[this.updatedAtColumn]).getTime()
                             : Date.now();
-                        if (rowTime > maxServerTimestamp) {
-                            maxServerTimestamp = rowTime;
-                        }
-                        changes.push({
+                        tableChanges.push({
                             tableName: table,
                             operation,
                             rowId: String(row[this.primaryKey]),
@@ -189,10 +382,55 @@ class SupabaseRemoteAdapter {
                             timestamp: rowTime,
                         });
                     }
+                    // Stop paging if unpaginated query or fewer rows than limit returned
+                    if (typeof query.limit !== 'function' || data.length < this.fetchLimit) {
+                        hasMore = false;
+                    }
+                    else {
+                        const lastRow = data[data.length - 1];
+                        const nextIso = lastRow[this.updatedAtColumn]
+                            ? new Date(lastRow[this.updatedAtColumn]).toISOString()
+                            : null;
+                        if (nextIso && nextIso !== currentSinceIso) {
+                            currentSinceIso = nextIso;
+                        }
+                        else {
+                            hasMore = false;
+                        }
+                    }
+                }
+                else {
+                    hasMore = false;
                 }
             }
-            catch (err) {
-                this.logger.error((0, logger_js_1.formatSupabaseError)(err, { table, operation: 'PULL' }));
+            return tableChanges;
+        };
+        // Query tables in concurrent chunks of 5 to avoid 100+ second serial roundtrips
+        const CHUNK_SIZE = 5;
+        for (let i = 0; i < this.tables.length; i += CHUNK_SIZE) {
+            const chunk = this.tables.slice(i, i + CHUNK_SIZE);
+            const results = await Promise.all(chunk.map(async (table) => {
+                try {
+                    return await fetchTableDeltas(table);
+                }
+                catch (err) {
+                    const msg = (0, logger_js_1.formatSupabaseError)(err, { table, operation: 'PULL' });
+                    if (msg.includes('Network Offline') || msg.includes('Failed to reach')) {
+                        this.logger.warn(msg);
+                    }
+                    else {
+                        this.logger.error(msg);
+                    }
+                    throw err;
+                }
+            }));
+            for (const tableChanges of results) {
+                for (const change of tableChanges) {
+                    if (change.timestamp !== undefined && change.timestamp > maxServerTimestamp) {
+                        maxServerTimestamp = change.timestamp;
+                    }
+                    changes.push(change);
+                }
             }
         }
         return {
@@ -218,14 +456,29 @@ class SupabaseRemoteAdapter {
      * Subscribes to live realtime postgres_changes from Supabase.
      */
     subscribeToLiveChanges(callback) {
-        if (this.activeChannel) {
-            this.client.removeChannel(this.activeChannel);
+        this.activeLiveCallback = callback;
+        const client = this.getClient();
+        if (this.activeChannel && client?.removeChannel) {
+            try {
+                client.removeChannel(this.activeChannel);
+            }
+            catch { }
             this.activeChannel = undefined;
         }
+        if (!client || typeof client.channel !== 'function') {
+            this.logger.debug('Supabase client is not available; skipping live changes subscription.');
+            return () => {
+                this.activeLiveCallback = undefined;
+                this.destroy();
+            };
+        }
         if (this.tables.length === 0) {
-            return;
+            return () => {
+                this.activeLiveCallback = undefined;
+                this.destroy();
+            };
         }
-        const channel = this.client.channel(this.channelName);
+        const channel = client.channel(this.channelName);
         for (const table of this.tables) {
             channel.on('postgres_changes', { event: '*', schema: this.schema, table }, (payload) => {
                 let op = 'UPDATE';
@@ -262,13 +515,21 @@ class SupabaseRemoteAdapter {
             }
         });
         this.activeChannel = channel;
+        return () => {
+            this.activeLiveCallback = undefined;
+            this.destroy();
+        };
     }
     /**
      * Clean up active realtime channels.
      */
     destroy() {
-        if (this.activeChannel) {
-            this.client.removeChannel(this.activeChannel);
+        const client = this.getClient();
+        if (this.activeChannel && client?.removeChannel) {
+            try {
+                client.removeChannel(this.activeChannel);
+            }
+            catch { }
             this.activeChannel = undefined;
         }
     }

package/dist/config/index.js

@@ -67,9 +67,7 @@ async function createSyncClient(config) {
     const remoteAdapter = await (0, resolve_remote_js_1.resolveRemoteAdapter)(config);
     // 3. Resolve Network Provider
     const network = config.network ?? new index_js_1.DefaultNetworkStatusProvider(true);
-    const autoSchema = config.autoSchema !== undefined
-        ? config.autoSchema
-        : !config.migrations || config.migrations.length === 0;
+    const autoSchema = config.autoSchema ?? false;
     // 4. Instantiate Local-First Client
     const client = new client_js_1.LocalFirstClient({
         local: localAdapter,
@@ -85,17 +83,16 @@ async function createSyncClient(config) {
         logLevel: config.logLevel,
         autoSchema,
         tables: config.tables ?? [],
+        migrations: config.migrations,
+        autoStart: config.autoStart,
+        jsonColumns: config.jsonColumns,
+        autoHydrateJSON: config.autoHydrateJSON,
+        syncScope: config.syncScope,
+        autoPauseOnBackground: config.autoPauseOnBackground,
     });
     // 5. Execute Migrations & Auto-initialize
     if (config.autoInitialize !== false) {
         await client.initialize();
-        if (config.migrations && config.migrations.length > 0) {
-            for (const query of config.migrations) {
-                if (query && query.trim()) {
-                    await client.db.execute(query);
-                }
-            }
-        }
     }
     return client;
 }