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

package/src/patchHelpers.ts

@@ -0,0 +1,254 @@
+import { Db } from './Db';
+import {
+    DbPatch, DbTablesSet, DbRelationType, DbEntitySchema, DbPkFieldType,
+} from './types';
+import { DbTable } from './DbTable';
+import * as I from 'immutable';
+import { objectKeys } from './utils';
+import groupBy from 'lodash.groupby';
+import map from 'lodash.map';
+import merge from 'lodash.merge';
+import countBy from 'lodash.countby';
+import filter from 'lodash.filter';
+import forEach from 'lodash.foreach';
+import pick from 'lodash.pick';
+import { IClientIdsMap } from './tempIds';
+
+export function unionPatches<TTables extends DbTablesSet<TTables>>(patches: DbPatch<TTables>[]): DbPatch<TTables> {
+    const result: DbPatch<TTables> = {};
+
+    patches.forEach((patch) => {
+        objectKeys(patch).forEach((tableName) => {
+            result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
+        });
+    });
+
+    return result;
+}
+
+export function mergeEntityPatches<TTables extends DbTablesSet<TTables>>(tables: TTables, patch: DbPatch<TTables>): DbPatch<TTables> {
+    const result: DbPatch<TTables> = {};
+
+    objectKeys(patch).forEach((key) => {
+        const table = tables[key];
+        const groupedEntities = groupBy(patch[key], (item) => table.getId(item));
+        const tablePatch = map(groupedEntities, (entities) => {
+            const tablePatchResult = merge({}, ...entities);
+
+            if (process.env.NODE_ENV !== 'production') {
+                const props = objectKeys(tablePatchResult).filter(
+                    (prop) =>
+                        Object.keys(
+                            countBy(
+                                entities.filter((entity) => entity[prop as string] !== undefined),
+                                (entity) => entity[prop as string],
+                            ),
+                        ).length > 1,
+                );
+                if (props.length) {
+                    console.warn('mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n', ...entities);
+                }
+            }
+
+            return tablePatchResult;
+        });
+
+        result[key] = tablePatch;
+    });
+
+    return result;
+}
+
+function flattenResponseHelper<TTables extends DbTablesSet<any>>(result: DbPatch<TTables>, object: any, tablesByTypeName: Record<string, DbTable<any, any, any>>) {
+    if (Array.isArray(object)) {
+        object.forEach((item) => flattenResponseHelper(result, item, tablesByTypeName));
+    } else if (typeof object === 'object') {
+        const clone: any = {};
+        let tableKey;
+        let fields: { [id: string]: any } = {};
+
+        if ('__typename' in object) {
+            const table = tablesByTypeName[object.__typename];
+            if (table) {
+                tableKey = table.schema.tableName as string;
+                fields = table.schema.fields;
+            }
+        }
+
+        for (const key in object) {
+            const value = object[key];
+            const field = fields[key];
+
+            if (
+                (field && !!field.disableFlatten)
+                || typeof value !== 'object'
+                || value === null
+                || (Array.isArray(value) && value.every((item) => typeof item !== 'object'))
+            ) {
+                clone[key] = value;
+            } else {
+                flattenResponseHelper(result, value, tablesByTypeName);
+            }
+        }
+
+        if (tableKey) {
+            result[tableKey].push(clone);
+        }
+    }
+}
+
+export function flattenResponse<TTables extends DbTablesSet<any>>(response: any, tables: TTables): DbPatch<TTables> {
+    const result: DbPatch<TTables> = {};
+
+    const tablesByTypeName: Record<string, DbTable<any, any, any>> = {};
+    Object.values(tables).forEach((table) => (tablesByTypeName[table.schema.typeName] = table));
+    objectKeys(tables).forEach(() => tablesByTypeName);
+
+    objectKeys(tables).forEach((key) => (result[key] = []));
+
+    flattenResponseHelper(result, response, tablesByTypeName);
+    return result;
+}
+
+export function isPatchBlank<TTables extends DbTablesSet<TTables>>(patch: DbPatch<TTables>): boolean {
+    return !objectKeys(patch).some((key) => patch[key].length > 0);
+}
+
+/**
+ * Given several patches, creates a new single patch with all fields from all entities in all patches.
+ */
+export function makeCumulativePatch<TTables extends DbTablesSet<TTables>>(
+    updatedDb: Db<TTables>,
+    patches: DbPatch<TTables>[],
+    clientIdsMap: IClientIdsMap,
+): DbPatch<TTables> {
+    const result: DbPatch<TTables> = {};
+
+    objectKeys(updatedDb.tables).forEach((entityName) => {
+        const table = updatedDb.tables[entityName];
+        const schema = table.schema;
+
+        let ids = I.Set();
+        patches.forEach((patch) => {
+            const filteredPatch = (patch[entityName] || []).filter((entity) => hasServerFields(entity, schema, clientIdsMap, updatedDb.tables));
+            ids = ids.union(filteredPatch.map((e) => table.getId(e)));
+        });
+
+        const entities = ids
+            .map((id) => table.byId(id))
+            .filter((e) => !isClientOnly(e, schema))
+            .toArray();
+
+        if (entities.length > 0) {
+            result[entityName] = entities;
+        }
+    });
+
+    return result;
+}
+
+export function isClientOnly<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: T, schema: DbEntitySchema<T, TId, TTables>) {
+    if (typeof schema.isClientOnly === 'function') {
+        return schema.isClientOnly(entity);
+    }
+
+    return !!schema.isClientOnly;
+}
+
+export function getId<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: Partial<T>, schema: DbEntitySchema<T, TId, TTables>): TId {
+    if (typeof schema.primaryKey == 'string') {
+        return (entity as any)[schema.primaryKey] as TId;
+    }
+
+    const result: (string | number)[] = [];
+    forEach(pick(entity, schema.primaryKey), (value) => {
+        result.push(value as unknown as string | number);
+    });
+
+    return result as TId;
+}
+
+export function isNew<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(
+    entity: Partial<T>,
+    schema: DbEntitySchema<T, TId, TTables>,
+    clientIdsMap: IClientIdsMap,
+) {
+    const id = getId(entity, schema);
+    return !clientIdsMap.clientToServer(id as number);
+}
+
+export function hasServerFields<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(
+    entity: Partial<T>,
+    schema: DbEntitySchema<T, TId, TTables>,
+    clientIdsMap: IClientIdsMap,
+    tables: TTables,
+) {
+    const fullEntity = {
+        ...(tables[schema.tableName].byId((entity as any).id) || {}),
+        ...entity,
+    };
+
+    if (isClientOnly(fullEntity, schema)) {
+        return false;
+    }
+
+    return objectKeys(entity).some((fieldName) => {
+        const fieldSchema = schema.fields[fieldName];
+        return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
+    });
+}
+
+export function getParentEntities<TTables extends DbTablesSet<TTables>>(patch: DbPatch<TTables>, tables: TTables): DbPatch<TTables> {
+    const dependenciesPatch: DbPatch<TTables> = {};
+    objectKeys(patch).forEach((key) => {
+        const table = tables[key];
+        const tableSchema = table.schema;
+
+        const fields = filter(
+            map(tableSchema.fields, (field, name) => ({ ...field, name })),
+            (field) => field.fk && field.fk.relationType == DbRelationType.Aggregation,
+        );
+
+        const tablePatch = patch[key];
+        fields.forEach((field) => {
+            const {
+                fk: { tableName },
+                name,
+            } = field;
+            tablePatch.forEach((entity) => {
+                const actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName) as keyof TTables;
+                const dbEntity = table.byId(table.getId(entity));
+                const parentEntity = tables[actualTableName].byId(dbEntity[name]);
+                const idFields = pick(parentEntity, tables[actualTableName].schema.primaryKey);
+                if (parentEntity) {
+                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
+                    dependenciesPatch[actualTableName].push(idFields as any);
+                }
+            });
+        });
+    });
+    return dependenciesPatch;
+}
+
+export function getEntityParentDependencies<TEntity, TTables extends DbTablesSet<TTables>>(
+    entity: Partial<TEntity>,
+    entityName: keyof TTables,
+    tables: TTables,
+): DbPatch<TTables> {
+    let patch = { [entityName]: [entity] } as DbPatch<TTables>;
+    const resultPatches: DbPatch<TTables>[] = [];
+
+    while (true) {
+        const parents = getParentEntities(patch, tables);
+        if (isPatchBlank(parents)) {
+            break;
+        }
+        resultPatches.push(parents);
+        patch = parents;
+    }
+
+    let result = unionPatches([patch, ...resultPatches]);
+    result = mergeEntityPatches(tables, result);
+
+    return result;
+}

package/src/reactHooks.ts

@@ -0,0 +1,28 @@
+import {
+    useState, createContext, useContext, useMemo, useEffect,
+} from 'react';
+import { DbRef } from './DbRef';
+import { DbViewOptions } from '.';
+
+export const DbContext = createContext(null);
+
+export function useDbRef<TDbRef extends DbRef<any, any>>() {
+    return useContext(DbContext) as TDbRef;
+}
+
+export function useDbView<TDb, TResult, TParams = void, TDependencies = void>(
+    fn: (db: TDb, params: TParams, dependencies: TDependencies) => TResult,
+    params?: TParams,
+    options?: DbViewOptions<TDb, TResult, TParams, TDependencies>,
+): TResult {
+    const dbRef = useDbRef();
+    const [state, setState] = useState<TResult>();
+    const subscription = useMemo(() => dbRef.subscribe<TResult, TParams, TDependencies>({ compute: fn, ...options }, params, setState), []);
+    subscription.update(params);
+
+    useEffect(() => {
+        return () => subscription.unsubscribe();
+    }, []);
+
+    return subscription.currentValue;
+}

package/src/tempIds.tsx

@@ -0,0 +1,236 @@
+import {
+    DbTablePatch, DbTablesSet, DbPatch, DbFieldSchema, DbSaveResponse,
+} from './types';
+import { Db } from './Db';
+import { objectKeys } from './utils';
+import { DataQueryFilter, DataQueryFilterCondition } from '@epam/uui-core';
+
+let lastTempId = -1;
+
+export function getTempId() {
+    return --lastTempId;
+}
+
+export function isTempId(val: any): val is number {
+    return typeof val === 'number' && val < 0;
+}
+
+export interface IClientIdsMap {
+    clientToServer(id: number): any;
+    serverToClient(tableName: string, id: any): number;
+    clientToServerRequest<T>(request: T): T;
+    clientToServerDataFilter(filter: DataQueryFilter<any>): DataQueryFilter<any>;
+}
+
+export class TempIdMap<TTables extends DbTablesSet<TTables>> implements IClientIdsMap {
+    private serverToClientIds = new Map<keyof TTables, Map<any, number>>();
+    private clientToServerIds = new Map<number, any>();
+    constructor(private db: Db<TTables>) {}
+    public clientToServer = (id: number): any => this.clientToServerIds.get(id);
+    public serverToClient = (tableName: string, id: any): number => this.getServerToClientMap(tableName as any).get(id);
+    public clientToServerRequest = (request: any) => {
+        request = { ...request };
+
+        if (request.filter) {
+            request.filter = this.clientToServerDataFilter(request.filter);
+        }
+
+        return request;
+    };
+
+    public clientToServerDataFilter = (filter: DataQueryFilter<any>) => {
+        filter = { ...filter };
+        const keys = Object.keys(filter);
+
+        // I hope that we can rely that there won't be any negative numbers, which are not IDs, in queries.
+        // We need to invent better heuristics or a schema otherwise.
+        const clientToServer = (id: number) => {
+            const found = this.clientToServer(id);
+            if (found) {
+                return found;
+            } else {
+                return id;
+            }
+        };
+
+        for (let n = 0; n < keys.length; n++) {
+            const key = keys[n];
+            let condition = filter[key] as DataQueryFilterCondition<any>;
+            if (condition != null && typeof condition === 'object') {
+                condition = { ...condition };
+                if ('in' in condition && Array.isArray(condition.in) && condition.in.length) {
+                    condition.in = condition.in.map(clientToServer);
+                }
+            } else {
+                condition = clientToServer(condition);
+            }
+            filter[key] = condition;
+        }
+        return filter;
+    };
+
+    private copyPatch(patch: DbPatch<TTables>) {
+        const newPatch = { ...patch };
+
+        objectKeys(patch).forEach((tableName) => {
+            const tablePatch: DbTablePatch<any> = patch[tableName].map((entityPatch) => ({ ...entityPatch }));
+            newPatch[tableName] = tablePatch;
+        });
+
+        return newPatch;
+    }
+
+    // Iterate thru every field in every patch for every table, matching certain field criteria. The patch is mutated!
+    protected mapFields(
+        patch: DbPatch<TTables>,
+        filter: (schema: DbFieldSchema<any, any>, name: string) => boolean,
+        callback: (fieldName: any, fieldSchema: DbFieldSchema<any, any>, fieldValue: any, entityPatch: any, tableName: keyof TTables) => void,
+    ): void {
+        objectKeys(patch).forEach((tableName) => {
+            const schema = this.db.tables[tableName].schema;
+            const fields = objectKeys(schema.fields || [])
+                .map((fieldName) => {
+                    const fieldSchema = schema.fields[fieldName as any];
+                    if (filter(fieldSchema, fieldName as string)) {
+                        return { name: fieldName, schema: fieldSchema };
+                    }
+                })
+                .filter((f) => !!f);
+
+            if (!fields.length) {
+                return;
+            }
+
+            patch[tableName].forEach((entityPatch) => {
+                for (let n = 0; n < fields.length; n++) {
+                    const field = fields[n];
+
+                    const fieldValue = entityPatch[field.name as any];
+
+                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
+                }
+            });
+        });
+    }
+
+    protected getServerToClientMap(tableName: keyof TTables) {
+        const existing = this.serverToClientIds.get(tableName);
+
+        if (existing) {
+            return existing;
+        } else {
+            const newMap = new Map();
+            this.serverToClientIds.set(tableName, newMap);
+            return newMap;
+        }
+    }
+
+    public serverToClientPatch(patch: DbPatch<TTables>) {
+        patch = this.copyPatch(patch);
+
+        // We map PK in a separate pass, as we need to remap all PKs before re-mapping FKs
+        this.mapFields(
+            patch,
+            (f) => f.isGenerated,
+            (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+                let clientId = this.getServerToClientMap(tableName).get(fieldValue);
+                if (!clientId) {
+                    clientId = getTempId();
+                    this.clientToServerIds.set(clientId, fieldValue);
+                    this.getServerToClientMap(tableName).set(fieldValue, clientId);
+                }
+                entityPatch[fieldName] = clientId;
+            },
+        );
+
+        this.mapFields(
+            patch,
+            (f) => !!(f.fk || f.default != null || f.toClient),
+            (fieldName, fieldSchema, fieldValue, entityPatch) => {
+                let isUndefined = typeof fieldValue === 'undefined';
+
+                if (fieldSchema.default != null && fieldValue == null) {
+                    fieldValue = fieldSchema.default;
+                    isUndefined = false;
+                }
+
+                if (fieldSchema.fk && fieldValue != null) {
+                    const fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
+                    let clientId = this.getServerToClientMap(fkTableName as keyof TTables).get(fieldValue);
+                    if (!clientId) {
+                        clientId = getTempId();
+                        this.clientToServerIds.set(clientId, fieldValue);
+                        this.getServerToClientMap(fkTableName as keyof TTables).set(fieldValue, clientId);
+                    }
+                    fieldValue = clientId;
+                }
+
+                if (!isUndefined && fieldSchema.toClient) {
+                    fieldValue = fieldSchema.toClient(fieldValue);
+                }
+
+                if (!isUndefined) {
+                    entityPatch[fieldName] = fieldValue;
+                }
+            },
+        );
+
+        return patch;
+    }
+
+    public clientToServerPatch(patch: DbPatch<TTables>) {
+        patch = this.copyPatch(patch);
+
+        this.mapFields(
+            patch,
+            (f) => f.isGenerated || !!f.fk,
+            (fieldName, fieldSchema, fieldValue, entityPatch) => {
+                if (fieldValue != null) {
+                    const existingId = this.clientToServerIds.get(fieldValue);
+                    if (existingId) {
+                        entityPatch[fieldName] = existingId;
+                    }
+                }
+            },
+        );
+
+        this.mapFields(
+            patch,
+            (f) => !(f.isClientOnly || f.isReadOnly) && !!f.toServer,
+            (fieldName, fieldSchema, _, entityPatch) => {
+                entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
+            },
+        );
+
+        this.mapFields(
+            patch,
+            (meta) => meta.isClientOnly || meta.isReadOnly,
+            (fieldName, _, __, entityPatch) => {
+                delete entityPatch[fieldName];
+            },
+        );
+
+        return patch;
+    }
+
+    public appendServerMapping(response: DbSaveResponse<TTables>) {
+        objectKeys(response.submit).forEach((tableName) => {
+            if (this.db.tables[tableName]) {
+                const tablePatch = response.submit[tableName];
+                if (tablePatch) {
+                    const serverToClientIds = this.getServerToClientMap(tableName);
+                    const table = this.db.tables[tableName];
+
+                    tablePatch.forEach((patch) => {
+                        if (isTempId(patch.id)) {
+                            const clientId = patch.id;
+                            const serverId = table.getId(patch.payload);
+                            serverToClientIds.set(serverId, clientId);
+                            this.clientToServerIds.set(clientId, serverId);
+                        }
+                    });
+                }
+            }
+        });
+    }
+}

package/src/types.ts

@@ -0,0 +1,126 @@
+import { DataQuery } from '@epam/uui-core';
+import { DbTable } from './DbTable';
+import { IClientIdsMap } from './tempIds';
+
+export type DbTablesSet<TTables extends DbTablesSet<TTables>> = { [TEntityName in keyof TTables]: DbTable<any, any, TTables> };
+
+export type DbTablePatch<TEntity> = Partial<TEntity>[];
+
+export type DbTableEntityByTable<TTable, TTables extends DbTablesSet<TTables>> = TTable extends DbTable<infer TEntity, any, TTables> ? TEntity : void;
+export type DbTableIdByTable<TTable, TTables extends DbTablesSet<TTables>> = TTable extends DbTable<any, infer TId, TTables> ? TId : void;
+type DbTablePatchByTable<TTable, TTables extends DbTablesSet<TTables>> = DbTablePatch<DbTableEntityByTable<TTable, TTables>>;
+
+export type DbPatch<TTables extends DbTablesSet<TTables>> = { [TEntityName in keyof TTables]?: DbTablePatchByTable<TTables[TEntityName], TTables> };
+
+export enum DbRelationType {
+    Aggregation,
+    Association
+}
+
+export type DbFieldFk<TEntity> = {
+    tableName: string | ((entity: TEntity) => string);
+    relationType: DbRelationType;
+};
+
+export interface DbFieldSchema<TField extends keyof TEntity, TEntity> {
+    fk?: DbFieldFk<TEntity>;
+    isGenerated?: boolean;
+    isClientOnly?: boolean;
+    isReadOnly?: boolean;
+    default?: TEntity[TField];
+    toServer?: (value: TEntity[TField]) => TEntity[TField];
+    toClient?: (value: TEntity[TField]) => TEntity[TField];
+    disableFlatten?: boolean;
+}
+
+export type DbPkFieldType = string | number | (string | number)[];
+
+export type BeforeUpdateContext<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> = {
+    clientIdsMap: IClientIdsMap;
+    schema: DbEntitySchema<TEntity, TId, TTables>;
+    tables: DbTablesSet<TTables>;
+};
+
+type DbEntityBeforeUpdateResult<TEntity, TTables extends DbTablesSet<TTables>> = {
+    entity: TEntity;
+    dependentEntities?: DbPatch<TTables>;
+};
+
+type DbTableIndexDefinition<TEntity> = keyof TEntity;
+
+export type DbEntitySchema<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> = {
+    tableName: keyof TTables;
+    typeName: string;
+    searchBy?: (keyof TEntity)[];
+    fields?: Partial<{ [TField in keyof TEntity]: DbFieldSchema<TField, TEntity> }>;
+    isClientOnly?: boolean | ((entity: Partial<TEntity>) => boolean);
+    beforeUpdate?: (entity: TEntity, context: BeforeUpdateContext<TEntity, TId, TTables>) => DbEntityBeforeUpdateResult<TEntity, TTables>;
+    primaryKey: TId extends any[] ? KeysOfType<TEntity, string | number>[] : KeysOfType<TEntity, string | number>;
+    indexes?: DbTableIndexDefinition<TEntity>[];
+    deleteFlag?: keyof TEntity;
+};
+
+export type DbSchema<TTables extends DbTablesSet<TTables>> = {
+    [TTypeName in keyof TTables]: DbEntitySchema<any, any, TTables>;
+};
+
+export interface DbQuery<TEntity> extends DataQuery<TEntity> {}
+
+export interface IQueryable<TEntity, TId> {
+    query(q: DbQuery<TEntity>): TEntity[];
+    byId(id: TId): TEntity;
+}
+
+export interface ServerError {
+    message?: string;
+}
+
+type DbSaveEntityResponse<TEntity, TId> = {
+    id: TId;
+    payload: Partial<TEntity>;
+};
+
+export interface DbSaveResponse<TTables extends DbTablesSet<TTables>> {
+    submit: {
+        [EntityName in keyof TTables]?: DbSaveEntityResponse<DbTableEntityByTable<TTables[EntityName], TTables>, DbTableIdByTable<TTables[EntityName], TTables>>[];
+    };
+}
+
+export type DbViewFunction<TDb, TResult, TParams = void, TDependencies = void> = (db: TDb, parameters?: TParams, dependencies?: TDependencies) => TResult;
+
+export interface DbViewOptions<TDb, TResult, TParams, TDependencies = void> {
+    getKey?: (parameters: TParams) => string;
+    getDependencies?: (db: TDb, parameters: TParams) => TDependencies;
+    compareDependencies?: (prev: TDependencies, next: TDependencies) => boolean;
+    compareResults?: (prev: TResult, current: TResult) => boolean;
+    traceDiff?: boolean;
+}
+
+export interface DbView<TDb, TResult, TParams = void, TDependencies = void> extends DbViewOptions<TDb, TResult, TParams, TDependencies> {
+    compute: DbViewFunction<TDb, TResult, TParams, TDependencies>;
+}
+
+export type KeysOfType<T, TProp> = { [P in keyof T]: T[P] extends TProp ? P : never }[keyof T];
+
+export interface DbSubscription<TValue, TParams> {
+    update(params: TParams): TValue;
+    currentValue: TValue;
+    currentParams: TParams;
+    onUpdate: (newValue: TValue) => void;
+    unsubscribe: () => void;
+}
+
+export type ViewCacheItem = { dependencies: any; currentValue: any; computedOnDb: any };
+
+export interface LoadingState<TRequest> {
+    isLoading: boolean;
+    isComplete: boolean;
+    request: TRequest;
+    missing?: TRequest;
+}
+
+export interface ILoadingTracker<TRequest, TResult> {
+    diff(request: TRequest): TRequest;
+    append(request: TRequest, result?: TResult): void;
+    count?(request: TRequest): { knownCount: number; exactCount: number };
+}

package/src/utils.ts

@@ -0,0 +1,34 @@
+import shallowEqual from 'shallowequal';
+import zip from 'lodash.zip';
+import transform from 'lodash.transform';
+import isEqual from 'lodash.isequal';
+
+// TBD: New typescript would contain better typing for this. Remove this hack after update.
+export const objectKeys: <T>(obj: T) => (keyof T)[] = Object.keys as any;
+
+export function defaultCompareViewDependencies<T>(prev: T, next: T): boolean {
+    if (Array.isArray(prev) && Array.isArray(next)) {
+        if (prev.length === next.length) {
+            return zip(prev, next).every(([p, n]) => shallowEqual(p, n));
+        }
+        return false;
+    }
+    return shallowEqual(prev, next);
+}
+
+/**
+ * Deep diff between two object, using lodash
+ * @param  {Object} object Object compared
+ * @param  {Object} base   Object to compare with
+ * @return {Object}        Return a new object who represent the diff
+ */
+export function difference(obj: any, baseObj: any) {
+    function changes(object: any, base: any) {
+        return transform(object, function (result: any, value: any, key: any) {
+            if (!isEqual(value, base[key])) {
+                result[key] = (typeof value === 'object' && typeof base[key] === 'object') ? changes(value, base[key]) : value;
+            }
+        });
+    }
+    return changes(obj, baseObj);
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "./build"
+  },
+  "exclude": [
+    "**/__tests__",
+    "build",
+    "node_modules"
+  ]
+}