@anfenn/dync 1.0.0

package/src/react/useDync.ts

@@ -0,0 +1,156 @@
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from 'react';
+import { Dync } from '../index';
+import type { ApiFunctions, BatchSync, MutationEvent, SyncOptions, SyncState } from '../types';
+import type { StorageAdapter } from '../storage/types';
+
+export interface MakeDyncConfigPerTable {
+    databaseName: string;
+    syncApis: Record<string, ApiFunctions>;
+    storageAdapter: StorageAdapter;
+    options?: SyncOptions;
+}
+
+export interface MakeDyncConfigBatch {
+    databaseName: string;
+    batchSync: BatchSync;
+    storageAdapter: StorageAdapter;
+    options?: SyncOptions;
+}
+
+export type MakeDyncConfig = MakeDyncConfigPerTable | MakeDyncConfigBatch;
+
+export interface UseDyncValue<TStoreMap extends Record<string, any>> {
+    db: Dync<TStoreMap>;
+    syncState: SyncState;
+}
+
+/**
+ * A hook returned by makeDync that observes database queries and automatically
+ * re-runs them when data changes. The db instance is passed to the querier callback.
+ *
+ * @param querier - Function that receives db and returns query result
+ * @param deps - Optional React dependency list for re-running the query
+ * @param tables - Optional array of table names to watch for mutations, otherwise it's all tables
+ * @returns The query result, or undefined if not yet available
+ */
+export type BoundUseLiveQuery<TStoreMap extends Record<string, any>> = <T>(
+    querier: (db: Dync<TStoreMap>) => Promise<T> | T,
+    deps?: React.DependencyList,
+    tables?: string[],
+) => T | undefined;
+
+export interface MakeDyncResult<TStoreMap extends Record<string, any>> {
+    // The Dync database instance
+    db: Dync<TStoreMap>;
+    // Hook to get db and syncState in components
+    useDync: () => UseDyncValue<TStoreMap>;
+    // Hook for live queries - db is passed to the querier callback
+    useLiveQuery: BoundUseLiveQuery<TStoreMap>;
+}
+
+export function makeDync<TStoreMap extends Record<string, any> = Record<string, unknown>>(config: MakeDyncConfig): MakeDyncResult<TStoreMap> {
+    // Determine which mode based on config shape
+    const db =
+        'syncApis' in config
+            ? new Dync<TStoreMap>(config.databaseName, config.syncApis, config.storageAdapter, config.options)
+            : new Dync<TStoreMap>(config.databaseName, config.batchSync, config.storageAdapter, config.options);
+
+    // Cache to provide referential stability (React requires stable references)
+    // Updated when subscription fires OR when getSnapshot detects value changes
+    let cachedState = db.sync.getState();
+
+    const subscribe = (listener: () => void) =>
+        db.sync.onStateChange((nextState) => {
+            // Update cache immediately when notified, before React calls getSnapshot
+            cachedState = nextState;
+            listener();
+        });
+
+    // getSnapshot returns cached state, but also checks for changes that happened
+    // before subscription was active (e.g., hydration during initial mount)
+    const getSnapshot = () => {
+        const fresh = db.sync.getState();
+        if (JSON.stringify(fresh) !== JSON.stringify(cachedState)) {
+            cachedState = fresh;
+        }
+        return cachedState;
+    };
+
+    const useDync = () => {
+        const syncState = useSyncExternalStore<SyncState>(subscribe, getSnapshot, getSnapshot);
+        return { db, syncState } as UseDyncValue<TStoreMap>;
+    };
+
+    // Create a bound useLiveQuery that passes db to the querier
+    const boundUseLiveQuery: BoundUseLiveQuery<TStoreMap> = <T>(
+        querier: (db: Dync<TStoreMap>) => Promise<T> | T,
+        deps: React.DependencyList = [],
+        tables?: string[],
+    ): T | undefined => {
+        return useLiveQueryImpl(db, querier, deps, tables);
+    };
+
+    return {
+        db,
+        useDync,
+        useLiveQuery: boundUseLiveQuery,
+    };
+}
+
+function useLiveQueryImpl<TStoreMap extends Record<string, any>, T>(
+    db: Dync<TStoreMap>,
+    querier: (db: Dync<TStoreMap>) => Promise<T> | T,
+    deps: React.DependencyList = [],
+    tables?: string[],
+): T | undefined {
+    const [result, setResult] = useState<T | undefined>(undefined);
+    const [, setError] = useState<Error | null>(null);
+    const isMountedRef = useRef(true);
+    const queryVersionRef = useRef(0);
+    const querierRef = useRef(querier);
+    const tablesRef = useRef(tables);
+
+    // Keep refs up to date
+    querierRef.current = querier;
+    tablesRef.current = tables;
+
+    const runQuery = useCallback(async () => {
+        const currentVersion = ++queryVersionRef.current;
+        try {
+            const queryResult = await querierRef.current(db);
+            // Only update if still mounted and this is the latest query
+            if (isMountedRef.current && currentVersion === queryVersionRef.current) {
+                setResult(queryResult);
+                setError(null);
+            }
+        } catch (err) {
+            if (isMountedRef.current && currentVersion === queryVersionRef.current) {
+                setError(err as Error);
+            }
+        }
+    }, [db]);
+
+    // Re-run query when deps change
+    useEffect(() => {
+        runQuery();
+    }, [...deps, runQuery]);
+
+    useEffect(() => {
+        isMountedRef.current = true;
+
+        // Subscribe to mutation events
+        const unsubscribe = db.sync.onMutation((event: MutationEvent) => {
+            // Only re-run if no tables filter specified, or if the mutation affects a watched table
+            if (!tablesRef.current || tablesRef.current.includes(event.tableName)) {
+                runQuery();
+            }
+        });
+
+        return () => {
+            isMountedRef.current = false;
+            unsubscribe();
+        };
+    }, [db, runQuery]);
+
+    return result;
+}

package/src/storage/dexie/DexieAdapter.ts

@@ -0,0 +1,72 @@
+import Dexie from 'dexie';
+import type { StorageAdapter, StorageTable, StorageTransactionContext, TransactionMode } from '../types';
+import type { StorageSchemaDefinitionOptions } from '../sqlite/types';
+import type { TableSchemaDefinition } from '../sqlite/schema';
+import { DexieQueryContext } from './DexieQueryContext';
+import { DexieStorageTable } from './DexieStorageTable';
+
+export class DexieAdapter implements StorageAdapter {
+    readonly type = 'DexieAdapter';
+    readonly name: string;
+    readonly db: Dexie;
+    private readonly tableCache = new Map<string, StorageTable<any>>();
+
+    constructor(databaseName: string) {
+        this.db = new Dexie(databaseName);
+        this.name = this.db.name;
+    }
+
+    async open(): Promise<void> {
+        // Dexie auto-opens on first operation, so this is typically a no-op.
+        // However, after delete() we explicitly re-open to ensure continued usability.
+    }
+
+    async close(): Promise<void> {
+        if (this.db.isOpen()) {
+            this.db.close();
+        }
+        this.tableCache.clear();
+    }
+
+    async delete(): Promise<void> {
+        await this.db.delete();
+        this.tableCache.clear();
+        // Dexie.delete() closes the database, so re-open it to allow continued use.
+        // Without this, subsequent operations would fail with DatabaseClosedError.
+        await this.db.open();
+    }
+
+    async query<R>(callback: (ctx: DexieQueryContext) => Promise<R>): Promise<R> {
+        return callback(new DexieQueryContext(this));
+    }
+
+    defineSchema(version: number, schema: Record<string, TableSchemaDefinition>, _options?: StorageSchemaDefinitionOptions): void {
+        const normalized: Record<string, string> = {};
+        for (const [tableName, definition] of Object.entries(schema)) {
+            if (typeof definition !== 'string') {
+                throw new Error(`DexieAdapter requires string schema definitions. Received non-string definition for table '${tableName}'.`);
+            }
+            normalized[tableName] = definition;
+        }
+        const dexieVersion = this.db.version(version);
+        dexieVersion.stores(normalized);
+    }
+
+    table<T = any>(name: string): StorageTable<T> {
+        if (!this.tableCache.has(name)) {
+            const table = this.db.table<T>(name);
+            this.tableCache.set(name, new DexieStorageTable(table));
+        }
+        return this.tableCache.get(name)! as StorageTable<T>;
+    }
+
+    async transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T> {
+        return (this.db.transaction as any)(mode, ...tableNames, async () => {
+            const tables: Record<string, StorageTable<any>> = {};
+            for (const tableName of tableNames) {
+                tables[tableName] = this.table(tableName);
+            }
+            return callback({ tables });
+        });
+    }
+}

package/src/storage/dexie/DexieQueryContext.ts

@@ -0,0 +1,14 @@
+import type { StorageTable, StorageTransactionContext, TransactionMode } from '../types';
+import type { DexieAdapter } from './DexieAdapter';
+
+export class DexieQueryContext {
+    constructor(private readonly adapter: DexieAdapter) {}
+
+    table<T = any>(name: string): StorageTable<T> {
+        return this.adapter.table(name);
+    }
+
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T> {
+        return this.adapter.transaction(mode, tableNames, callback);
+    }
+}

package/src/storage/dexie/DexieStorageCollection.ts

@@ -0,0 +1,124 @@
+import type { Collection as DexieCollection } from 'dexie';
+import type { StorageCollection, StorageWhereClause } from '../types';
+import { normalizeIndexName } from './helpers';
+import { DexieStorageWhereClause } from './DexieStorageWhereClause';
+
+export class DexieStorageCollection<T = any> implements StorageCollection<T> {
+    private readonly collection: DexieCollection<T, any, T>;
+
+    constructor(collection: DexieCollection<T, any, T>) {
+        this.collection = collection;
+    }
+
+    first(): Promise<T | undefined> {
+        return this.collection.first();
+    }
+
+    async last(): Promise<T | undefined> {
+        return this.collection.last();
+    }
+
+    async each(callback: (item: T, index: number) => void | Promise<void>): Promise<void> {
+        const tasks: Array<void | Promise<void>> = [];
+        let index = 0;
+        await this.collection.each((item) => {
+            tasks.push(callback(item, index));
+            index += 1;
+        });
+        await Promise.all(tasks.map((task) => (task ? Promise.resolve(task) : Promise.resolve())));
+    }
+
+    async eachKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void> {
+        const tasks: Array<void | Promise<void>> = [];
+        let index = 0;
+        await this.collection.eachKey((key) => {
+            tasks.push(callback(key, index));
+            index += 1;
+        });
+        await Promise.all(tasks.map((task) => (task ? Promise.resolve(task) : Promise.resolve())));
+    }
+
+    async eachPrimaryKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void> {
+        const tasks: Array<void | Promise<void>> = [];
+        let index = 0;
+        await this.collection.eachPrimaryKey((key) => {
+            tasks.push(callback(key, index));
+            index += 1;
+        });
+        await Promise.all(tasks.map((task) => (task ? Promise.resolve(task) : Promise.resolve())));
+    }
+
+    async eachUniqueKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void> {
+        const tasks: Array<void | Promise<void>> = [];
+        let index = 0;
+        await this.collection.eachUniqueKey((key) => {
+            tasks.push(callback(key, index));
+            index += 1;
+        });
+        await Promise.all(tasks.map((task) => (task ? Promise.resolve(task) : Promise.resolve())));
+    }
+
+    keys(): Promise<unknown[]> {
+        return this.collection.keys();
+    }
+
+    primaryKeys(): Promise<unknown[]> {
+        return this.collection.primaryKeys();
+    }
+
+    uniqueKeys(): Promise<unknown[]> {
+        return this.collection.uniqueKeys();
+    }
+
+    count(): Promise<number> {
+        return this.collection.count();
+    }
+
+    sortBy(key: string): Promise<T[]> {
+        return this.collection.sortBy(key);
+    }
+
+    distinct(): StorageCollection<T> {
+        return new DexieStorageCollection(this.collection.distinct());
+    }
+
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T> {
+        return new DexieStorageCollection(this.collection.filter(predicate));
+    }
+
+    or(index: string): StorageWhereClause<T> {
+        return new DexieStorageWhereClause(this.collection.or(normalizeIndexName(index)));
+    }
+
+    clone(props?: Record<string, unknown>): StorageCollection<T> {
+        return new DexieStorageCollection(this.collection.clone(props));
+    }
+
+    reverse(): StorageCollection<T> {
+        return new DexieStorageCollection(this.collection.reverse());
+    }
+
+    offset(offset: number): StorageCollection<T> {
+        return new DexieStorageCollection(this.collection.offset(offset));
+    }
+
+    limit(count: number): StorageCollection<T> {
+        return new DexieStorageCollection(this.collection.limit(count));
+    }
+
+    toCollection(): StorageCollection<T> {
+        return this.clone();
+    }
+
+    delete(): Promise<number> {
+        return this.collection.delete();
+    }
+
+    modify(changes: Partial<T> | ((item: T) => void | Promise<void>)): Promise<number> {
+        return this.collection.modify(changes as any);
+    }
+
+    toArray(): Promise<T[]> {
+        return this.collection.toArray();
+    }
+}

package/src/storage/dexie/DexieStorageTable.ts

@@ -0,0 +1,123 @@
+import type { Table as DexieTable } from 'dexie';
+import type { StorageCollection, StorageTable, StorageWhereClause } from '../types';
+import { normalizeIndexName } from './helpers';
+import { DexieStorageCollection } from './DexieStorageCollection';
+import { DexieStorageWhereClause } from './DexieStorageWhereClause';
+
+export class DexieStorageTable<T = any> implements StorageTable<T> {
+    readonly name: string;
+    readonly schema: unknown;
+    readonly primaryKey: unknown;
+    readonly hook: unknown;
+    readonly raw = Object.freeze({
+        add: (item: T) => this.table.add(item),
+        put: (item: T) => this.table.put(item),
+        update: (key: unknown, changes: Partial<T>) => this.table.update(key as any, changes as any),
+        delete: (key: unknown) => this.table.delete(key as any),
+        get: (key: unknown) => this.table.get(key as any),
+        bulkAdd: (items: T[]) => this.table.bulkAdd(items),
+        bulkPut: (items: T[]) => this.table.bulkPut(items),
+        bulkUpdate: (keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>) => this.table.bulkUpdate(keysAndChanges as any),
+        bulkDelete: (keys: Array<unknown>) => this.table.bulkDelete(keys as any),
+        clear: () => this.table.clear(),
+    });
+
+    private readonly table: DexieTable<T, any, T>;
+
+    constructor(table: DexieTable<T, any, T>) {
+        this.table = table;
+        this.name = table.name;
+        this.schema = table.schema;
+        this.primaryKey = table.schema?.primKey;
+        this.hook = table.hook;
+    }
+
+    add(item: T): Promise<unknown> {
+        return this.table.add(item);
+    }
+
+    put(item: T): Promise<unknown> {
+        return this.table.put(item);
+    }
+
+    update(key: unknown, changes: Partial<T>): Promise<number> {
+        return this.table.update(key as any, changes as any);
+    }
+
+    delete(key: unknown): Promise<void> {
+        return this.table.delete(key as any).then(() => undefined);
+    }
+
+    clear(): Promise<void> {
+        return this.table.clear();
+    }
+
+    get(key: unknown): Promise<T | undefined> {
+        return this.table.get(key as any);
+    }
+
+    toArray(): Promise<T[]> {
+        return this.table.toArray();
+    }
+
+    count(): Promise<number> {
+        return this.table.count();
+    }
+
+    bulkAdd(items: T[]): Promise<unknown> {
+        return this.table.bulkAdd(items);
+    }
+
+    bulkPut(items: T[]): Promise<unknown> {
+        return this.table.bulkPut(items);
+    }
+
+    bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>> {
+        return this.table.bulkGet(keys as any);
+    }
+
+    bulkUpdate(keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>): Promise<number> {
+        return this.table.bulkUpdate(keysAndChanges as any);
+    }
+
+    bulkDelete(keys: Array<unknown>): Promise<void> {
+        return this.table.bulkDelete(keys as any);
+    }
+
+    where(index: string | string[]): StorageWhereClause<T> {
+        return new DexieStorageWhereClause(this.table.where(normalizeIndexName(index)));
+    }
+
+    orderBy(index: string | string[]): StorageCollection<T> {
+        return new DexieStorageCollection(this.table.orderBy(normalizeIndexName(index)));
+    }
+
+    reverse(): StorageCollection<T> {
+        return new DexieStorageCollection(this.table.reverse());
+    }
+
+    offset(offset: number): StorageCollection<T> {
+        return new DexieStorageCollection(this.table.offset(offset));
+    }
+
+    limit(count: number): StorageCollection<T> {
+        return new DexieStorageCollection(this.table.limit(count));
+    }
+
+    mapToClass(ctor: new (...args: any[]) => any): StorageTable<T> {
+        this.table.mapToClass(ctor as any);
+        return this;
+    }
+
+    async each(callback: (item: T) => void | Promise<void>): Promise<void> {
+        const tasks: Array<void | Promise<void>> = [];
+        await this.table.each((item) => {
+            tasks.push(callback(item));
+        });
+        await Promise.all(tasks.map((task) => (task ? Promise.resolve(task) : Promise.resolve())));
+    }
+
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T> {
+        return new DexieStorageCollection(this.table.filter(predicate));
+    }
+}

package/src/storage/dexie/DexieStorageWhereClause.ts

@@ -0,0 +1,103 @@
+import type { WhereClause as DexieWhereClause } from 'dexie';
+import type { StorageCollection, StorageWhereClause } from '../types';
+import { DexieStorageCollection } from './DexieStorageCollection';
+
+export class DexieStorageWhereClause<T = any> implements StorageWhereClause<T> {
+    private readonly clause: DexieWhereClause<T, any, T>;
+
+    constructor(clause: DexieWhereClause<T, any, T>) {
+        this.clause = clause;
+    }
+
+    equals(value: any): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.equals(value));
+    }
+
+    above(value: any): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.above(value));
+    }
+
+    aboveOrEqual(value: any): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.aboveOrEqual(value));
+    }
+
+    below(value: any): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.below(value));
+    }
+
+    belowOrEqual(value: any): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.belowOrEqual(value));
+    }
+
+    between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.between(lower, upper, includeLower, includeUpper));
+    }
+
+    inAnyRange(ranges: Array<[any, any]>, options?: { includeLower?: boolean; includeUpper?: boolean }): StorageCollection<T> {
+        const normalizedOptions = options
+            ? {
+                  includeLowers: options.includeLower,
+                  includeUppers: options.includeUpper,
+              }
+            : undefined;
+        return new DexieStorageCollection(this.clause.inAnyRange(ranges as any, normalizedOptions));
+    }
+
+    startsWith(prefix: string): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.startsWith(prefix));
+    }
+
+    startsWithIgnoreCase(prefix: string): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.startsWithIgnoreCase(prefix));
+    }
+
+    startsWithAnyOf(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<string>(args);
+        return new DexieStorageCollection(this.clause.startsWithAnyOf(...values));
+    }
+
+    startsWithAnyOfIgnoreCase(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<string>(args);
+        return new DexieStorageCollection(this.clause.startsWithAnyOfIgnoreCase(...values));
+    }
+
+    equalsIgnoreCase(value: string): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.equalsIgnoreCase(value));
+    }
+
+    anyOf(...values: any[]): StorageCollection<T>;
+    anyOf(values: any[]): StorageCollection<T>;
+    anyOf(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<any>(args);
+        return new DexieStorageCollection(this.clause.anyOf(...values));
+    }
+
+    anyOfIgnoreCase(...values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<string>(args);
+        return new DexieStorageCollection(this.clause.anyOfIgnoreCase(...values));
+    }
+
+    noneOf(...values: any[]): StorageCollection<T>;
+    noneOf(values: any[]): StorageCollection<T>;
+    noneOf(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<any>(args);
+        return new DexieStorageCollection(this.clause.noneOf(values as any));
+    }
+
+    notEqual(value: any): StorageCollection<T> {
+        return new DexieStorageCollection(this.clause.notEqual(value));
+    }
+
+    private flattenArgs<TValue>(args: any[]): TValue[] {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            return args[0] as TValue[];
+        }
+        return args as TValue[];
+    }
+}

package/src/storage/dexie/helpers.ts

@@ -0,0 +1 @@
+export const normalizeIndexName = (index: string | string[]): string => (Array.isArray(index) ? `[${index.join('+')}]` : index);

package/src/storage/dexie/index.ts

@@ -0,0 +1,7 @@
+// Export all classes
+export { DexieAdapter } from './DexieAdapter';
+export { DexieQueryContext } from './DexieQueryContext';
+export { DexieStorageCollection } from './DexieStorageCollection';
+export { DexieStorageWhereClause } from './DexieStorageWhereClause';
+export { DexieStorageTable } from './DexieStorageTable';
+export { normalizeIndexName } from './helpers';

package/src/storage/memory/MemoryAdapter.ts

@@ -0,0 +1,55 @@
+import type { StorageAdapter, StorageTable, StorageTransactionContext, TransactionMode } from '../types';
+import type { StorageSchemaDefinitionOptions } from '../sqlite/types';
+import { MemoryQueryContext } from './MemoryQueryContext';
+import { MemoryTable } from './MemoryTable';
+
+export class MemoryAdapter implements StorageAdapter {
+    readonly type = 'MemoryAdapter';
+    readonly name: string;
+    readonly tables = new Map<string, MemoryTable<any>>();
+
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    async open(): Promise<void> {
+        // No-op for memory adapter - always "open"
+    }
+
+    async close(): Promise<void> {
+        this.tables.clear();
+    }
+
+    async delete(): Promise<void> {
+        this.tables.clear();
+    }
+
+    async query<R>(callback: (ctx: MemoryQueryContext) => Promise<R>): Promise<R> {
+        return callback(new MemoryQueryContext(this));
+    }
+
+    defineSchema(_version: number, schema: Record<string, string>, _options?: StorageSchemaDefinitionOptions): void {
+        for (const tableName of Object.keys(schema)) {
+            this.ensureTable(tableName);
+        }
+    }
+
+    table<T = any>(name: string): StorageTable<T> {
+        return this.ensureTable(name) as StorageTable<T>;
+    }
+
+    async transaction<T>(_mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T> {
+        const tables: Record<string, StorageTable<any>> = {};
+        for (const tableName of tableNames) {
+            tables[tableName] = this.ensureTable(tableName);
+        }
+        return callback({ tables });
+    }
+
+    private ensureTable(name: string): MemoryTable<any> {
+        if (!this.tables.has(name)) {
+            this.tables.set(name, new MemoryTable(name));
+        }
+        return this.tables.get(name)!;
+    }
+}