@anfenn/dync 1.0.0

package/src/storage/memory/MemoryCollection.ts

@@ -0,0 +1,215 @@
+import type { StorageCollection, StorageWhereClause } from '../types';
+import type { MemoryCollectionState, MemoryRecord } from './types';
+import type { MemoryTable } from './MemoryTable';
+
+export class MemoryCollection<T extends MemoryRecord = MemoryRecord> implements StorageCollection<T> {
+    private readonly table: MemoryTable<T>;
+    private readonly state: MemoryCollectionState<T>;
+
+    constructor(table: MemoryTable<T>, state: MemoryCollectionState<T>) {
+        this.table = table;
+        this.state = state;
+    }
+
+    getState(): MemoryCollectionState<T> {
+        return { ...this.state };
+    }
+
+    matches(record: T, key: string): boolean {
+        return this.state.predicate(record, key);
+    }
+
+    clone(_props?: Record<string, unknown>): StorageCollection<T> {
+        return new MemoryCollection(this.table, { ...this.state });
+    }
+
+    reverse(): StorageCollection<T> {
+        return this.withState({ reverse: !this.state.reverse });
+    }
+
+    offset(offset: number): StorageCollection<T> {
+        return this.withState({ offset });
+    }
+
+    limit(count: number): StorageCollection<T> {
+        return this.withState({ limit: count });
+    }
+
+    toCollection(): StorageCollection<T> {
+        return this.clone();
+    }
+
+    distinct(): StorageCollection<T> {
+        return this.withState({ distinct: true });
+    }
+
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T> {
+        return this.withState({ predicate: this.combinePredicate(predicate, 'and') });
+    }
+
+    or(index: string): StorageWhereClause<T> {
+        return this.table.createWhereClause(index, this);
+    }
+
+    async first(): Promise<T | undefined> {
+        const entries = this.materializeEntries(true);
+        return entries.at(0)?.[1];
+    }
+
+    async last(): Promise<T | undefined> {
+        const entries = this.materializeEntries(true);
+        return entries.at(-1)?.[1];
+    }
+
+    async each(callback: (item: T, index: number) => void | Promise<void>): Promise<void> {
+        const entries = this.materializeEntries(true);
+        for (let index = 0; index < entries.length; index += 1) {
+            const [, record] = entries[index]!;
+            await callback(record, index);
+        }
+    }
+
+    async eachKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void> {
+        const keys = await this.keys();
+        for (let index = 0; index < keys.length; index += 1) {
+            await callback(keys[index], index);
+        }
+    }
+
+    async eachPrimaryKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void> {
+        const keys = await this.primaryKeys();
+        for (let index = 0; index < keys.length; index += 1) {
+            await callback(keys[index], index);
+        }
+    }
+
+    async eachUniqueKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void> {
+        const keys = await this.uniqueKeys();
+        for (let index = 0; index < keys.length; index += 1) {
+            await callback(keys[index], index);
+        }
+    }
+
+    async keys(): Promise<unknown[]> {
+        return this.materializeEntries(false).map(([key, record]) => this.table.resolvePublicKey(record, key));
+    }
+
+    async primaryKeys(): Promise<unknown[]> {
+        return this.keys();
+    }
+
+    async uniqueKeys(): Promise<unknown[]> {
+        const seen = new Set<string>();
+        const keys: unknown[] = [];
+        for (const [key, record] of this.materializeEntries(false)) {
+            const publicKey = this.table.resolvePublicKey(record, key);
+            const signature = JSON.stringify(publicKey);
+            if (!seen.has(signature)) {
+                seen.add(signature);
+                keys.push(publicKey);
+            }
+        }
+        return keys;
+    }
+
+    async count(): Promise<number> {
+        return this.materializeEntries(false).length;
+    }
+
+    async sortBy(key: string): Promise<T[]> {
+        const entries = this.materializeEntries(true);
+        entries.sort((a, b) => this.table.compareValues((a[1] as any)[key], (b[1] as any)[key]));
+        return entries.map(([, record]) => record);
+    }
+
+    async delete(): Promise<number> {
+        const entries = this.materializeEntries(false);
+        for (const [key] of entries) {
+            this.table.deleteByKey(key);
+        }
+        return entries.length;
+    }
+
+    async modify(changes: Partial<T> | ((item: T) => void | Promise<void>)): Promise<number> {
+        const entries = this.materializeEntries(false);
+        let modified = 0;
+        for (const [key] of entries) {
+            const current = this.table.getMutableRecord(key);
+            if (!current) {
+                continue;
+            }
+            if (typeof changes === 'function') {
+                const clone = this.table.cloneRecord(current);
+                await changes(clone);
+                (clone as MemoryRecord)._localId = current._localId ?? key;
+                this.table.setMutableRecord(key, clone);
+            } else {
+                const updated = { ...current, ...changes, _localId: current._localId ?? key } as T;
+                this.table.setMutableRecord(key, updated);
+            }
+            modified += 1;
+        }
+        return modified;
+    }
+
+    async toArray(): Promise<T[]> {
+        return this.materializeEntries(true).map(([, record]) => record);
+    }
+
+    private withState(overrides: Partial<MemoryCollectionState<T>>): MemoryCollection<T> {
+        return new MemoryCollection(this.table, {
+            ...this.state,
+            ...overrides,
+            predicate: overrides.predicate ?? this.state.predicate,
+        });
+    }
+
+    private combinePredicate(predicate: (record: T) => boolean, mode: 'and' | 'or'): (record: T, key: string) => boolean {
+        if (mode === 'and') {
+            return (record: T, key: string) => this.state.predicate(record, key) && predicate(record);
+        }
+        return (record: T, key: string) => this.state.predicate(record, key) || predicate(record);
+    }
+
+    private materializeEntries(clone: boolean): Array<[string, T]> {
+        let entries = this.table.entries().filter(([key, record]) => this.state.predicate(record, key));
+
+        if (this.state.orderBy) {
+            const { index, direction } = this.state.orderBy;
+            entries = [...entries].sort((a, b) => this.table.compareEntries(a[1], b[1], index));
+            if (direction === 'desc') {
+                entries.reverse();
+            }
+        }
+
+        if (this.state.reverse) {
+            entries = [...entries].reverse();
+        }
+
+        if (this.state.distinct) {
+            const seen = new Set<string>();
+            entries = entries.filter(([, record]) => {
+                const signature = JSON.stringify(record);
+                if (seen.has(signature)) {
+                    return false;
+                }
+                seen.add(signature);
+                return true;
+            });
+        }
+
+        if (this.state.offset > 0) {
+            entries = entries.slice(this.state.offset);
+        }
+
+        if (typeof this.state.limit === 'number') {
+            entries = entries.slice(0, this.state.limit);
+        }
+
+        if (clone) {
+            return entries.map(([key, record]) => [key, this.table.cloneRecord(record)] as [string, T]);
+        }
+
+        return entries;
+    }
+}

package/src/storage/memory/MemoryQueryContext.ts

@@ -0,0 +1,14 @@
+import type { StorageTable, StorageTransactionContext, TransactionMode } from '../types';
+import type { MemoryAdapter } from './MemoryAdapter';
+
+export class MemoryQueryContext {
+    constructor(private readonly adapter: MemoryAdapter) {}
+
+    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/memory/MemoryTable.ts

@@ -0,0 +1,336 @@
+import type { StorageCollection, StorageTable, StorageWhereClause } from '../types';
+import { LOCAL_PK } from '../../types';
+import { createLocalId } from '../../helpers';
+import type { MemoryCollectionState, MemoryRecord } from './types';
+import { createDefaultState } from './types';
+import { MemoryCollection } from './MemoryCollection';
+import { MemoryWhereClause } from './MemoryWhereClause';
+
+export class MemoryTable<T extends MemoryRecord = MemoryRecord> implements StorageTable<T> {
+    readonly name: string;
+    readonly schema: unknown = undefined;
+    readonly primaryKey: unknown = LOCAL_PK;
+    readonly hook: unknown = Object.freeze({});
+    readonly raw: {
+        add: (item: T) => Promise<unknown>;
+        put: (item: T) => Promise<unknown>;
+        update: (key: unknown, changes: Partial<T>) => Promise<number>;
+        delete: (key: unknown) => Promise<void>;
+        get: (key: unknown) => Promise<T | undefined>;
+        bulkAdd: (items: T[]) => Promise<unknown>;
+        bulkPut: (items: T[]) => Promise<unknown>;
+        bulkUpdate: (keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>) => Promise<number>;
+        bulkDelete: (keys: Array<unknown>) => Promise<void>;
+        clear: () => Promise<void>;
+    };
+    private readonly records = new Map<string, T>();
+
+    constructor(name: string) {
+        this.name = name;
+        this.raw = {
+            add: async (item: T) => this.baseAdd(item),
+            put: async (item: T) => this.basePut(item),
+            update: async (key: unknown, changes: Partial<T>) => this.baseUpdate(key, changes),
+            delete: async (key: unknown) => {
+                this.baseDelete(key);
+            },
+            get: async (key: unknown) => this.baseGet(key),
+            bulkAdd: async (items: T[]) => this.baseBulkAdd(items),
+            bulkPut: async (items: T[]) => this.baseBulkPut(items),
+            bulkUpdate: async (keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>) => this.baseBulkUpdate(keysAndChanges),
+            bulkDelete: async (keys: Array<unknown>) => this.baseBulkDelete(keys),
+            clear: async () => this.baseClear(),
+        };
+    }
+
+    async add(item: T): Promise<unknown> {
+        return this.baseAdd(item);
+    }
+
+    async put(item: T): Promise<unknown> {
+        return this.basePut(item);
+    }
+
+    async update(key: unknown, changes: Partial<T>): Promise<number> {
+        return this.baseUpdate(key, changes);
+    }
+
+    async delete(key: unknown): Promise<void> {
+        this.baseDelete(key);
+    }
+
+    async clear(): Promise<void> {
+        this.baseClear();
+    }
+
+    private baseClear(): void {
+        this.records.clear();
+    }
+
+    async get(key: unknown): Promise<T | undefined> {
+        const stored = this.baseGet(key);
+        return stored ? this.cloneRecord(stored) : undefined;
+    }
+
+    async toArray(): Promise<T[]> {
+        return this.entries().map(([, record]) => this.cloneRecord(record));
+    }
+
+    async count(): Promise<number> {
+        return this.records.size;
+    }
+
+    async bulkAdd(items: T[]): Promise<unknown> {
+        return this.baseBulkAdd(items);
+    }
+
+    private baseBulkAdd(items: T[]): unknown {
+        let lastKey: unknown = undefined;
+        for (let index = 0; index < items.length; index += 1) {
+            const item = items[index]!;
+            lastKey = this.baseAdd(item);
+        }
+        return lastKey;
+    }
+
+    async bulkPut(items: T[]): Promise<unknown> {
+        return this.baseBulkPut(items);
+    }
+
+    private baseBulkPut(items: T[]): unknown {
+        let lastKey: unknown = undefined;
+        for (let index = 0; index < items.length; index += 1) {
+            const item = items[index]!;
+            lastKey = this.basePut(item);
+        }
+        return lastKey;
+    }
+
+    async bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>> {
+        return Promise.all(keys.map((key) => this.get(key)));
+    }
+
+    async bulkUpdate(keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>): Promise<number> {
+        return this.baseBulkUpdate(keysAndChanges);
+    }
+
+    private baseBulkUpdate(keysAndChanges: Array<{ key: unknown; changes: Partial<T> }>): number {
+        let updatedCount = 0;
+        for (const { key, changes } of keysAndChanges) {
+            const result = this.baseUpdate(key, changes);
+            updatedCount += result;
+        }
+        return updatedCount;
+    }
+
+    async bulkDelete(keys: Array<unknown>): Promise<void> {
+        this.baseBulkDelete(keys);
+    }
+
+    private baseBulkDelete(keys: Array<unknown>): void {
+        for (const key of keys) {
+            this.baseDelete(key);
+        }
+    }
+
+    where(index: string | string[]): StorageWhereClause<T> {
+        return this.createWhereClause(index);
+    }
+
+    orderBy(index: string | string[]): StorageCollection<T> {
+        return this.createCollection({
+            orderBy: { index, direction: 'asc' },
+        });
+    }
+
+    reverse(): StorageCollection<T> {
+        return this.createCollection({ reverse: true });
+    }
+
+    offset(offset: number): StorageCollection<T> {
+        return this.createCollection({ offset });
+    }
+
+    limit(count: number): StorageCollection<T> {
+        return this.createCollection({ limit: count });
+    }
+
+    mapToClass(_ctor: new (...args: any[]) => any): StorageTable<T> {
+        return this;
+    }
+
+    async each(callback: (item: T) => void | Promise<void>): Promise<void> {
+        for (const [, record] of this.entries()) {
+            await callback(this.cloneRecord(record));
+        }
+    }
+
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T> {
+        return this.createCollection({ predicate: (record) => predicate(record) });
+    }
+
+    private createCollection(stateOverrides?: Partial<MemoryCollectionState<T>>): MemoryCollection<T> {
+        const baseState = createDefaultState<T>();
+        const state: MemoryCollectionState<T> = {
+            ...baseState,
+            ...stateOverrides,
+            predicate: stateOverrides?.predicate ?? baseState.predicate,
+        };
+        return new MemoryCollection(this, state);
+    }
+
+    createCollectionFromPredicate(predicate: (record: T, key: string) => boolean, template?: MemoryCollection<T>): MemoryCollection<T> {
+        const baseState = template ? template.getState() : createDefaultState<T>();
+        return new MemoryCollection(this, {
+            ...baseState,
+            predicate,
+        });
+    }
+
+    createWhereClause(index: string | string[], baseCollection?: MemoryCollection<T>): MemoryWhereClause<T> {
+        return new MemoryWhereClause(this, index, baseCollection);
+    }
+
+    entries(): Array<[string, T]> {
+        return Array.from(this.records.entries());
+    }
+
+    cloneRecord(record: T): T {
+        return { ...(record as object) } as T;
+    }
+
+    deleteByKey(key: string): void {
+        this.records.delete(key);
+    }
+
+    getMutableRecord(key: string): T | undefined {
+        return this.records.get(key);
+    }
+
+    setMutableRecord(key: string, record: T): void {
+        this.records.set(key, { ...record, _localId: record._localId ?? key } as T);
+    }
+
+    resolvePublicKey(record: T, key: string): unknown {
+        if (record._localId !== undefined) {
+            return record._localId;
+        }
+        if (record.id !== undefined) {
+            return record.id;
+        }
+        return key;
+    }
+
+    getIndexValue(record: T, index: string | string[]): unknown {
+        if (Array.isArray(index)) {
+            return index.map((key) => (record as any)[key]);
+        }
+        return (record as any)[index];
+    }
+
+    compareEntries(left: T, right: T, index: string | string[]): number {
+        if (Array.isArray(index)) {
+            for (const key of index) {
+                const diff = this.compareValues((left as any)[key], (right as any)[key]);
+                if (diff !== 0) {
+                    return diff;
+                }
+            }
+            return 0;
+        }
+        return this.compareValues((left as any)[index], (right as any)[index]);
+    }
+
+    compareValues(left: unknown, right: unknown): number {
+        const normalizedLeft = this.normalizeComparableValue(left) as any;
+        const normalizedRight = this.normalizeComparableValue(right) as any;
+        if (normalizedLeft < normalizedRight) {
+            return -1;
+        }
+        if (normalizedLeft > normalizedRight) {
+            return 1;
+        }
+        return 0;
+    }
+
+    private normalizeComparableValue(value: unknown): unknown {
+        if (Array.isArray(value)) {
+            return value.map((entry) => this.normalizeComparableValue(entry));
+        }
+        if (value instanceof Date) {
+            return value.valueOf();
+        }
+        return value ?? null;
+    }
+
+    private baseAdd(item: T): string {
+        const primaryKey = this.createPrimaryKey(item);
+        const stored = { ...item, _localId: primaryKey } as T;
+        this.records.set(primaryKey, stored);
+        return primaryKey;
+    }
+
+    private basePut(item: T): string {
+        const primaryKey = this.createPrimaryKey(item);
+        const stored = { ...item, _localId: primaryKey } as T;
+        this.records.set(primaryKey, stored);
+        return primaryKey;
+    }
+
+    private baseUpdate(key: unknown, changes: Partial<T>): number {
+        const primaryKey = this.resolveKey(key);
+        if (!primaryKey) {
+            return 0;
+        }
+        const existing = this.records.get(primaryKey);
+        if (!existing) {
+            return 0;
+        }
+        const updated = { ...existing, ...changes, _localId: existing._localId ?? primaryKey } as T;
+        this.records.set(primaryKey, updated);
+        return 1;
+    }
+
+    private baseDelete(key: unknown): void {
+        const primaryKey = this.resolveKey(key);
+        if (primaryKey) {
+            this.records.delete(primaryKey);
+        }
+    }
+
+    private baseGet(key: unknown): T | undefined {
+        const primaryKey = this.resolveKey(key);
+        if (!primaryKey) {
+            return undefined;
+        }
+        return this.records.get(primaryKey);
+    }
+
+    private createPrimaryKey(item: T): string {
+        if (item._localId && typeof item._localId === 'string') {
+            return item._localId;
+        }
+        if (item.id !== undefined && (typeof item.id === 'string' || typeof item.id === 'number' || typeof item.id === 'bigint')) {
+            return String(item.id);
+        }
+        return createLocalId();
+    }
+
+    private resolveKey(key: unknown): string | undefined {
+        if (typeof key === 'string') {
+            return key;
+        }
+        if (typeof key === 'number' || typeof key === 'bigint') {
+            return String(key);
+        }
+        if (key && typeof key === 'object' && 'id' in (key as Record<string, unknown>)) {
+            const lookup = (key as Record<string, unknown>).id;
+            for (const [storedKey, record] of this.records.entries()) {
+                if (record.id === lookup) {
+                    return storedKey;
+                }
+            }
+        }
+        return undefined;
+    }
+}

package/src/storage/memory/MemoryWhereClause.ts

@@ -0,0 +1,134 @@
+import type { StorageCollection, StorageWhereClause } from '../types';
+import type { MemoryRecord } from './types';
+import type { MemoryTable } from './MemoryTable';
+import type { MemoryCollection } from './MemoryCollection';
+
+export class MemoryWhereClause<T extends MemoryRecord = MemoryRecord> implements StorageWhereClause<T> {
+    private readonly table: MemoryTable<T>;
+    private readonly index: string | string[];
+    private readonly baseCollection?: MemoryCollection<T>;
+
+    constructor(table: MemoryTable<T>, index: string | string[], baseCollection?: MemoryCollection<T>) {
+        this.table = table;
+        this.index = index;
+        this.baseCollection = baseCollection;
+    }
+
+    equals(value: any): StorageCollection<T> {
+        return this.createCollection((current) => this.table.compareValues(current, value) === 0);
+    }
+
+    above(value: any): StorageCollection<T> {
+        return this.createCollection((current) => this.table.compareValues(current, value) > 0);
+    }
+
+    aboveOrEqual(value: any): StorageCollection<T> {
+        return this.createCollection((current) => this.table.compareValues(current, value) >= 0);
+    }
+
+    below(value: any): StorageCollection<T> {
+        return this.createCollection((current) => this.table.compareValues(current, value) < 0);
+    }
+
+    belowOrEqual(value: any): StorageCollection<T> {
+        return this.createCollection((current) => this.table.compareValues(current, value) <= 0);
+    }
+
+    between(lower: any, upper: any, includeLower = true, includeUpper = false): StorageCollection<T> {
+        return this.createCollection((current) => {
+            const lowerCmp = this.table.compareValues(current, lower);
+            const upperCmp = this.table.compareValues(current, upper);
+            const lowerOk = includeLower ? lowerCmp >= 0 : lowerCmp > 0;
+            const upperOk = includeUpper ? upperCmp <= 0 : upperCmp < 0;
+            return lowerOk && upperOk;
+        });
+    }
+
+    inAnyRange(ranges: Array<[any, any]>, options?: { includeLower?: boolean; includeUpper?: boolean }): StorageCollection<T> {
+        const includeLower = options?.includeLower ?? true;
+        const includeUpper = options?.includeUpper ?? false;
+        return this.createCollection((current) => {
+            for (const [lower, upper] of ranges) {
+                const lowerCmp = this.table.compareValues(current, lower);
+                const upperCmp = this.table.compareValues(current, upper);
+                const lowerOk = includeLower ? lowerCmp >= 0 : lowerCmp > 0;
+                const upperOk = includeUpper ? upperCmp <= 0 : upperCmp < 0;
+                if (lowerOk && upperOk) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+
+    startsWith(prefix: string): StorageCollection<T> {
+        return this.createCollection((current) => typeof current === 'string' && current.startsWith(prefix));
+    }
+
+    startsWithIgnoreCase(prefix: string): StorageCollection<T> {
+        return this.createCollection((current) => typeof current === 'string' && current.toLowerCase().startsWith(prefix.toLowerCase()));
+    }
+
+    startsWithAnyOf(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(...args: any[]): StorageCollection<T> {
+        const prefixes = this.flattenArgs<string>(args);
+        return this.createCollection((current) => typeof current === 'string' && prefixes.some((prefix) => current.startsWith(prefix)));
+    }
+
+    startsWithAnyOfIgnoreCase(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(...args: any[]): StorageCollection<T> {
+        const prefixes = this.flattenArgs<string>(args).map((prefix) => prefix.toLowerCase());
+        return this.createCollection((current) => typeof current === 'string' && prefixes.some((prefix) => current.toLowerCase().startsWith(prefix)));
+    }
+
+    equalsIgnoreCase(value: string): StorageCollection<T> {
+        return this.createCollection((current) => typeof current === 'string' && current.toLowerCase() === value.toLowerCase());
+    }
+
+    anyOf(...values: any[]): StorageCollection<T>;
+    anyOf(values: any[]): StorageCollection<T>;
+    anyOf(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<any>(args);
+        const valueSet = new Set(values.map((entry) => JSON.stringify(entry)));
+        return this.createCollection((current) => valueSet.has(JSON.stringify(current)));
+    }
+
+    anyOfIgnoreCase(...values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<string>(args).map((value) => value.toLowerCase());
+        const valueSet = new Set(values);
+        return this.createCollection((current) => typeof current === 'string' && valueSet.has(current.toLowerCase()));
+    }
+
+    noneOf(...values: any[]): StorageCollection<T>;
+    noneOf(values: any[]): StorageCollection<T>;
+    noneOf(...args: any[]): StorageCollection<T> {
+        const values = this.flattenArgs<any>(args);
+        const valueSet = new Set(values.map((entry) => JSON.stringify(entry)));
+        return this.createCollection((current) => !valueSet.has(JSON.stringify(current)));
+    }
+
+    notEqual(value: any): StorageCollection<T> {
+        return this.createCollection((current) => this.table.compareValues(current, value) !== 0);
+    }
+
+    private createCollection(predicate: (indexValue: unknown) => boolean): StorageCollection<T> {
+        const condition = (record: T, _key: string): boolean => predicate(this.table.getIndexValue(record, this.index));
+        if (this.baseCollection) {
+            const combined = (record: T, key: string): boolean =>
+                this.baseCollection!.matches(record, key) || predicate(this.table.getIndexValue(record, this.index));
+            return this.table.createCollectionFromPredicate(combined, this.baseCollection);
+        }
+        return this.table.createCollectionFromPredicate(condition);
+    }
+
+    private flattenArgs<TValue>(args: any[]): TValue[] {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            return args[0] as TValue[];
+        }
+        return args as TValue[];
+    }
+}