local-lite 0.0.0-stage → 0.0.1

package/dist/adapters/remote/supabase.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseRemoteAdapter = void 0;
+const logger_js_1 = require("../../utils/logger.js");
+class SupabaseRemoteAdapter {
+    client;
+    tables;
+    updatedAtColumn;
+    primaryKey;
+    deletedColumn;
+    deletedValue;
+    pushRpcName;
+    schema;
+    channelName;
+    activeChannel;
+    logger;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.tables = options.tables ?? [];
+        this.updatedAtColumn = options.updatedAtColumn ?? 'updated_at';
+        this.primaryKey = options.primaryKey ?? 'id';
+        this.deletedColumn = options.deletedColumn ?? options.deletedAtColumn ?? 'deleted';
+        this.deletedValue = options.deletedValue !== undefined ? options.deletedValue : true;
+        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 });
+        }
+        else if (options.logger && typeof options.logger === 'object') {
+            this.logger = new logger_js_1.SyncLogger({ customLogger: options.logger, level: options.logLevel });
+        }
+        else {
+            this.logger = options.logLevel ? new logger_js_1.SyncLogger({ level: options.logLevel }) : logger_js_1.defaultLogger;
+        }
+    }
+    /**
+     * Set or update tracked tables dynamically.
+     */
+    setTables(tables) {
+        this.tables = tables;
+    }
+    /**
+     * Pushes outbox operations to Supabase.
+     */
+    async pushChanges(operations) {
+        if (!operations || operations.length === 0) {
+            return true;
+        }
+        // 1. If custom RPC is configured, perform atomic batch RPC
+        if (this.pushRpcName) {
+            const { error } = await this.client.rpc(this.pushRpcName, {
+                operations: operations.map((op) => ({
+                    id: op.id,
+                    table_name: op.tableName,
+                    row_id: op.rowId,
+                    operation: op.operation,
+                    payload: op.payload,
+                    timestamp: op.timestamp,
+                })),
+            });
+            if (error) {
+                this.logger.error((0, logger_js_1.formatSupabaseError)(error, { operation: 'batch_rpc' }));
+                return false;
+            }
+            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
+                    const patch = {
+                        [this.deletedColumn]: this.deletedValue,
+                    };
+                    if (this.updatedAtColumn) {
+                        patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                    }
+                    const { error } = await this.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;
+                    }
+                }
+                else if (op.operation === 'UPDATE') {
+                    // Partial UPDATE on existing record: only updates the modified columns to respect NOT NULL constraints
+                    const patch = {
+                        ...(op.payload || {}),
+                        [this.deletedColumn]: false,
+                    };
+                    if (this.updatedAtColumn) {
+                        patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                    }
+                    const { error, data } = await this.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;
+                    }
+                    // If row did not exist remotely (e.g. created & modified offline), fallback to upsert
+                    if (!data || data.length === 0) {
+                        const rowData = {
+                            ...patch,
+                            [this.primaryKey]: op.rowId,
+                        };
+                        const { error: upsertErr } = await this.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;
+                        }
+                    }
+                }
+                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;
+                    }
+                }
+            }
+            catch (err) {
+                this.logger.error((0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: op.operation }));
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Fetches delta changes from Supabase since a given timestamp.
+     * Reads updated records and checks `deleted: true` to propagate soft deletes.
+     */
+    async fetchChanges(sinceTimestamp) {
+        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);
+                }
+                if (typeof query.order === 'function') {
+                    query = query.order(this.updatedAtColumn, { ascending: true });
+                }
+                const { data, error } = await query;
+                if (error) {
+                    this.logger.error((0, logger_js_1.formatSupabaseError)(error, { table, operation: 'PULL' }));
+                    continue;
+                }
+                if (data && Array.isArray(data)) {
+                    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({
+                            tableName: table,
+                            operation,
+                            rowId: String(row[this.primaryKey]),
+                            payload: isSoftDeleted ? null : row,
+                            timestamp: rowTime,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                this.logger.error((0, logger_js_1.formatSupabaseError)(err, { table, operation: 'PULL' }));
+            }
+        }
+        return {
+            timestamp: changes.length > 0 ? maxServerTimestamp : sinceTimestamp,
+            changes,
+        };
+    }
+    /**
+     * Helper to determine if a record represents a soft delete.
+     */
+    isSoftDeleted(record) {
+        if (!record)
+            return false;
+        const val = record[this.deletedColumn];
+        if (val === true || val === 1)
+            return true;
+        if (val && !['false', '0', 'null', 'undefined'].includes(String(val).toLowerCase())) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Subscribes to live realtime postgres_changes from Supabase.
+     */
+    subscribeToLiveChanges(callback) {
+        if (this.activeChannel) {
+            this.client.removeChannel(this.activeChannel);
+            this.activeChannel = undefined;
+        }
+        if (this.tables.length === 0) {
+            return;
+        }
+        const channel = this.client.channel(this.channelName);
+        for (const table of this.tables) {
+            channel.on('postgres_changes', { event: '*', schema: this.schema, table }, (payload) => {
+                let op = 'UPDATE';
+                if (payload.eventType === 'INSERT')
+                    op = 'INSERT';
+                else if (payload.eventType === 'DELETE')
+                    op = 'DELETE';
+                const record = op === 'DELETE' ? payload.old : payload.new;
+                if (!record)
+                    return;
+                const isSoftDeleted = op !== 'DELETE' && this.isSoftDeleted(record);
+                const finalOp = isSoftDeleted ? 'DELETE' : op;
+                const rowId = String(record[this.primaryKey]);
+                const timestamp = record[this.updatedAtColumn]
+                    ? new Date(record[this.updatedAtColumn]).getTime()
+                    : Date.now();
+                callback({
+                    timestamp,
+                    changes: [
+                        {
+                            tableName: table,
+                            operation: finalOp,
+                            rowId,
+                            payload: finalOp === 'DELETE' ? null : record,
+                            timestamp,
+                        },
+                    ],
+                });
+            });
+        }
+        channel.subscribe((status) => {
+            if (status === 'SUBSCRIBED') {
+                // Successfully subscribed to Supabase realtime
+            }
+        });
+        this.activeChannel = channel;
+    }
+    /**
+     * Clean up active realtime channels.
+     */
+    destroy() {
+        if (this.activeChannel) {
+            this.client.removeChannel(this.activeChannel);
+            this.activeChannel = undefined;
+        }
+    }
+}
+exports.SupabaseRemoteAdapter = SupabaseRemoteAdapter;

package/dist/config/index.d.ts

@@ -0,0 +1,24 @@
+import { LocalFirstClient } from '../core/client.js';
+import { LocalLiteConfig } from './types.js';
+export * from './types.js';
+export { resolveLocalAdapter } from './resolve-local.js';
+export { resolveRemoteAdapter } from './resolve-remote.js';
+export { LocalFirstClient } from '../core/client.js';
+export { ExpoSQLiteAdapter } from '../adapters/local/expo-sqlite.js';
+export { OpSQLiteAdapter } from '../adapters/local/op-sqlite.js';
+export { BetterSQLite3Adapter } from '../adapters/local/better-sqlite3.js';
+export { LibSQLAdapter } from '../adapters/local/libsql.js';
+export { SqlJsAdapter } from '../adapters/local/sql-js.js';
+export { NodeSQLiteAdapter } from '../adapters/local/node-sqlite.js';
+export { SupabaseRemoteAdapter } from '../adapters/remote/supabase.js';
+export { ConvexRemoteAdapter } from '../adapters/remote/convex.js';
+export { FirestoreRemoteAdapter } from '../adapters/remote/firestore.js';
+export { MemoryDemoRemoteAdapter } from '../adapters/remote/demo.js';
+/**
+ * Type-safe configuration helper function (similar to defineConfig in Vite/Tailwind).
+ */
+export declare function defineSyncConfig(config: LocalLiteConfig): LocalLiteConfig;
+/**
+ * Factory that instantiates, wires up, and initializes a LocalFirstClient from a LocalLiteConfig.
+ */
+export declare function createSyncClient(config: LocalLiteConfig): Promise<LocalFirstClient>;

package/dist/config/index.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDemoRemoteAdapter = exports.FirestoreRemoteAdapter = exports.ConvexRemoteAdapter = exports.SupabaseRemoteAdapter = exports.NodeSQLiteAdapter = exports.SqlJsAdapter = exports.LibSQLAdapter = exports.BetterSQLite3Adapter = exports.OpSQLiteAdapter = exports.ExpoSQLiteAdapter = exports.LocalFirstClient = exports.resolveRemoteAdapter = exports.resolveLocalAdapter = void 0;
+exports.defineSyncConfig = defineSyncConfig;
+exports.createSyncClient = createSyncClient;
+const client_js_1 = require("../core/client.js");
+const index_js_1 = require("../adapters/network/index.js");
+const resolve_local_js_1 = require("./resolve-local.js");
+const resolve_remote_js_1 = require("./resolve-remote.js");
+// Export all config types
+__exportStar(require("./types.js"), exports);
+// Export adapter resolvers
+var resolve_local_js_2 = require("./resolve-local.js");
+Object.defineProperty(exports, "resolveLocalAdapter", { enumerable: true, get: function () { return resolve_local_js_2.resolveLocalAdapter; } });
+var resolve_remote_js_2 = require("./resolve-remote.js");
+Object.defineProperty(exports, "resolveRemoteAdapter", { enumerable: true, get: function () { return resolve_remote_js_2.resolveRemoteAdapter; } });
+// Re-export adapters and core client for convenience
+var client_js_2 = require("../core/client.js");
+Object.defineProperty(exports, "LocalFirstClient", { enumerable: true, get: function () { return client_js_2.LocalFirstClient; } });
+var expo_sqlite_js_1 = require("../adapters/local/expo-sqlite.js");
+Object.defineProperty(exports, "ExpoSQLiteAdapter", { enumerable: true, get: function () { return expo_sqlite_js_1.ExpoSQLiteAdapter; } });
+var op_sqlite_js_1 = require("../adapters/local/op-sqlite.js");
+Object.defineProperty(exports, "OpSQLiteAdapter", { enumerable: true, get: function () { return op_sqlite_js_1.OpSQLiteAdapter; } });
+var better_sqlite3_js_1 = require("../adapters/local/better-sqlite3.js");
+Object.defineProperty(exports, "BetterSQLite3Adapter", { enumerable: true, get: function () { return better_sqlite3_js_1.BetterSQLite3Adapter; } });
+var libsql_js_1 = require("../adapters/local/libsql.js");
+Object.defineProperty(exports, "LibSQLAdapter", { enumerable: true, get: function () { return libsql_js_1.LibSQLAdapter; } });
+var sql_js_js_1 = require("../adapters/local/sql-js.js");
+Object.defineProperty(exports, "SqlJsAdapter", { enumerable: true, get: function () { return sql_js_js_1.SqlJsAdapter; } });
+var node_sqlite_js_1 = require("../adapters/local/node-sqlite.js");
+Object.defineProperty(exports, "NodeSQLiteAdapter", { enumerable: true, get: function () { return node_sqlite_js_1.NodeSQLiteAdapter; } });
+var supabase_js_1 = require("../adapters/remote/supabase.js");
+Object.defineProperty(exports, "SupabaseRemoteAdapter", { enumerable: true, get: function () { return supabase_js_1.SupabaseRemoteAdapter; } });
+var convex_js_1 = require("../adapters/remote/convex.js");
+Object.defineProperty(exports, "ConvexRemoteAdapter", { enumerable: true, get: function () { return convex_js_1.ConvexRemoteAdapter; } });
+var firestore_js_1 = require("../adapters/remote/firestore.js");
+Object.defineProperty(exports, "FirestoreRemoteAdapter", { enumerable: true, get: function () { return firestore_js_1.FirestoreRemoteAdapter; } });
+var demo_js_1 = require("../adapters/remote/demo.js");
+Object.defineProperty(exports, "MemoryDemoRemoteAdapter", { enumerable: true, get: function () { return demo_js_1.MemoryDemoRemoteAdapter; } });
+/**
+ * Type-safe configuration helper function (similar to defineConfig in Vite/Tailwind).
+ */
+function defineSyncConfig(config) {
+    return config;
+}
+/**
+ * Factory that instantiates, wires up, and initializes a LocalFirstClient from a LocalLiteConfig.
+ */
+async function createSyncClient(config) {
+    // 1. Resolve Local Database Adapter
+    const localAdapter = await (0, resolve_local_js_1.resolveLocalAdapter)(config);
+    // 2. Resolve Remote Cloud Adapter
+    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;
+    // 4. Instantiate Local-First Client
+    const client = new client_js_1.LocalFirstClient({
+        local: localAdapter,
+        remote: remoteAdapter,
+        network,
+        primaryKey: config.primaryKey ?? 'id',
+        conflictResolver: config.conflictResolver ?? 'last-write-wins',
+        pushIntervalMs: config.pushIntervalMs ?? 5000,
+        pullIntervalMs: config.pullIntervalMs ?? 10000,
+        maxRetries: config.maxRetries ?? 5,
+        retry: config.retry,
+        logger: config.logger,
+        logLevel: config.logLevel,
+        autoSchema,
+        tables: config.tables ?? [],
+    });
+    // 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;
+}

package/dist/config/resolve-local.d.ts

@@ -0,0 +1,7 @@
+import { LocalDBAdapter } from '../adapters/local/index.js';
+import { LocalLiteConfig } from './types.js';
+/**
+ * Resolves or instantiates the appropriate LocalDBAdapter based on the provided configuration.
+ * Auto-detects Expo SQLite, OP-SQLite, better-sqlite3, LibSQL, sql.js, and Node.js built-in sqlite.
+ */
+export declare function resolveLocalAdapter(config: LocalLiteConfig): Promise<LocalDBAdapter>;

package/dist/config/resolve-local.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocalAdapter = resolveLocalAdapter;
+const expo_sqlite_js_1 = require("../adapters/local/expo-sqlite.js");
+const op_sqlite_js_1 = require("../adapters/local/op-sqlite.js");
+const better_sqlite3_js_1 = require("../adapters/local/better-sqlite3.js");
+const libsql_js_1 = require("../adapters/local/libsql.js");
+const sql_js_js_1 = require("../adapters/local/sql-js.js");
+const node_sqlite_js_1 = require("../adapters/local/node-sqlite.js");
+/**
+ * Resolves or instantiates the appropriate LocalDBAdapter based on the provided configuration.
+ * Auto-detects Expo SQLite, OP-SQLite, better-sqlite3, LibSQL, sql.js, and Node.js built-in sqlite.
+ */
+async function resolveLocalAdapter(config) {
+    let rawDb = config.database;
+    if (typeof rawDb === 'function') {
+        rawDb = await rawDb();
+    }
+    // 1. @libsql/client (Turso / LibSQL) instance
+    if (rawDb && typeof rawDb.batch === 'function' && typeof rawDb.execute === 'function') {
+        return new libsql_js_1.LibSQLAdapter(rawDb);
+    }
+    // 2. sql.js Database instance
+    if (rawDb && typeof rawDb.export === 'function' && typeof rawDb.exec === 'function') {
+        return new sql_js_js_1.SqlJsAdapter(rawDb);
+    }
+    // 3. Custom object already implementing LocalDBAdapter
+    if (rawDb && typeof rawDb.execute === 'function' && typeof rawDb.transaction === 'function') {
+        return rawDb;
+    }
+    // 4. Expo SQLite database instance (openDatabaseAsync)
+    if (rawDb && typeof rawDb.getAllAsync === 'function') {
+        return new expo_sqlite_js_1.ExpoSQLiteAdapter(rawDb);
+    }
+    // 5. @op-engineering/op-sqlite or react-native-quick-sqlite instance
+    if (rawDb && typeof rawDb.executeAsync === 'function') {
+        return new op_sqlite_js_1.OpSQLiteAdapter(rawDb);
+    }
+    // 6. better-sqlite3 database instance
+    if (rawDb && typeof rawDb.prepare === 'function' && typeof rawDb.pragma === 'function') {
+        return new better_sqlite3_js_1.BetterSQLite3Adapter(rawDb);
+    }
+    // 7. Node.js 22+ built-in node:sqlite (DatabaseSync) instance
+    if (rawDb && typeof rawDb.prepare === 'function' && typeof rawDb.exec === 'function') {
+        return new node_sqlite_js_1.NodeSQLiteAdapter(rawDb);
+    }
+    // 8. Fallback for prepare-based SQLite instances
+    if (rawDb && typeof rawDb.prepare === 'function') {
+        return new better_sqlite3_js_1.BetterSQLite3Adapter(rawDb);
+    }
+    // 9. Auto-open by name using expo-sqlite if available
+    if (typeof rawDb === 'string' || config.databaseName) {
+        const dbName = typeof rawDb === 'string' ? rawDb : (config.databaseName ?? 'local_lite.db');
+        try {
+            const expoSqlite = await import('expo-sqlite');
+            if (expoSqlite && typeof expoSqlite.openDatabaseAsync === 'function') {
+                const expoDb = await expoSqlite.openDatabaseAsync(dbName);
+                return new expo_sqlite_js_1.ExpoSQLiteAdapter(expoDb);
+            }
+            throw new Error('expo-sqlite openDatabaseAsync not found');
+        }
+        catch (err) {
+            throw new Error(`Failed to auto-open SQLite database "${dbName}". ` +
+                `Please pass the database instance to config.database: ${err}`);
+        }
+    }
+    throw new Error('No database provided in sync config. Please specify config.database or config.databaseName.');
+}

package/dist/config/resolve-remote.d.ts

@@ -0,0 +1,7 @@
+import { RemoteDBAdapter } from '../adapters/remote/index.js';
+import { LocalLiteConfig } from './types.js';
+/**
+ * Resolves or instantiates the appropriate RemoteDBAdapter based on the provided configuration.
+ * Supports Supabase, Convex, Firebase / Firestore, in-memory demo adapter, or custom adapters.
+ */
+export declare function resolveRemoteAdapter(config: LocalLiteConfig): Promise<RemoteDBAdapter>;

package/dist/config/resolve-remote.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRemoteAdapter = resolveRemoteAdapter;
+const supabase_js_1 = require("../adapters/remote/supabase.js");
+const convex_js_1 = require("../adapters/remote/convex.js");
+const firestore_js_1 = require("../adapters/remote/firestore.js");
+const demo_js_1 = require("../adapters/remote/demo.js");
+/**
+ * Resolves or instantiates the appropriate RemoteDBAdapter based on the provided configuration.
+ * Supports Supabase, Convex, Firebase / Firestore, in-memory demo adapter, or custom adapters.
+ */
+async function resolveRemoteAdapter(config) {
+    // 1. Explicit custom remote adapter
+    if (config.remote) {
+        return config.remote;
+    }
+    // 2. Firebase / Cloud Firestore
+    if (config.firebase?.firestore) {
+        return new firestore_js_1.FirestoreRemoteAdapter(config.firebase.firestore, {
+            tables: config.tables,
+            primaryKey: config.firebase.primaryKey ?? config.primaryKey,
+            deletedColumn: config.firebase.deletedColumn,
+            updatedAtColumn: config.firebase.updatedAtColumn,
+            firestoreModule: config.firebase.firestoreModule,
+        });
+    }
+    // 3. Convex
+    if (config.convex?.client) {
+        return new convex_js_1.ConvexRemoteAdapter(config.convex.client, {
+            tables: config.tables,
+            primaryKey: config.convex.primaryKey ?? config.primaryKey,
+            pushMutation: config.convex.pushMutation,
+            pullQuery: config.convex.pullQuery,
+            deletedColumn: config.convex.deletedColumn,
+            updatedAtColumn: config.convex.updatedAtColumn,
+        });
+    }
+    // 4. Supabase with pre-configured client
+    if (config.supabase?.client) {
+        return new supabase_js_1.SupabaseRemoteAdapter(config.supabase.client, {
+            tables: config.tables,
+            primaryKey: config.primaryKey,
+            schema: config.supabase.schema,
+            updatedAtColumn: config.supabase.updatedAtColumn,
+            deletedColumn: config.supabase.deletedColumn,
+            deletedValue: config.supabase.deletedValue,
+            deletedAtColumn: config.supabase.deletedAtColumn,
+            pushRpcName: config.supabase.pushRpcName,
+            channelName: config.supabase.channelName,
+        });
+    }
+    // 5. Supabase with URL + anonKey (lazy dynamic import)
+    if (config.supabase?.url && config.supabase?.anonKey) {
+        let supabaseModule;
+        try {
+            // @ts-ignore
+            supabaseModule = await import('@supabase/supabase-js');
+        }
+        catch {
+            throw new Error('To initialize Supabase from url and anonKey, please install @supabase/supabase-js or provide a pre-configured client to config.supabase.client');
+        }
+        const createClientFn = supabaseModule.createClient || supabaseModule.default?.createClient;
+        const supabaseClient = createClientFn(config.supabase.url, config.supabase.anonKey);
+        return new supabase_js_1.SupabaseRemoteAdapter(supabaseClient, {
+            tables: config.tables,
+            primaryKey: config.primaryKey,
+            schema: config.supabase.schema,
+            updatedAtColumn: config.supabase.updatedAtColumn,
+            deletedColumn: config.supabase.deletedColumn,
+            deletedValue: config.supabase.deletedValue,
+            deletedAtColumn: config.supabase.deletedAtColumn,
+            pushRpcName: config.supabase.pushRpcName,
+            channelName: config.supabase.channelName,
+        });
+    }
+    // 6. In-Memory Simulated Remote (Default when no cloud credentials provided)
+    if (config.inMemoryRemote !== false) {
+        return new demo_js_1.MemoryDemoRemoteAdapter(300);
+    }
+    throw new Error('No remote adapter configured. Please specify config.supabase, config.convex, config.firebase, or config.remote.');
+}