@epam/uui-db 4.5.0 → 4.5.4

package/src/tempIds.d.ts

@@ -1,28 +1,28 @@
-import { DbTablesSet, DbPatch, DbFieldSchema, DbSaveResponse } from "./types";
-import { Db } from "./Db";
-import { DataQueryFilter } from '@epam/uui';
-export declare function getTempId(): number;
-export declare function isTempId(val: any): val is number;
-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 declare class TempIdMap<TTables extends DbTablesSet<TTables>> implements IClientIdsMap {
-    private db;
-    private serverToClientIds;
-    private clientToServerIds;
-    constructor(db: Db<TTables>);
-    clientToServer: (id: number) => any;
-    serverToClient: (tableName: string, id: any) => number;
-    clientToServerRequest: (request: any) => any;
-    clientToServerDataFilter: (filter: DataQueryFilter<any>) => DataQueryFilter<any>;
-    private copyPatch;
-    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;
-    protected getServerToClientMap(tableName: keyof TTables): Map<any, any>;
-    serverToClientPatch(patch: DbPatch<TTables>): DbPatch<TTables>;
-    clientToServerPatch(patch: DbPatch<TTables>): DbPatch<TTables>;
-    appendServerMapping(response: DbSaveResponse<TTables>): void;
-}
+import { DbTablesSet, DbPatch, DbFieldSchema, DbSaveResponse } from "./types";
+import { Db } from "./Db";
+import { DataQueryFilter } from '@epam/uui';
+export declare function getTempId(): number;
+export declare function isTempId(val: any): val is number;
+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 declare class TempIdMap<TTables extends DbTablesSet<TTables>> implements IClientIdsMap {
+    private db;
+    private serverToClientIds;
+    private clientToServerIds;
+    constructor(db: Db<TTables>);
+    clientToServer: (id: number) => any;
+    serverToClient: (tableName: string, id: any) => number;
+    clientToServerRequest: (request: any) => any;
+    clientToServerDataFilter: (filter: DataQueryFilter<any>) => DataQueryFilter<any>;
+    private copyPatch;
+    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;
+    protected getServerToClientMap(tableName: keyof TTables): Map<any, any>;
+    serverToClientPatch(patch: DbPatch<TTables>): DbPatch<TTables>;
+    clientToServerPatch(patch: DbPatch<TTables>): DbPatch<TTables>;
+    appendServerMapping(response: DbSaveResponse<TTables>): void;
+}
 //# sourceMappingURL=tempIds.d.ts.map

package/src/types.d.ts

@@ -1,117 +1,117 @@
-import { DataQuery } from '@epam/uui';
-import { DbTable } from "./DbTable";
-import { IClientIdsMap } from './tempIds';
-export declare type DbTablesSet<TTables extends DbTablesSet<TTables>> = {
-    [TEntityName in keyof TTables]: DbTable<any, any, TTables>;
-};
-export declare type DbTablePatch<TEntity> = Partial<TEntity>[];
-export declare type DbTableEntityByTable<TTable, TTables extends DbTablesSet<TTables>> = TTable extends DbTable<infer TEntity, any, TTables> ? TEntity : void;
-export declare type DbTableIdByTable<TTable, TTables extends DbTablesSet<TTables>> = TTable extends DbTable<any, infer TId, TTables> ? TId : void;
-declare type DbTablePatchByTable<TTable, TTables extends DbTablesSet<TTables>> = DbTablePatch<DbTableEntityByTable<TTable, TTables>>;
-export declare type DbPatch<TTables extends DbTablesSet<TTables>> = {
-    [TEntityName in keyof TTables]?: DbTablePatchByTable<TTables[TEntityName], TTables>;
-};
-export declare enum DbRelationType {
-    Aggregation = 0,
-    Association = 1
-}
-export declare 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 declare type DbPkFieldType = string | number | (string | number)[];
-export declare type BeforeUpdateContext<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> = {
-    clientIdsMap: IClientIdsMap;
-    schema: DbEntitySchema<TEntity, TId, TTables>;
-    tables: DbTablesSet<TTables>;
-};
-declare type DbEntityBeforeUpdateResult<TEntity, TTables extends DbTablesSet<TTables>> = {
-    entity: TEntity;
-    dependentEntities?: DbPatch<TTables>;
-};
-declare type DbTableIndexDefinition<TEntity> = keyof TEntity;
-export declare 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>[];
-};
-export declare 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;
-}
-declare 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 declare 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 declare 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 declare 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;
-    };
-}
-export {};
+import { DataQuery } from '@epam/uui';
+import { DbTable } from "./DbTable";
+import { IClientIdsMap } from './tempIds';
+export declare type DbTablesSet<TTables extends DbTablesSet<TTables>> = {
+    [TEntityName in keyof TTables]: DbTable<any, any, TTables>;
+};
+export declare type DbTablePatch<TEntity> = Partial<TEntity>[];
+export declare type DbTableEntityByTable<TTable, TTables extends DbTablesSet<TTables>> = TTable extends DbTable<infer TEntity, any, TTables> ? TEntity : void;
+export declare type DbTableIdByTable<TTable, TTables extends DbTablesSet<TTables>> = TTable extends DbTable<any, infer TId, TTables> ? TId : void;
+declare type DbTablePatchByTable<TTable, TTables extends DbTablesSet<TTables>> = DbTablePatch<DbTableEntityByTable<TTable, TTables>>;
+export declare type DbPatch<TTables extends DbTablesSet<TTables>> = {
+    [TEntityName in keyof TTables]?: DbTablePatchByTable<TTables[TEntityName], TTables>;
+};
+export declare enum DbRelationType {
+    Aggregation = 0,
+    Association = 1
+}
+export declare 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 declare type DbPkFieldType = string | number | (string | number)[];
+export declare type BeforeUpdateContext<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> = {
+    clientIdsMap: IClientIdsMap;
+    schema: DbEntitySchema<TEntity, TId, TTables>;
+    tables: DbTablesSet<TTables>;
+};
+declare type DbEntityBeforeUpdateResult<TEntity, TTables extends DbTablesSet<TTables>> = {
+    entity: TEntity;
+    dependentEntities?: DbPatch<TTables>;
+};
+declare type DbTableIndexDefinition<TEntity> = keyof TEntity;
+export declare 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>[];
+};
+export declare 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;
+}
+declare 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 declare 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 declare 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 declare 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;
+    };
+}
+export {};
 //# sourceMappingURL=types.d.ts.map

package/src/utils.d.ts

@@ -1,10 +1,10 @@
-export declare let objectKeys: <T>(obj: T) => (keyof T)[];
-export declare function defaultCompareViewDependencies<T>(prev: T, next: T): boolean;
-/**
- * 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 declare function difference(object: any, base: any): any;
+export declare let objectKeys: <T>(obj: T) => (keyof T)[];
+export declare function defaultCompareViewDependencies<T>(prev: T, next: T): boolean;
+/**
+ * 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 declare function difference(object: any, base: any): any;
 //# sourceMappingURL=utils.d.ts.map