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

package/src/__tests__/ixSet.perf.test.ts

@@ -0,0 +1,129 @@
+import { IxSet } from '../IxSet';
+import sortBy from 'lodash.sortby';
+import range from 'lodash.range';
+
+interface Person {
+    id: number;
+    name: string;
+    departmentId: number;
+    location?: string;
+}
+
+const alice = {
+    id: 1, name: 'Alice', departmentId: 1, location: 'UK',
+} as Person;
+const bob = {
+    id: 2, name: 'Bob', departmentId: 1, location: 'UK',
+} as Person;
+const sandra = {
+    id: 3, name: 'Sandra', departmentId: 1, location: 'UK',
+} as Person;
+const edward = {
+    id: 4, name: 'Edward', departmentId: 1, location: 'UK',
+} as Person;
+const pete = {
+    id: 5, name: 'Pete', departmentId: 1, location: 'US',
+} as Person;
+const jack = {
+    id: 6, name: 'Jack', departmentId: 2, location: 'UK',
+} as Person;
+const william = {
+    id: 7, name: 'William', departmentId: 2, location: 'US',
+} as Person;
+
+const john = {
+    id: 8, name: 'John', departmentId: 1, location: 'US',
+} as Person;
+
+const blankSet = new IxSet<Person, number>((i) => i.id, [{ fields: ['name'] }, { fields: ['departmentId', 'name'] }]);
+
+const smallSet = blankSet.with([
+    alice, bob, sandra, edward, pete, jack, william,
+]);
+
+describe.skip('db - IxSet Performance', () => {
+    let hugeSet = smallSet;
+    let test100Persons: Person[];
+    let test1KPersons: Person[];
+    let test10KPersons: Person[];
+    let test100KPersons: Person[];
+    let completeTestSetInArray: Person[];
+
+    // let test1MPersons: Person[];
+
+    // Generating and loading data is split into separate tests to see timing in JEST logs
+    it('Can generate huge data set', () => {
+        test100Persons = range(10, 110).map((id) => ({ id, name: 'Just Person', departmentId: 2 }));
+        test1KPersons = range(110, 1110).map((id) => ({ id, name: `Person ${id}`, departmentId: 3 }));
+        test10KPersons = range(1110, 11110).map((id) => ({ id, name: `Person ${id}`, departmentId: 3 }));
+        test100KPersons = range(111110, 111110).map((id) => ({ id, name: `Person ${id}`, departmentId: 3 }));
+        // test1MPersons = range(200000, 1200000).map((id) => ({ id, name: 'Person ' + id, departmentId: 4 }));
+
+        completeTestSetInArray = [
+            ...smallSet.query({}), ...test100Persons, ...test1KPersons, ...test10KPersons, ...test100KPersons,
+        ];
+    });
+
+    it('Can load 100 Persons', () => {
+        hugeSet = hugeSet.with(test100Persons);
+    });
+    it('Can load 1K Persons', () => {
+        hugeSet = hugeSet.with(test1KPersons);
+    });
+    it('Can load 10K Persons', () => {
+        hugeSet = hugeSet.with(test10KPersons);
+    });
+    it('Can load 100K Persons', () => {
+        hugeSet = hugeSet.with(test100KPersons);
+    });
+    // it("Can load 1M Persons", () => { hugeSet = hugeSet.with(test1MPersons); });
+
+    [
+        200, 1000, 100000, 111109,
+    ].forEach((id) => {
+        it(`Can find Person ${id} by name`, () => {
+            const result = hugeSet.queryOne({ filter: { name: `Person ${id}` } });
+            expect(result.id).toEqual(id);
+        });
+    });
+
+    it("Can find all 'Just Person' people", () => {
+        const result = hugeSet.query({ filter: { name: 'Just Person' } });
+        expect(result.length).toEqual(100);
+        expect(result[54].name).toEqual('Just Person');
+    });
+
+    it('Can find by DepartmentId sorted by name', () => {
+        expect(
+            hugeSet.query({
+                filter: { departmentId: 1 },
+                sorting: [{ field: 'name' }],
+            }),
+        ).toEqual([
+            alice, bob, edward, pete, sandra,
+        ]);
+    });
+
+    it('Can find by DepartmentId sorted by name  - with basic array', () => {
+        let result = completeTestSetInArray.filter((p) => p.departmentId === 1);
+        result = sortBy(result, 'name');
+        expect(result).toEqual([
+            alice, bob, edward, pete, sandra,
+        ]);
+    });
+
+    it('Can find by location and sort by name', () => {
+        expect(
+            hugeSet.query({
+                filter: { location: 'US' },
+                sorting: [{ field: 'name' }],
+            }),
+        ).toEqual([pete, william]);
+    });
+
+    it('Find by location and sort by name - with basic array', () => {
+        let result = completeTestSetInArray.filter((p) => p.location == 'US');
+        result = sortBy(result, 'name');
+        expect(result).toEqual([pete, william]);
+    });
+});

package/src/__tests__/ixSet.test.ts

@@ -0,0 +1,73 @@
+import { IxSet } from '../IxSet';
+
+interface Person {
+    id: number;
+    name: string;
+    departmentId: number;
+    location?: string;
+}
+
+const alice = {
+    id: 1, name: 'Alice', departmentId: 1, location: 'UK',
+} as Person;
+const bob = {
+    id: 2, name: 'Bob', departmentId: 1, location: 'UK',
+} as Person;
+const sandra = {
+    id: 3, name: 'Sandra', departmentId: 1, location: 'UK',
+} as Person;
+const edward = {
+    id: 4, name: 'Edward', departmentId: 1, location: 'UK',
+} as Person;
+const pete = {
+    id: 5, name: 'Pete', departmentId: 1, location: 'US',
+} as Person;
+const jack = {
+    id: 6, name: 'Jack', departmentId: 2, location: 'UK',
+} as Person;
+const william = {
+    id: 7, name: 'William', departmentId: 2, location: 'US',
+} as Person;
+
+const john = {
+    id: 8, name: 'John', departmentId: 1, location: 'US',
+} as Person;
+
+const blankSet = new IxSet<Person, number>((i) => i.id, [{ fields: ['name'] }, { fields: ['departmentId', 'name'] }]);
+
+const smallSet = blankSet.with([
+    alice, bob, sandra, edward, pete, jack, william,
+]);
+
+describe('db - IxSet', () => {
+    describe('Small data set', () => {
+        it('Can put some values', () => {
+            const set = blankSet.with([bob, alice]);
+            expect(set.byId(1).name).toBe(alice.name);
+        });
+
+        it('Can get byId', () => {
+            expect(smallSet.byId(2).name).toBe(bob.name);
+        });
+
+        it('Can find by department ID', () => {
+            const result = smallSet.query({ filter: { departmentId: 1 } });
+            expect(result.length).toEqual(5);
+        });
+
+        it('Can find Alice by name', () => {
+            expect(smallSet.query({ filter: { name: alice.name } })).toEqual([alice]);
+        });
+
+        it('Can add John and find him', () => {
+            const updated = smallSet.with([john]);
+            const result = updated.query({ filter: { name: john.name } });
+            expect(result.length).toEqual(1);
+            expect(result[0]).toEqual(john);
+        });
+
+        it('Can find by Name and DepartmentId', () => {
+            expect(smallSet.query({ filter: { name: bob.name, departmentId: bob.departmentId } })).toEqual([bob]);
+        });
+    });
+});

package/src/__tests__/listLoader.test.ts

@@ -0,0 +1,85 @@
+import {
+    emptyDb, TaskDb, Task, TaskDbTables,
+} from './TaskDb';
+import { DbRef } from '../DbRef';
+import { DbSaveResponse, DbPatch } from '../types';
+import { DataQuery, runDataQuery } from '@epam/uui-core';
+import range from 'lodash.range';
+
+const delay = (t: number) =>
+    new Promise((resolve) => {
+        setTimeout(resolve, t || 1);
+    });
+
+describe('db - list loaders', () => {
+    const testItems = range(200).map((id) => {
+        return {
+            id,
+            name: 'Task',
+            isDone: false,
+            createdBy: 'JS',
+            isDraft: false,
+            assignedTo: 'DT',
+        } as Task;
+    });
+
+    class TaskDbRef extends DbRef<TaskDbTables, TaskDb> {
+        constructor() {
+            super(emptyDb);
+        }
+
+        public saveCallback = jest.fn(() => Promise.resolve({ submit: {} }));
+        public apiCallback = jest.fn((rq: DataQuery<Task> & { t?: number }) => delay(rq?.t).then(() => runDataQuery(testItems, rq)));
+        protected savePatch(patch: DbPatch<TaskDbTables>): Promise<DbSaveResponse<TaskDbTables>> {
+            return Promise.resolve({ submit: {} });
+        }
+
+        public tasksLoader = this.makeListLoader({
+            api: this.apiCallback,
+            convertToPatch: (r) => ({ tasks: r.items }),
+        });
+    }
+
+    it('Should correctly process happy-path', async () => {
+        const dbRef = new TaskDbRef();
+        const r1 = dbRef.tasksLoader.load({ range: { from: 0, count: 10 } });
+        expect(r1.isComplete).toBe(false);
+        expect(r1.isLoading).toBe(true);
+        expect(dbRef.db.tasks.toArray()).toEqual([]);
+        await r1.promise;
+        expect(dbRef.apiCallback).toBeCalledTimes(1);
+        expect(r1.isLoading).toBe(false);
+        expect(r1.isComplete).toBe(true);
+        expect(dbRef.db.tasks.count()).toEqual(10);
+        r1.reload();
+        expect(r1.isComplete).toBe(true);
+        expect(r1.isLoading).toBe(true);
+        await r1.promise;
+        expect(dbRef.apiCallback).toBeCalledTimes(2);
+        expect(r1.isLoading).toBe(false);
+        expect(r1.isComplete).toBe(true);
+    });
+
+    it('Should correctly process overlapping ranges', async () => {
+        const dbRef = new TaskDbRef();
+        const r1 = dbRef.tasksLoader.load({ range: { from: 0, count: 100 } });
+        const r2 = dbRef.tasksLoader.load({ range: { from: 95, count: 20 } });
+        expect(r1.isComplete).toBe(false);
+        expect(r1.isLoading).toBe(true);
+        expect(r1.missing).toEqual({ range: { from: 0, count: 100 } });
+        expect(r2.isComplete).toBe(false);
+        expect(r2.isLoading).toBe(true);
+        expect(r2.missing).toEqual({ range: { from: 100, count: 15 } });
+        expect(dbRef.db.tasks.toArray()).toEqual([]);
+        await r1.promise;
+        await r2.promise;
+        expect(dbRef.apiCallback).toBeCalledTimes(2);
+        expect(dbRef.apiCallback).nthCalledWith(1, { range: { from: 0, count: 100 } });
+        expect(dbRef.apiCallback).nthCalledWith(2, { range: { from: 100, count: 15 } });
+        expect(r1.isComplete).toBe(true);
+        expect(r1.isLoading).toBe(false);
+        expect(r2.isComplete).toBe(true);
+        expect(r2.isLoading).toBe(false);
+        expect(dbRef.db.tasks.count()).toEqual(115);
+    });
+});

package/src/__tests__/loader.test.ts

@@ -0,0 +1,92 @@
+import { emptyDb, TaskDb, TaskDbTables, sampleData } from './TaskDb';
+import { DbRef } from '../DbRef';
+import { DbSaveResponse, DbPatch } from '../types';
+
+const delay = (t: number) =>
+    new Promise((resolve) => {
+        setTimeout(resolve, t || 1);
+    });
+
+describe('db - loaders', () => {
+    class TaskDbRef extends DbRef<TaskDbTables, TaskDb> {
+        constructor() {
+            super(emptyDb);
+        }
+
+        public saveCallback = jest.fn(() => Promise.resolve({ submit: {} }));
+        public apiCallback = jest.fn((rq: { ids: string[]; t?: number }) =>
+            delay(rq?.t).then(() => ({ items: sampleData.users.filter((u) => !rq?.ids || rq.ids.includes(u.id)) })));
+
+        protected savePatch(): Promise<DbSaveResponse<TaskDbTables>> {
+            return Promise.resolve({ submit: {} });
+        }
+
+        public tasksLoader = this.makeLoader({
+            api: this.apiCallback,
+            convertToPatch: (r) => ({ users: r.items }),
+        });
+    }
+
+    it('Should correctly process happy-path', async () => {
+        const dbRef = new TaskDbRef();
+        const r1 = dbRef.tasksLoader.load({ ids: ['JS'] });
+        expect(r1.isComplete).toBe(false);
+        expect(r1.isLoading).toBe(true);
+        expect(dbRef.db.users.toArray()).toEqual([]);
+        await r1.promise;
+        expect(dbRef.apiCallback).toBeCalledTimes(1);
+        expect(r1.isLoading).toBe(false);
+        expect(r1.isComplete).toBe(true);
+        expect(dbRef.db.users.count()).toEqual(1);
+        r1.reload();
+        expect(r1.isComplete).toBe(true);
+        expect(r1.isLoading).toBe(true);
+        await r1.promise;
+        expect(dbRef.apiCallback).toBeCalledTimes(2);
+        expect(r1.isLoading).toBe(false);
+        expect(r1.isComplete).toBe(true);
+    });
+
+    it('Same requests should not result same parallel requests', async () => {
+        const dbRef = new TaskDbRef();
+        let r1 = dbRef.tasksLoader.load({ ids: ['JS'] });
+        let r2 = dbRef.tasksLoader.load({ ids: ['JS'] });
+        expect(r1.isComplete).toBe(false);
+        expect(r1.isLoading).toBe(true);
+        expect(r2.isComplete).toBe(false);
+        expect(r2.isLoading).toBe(true);
+        await r1.promise;
+        await r2.promise;
+        expect(dbRef.apiCallback).toBeCalledTimes(1);
+        r1 = dbRef.tasksLoader.load({ ids: ['JS'] });
+        r2 = dbRef.tasksLoader.load({ ids: ['JS'] });
+        expect(r1.isComplete).toBe(true);
+        expect(r1.isLoading).toBe(false);
+        expect(r2.isComplete).toBe(true);
+        expect(r2.isLoading).toBe(false);
+    });
+
+    it('Different requests should be processed separately', async () => {
+        const dbRef = new TaskDbRef();
+        const r1 = dbRef.tasksLoader.load({ ids: ['JS'] });
+        const r2 = dbRef.tasksLoader.load({ ids: ['DT'], t: 2 });
+        expect(r1).not.toBe(r2);
+        expect(r1.isComplete).toBe(false);
+        expect(r1.isLoading).toBe(true);
+        expect(r2.isComplete).toBe(false);
+        expect(r2.isLoading).toBe(true);
+        await r1.promise;
+        expect(r1.isComplete).toBe(true);
+        expect(r1.isLoading).toBe(false);
+        expect(r2.isComplete).toBe(false);
+        expect(r2.isLoading).toBe(true);
+        expect(dbRef.db.users.count()).toEqual(1);
+        await r2.promise;
+        expect(dbRef.apiCallback).toBeCalledTimes(2);
+        expect(r1.isComplete).toBe(true);
+        expect(r1.isLoading).toBe(false);
+        expect(r2.isComplete).toBe(true);
+        expect(r2.isLoading).toBe(false);
+        expect(dbRef.db.users.count()).toEqual(2);
+    });
+});

package/src/__tests__/patchHelpers.test.ts

@@ -0,0 +1,202 @@
+import {
+    getId, isClientOnly, unionPatches, mergeEntityPatches, flattenResponse, isNew, hasServerFields, getParentEntities,
+} from '../patchHelpers';
+import {
+    emptyDb, sampleDb, Task, User, Manager, View, TaskDbTables,
+} from './TaskDb';
+import { DbPatch } from '../types';
+import orderBy from 'lodash.orderby';
+import { IClientIdsMap } from '..';
+
+const task: Partial<Task> = {
+    id: 100500,
+};
+
+const user: User = {
+    id: 'AB',
+    name: 'Cruella de Vil',
+    title: 'Villain',
+    sex: 'f',
+    orderStr: 'h',
+};
+
+const manager: Partial<Manager> = {
+    managerId: 'AB',
+    subordinateId: 'CD',
+};
+
+const view: View = {
+    id: 10,
+    title: 'list',
+};
+
+const clientOnlyView: View = {
+    id: -10,
+    title: 'list',
+};
+
+describe('db - patchHelpers', () => {
+    const newClientIdsMap: IClientIdsMap = {
+        clientToServer: (id: number): any => undefined,
+        serverToClient: (tableName: string, id: any): any => undefined,
+        clientToServerDataFilter: null,
+        clientToServerRequest: null,
+    };
+
+    const existingClientIdsMap: IClientIdsMap = {
+        clientToServer: (id: number): any => id,
+        serverToClient: (tableName: string, id: any): any => id,
+        clientToServerDataFilter: null,
+        clientToServerRequest: null,
+    };
+
+    describe('getId', () => {
+        it('should return numeric id', () => {
+            expect(getId(task, emptyDb.tables.tasks.schema)).toEqual(task.id);
+        });
+
+        it('should return string id', () => {
+            expect(getId(user, emptyDb.tables.users.schema)).toEqual(user.id);
+        });
+
+        it('should return compound id', () => {
+            expect(getId(manager, emptyDb.tables.managers.schema)).toEqual([manager.subordinateId, manager.managerId]);
+        });
+    });
+
+    describe('isClientOnly', () => {
+        it('should return false if isClientOnly is not provided', () => {
+            expect(isClientOnly(user, emptyDb.tables.users.schema)).toEqual(false);
+        });
+
+        it('should return true if isClientOnly == true', () => {
+            expect(isClientOnly(view, emptyDb.tables.views.schema)).toEqual(true);
+        });
+
+        it('should return result of isClientOnly function', () => {
+            expect(isClientOnly(view, emptyDb.tables.viewsFn.schema)).toEqual(false);
+            expect(isClientOnly(clientOnlyView, emptyDb.tables.viewsFn.schema)).toEqual(true);
+        });
+    });
+
+    describe('unionPatches', () => {
+        it('should union patches', () => {
+            const patches: DbPatch<TaskDbTables>[] = [
+                {
+                    users: [{ id: 'AB' }],
+                }, {
+                    users: [{ id: 'CD' }],
+                },
+            ];
+
+            const result = unionPatches(patches);
+            expect(result).toEqual({ users: [{ id: 'AB' }, { id: 'CD' }] });
+        });
+    });
+
+    describe('mergeEntityPatches', () => {
+        it('should merge entities with the same ids', () => {
+            const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+            const patch: DbPatch<TaskDbTables> = {
+                users: [{ id: 'YZ', name: 'Yakov Zhmurov' }, { id: 'YZ', sex: 'm' }],
+            };
+
+            const result = mergeEntityPatches(emptyDb.tables, patch);
+            expect(result).toEqual({ users: [{ id: 'YZ', name: 'Yakov Zhmurov', sex: 'm' }] });
+            expect(spy).not.toHaveBeenCalled();
+        });
+
+        it('should log console warning if properties of entities intersect', () => {
+            const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+            const patch: DbPatch<TaskDbTables> = {
+                users: [{ id: 'YZ', name: 'Yakov Zhmurov' }, { id: 'YZ', name: 'Ilya Kuznetsov' }],
+            };
+
+            mergeEntityPatches(emptyDb.tables, patch);
+            expect(spy).toHaveBeenCalled();
+        });
+    });
+
+    describe('flattenResponse', () => {
+        it('should flatten provided object', () => {
+            const response: any = {
+                users: [
+                    {
+                        id: 'YZ',
+                        name: 'Yakov Zhmurov',
+                        __typename: 'User',
+                        manager: { id: 'AU', name: 'Andrei Urban', __typename: 'User' },
+                        subordinates: [{ id: 'PS', name: 'Pavel Shchur', __typename: 'User' }, { id: 'IK', name: 'Ilya Kuznetsov', __typename: 'User' }],
+                    },
+                ],
+            };
+
+            const users = orderBy(flattenResponse(response, emptyDb.tables).users, 'id');
+            expect(users).toEqual([
+                { id: 'AU', name: 'Andrei Urban', __typename: 'User' }, { id: 'IK', name: 'Ilya Kuznetsov', __typename: 'User' }, { id: 'PS', name: 'Pavel Shchur', __typename: 'User' }, { id: 'YZ', name: 'Yakov Zhmurov', __typename: 'User' },
+            ]);
+        });
+
+        it('should process non-entity arrays and objects as fields', () => {
+            const processTask: any = {
+                id: 'YZ',
+                tags: ['important', 'db'],
+                // details: { test: 'test' }, // FIXME
+                __typename: 'Task',
+            };
+
+            const result = flattenResponse(processTask, emptyDb.tables);
+            expect(result.tasks).toEqual([processTask]);
+        });
+    });
+
+    describe('isNew', () => {
+        it('should return false if no server-client mapping exists', () => {
+            expect(isNew(user, emptyDb.tables.users.schema, newClientIdsMap)).toEqual(true);
+        });
+
+        it('should return true if server-client mapping exists', () => {
+            expect(isNew(user, emptyDb.tables.users.schema, existingClientIdsMap)).toEqual(false);
+        });
+    });
+
+    describe('hasServerFields', () => {
+        it('should return false if entity is client only', () => {
+            expect(hasServerFields(view, emptyDb.tables.views.schema, newClientIdsMap, emptyDb.tables)).toEqual(false);
+            expect(hasServerFields(view, emptyDb.tables.views.schema, existingClientIdsMap, emptyDb.tables)).toEqual(false);
+            expect(hasServerFields(clientOnlyView, emptyDb.tables.viewsFn.schema, newClientIdsMap, emptyDb.tables)).toEqual(false);
+            expect(hasServerFields(clientOnlyView, emptyDb.tables.viewsFn.schema, existingClientIdsMap, emptyDb.tables)).toEqual(false);
+        });
+
+        it('should return true if entity has id only and it is a new entity', () => {
+            expect(hasServerFields({ id: 100 }, emptyDb.tables.tasks.schema, newClientIdsMap, emptyDb.tables)).toEqual(true);
+        });
+
+        it('should return false if entity has id only and it is an existing entity', () => {
+            expect(hasServerFields({ id: 100 }, emptyDb.tables.tasks.schema, existingClientIdsMap, emptyDb.tables)).toEqual(false);
+        });
+
+        it('should return false if entity has readonly fields only', () => {
+            expect(hasServerFields({ id: 100, createdBy: 'Ilya Kuznetsov' }, emptyDb.tables.tasks.schema, existingClientIdsMap, emptyDb.tables)).toEqual(false);
+        });
+
+        it('should return false if entity has client-only fields only', () => {
+            expect(hasServerFields({ id: 100, isDraft: false }, emptyDb.tables.tasks.schema, existingClientIdsMap, emptyDb.tables)).toEqual(false);
+        });
+    });
+
+    describe('getParentEntities', () => {
+        it('should return parent aggregate entities only', () => {
+            const parents = getParentEntities(
+                {
+                    tasks: [{ id: 1 }],
+                },
+                sampleDb.tables,
+            );
+
+            expect(parents.users).toEqual([{ id: 'DT' }]);
+        });
+    });
+});

package/src/__tests__/tempIds.test.ts

@@ -0,0 +1,98 @@
+import { emptyDb } from './TaskDb';
+import { TempIdMap, getTempId, isTempId } from '../tempIds';
+
+describe('tempIds', () => {
+    beforeEach(() => {
+        // testTask.mockReset();
+    });
+
+    it('generates ids', () => {
+        const id1 = getTempId();
+        const id2 = getTempId();
+        expect(id1).not.toBe(id2);
+    });
+
+    it('isTempId works', () => {
+        const id = getTempId();
+        expect(isTempId(id)).toBe(true);
+        expect(isTempId(0)).toBe(false);
+        expect(isTempId(1)).toBe(false);
+        expect(isTempId(null)).toBe(false);
+    });
+
+    it('serverToClientPatch - should re-map PK', () => {
+        const ids = new TempIdMap(emptyDb);
+
+        const patch = ids.serverToClientPatch({
+            tasks: [{ id: 1, name: 'Test', isDone: true }],
+        });
+
+        expect(patch.tasks).toEqual([
+            {
+                id: ids.serverToClient('tasks', 1),
+                name: 'Test',
+                isDone: true,
+            },
+        ]);
+    });
+
+    it('serverToClientPatch - should re-map FK', () => {
+        const ids = new TempIdMap(emptyDb);
+
+        const patch = ids.serverToClientPatch({
+            tasks: [
+                {
+                    id: 1, name: 'Test', assignedTo: 'J', isDone: false,
+                },
+            ],
+            users: [{ id: 'J', name: 'John' }],
+        });
+
+        expect(patch.tasks).toEqual([
+            {
+                id: ids.serverToClient('tasks', 1),
+                assignedTo: ids.serverToClient('users', 'J'),
+                name: 'Test',
+                isDone: false,
+            },
+        ]);
+    });
+
+    it('serverToClientPatch - handles defaults', () => {
+        const ids = new TempIdMap(emptyDb);
+
+        const patch = ids.serverToClientPatch({
+            tasks: [{ id: 1, name: 'Test' }],
+        });
+
+        expect(patch.tasks).toEqual([
+            {
+                id: ids.serverToClient('tasks', 1),
+                name: 'Test',
+                isDone: false,
+            },
+        ]);
+    });
+
+    it('clientToServerPatch - should re-map PKs and FKs back, and apply toServer conversions', () => {
+        const ids = new TempIdMap(emptyDb);
+
+        const initialPatch = {
+            tasks: [
+                {
+                    id: 1, estimate: '1' as any, assignedTo: 'JS', isDone: true,
+                }, { id: 2, estimate: '2' as any, isDone: false },
+            ],
+            users: [{ id: 'JS', name: 'John Snow' }, { id: 'DT', name: 'Daenerys Targaryen' }],
+            managers: [{ subordinateId: 'JS', managerId: 'DT' }],
+        };
+
+        const clientPatch = ids.serverToClientPatch(initialPatch);
+
+        expect(clientPatch.managers[0].managerId).toBe(ids.serverToClient('managers', 'DT'));
+
+        const serverPatch = ids.clientToServerPatch(clientPatch);
+
+        expect(serverPatch).toEqual(initialPatch);
+    });
+});

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './Db';
+export * from './DbTable';
+export * from './DbRef';
+export * from './tempIds';
+export * from './utils';
+export * from './patchHelpers';
+export * from './reactHooks';