@epam/uui-db 5.3.0-rc.1 → 5.3.0

package/src/__tests__/TaskDb.ts

@@ -0,0 +1,187 @@
+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

@@ -0,0 +1,293 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,76 @@
+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);
+    });
+});