local-lite 0.0.0-stage → 0.0.1

package/dist/config/types.d.ts

@@ -0,0 +1,159 @@
+import { LocalDBAdapter } from '../adapters/local/index.js';
+import { RemoteDBAdapter } from '../adapters/remote/index.js';
+import { ConflictResolver, ConflictStrategy, NetworkStatusProvider, RetryConfig } from '../core/types.js';
+import { SyncLogger, CustomLogger, LogLevel } from '../utils/logger.js';
+export interface SupabaseConfigOptions {
+    url?: string;
+    anonKey?: string;
+    client?: any;
+    schema?: string;
+    updatedAtColumn?: string;
+    deletedColumn?: string;
+    deletedValue?: any;
+    deletedAtColumn?: string;
+    pushRpcName?: string;
+    channelName?: string;
+}
+export interface ConvexConfigOptions {
+    /**
+     * ConvexClient instance.
+     */
+    client: any;
+    /**
+     * Primary key field name. Default: config.primaryKey or 'id'
+     */
+    primaryKey?: string;
+    /**
+     * Convex mutation function or name for pushing changes.
+     * Default: 'sync:pushBatch'
+     */
+    pushMutation?: any;
+    /**
+     * Convex query function or name for pulling changes.
+     * Default: 'sync:pullDeltas'
+     */
+    pullQuery?: any;
+    /**
+     * Column used for soft deletes. Default: 'deleted'
+     */
+    deletedColumn?: string;
+    /**
+     * Column used for updatedAt timestamp. Default: 'updatedAt'
+     */
+    updatedAtColumn?: string;
+}
+export interface FirebaseConfigOptions {
+    /**
+     * Firestore database instance (from modular firebase/firestore, @react-native-firebase/firestore, or compat SDK).
+     */
+    firestore: any;
+    /**
+     * Primary key field name. Default: config.primaryKey or 'id'
+     */
+    primaryKey?: string;
+    /**
+     * Field used for soft deletes. Default: 'deleted'
+     */
+    deletedColumn?: string;
+    /**
+     * Field used for updatedAt timestamp tracking. Default: 'updatedAt'
+     */
+    updatedAtColumn?: string;
+    /**
+     * Optional reference to modular firebase/firestore module if not globally available.
+     */
+    firestoreModule?: any;
+}
+export interface LocalLiteConfig {
+    /**
+     * Local SQLite Database instance, name, factory function, or LocalDBAdapter.
+     * - Pass an Expo database instance (e.g. from SQLite.openDatabaseAsync('app.db'))
+     * - Pass a factory: () => SQLite.openDatabaseAsync('app.db')
+     * - Pass a database file name: 'app.db'
+     * - Or a custom LocalDBAdapter
+     */
+    database?: any | string | (() => Promise<any> | any) | LocalDBAdapter;
+    /**
+     * Database name if database is not provided. Default: 'local_lite.db'
+     */
+    databaseName?: string;
+    /**
+     * List of tables to sync.
+     * e.g. ['todos', 'notes']
+     */
+    tables?: string[];
+    /**
+     * Initial SQL table schema migration queries to execute on startup.
+     * e.g. ["CREATE TABLE IF NOT EXISTS todos (id TEXT PRIMARY KEY, title TEXT);"]
+     */
+    migrations?: string[];
+    /**
+     * Automatically create tables and columns dynamically on the fly without manual SQL migrations.
+     * When true (default if migrations is not provided), tables in `tables` are created automatically,
+     * and any missing columns are added dynamically on insert/update/pull.
+     */
+    autoSchema?: boolean;
+    /**
+     * Primary key column. Default: 'id'
+     */
+    primaryKey?: string;
+    /**
+     * Supabase backend connection options.
+     */
+    supabase?: SupabaseConfigOptions;
+    /**
+     * Convex backend connection options.
+     */
+    convex?: ConvexConfigOptions;
+    /**
+     * Firebase / Firestore backend connection options.
+     */
+    firebase?: FirebaseConfigOptions;
+    /**
+     * Custom remote adapter (overrides Supabase / Convex / Firebase).
+     */
+    remote?: RemoteDBAdapter;
+    /**
+     * Whether to use an in-memory simulated remote backend if Supabase, Convex, or Firebase credentials are not provided.
+     * Allows running and testing full local-first sync workflows without cloud infrastructure.
+     * Default: true
+     */
+    inMemoryRemote?: boolean;
+    /**
+     * Conflict resolution strategy. Default: 'last-write-wins'
+     */
+    conflictResolver?: ConflictStrategy | ConflictResolver;
+    /**
+     * Periodic outbox push interval in ms. Default: 5000
+     */
+    pushIntervalMs?: number;
+    /**
+     * Periodic remote pull interval in ms. Default: 10000
+     */
+    pullIntervalMs?: number;
+    /**
+     * Maximum retry attempts for failed push items. Default: 5
+     */
+    maxRetries?: number;
+    /**
+     * Advanced retry configuration with exponential backoff and custom retry predicates.
+     */
+    retry?: number | RetryConfig;
+    /**
+     * Custom logger or false to silence logs in production.
+     */
+    logger?: SyncLogger | CustomLogger | boolean;
+    /**
+     * Minimum log level. Default: 'info'
+     */
+    logLevel?: LogLevel;
+    /**
+     * Network status provider. Default: DefaultNetworkStatusProvider
+     */
+    network?: NetworkStatusProvider;
+    /**
+     * Automatically call client.initialize() and create tables.
+     * Default: true
+     */
+    autoInitialize?: boolean;
+}

package/dist/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/client.d.ts

@@ -0,0 +1,100 @@
+import { LocalDBAdapter } from '../adapters/local/index.js';
+import { RemoteDBAdapter } from '../adapters/remote/index.js';
+import { EventEmitter } from '../reactive/event-emitter.js';
+import { SyncWorker } from './sync-worker.js';
+import { SchemaManager } from './schema-manager.js';
+import { ConflictResolver, ConflictStrategy, MutateOptions, NetworkStatusProvider, QueryOptions, RetryConfig, SyncOp } from './types.js';
+import { SyncLogger, CustomLogger, LogLevel } from '../utils/logger.js';
+export interface LocalFirstClientConfig {
+    local: LocalDBAdapter;
+    remote: RemoteDBAdapter;
+    network?: NetworkStatusProvider;
+    conflictResolver?: ConflictStrategy | ConflictResolver;
+    primaryKey?: string;
+    pushIntervalMs?: number;
+    pullIntervalMs?: number;
+    maxRetries?: number;
+    retry?: number | RetryConfig;
+    logger?: SyncLogger | CustomLogger | boolean;
+    logLevel?: LogLevel;
+    autoSchema?: boolean;
+    tables?: string[];
+}
+export declare class LocalFirstClient {
+    db: LocalDBAdapter;
+    remote: RemoteDBAdapter;
+    events: EventEmitter;
+    syncWorker: SyncWorker;
+    schemaManager: SchemaManager;
+    autoSchema: boolean;
+    tables: string[];
+    private primaryKey;
+    constructor(config: LocalFirstClientConfig);
+    /**
+     * Initializes the client: creates sync_outbox schema, ensures autoSchema tables if enabled,
+     * and starts the background sync worker.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Performs an atomic dual-write: mutates the local data table AND writes
+     * to sync_outbox within the same database transaction.
+     */
+    mutate(tableName: string, rowId: string, operation: SyncOp, payload: Record<string, any> | null, options?: MutateOptions): Promise<void>;
+    /**
+     * Convenience helper to insert a record into a table.
+     * Auto-generates a UUID if rowId is omitted or passed inside payload.
+     *
+     * Example:
+     * await client.insert('todos', { title: 'Buy milk' });
+     * await client.insert('todos', 'custom-id', { title: 'Buy milk' });
+     */
+    insert(tableName: string, rowIdOrPayload: string | Record<string, any>, payloadOrOptions?: Record<string, any> | MutateOptions, options?: MutateOptions): Promise<string>;
+    /**
+     * Convenience helper to update an existing record by ID.
+     *
+     * Example:
+     * await client.update('todos', 'todo-1', { completed: 1 });
+     */
+    update(tableName: string, rowId: string, payload: Record<string, any>, options?: MutateOptions): Promise<void>;
+    /**
+     * Convenience helper to delete a record by ID.
+     *
+     * Example:
+     * await client.delete('todos', 'todo-1');
+     */
+    delete(tableName: string, rowId: string, options?: MutateOptions): Promise<void>;
+    /**
+     * Reads records from a local SQLite table without requiring manual SQL.
+     * Supports where filtering, order, limit, and offset.
+     * Gracefully returns [] if table or columns have not been populated yet on empty schemas.
+     *
+     * Example:
+     * const tenants = await client.findMany('tenants', { where: { status: 'ACTIVE' }, orderBy: 'name' });
+     */
+    findMany<T = any>(tableName: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Finds a single record by primary key.
+     *
+     * Example:
+     * const tenant = await client.findById('tenants', 'ten-1');
+     */
+    findById<T = any>(tableName: string, id: string): Promise<T | null>;
+    /**
+     * Tracks an existing mutation into sync_outbox without modifying the table.
+     * Can accept an external transaction `options.tx` for custom atomic SQL workflows.
+     */
+    trackMutation(tableName: string, rowId: string, operation: SyncOp, payload: Record<string, any> | null, options?: MutateOptions): Promise<string>;
+    /**
+     * Retrieves the persisted last_synced_at timestamp cursor (in ms).
+     */
+    getLastSyncedAt(): Promise<number>;
+    /**
+     * Resets the persistent sync cursor back to 0, forcing the next pull
+     * to query all remote records.
+     */
+    resetSyncCursor(): Promise<void>;
+    /**
+     * Stops all active intervals, background sync loops, and network listeners.
+     */
+    stop(): void;
+}

package/dist/core/client.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFirstClient = void 0;
+const event_emitter_js_1 = require("../reactive/event-emitter.js");
+const sync_worker_js_1 = require("./sync-worker.js");
+const table_manager_js_1 = require("./table-manager.js");
+const outbox_store_js_1 = require("./outbox-store.js");
+const meta_store_js_1 = require("./meta-store.js");
+const schema_manager_js_1 = require("./schema-manager.js");
+const uuid_js_1 = require("../utils/uuid.js");
+const sql_js_1 = require("../utils/sql.js");
+class LocalFirstClient {
+    db;
+    remote;
+    events;
+    syncWorker;
+    schemaManager;
+    autoSchema;
+    tables;
+    primaryKey;
+    constructor(config) {
+        this.db = config.local;
+        this.remote = config.remote;
+        this.events = new event_emitter_js_1.EventEmitter();
+        this.primaryKey = config.primaryKey ?? 'id';
+        this.autoSchema = config.autoSchema ?? false;
+        this.tables = config.tables ?? [];
+        this.schemaManager = new schema_manager_js_1.SchemaManager();
+        const workerOptions = {
+            network: config.network,
+            conflictResolver: config.conflictResolver,
+            primaryKey: this.primaryKey,
+            pushIntervalMs: config.pushIntervalMs,
+            pullIntervalMs: config.pullIntervalMs,
+            maxRetries: config.maxRetries,
+            retry: config.retry,
+            logger: config.logger,
+            logLevel: config.logLevel,
+            autoSchema: this.autoSchema,
+            schemaManager: this.schemaManager,
+        };
+        this.syncWorker = new sync_worker_js_1.SyncWorker(this.db, this.remote, this.events, workerOptions);
+    }
+    /**
+     * Initializes the client: creates sync_outbox schema, ensures autoSchema tables if enabled,
+     * and starts the background sync worker.
+     */
+    async initialize() {
+        await outbox_store_js_1.OutboxStore.ensureSchema(this.db);
+        await meta_store_js_1.MetaStore.ensureSchema(this.db);
+        await outbox_store_js_1.OutboxStore.resetStaleProcessing(this.db);
+        if (this.autoSchema && this.tables.length > 0) {
+            for (const table of this.tables) {
+                await this.schemaManager.ensureTable(this.db, table, this.primaryKey);
+            }
+        }
+        this.syncWorker.start();
+    }
+    /**
+     * Performs an atomic dual-write: mutates the local data table AND writes
+     * to sync_outbox within the same database transaction.
+     */
+    async mutate(tableName, rowId, operation, payload, options = {}) {
+        const pk = options.primaryKey ?? this.primaryKey;
+        const outboxId = (0, uuid_js_1.generateUUID)();
+        const timestamp = options.customTimestamp ?? Date.now();
+        const executeInTransaction = async (tx) => {
+            // 1. Mutate local table
+            await table_manager_js_1.TableManager.applyMutation(tx, tableName, rowId, operation, payload, pk, {
+                autoSchema: this.autoSchema,
+                schemaManager: this.schemaManager,
+            });
+            // 2. Insert into sync_outbox (if not skipped)
+            if (!options.skipOutbox) {
+                await outbox_store_js_1.OutboxStore.insertRecord(tx, {
+                    id: outboxId,
+                    tableName,
+                    rowId,
+                    operation,
+                    payload,
+                    timestamp,
+                });
+            }
+        };
+        if (options.tx) {
+            await executeInTransaction(options.tx);
+        }
+        else {
+            await this.db.transaction(executeInTransaction);
+        }
+        // 3. Emit reactive change events
+        this.events.emit(tableName, {
+            operation,
+            rowId,
+            payload,
+            source: 'local',
+        });
+        if (!options.skipOutbox) {
+            this.events.emit('sync_outbox', { operation: 'INSERT', rowId: outboxId });
+            // 4. Trigger immediate debounced push
+            this.syncWorker.schedulePush(20);
+        }
+    }
+    /**
+     * Convenience helper to insert a record into a table.
+     * Auto-generates a UUID if rowId is omitted or passed inside payload.
+     *
+     * Example:
+     * await client.insert('todos', { title: 'Buy milk' });
+     * await client.insert('todos', 'custom-id', { title: 'Buy milk' });
+     */
+    async insert(tableName, rowIdOrPayload, payloadOrOptions, options) {
+        let rowId;
+        let payload;
+        let opts = {};
+        if (typeof rowIdOrPayload === 'string') {
+            rowId = rowIdOrPayload;
+            payload = payloadOrOptions || {};
+            opts = options || {};
+        }
+        else {
+            payload = rowIdOrPayload || {};
+            rowId = payload[this.primaryKey] || (0, uuid_js_1.generateUUID)();
+            opts = payloadOrOptions || {};
+        }
+        await this.mutate(tableName, rowId, 'INSERT', payload, opts);
+        return rowId;
+    }
+    /**
+     * Convenience helper to update an existing record by ID.
+     *
+     * Example:
+     * await client.update('todos', 'todo-1', { completed: 1 });
+     */
+    async update(tableName, rowId, payload, options = {}) {
+        await this.mutate(tableName, rowId, 'UPDATE', payload, options);
+    }
+    /**
+     * Convenience helper to delete a record by ID.
+     *
+     * Example:
+     * await client.delete('todos', 'todo-1');
+     */
+    async delete(tableName, rowId, options = {}) {
+        await this.mutate(tableName, rowId, 'DELETE', null, options);
+    }
+    /**
+     * Reads records from a local SQLite table without requiring manual SQL.
+     * Supports where filtering, order, limit, and offset.
+     * Gracefully returns [] if table or columns have not been populated yet on empty schemas.
+     *
+     * Example:
+     * const tenants = await client.findMany('tenants', { where: { status: 'ACTIVE' }, orderBy: 'name' });
+     */
+    async findMany(tableName, options) {
+        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+        let rows;
+        try {
+            rows = await this.db.execute(`SELECT * FROM ${safeTable}`);
+        }
+        catch (err) {
+            const msg = String(err?.message || err || '');
+            if (msg.includes('no such table') || msg.includes('no such column')) {
+                return [];
+            }
+            throw err;
+        }
+        if (!rows || rows.length === 0)
+            return [];
+        let result = [...rows];
+        // 1. Where filtering
+        if (options?.where) {
+            const filterKeys = Object.keys(options.where);
+            result = result.filter((row) => filterKeys.every((k) => row[k] === options.where[k]));
+        }
+        // 2. Order by
+        if (options?.orderBy) {
+            const key = options.orderBy;
+            const isAsc = (options.order || 'asc').toLowerCase() === 'asc';
+            result.sort((a, b) => {
+                const valA = a[key];
+                const valB = b[key];
+                if (valA === valB)
+                    return 0;
+                if (valA === null || valA === undefined)
+                    return isAsc ? 1 : -1;
+                if (valB === null || valB === undefined)
+                    return isAsc ? -1 : 1;
+                if (typeof valA === 'string' && typeof valB === 'string') {
+                    return isAsc ? valA.localeCompare(valB) : valB.localeCompare(valA);
+                }
+                if (typeof valA === 'number' && typeof valB === 'number') {
+                    return isAsc ? valA - valB : valB - valA;
+                }
+                return isAsc ? (valA > valB ? 1 : -1) : (valA < valB ? 1 : -1);
+            });
+        }
+        // 3. Offset and Limit
+        if (options?.offset !== undefined && options.offset > 0) {
+            result = result.slice(options.offset);
+        }
+        if (options?.limit !== undefined && options.limit > 0) {
+            result = result.slice(0, options.limit);
+        }
+        return result;
+    }
+    /**
+     * Finds a single record by primary key.
+     *
+     * Example:
+     * const tenant = await client.findById('tenants', 'ten-1');
+     */
+    async findById(tableName, id) {
+        const results = await this.findMany(tableName, {
+            where: { [this.primaryKey]: id },
+            limit: 1,
+        });
+        return results.length > 0 ? results[0] : null;
+    }
+    /**
+     * Tracks an existing mutation into sync_outbox without modifying the table.
+     * Can accept an external transaction `options.tx` for custom atomic SQL workflows.
+     */
+    async trackMutation(tableName, rowId, operation, payload, options = {}) {
+        const outboxId = (0, uuid_js_1.generateUUID)();
+        const timestamp = options.customTimestamp ?? Date.now();
+        const executeInsert = async (tx) => {
+            await outbox_store_js_1.OutboxStore.insertRecord(tx, {
+                id: outboxId,
+                tableName,
+                rowId,
+                operation,
+                payload,
+                timestamp,
+            });
+        };
+        if (options.tx) {
+            await executeInsert(options.tx);
+        }
+        else {
+            await this.db.transaction(executeInsert);
+        }
+        this.events.emit(tableName, {
+            operation,
+            rowId,
+            payload,
+            source: 'local',
+        });
+        this.events.emit('sync_outbox', { operation: 'INSERT', rowId: outboxId });
+        this.syncWorker.schedulePush(20);
+        return outboxId;
+    }
+    /**
+     * Retrieves the persisted last_synced_at timestamp cursor (in ms).
+     */
+    async getLastSyncedAt() {
+        return await this.syncWorker.getLastPulledTimestamp();
+    }
+    /**
+     * Resets the persistent sync cursor back to 0, forcing the next pull
+     * to query all remote records.
+     */
+    async resetSyncCursor() {
+        await this.syncWorker.resetSyncCursor();
+    }
+    /**
+     * Stops all active intervals, background sync loops, and network listeners.
+     */
+    stop() {
+        this.syncWorker.stop();
+    }
+}
+exports.LocalFirstClient = LocalFirstClient;

package/dist/core/conflict.d.ts

@@ -0,0 +1,5 @@
+import { ConflictResolver, ConflictStrategy } from './types.js';
+export declare const lastWriteWinsResolver: ConflictResolver;
+export declare const serverWinsResolver: ConflictResolver;
+export declare const clientWinsResolver: ConflictResolver;
+export declare function getConflictResolver(strategyOrResolver?: ConflictStrategy | ConflictResolver): ConflictResolver;

package/dist/core/conflict.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientWinsResolver = exports.serverWinsResolver = exports.lastWriteWinsResolver = void 0;
+exports.getConflictResolver = getConflictResolver;
+const lastWriteWinsResolver = (context) => {
+    const remoteTime = context.remoteChange.timestamp ?? 0;
+    const localTime = context.localOutboxRecord?.timestamp ?? 0;
+    if (remoteTime >= localTime) {
+        return 'apply-remote';
+    }
+    return 'keep-local';
+};
+exports.lastWriteWinsResolver = lastWriteWinsResolver;
+const serverWinsResolver = () => {
+    return 'apply-remote';
+};
+exports.serverWinsResolver = serverWinsResolver;
+const clientWinsResolver = (context) => {
+    if (context.localOutboxRecord) {
+        return 'keep-local';
+    }
+    return 'apply-remote';
+};
+exports.clientWinsResolver = clientWinsResolver;
+function getConflictResolver(strategyOrResolver) {
+    if (typeof strategyOrResolver === 'function') {
+        return strategyOrResolver;
+    }
+    switch (strategyOrResolver) {
+        case 'server-wins':
+            return exports.serverWinsResolver;
+        case 'client-wins':
+            return exports.clientWinsResolver;
+        case 'last-write-wins':
+        default:
+            return exports.lastWriteWinsResolver;
+    }
+}

package/dist/core/meta-store.d.ts

@@ -0,0 +1,28 @@
+import { LocalDBAdapter, LocalTransaction } from '../adapters/local/index.js';
+export declare class MetaStore {
+    /**
+     * Initializes the sync_meta schema if it does not already exist.
+     * This table is strictly local to the device and is never synced to the remote server.
+     */
+    static ensureSchema(db: LocalDBAdapter): Promise<void>;
+    /**
+     * Gets a metadata string value by key.
+     */
+    static get(db: LocalDBAdapter, key: string): Promise<string | null>;
+    /**
+     * Sets a metadata value by key (atomic upsert).
+     */
+    static set(db: LocalDBAdapter | LocalTransaction, key: string, value: string): Promise<void>;
+    /**
+     * Retrieves the persisted last_synced_at cursor timestamp (in ms). Returns 0 if never synced.
+     */
+    static getLastSyncedAt(db: LocalDBAdapter): Promise<number>;
+    /**
+     * Persists the last_synced_at cursor timestamp.
+     */
+    static setLastSyncedAt(db: LocalDBAdapter | LocalTransaction, timestamp: number): Promise<void>;
+    /**
+     * Clears the persisted cursor (forces next pull to re-query active remote records).
+     */
+    static clearLastSyncedAt(db: LocalDBAdapter | LocalTransaction): Promise<void>;
+}

package/dist/core/meta-store.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaStore = void 0;
+class MetaStore {
+    /**
+     * Initializes the sync_meta schema if it does not already exist.
+     * This table is strictly local to the device and is never synced to the remote server.
+     */
+    static async ensureSchema(db) {
+        await db.execute(`CREATE TABLE IF NOT EXISTS sync_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );`);
+    }
+    /**
+     * Gets a metadata string value by key.
+     */
+    static async get(db, key) {
+        try {
+            const rows = await db.execute(`SELECT value FROM sync_meta WHERE key = ? LIMIT 1`, [key]);
+            if (rows && rows.length > 0) {
+                return rows[0].value ?? null;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Sets a metadata value by key (atomic upsert).
+     */
+    static async set(db, key, value) {
+        await db.execute(`INSERT OR REPLACE INTO sync_meta (key, value) VALUES (?, ?)`, [key, String(value)]);
+    }
+    /**
+     * Retrieves the persisted last_synced_at cursor timestamp (in ms). Returns 0 if never synced.
+     */
+    static async getLastSyncedAt(db) {
+        const val = await this.get(db, 'last_synced_at');
+        if (!val)
+            return 0;
+        const parsed = parseInt(val, 10);
+        return isNaN(parsed) ? 0 : parsed;
+    }
+    /**
+     * Persists the last_synced_at cursor timestamp.
+     */
+    static async setLastSyncedAt(db, timestamp) {
+        await this.set(db, 'last_synced_at', String(timestamp));
+    }
+    /**
+     * Clears the persisted cursor (forces next pull to re-query active remote records).
+     */
+    static async clearLastSyncedAt(db) {
+        try {
+            await db.execute(`DELETE FROM sync_meta WHERE key = 'last_synced_at'`);
+        }
+        catch {
+            // Ignored if table doesn't exist yet
+        }
+    }
+}
+exports.MetaStore = MetaStore;