@epam/uui-db 5.3.0 → 5.4.0

package/src/__tests__/TaskDb.ts

@@ -1,187 +0,0 @@
-import { DbRef } from '../DbRef';
-import {
-    Db, DbTable, DbRelationType, DbView,
-} from '../index';
-import { DbPatch, DbSaveResponse } from '../types';
-
-export interface Task {
-    id: number;
-    name: string;
-    isDone: boolean;
-    createdBy: string;
-    assignedTo: string;
-    isDraft: boolean;
-    tags?: string[];
-    details?: any;
-    estimate?: number;
-    isDeleted?: boolean;
-}
-
-export interface User {
-    id: string;
-    name: string;
-    title: string;
-    sex: 'm' | 'f';
-    orderStr: string;
-}
-
-export interface Manager {
-    subordinateId: string;
-    managerId: string;
-    role: string;
-}
-
-export interface View {
-    id: number;
-    title: string;
-}
-
-const tasks = new DbTable<Task, number, any>({
-    tableName: 'tasks',
-    typeName: 'Task',
-    primaryKey: 'id',
-    fields: {
-        id: { isGenerated: true },
-        createdBy: {
-            isReadOnly: true,
-            fk: {
-                tableName: 'users',
-                relationType: DbRelationType.Aggregation,
-            },
-        },
-        assignedTo: {
-            fk: {
-                tableName: 'users',
-                relationType: DbRelationType.Association,
-            },
-        },
-        estimate: {
-            toClient: (value: any) => value && parseInt(value),
-            toServer: (value: number) => value && ((value + '') as any),
-        },
-        isDone: { default: false },
-        isDraft: { isClientOnly: true },
-    },
-    indexes: ['createdBy', 'assignedTo'],
-    deleteFlag: 'isDeleted',
-});
-
-const users = new DbTable<User, string, any>({
-    tableName: 'users',
-    typeName: 'User',
-    primaryKey: 'id',
-    fields: {
-        id: { isGenerated: true },
-    },
-    indexes: ['title'],
-});
-
-const managers = new DbTable<Manager, [string, string], any>({
-    tableName: 'managers',
-    typeName: 'Manager',
-    primaryKey: ['subordinateId', 'managerId'],
-    fields: {
-        subordinateId: { isGenerated: true },
-        managerId: { isGenerated: true },
-    },
-    indexes: ['subordinateId', 'managerId'],
-});
-
-const views = new DbTable<View, number, any>({
-    tableName: 'views',
-    typeName: 'View',
-    primaryKey: 'id',
-    fields: {
-        id: { isGenerated: true },
-    },
-    isClientOnly: true,
-});
-
-const viewsFn = new DbTable<View, number, any>({
-    tableName: 'viewsFn',
-    typeName: 'ViewFn',
-    primaryKey: 'id',
-    fields: {
-        id: { isGenerated: true },
-    },
-    isClientOnly: (view) => view.id < 0,
-});
-
-const taskDbTables = {
-    tasks, users, managers, views, viewsFn,
-};
-export type TaskDbTables = typeof taskDbTables;
-
-export class TaskDb extends Db<TaskDbTables> {
-    public get tasks() {
-        return this.tables.tasks;
-    }
-
-    public get users() {
-        return this.tables.users;
-    }
-
-    public get managers() {
-        return this.tables.managers;
-    }
-
-    public get views() {
-        return this.tables.views;
-    }
-
-    public get viewsFn() {
-        return this.tables.viewsFn;
-    }
-}
-
-export const emptyDb = new TaskDb(taskDbTables);
-
-export const sampleUsers = {
-    daenerys: {
-        id: 'DT', name: 'Daenerys Targaryen', sex: 'f', orderStr: 'b',
-    } as User,
-    john: {
-        id: 'JS', name: 'John Snow', sex: 'm', orderStr: 'a',
-    } as User,
-    arya: {
-        id: 'AS', name: 'Arya Stark', sex: 'f', orderStr: 'c',
-    } as User,
-};
-
-export const sampleData = {
-    tasks: [
-        {
-            id: 1, name: 'Implement DB', isDone: true, createdBy: 'DT', assignedTo: 'JS',
-        }, {
-            id: 2, name: 'Write Some Tests', isDone: true, createdBy: 'DT', assignedTo: null,
-        }, {
-            id: 3, name: 'Basic Indexes', isDone: true, createdBy: 'DT', assignedTo: 'JS',
-        }, {
-            id: 4, name: 'Views', isDone: false, createdBy: 'DT', assignedTo: 'JS',
-        }, {
-            id: 5, name: 'IO Scheduling', isDone: false, createdBy: 'DT', assignedTo: 'AS',
-        }, {
-            id: 6, name: 'DataSources', isDone: false, createdBy: 'JS', assignedTo: 'JS',
-        }, {
-            id: 7, name: 'Loaders', isDone: false, createdBy: 'AS', assignedTo: 'AS',
-        },
-    ] as Task[],
-    users: [
-        sampleUsers.daenerys, sampleUsers.john, sampleUsers.arya,
-    ] as User[],
-};
-
-export const sampleDb = emptyDb.with(sampleData);
-
-export type TaskDbView<TResult, TParams, TDependencies = void> = DbView<TaskDb, TResult, TParams, TDependencies>;
-
-export class TasksDbRef extends DbRef<TaskDbTables, TaskDb> {
-    constructor(private savePatchHandler: (patch: DbPatch<TaskDbTables>) => Promise<DbSaveResponse<TaskDbTables>>) {
-        super(emptyDb);
-        this.throttleSaveMs = 1;
-    }
-
-    override savePatch(patch: DbPatch<TaskDbTables>) {
-        return this.savePatchHandler?.(patch);
-    }
-}

package/src/__tests__/db.test.ts

@@ -1,293 +0,0 @@
-import { emptyDb, sampleDb } from './TaskDb';
-
-describe('db - DB queries and updates', () => {
-    describe('Queries', () => {
-        it('user by id with query/one', () => expect(sampleDb.users.find({ id: 'AS' }).one().name).toEqual('Arya Stark'));
-        it("user by id with 'byId'", () => expect(sampleDb.users.byId('AS').name).toEqual('Arya Stark'));
-        it("users by multiple id with 'in'", () =>
-            expect(
-                sampleDb.users
-                    .find({ id: { in: ['AS', 'JS'] } })
-                    .orderBy('id')
-                    .toArray()
-                    .map((u) => u.id),
-            ).toEqual(['AS', 'JS']));
-        it('user by name', () => expect(sampleDb.users.find({ name: 'Arya Stark' }).one().id).toEqual('AS'));
-        it('user by [null] name', () => expect(sampleDb.users.find({ name: null }).one()).toBeNull());
-        it('sort by name', () =>
-            expect(
-                sampleDb.users
-                    .orderBy('name')
-                    .toArray()
-                    .map((e) => e.name),
-            ).toEqual([
-                'Arya Stark', 'Daenerys Targaryen', 'John Snow',
-            ]));
-        it('sort by name and sex', () =>
-            expect(
-                sampleDb.users
-                    .orderBy('sex', 'desc')
-                    .thenBy('name')
-                    .map((e) => e.name),
-            ).toEqual([
-                'John Snow', 'Arya Stark', 'Daenerys Targaryen',
-            ]));
-        it('sort by name and sex via order', () =>
-            expect(sampleDb.users.order([{ field: 'sex' }, { field: 'name', direction: 'desc' }]).map((e) => e.name)).toEqual([
-                'Daenerys Targaryen', 'Arya Stark', 'John Snow',
-            ]));
-        it("find tasks by multiple values with 'in'", () =>
-            expect(
-                sampleDb.tasks
-                    .find({ createdBy: { in: ['AS', 'JS'] } })
-                    .orderBy('id')
-                    .map((t) => t.id),
-            ).toEqual([6, 7]));
-
-        it('find tasks by both indexed and non-indexed fields', () =>
-            expect(
-                sampleDb.tasks
-                    .find({ createdBy: { in: ['DT'] }, assignedTo: 'JS', isDone: false })
-                    .orderBy('id')
-                    .map((t) => t.id),
-            ).toEqual([4]));
-
-        it('non-indexable filter criteria should work', () =>
-            expect(
-                sampleDb.tasks
-                    .find({ id: { gte: 4 }, assignedTo: 'AS', isDone: false })
-                    .orderBy('id')
-                    .map((t) => t.id),
-            ).toEqual([5, 7]));
-
-        it('non-indexable and indexable criteria for the same field', () =>
-            expect(sampleDb.tasks.find({ createdBy: { in: ['AS', 'JS'], gt: 'B' }, isDone: false }).map((t) => t.id)).toEqual([6]));
-
-        it('count should work with filter', () => expect(sampleDb.tasks.find({ assignedTo: 'AS' }).count()).toEqual(2));
-
-        it('range should work with filter', () =>
-            expect(
-                sampleDb.tasks
-                    .find({ createdBy: 'DT', assignedTo: { isNull: false } })
-                    .orderBy('assignedTo')
-                    .thenBy('id')
-                    .range(1, 3)
-                    .map((i) => i.id),
-            ).toEqual([
-                1, 3, 4,
-            ]));
-    });
-
-    describe('Indexes and updates', () => {
-        it('query after insert', () => {
-            const db = sampleDb.with({
-                tasks: [
-                    {
-                        id: 100, name: 'Test', assignedTo: 'QQ', createdBy: 'WW', isDone: false, isDraft: false,
-                    },
-                ],
-            });
-            expect(db.tasks.find({ assignedTo: 'QQ', createdBy: 'WW' }).one().id).toBe(100);
-        });
-
-        it('query after update', () => {
-            const db = sampleDb.with({
-                tasks: [
-                    {
-                        id: 1, name: 'Test', createdBy: 'QQ', isDone: false, isDraft: false,
-                    },
-                ],
-            });
-            expect(db.tasks.find({ createdBy: 'QQ' }).one().id).toBe(1);
-            expect(
-                db.tasks
-                    .find({ createdBy: 'DT' })
-                    .orderBy('id')
-                    .map((u) => u.id),
-            ).toEqual([
-                2, 3, 4, 5,
-            ]);
-        });
-
-        it('query after delete', () => {
-            const db = sampleDb.with({ tasks: [{ id: 1, isDeleted: true }] });
-            expect(db.tasks.byId(1)).toBeFalsy();
-            expect(db.tasks.find({ createdBy: 'AS' }).map((i) => i.id)).not.toContain(1);
-        });
-
-        it('user name update', () => {
-            const newDb = sampleDb.with({ users: [{ id: 'AS', name: 'Ivan Ivanov' }] });
-            expect(newDb.users.byId('AS').name).toEqual('Ivan Ivanov');
-            // DB is immutable, so shallow copy should be created at all levels.
-            expect(newDb.users).not.toBe(sampleDb.users);
-            expect(newDb.tables.users).not.toBe(sampleDb.tables.users);
-            expect(newDb.users.byId('AS')).not.toBe(sampleDb.users.byId('AS'));
-            expect(sampleDb.users.byId('AS').name).toEqual('Arya Stark');
-        });
-
-        it('Should return updated record if index is not touched', () => {
-            const db = sampleDb.with({
-                tasks: [
-                    {
-                        id: 7, name: 'Test', isDone: true, isDraft: false,
-                    },
-                ],
-            });
-            expect(db.tasks.find({ createdBy: 'AS' }).one().id).toBe(7);
-            expect(db.tasks.find({ createdBy: 'AS' }).one().name).toBe('Test');
-        });
-
-        it('should handle null and undefined values', () => {
-            const testDb = emptyDb.with({
-                tasks: [{ id: 1, assignedTo: null, isDone: null }, { id: 2 }],
-            });
-
-            expect(
-                testDb.tasks
-                    .find({ isDone: null })
-                    .toArray()
-                    .map((i) => i.id),
-            ).toEqual([1]);
-            expect(
-                testDb.tasks
-                    .find({ isDone: undefined })
-                    .toArray()
-                    .map((i) => i.id),
-            ).toEqual([2]);
-            expect(
-                testDb.tasks
-                    .find({ isDone: { isNull: true } })
-                    .toArray()
-                    .map((i) => i.id),
-            ).toEqual([1, 2]);
-
-            expect(
-                testDb.tasks
-                    .find({ assignedTo: null })
-                    .toArray()
-                    .map((i) => i.id),
-            ).toEqual([1]);
-            expect(
-                testDb.tasks
-                    .find({ assignedTo: undefined })
-                    .toArray()
-                    .map((i) => i.id),
-            ).toEqual([2]);
-            expect(
-                testDb.tasks
-                    .find({ assignedTo: { isNull: true } })
-                    .toArray()
-                    .map((i) => i.id),
-            ).toEqual([1, 2]);
-        });
-
-        it('Should correctly handle changes from undefined to non-undefined and reverse (non-indexed)', () => {
-            const db1 = sampleDb.with({ tasks: [{ id: 100 }] }); // initial - undefined
-            expect(db1.tasks.find({ name: { isNull: true } }).one().id).toBe(100);
-            expect(db1.tasks.find({ name: undefined }).one().id).toBe(100);
-            expect(db1.tasks.find({ name: { in: [undefined] } }).one().id).toBe(100);
-            const db2 = db1.with({ tasks: [{ id: 100, name: 'Test' }] }); // set value
-            expect(db2.tasks.find({ name: 'Test' }).one().id).toBe(100);
-            const db3 = db2.with({ tasks: [{ id: 100, isDone: true }] }); // keep value
-            expect(db2.tasks.find({ name: 'Test' }).one().id).toBe(100);
-            const db4 = db3.with({ tasks: [{ id: 100, name: undefined }] }); // set to undefined
-            expect(db4.tasks.find({ name: { isNull: true } }).one().id).toBe(100);
-            expect(db4.tasks.find({ name: undefined }).one().id).toBe(100);
-            expect(db4.tasks.find({ name: { in: [undefined] } }).one().id).toBe(100);
-        });
-
-        it('Should correctly handle changes from null to non-null and reverse (non-indexed)', () => {
-            const db1 = sampleDb.with({ tasks: [{ id: 100, name: null }] }); // initial - null
-            expect(db1.tasks.find({ name: { isNull: true } }).one().id).toBe(100);
-            expect(db1.tasks.find({ name: null }).one().id).toBe(100);
-            expect(db1.tasks.find({ name: { in: [null] } }).one().id).toBe(100);
-            const db2 = db1.with({ tasks: [{ id: 100, name: 'Test' }] }); // set value
-            expect(db2.tasks.find({ name: 'Test' }).one().id).toBe(100);
-            const db3 = db2.with({ tasks: [{ id: 100, isDone: true }] }); // keep value
-            expect(db2.tasks.find({ name: 'Test' }).one().id).toBe(100);
-            const db4 = db3.with({ tasks: [{ id: 100, name: null }] }); // set to null
-            expect(db4.tasks.find({ name: { isNull: true } }).one().id).toBe(100);
-            expect(db4.tasks.find({ name: null }).one().id).toBe(100);
-            expect(db4.tasks.find({ name: { in: [null] } }).one().id).toBe(100);
-        });
-
-        it('Should correctly handle changes from null to non-null and reverse (indexed)', () => {
-            const db1 = sampleDb.with({ tasks: [{ id: 100, name: 'Test', createdBy: null }] }); // initial - null
-            expect(db1.tasks.find({ createdBy: { isNull: true } }).one().id).toBe(100);
-            expect(db1.tasks.find({ createdBy: null }).one().id).toBe(100);
-            expect(db1.tasks.find({ createdBy: { in: [null] } }).one().id).toBe(100);
-            const db2 = db1.with({ tasks: [{ id: 100, createdBy: 'QQ' }] }); // set value
-            expect(db2.tasks.find({ createdBy: 'QQ' }).one().id).toBe(100);
-            const db3 = db2.with({ tasks: [{ id: 100, isDone: true }] }); // keep value
-            expect(db2.tasks.find({ createdBy: 'QQ' }).one().id).toBe(100);
-            const db4 = db3.with({ tasks: [{ id: 100, createdBy: null }] }); // set to null
-            expect(db4.tasks.find({ createdBy: { isNull: true } }).one().id).toBe(100);
-            expect(db4.tasks.find({ createdBy: null }).one().id).toBe(100);
-            expect(db4.tasks.find({ createdBy: { in: [null] } }).one().id).toBe(100);
-        });
-
-        it('Should correctly handle changes from undefined to non-undefined and reverse (indexed)', () => {
-            const db1 = sampleDb.with({ tasks: [{ id: 100, name: 'Test' }] }); // initial - undefined
-            expect(db1.tasks.find({ createdBy: { isNull: true } }).one().id).toBe(100);
-            expect(db1.tasks.find({ createdBy: undefined }).one().id).toBe(100);
-            expect(db1.tasks.find({ createdBy: { in: [undefined] } }).one().id).toBe(100);
-            const db2 = db1.with({ tasks: [{ id: 100, createdBy: 'QQ' }] }); // set value
-            expect(db2.tasks.find({ createdBy: 'QQ' }).one().id).toBe(100);
-            const db3 = db2.with({ tasks: [{ id: 100, isDone: true }] }); // keep value
-            expect(db2.tasks.find({ createdBy: 'QQ' }).one().id).toBe(100);
-            const db4 = db3.with({ tasks: [{ id: 100, createdBy: undefined }] }); // set to undefined
-            expect(db4.tasks.find({ createdBy: { isNull: true } }).one().id).toBe(100);
-            expect(db4.tasks.find({ createdBy: undefined }).one().id).toBe(100);
-            expect(db4.tasks.find({ createdBy: { in: [undefined] } }).one().id).toBe(100);
-        });
-
-        it("Should work with update which doesn't touch indexed field", () => {
-            const db = sampleDb.with({
-                tasks: [
-                    // existing, index field exists, should update index
-                    {
-                        id: 6, name: 'Test', isDone: true, isDraft: false, createdBy: 'XX',
-                    },
-                    // existing, index field omitted, should skip index update
-                    {
-                        id: 7, name: 'Test', isDone: true, isDraft: false,
-                    },
-                    // new, index field omitted, should be indexed as undefined
-                    {
-                        id: 123, name: 'Test', isDone: true, isDraft: false,
-                    },
-                ],
-            });
-            expect(db.tasks.find({ createdBy: 'XX' }).one().id).toBe(6);
-            expect(db.tasks.find({ createdBy: 'AS' }).one().id).toBe(7);
-            expect(db.tasks.find({ createdBy: undefined }).one().id).toBe(123);
-            const db2 = sampleDb.with({ tasks: [{ id: 123, createdBy: 'ZZ' }] });
-            expect(db2.tasks.find({ createdBy: 'ZZ' }).one().id).toBe(123);
-        });
-    });
-
-    describe('Composite key updates', () => {
-        it('Can merge new managers correctly', () => {
-            expect(sampleDb.managers.count()).toEqual(0);
-            const role1 = { subordinateId: 'JS', managerId: 'DT', role: 'RM' };
-            const role2 = { subordinateId: 'AS', managerId: 'DT', role: 'PM' };
-
-            // Add one role
-            const db1 = sampleDb.with({ managers: [role1] });
-            expect(db1.managers.one()).toEqual(role1);
-            expect(db1.managers).not.toBe(sampleDb.managers);
-
-            // Add second role
-            const db2 = db1.with({ managers: [role2] });
-            expect(db2.managers.find({ managerId: 'DT' }).count()).toEqual(2);
-            expect(db2.managers.byId(['JS', 'DT'])).toEqual(role1);
-            expect(db2.managers.find({ subordinateId: 'JS', managerId: 'DT' }).one()).toEqual(role1);
-            expect(db2.managers.find({ subordinateId: 'AS' }).one()).toEqual(role2);
-
-            // Update first role
-            const role1New = { ...role1, role: 'DM' };
-            const db3 = db2.with({ managers: [role1New] });
-            expect(db3.managers.find({ subordinateId: 'JS', managerId: 'DT' }).one()).toEqual(role1New);
-        });
-    });
-});

package/src/__tests__/dbRef.test.ts

@@ -1,100 +0,0 @@
-import {
-    sampleDb, sampleData, TasksDbRef,
-} from './TaskDb';
-import { DbRef } from '../index';
-import { delay } from '@epam/uui-test-utils';
-
-describe('db - DbRef query and updates', () => {
-    it('Get user by id', () => {
-        const db = new DbRef(sampleDb);
-        db.commitFetch(sampleData);
-        expect(db.db.users.byId('DT').name).toEqual('Daenerys Targaryen');
-    });
-
-    it('Basic update', () => {
-        const db = new DbRef(sampleDb);
-        db.commitFetch(sampleData);
-        db.commit({ users: [{ id: 'DT', name: 'Daenerys Snow' }] });
-        expect(db.db.users.byId('DT').name).toEqual('Daenerys Snow');
-    });
-
-    it('Revert changes', () => {
-        const db = new DbRef(sampleDb);
-        db.commitFetch(sampleData);
-        expect(db.db.users.byId('DT').name).toEqual('Daenerys Targaryen');
-        db.commit({ users: [{ id: 'DT', name: 'Daenerys Snow' }] });
-        expect(db.db.users.byId('DT').name).toEqual('Daenerys Snow');
-        db.revert();
-        expect(db.db.users.byId('DT').name).toEqual('Daenerys Targaryen');
-    });
-
-    it('Auto-saves changes', async () => {
-        const handleSave = jest.fn(async () => ({ submit: {} }));
-        const db = new TasksDbRef(handleSave);
-        db.commitFetch(sampleData);
-        const patch = { users: [{ id: 'DT', name: 'Daenerys Snow' }] };
-        db.commit(patch);
-        await delay(2);
-        expect(handleSave).toHaveBeenCalledTimes(1);
-        expect(handleSave).toHaveBeenCalledWith(patch);
-    });
-
-    it('Saves are throttled in auto-save mode', async () => {
-        const handleSave = jest.fn(async () => ({ submit: {} }));
-        const db = new TasksDbRef(handleSave);
-        db.commitFetch(sampleData);
-        const patch1 = { users: [{ id: 'DT', name: 'Daenerys Snow' }] };
-        db.commit(patch1);
-        const patch2 = { users: [{ id: 'DT', name: 'Daenerys' }] };
-        db.commit(patch2);
-        expect(handleSave).toHaveBeenCalledTimes(0);
-        await delay(2);
-        expect(handleSave).toHaveBeenCalledTimes(1);
-        expect(handleSave).toHaveBeenCalledWith(patch2);
-
-        // 2nd change
-        handleSave.mockClear();
-        db.commit(patch1);
-        expect(handleSave).toHaveBeenCalledTimes(0);
-        await delay(2);
-        expect(handleSave).toHaveBeenCalledTimes(1);
-        expect(handleSave).toHaveBeenCalledWith(patch1);
-    });
-
-    it('Manually saves changes', async () => {
-        const handleSave = jest.fn(async () => ({ submit: {} }));
-        const db = new TasksDbRef(handleSave);
-        db.setAutoSave(false);
-        db.commitFetch(sampleData);
-        const patch = { users: [{ id: 'DT', name: 'Daenerys Snow' }] };
-        db.commit(patch);
-        await delay(2);
-        expect(handleSave).not.toHaveBeenCalled();
-        await db.save();
-        expect(handleSave).toHaveBeenCalledWith(patch);
-    });
-
-    it('Pass-thru save errors', async () => {
-        const handleSave = jest.fn(async () => {
-            throw new Error();
-        });
-        const db = new TasksDbRef(handleSave);
-        db.setAutoSave(false);
-        const patch = { users: [{ id: 'DT', name: 'Daenerys Snow' }] };
-        db.commit(patch);
-        await expect(db.save()).rejects.toBeInstanceOf(Error);
-    });
-
-    describe('Basic lenses', () => {
-        it('update with entity lens', () => {
-            const db = new DbRef(sampleDb);
-            db.commitFetch(sampleData);
-            // const lens = db.entityLens('users', { id: 'DT' });
-            // expect(lens.get().name).eq("Daenerys Targaryen");
-            // lens.update({ name: "Daenerys Snow" });
-            // expect(lens.get().name).eq("Daenerys Snow");
-            // lens.prop('name').onValueChange("Ivan");
-            // expect(lens.get().name).eq("Ivan");
-        });
-    });
-});

package/src/__tests__/dbTable.test.ts

@@ -1,15 +0,0 @@
-import { emptyDb, sampleDb } from './TaskDb';
-
-describe('db - DbTable', () => {
-    describe('Basic updates', () => {
-        it('user name update', () => {
-            const users = sampleDb.tables.users;
-            const newUsers = users.with([{ id: 'AS', name: 'Ivan Ivanov' }]);
-            expect(newUsers.byId('AS').name).toEqual('Ivan Ivanov');
-            expect(users.byId('AS').name).toEqual('Arya Stark');
-            // DbTable is immutable, so shallow copy should be created at all levels.
-            expect(newUsers).not.toBe(users);
-            expect(newUsers.byId('AS')).not.toBe(users.byId('AS'));
-        });
-    });
-});

package/src/__tests__/dbViews.test.ts

@@ -1,76 +0,0 @@
-import {
-    emptyDb, sampleDb, TaskDbView, TaskDb, Task,
-} from './TaskDb';
-
-describe('db - Views', () => {
-    it('Should work with whole db as a view', () => {
-        const view: TaskDbView<TaskDb, void> = {
-            compute: (db) => db,
-        };
-
-        const baseResult = sampleDb.runView(view);
-        const updatedResult = sampleDb.with({ tasks: [{ id: 123, name: '123' }] }).runView(view);
-        const baseResult2 = sampleDb.runView(view);
-
-        expect(baseResult).toBe(baseResult2);
-        expect(baseResult).not.toBe(updatedResult);
-        expect(updatedResult.tables.tasks.byId(123).name).toBe('123');
-    });
-
-    it('Should correctly cache result', () => {
-        const view: TaskDbView<Task, number> = {
-            compute: jest.fn((db, id) => db.tasks.byId(id)),
-        };
-
-        sampleDb.runView(view, 1);
-
-        const baseResult = sampleDb.runView(view, 1);
-
-        const sampleDb2 = sampleDb.with({ tasks: [{ id: 1, name: 'updated' }] });
-
-        const result1 = sampleDb2.runView(view, 1);
-        const result2 = sampleDb2.runView(view, 1);
-        expect(baseResult).toBe(sampleDb.tasks.byId(1));
-        expect(result1).toBe(sampleDb2.tasks.byId(1));
-        expect(result1).not.toBe(baseResult);
-        expect(result1).toBe(result2);
-
-        expect(view.compute).toBeCalledTimes(2);
-    });
-
-    it('Should correctly reuse results when forked', () => {
-        const view: TaskDbView<Task, number> = {
-            compute: jest.fn((db, id) => db.tasks.byId(id)),
-        };
-
-        const db = emptyDb.with({ tasks: [{ id: 1, name: 'base' }] });
-        const baseResult = db.runView(view, 1);
-
-        expect(baseResult).toEqual({ id: 1, name: 'base' });
-
-        // Make three db versions:
-        // first updating a different entity
-        const sampleDb1 = db.with({ tasks: [{ id: 2, name: 'e2 - updated' }] });
-        // second - updating the same entity with the same value
-        const sampleDb2 = db.with({ tasks: [{ id: 1, name: 'base' }] });
-        // third - updating our entity with new value
-        const sampleDb3 = db.with({ tasks: [{ id: 1, name: 'updated' }] });
-
-        // In first db, the view should keep exactly same (===) existing value in the first fork
-        const result1 = sampleDb1.runView(view, 1);
-        expect(result1).toBe(baseResult);
-        expect(result1).toEqual({ id: 1, name: 'base' });
-
-        // In the second db, view should still return the same (===) object.
-        // It should re-compute the view, but find results the same as previous with deepEQ compare, and re-use previous results
-        const result2 = sampleDb2.runView(view, 1);
-        expect(result2).toBe(result1);
-        expect(result2).toEqual({ id: 1, name: 'base' });
-
-        // In the third db, view should return a new value
-        const result3 = sampleDb3.runView(view, 1);
-        expect(result3).toEqual({ id: 1, name: 'updated' });
-
-        expect(view.compute).toBeCalledTimes(4);
-    });
-});