@rentman/rm-core 1.1.16 → 1.1.18

package/changelog.md

@@ -1,6 +1,30 @@
 #Changelog
 Contains new features, breaking changes and their reasoning
 
+## v1.1.18
+- Calling `expand` on a `CollectionEntry` manually no longer defers the collection entry.
+- The `batchFetch` and `batchExpand` functions in the `CollectionHandler` class now properly defer and resolve the
+collection entries.
+
+## v1.1.17
+- Fixed issue where the `getLocalByQuery` function in the `ItemCache` class wouldn't return any items.
+- When batch resolving collection entries, `CollectionHandler` now looks for matching items using `getByQuery` instead
+of `getByParent`.
+
+### Cache invalidation
+- Added `queueReload` function to `ItemEntry` class. This will reload the item when the item entry itself or a
+collection entry containing the item is requested.
+- The `queueReload` function in the `CollectionEntry` class no longer directly defers the item.
+- Added `invalidateCache` function to the `ItemAdministrator` class. This will call `queueReload` on all item entries
+and collection entries.
+
+### Item entry refactoring
+- Renamed `process` to `setFields`. 
+- Replaced `processLocal` with `setLocalFields`. This function no longer has a `modified` parameter.
+- `setModified` now also sets local default values.
+- Removed `setCreator`. This function was called twice in some instances.
+- **Breaking:** Added `derived` parameter to `updateFields`  
+
 ##v1.16
 - Pass `hasChanges` as second argument to `onBeforeSave` callbacks in  the `LocalCache` class. This fixes an issue with
 project financial values in the front-end. [RM4-9577]

package/dist/dist/classes/ApiFormatter.d.ts

@@ -1,22 +1,25 @@
 /// <reference types="moment" />
 import * as moment from 'moment';
+import { FieldMap } from '../types';
+import { ColumnInfo } from './ColumnInfo';
 export declare class ApiFormatter {
     MOMENT_INVALID: string;
     SERVER_DATETIME_FORMAT: string;
     SERVER_TIME_FORMAT: string;
     SERVER_DATE_FORMAT: string;
     constructor();
-    formatResponse(fields: any, columns: any): void;
-    expandResponse(current: any, expanded: any, columns: any): void;
-    formatRequest(initial: any, modified: any, columns: any): {};
-    hasChanges(initial: any, modified: any, columns: any): boolean;
-    getChanges(initial: any, modified: any, columns: any): object[];
-    copyFields(source: any, destination: any, columns: any): any;
-    shallowCopyFields(shallowSource: any, deepSource: any, destination: any, columns: any): any;
-    setDefaultValues(destination: any, columns: any): any;
-    compareFields(columnType: any, first: any, second: any): any;
+    formatResponse(fields: FieldMap, columns: ColumnInfo[]): FieldMap;
+    expandResponse(current: FieldMap, expanded: FieldMap, columns: ColumnInfo[]): FieldMap;
+    formatRequest(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): FieldMap;
+    formatRequestLocal(fields: FieldMap, columns: ColumnInfo[]): FieldMap;
+    hasChanges(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): boolean;
+    getChanges(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): FieldMap;
+    copyFields(source: FieldMap, destination: FieldMap, columns: ColumnInfo[]): FieldMap;
+    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: ColumnInfo[]): FieldMap;
+    setDefaultValues(destination: FieldMap, columns: ColumnInfo[]): FieldMap;
+    compareFields<T>(columnType: string, first: T, second: T): boolean;
     compareFloats(a: any, b: any): boolean;
-    compareMomentObjects(first: any, second: any): any;
+    compareMomentObjects(first: any, second: any): boolean;
     compareDurations(first: any, second: any): boolean;
     formatResponseValue(columnType: any, value: any): any;
     formatRequestValue(columnType: any, value: any): any;
@@ -28,7 +31,7 @@ export declare class ApiFormatter {
     formatRequestDuration(value: any): any;
     formatRequestColor(value: any): any;
     getDefaultValue(columnType: any): false | 0 | "" | moment.Moment | moment.Duration | "0" | "#000000" | null;
-    isDefaultValue(columnType: any, value: any): any;
+    isDefaultValue(columnType: any, value: any): boolean;
     clone(columnType: any, value: any): any;
     getCloneFunction(columnType: any): (date: any) => any;
     cloneDuration(duration: any): moment.Duration;

package/dist/dist/classes/BatchStatus.d.ts

@@ -6,6 +6,7 @@ export declare class BatchStatus {
     private promiseService;
     getItemId: (itemEntry: ItemEntry) => ItemId;
     getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>;
+    readonly requestStatusArray: ENTRY_STATUS[];
     entries: ItemEntryEntryStatusMap;
     constructor(promiseService: PromiseInterface, getItemId: (itemEntry: ItemEntry) => ItemId, getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>);
     add(entryStatus: EntryStatus<ItemEntry>): void;

package/dist/dist/classes/CollectionHandler.d.ts

@@ -3,7 +3,7 @@ import { ENTRY_STATUS } from '../constants';
 import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemResource } from '../models';
-import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType } from '../types';
+import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, RequestColumn } from '../types';
 export declare class CollectionHandler {
     private errorHandler;
     private itemRequestService;
@@ -34,13 +34,13 @@ export declare class CollectionHandler {
      * @deprecated, use collectionMatcherFactory
      */
     addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
-    batchExpand(parentType: string, itemType: string, collections: CollectionResource[], newColumns: any): Promise<CollectionResource[]>;
+    batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResource[], newColumns: RequestColumn[]): Promise<CollectionResource[]>;
     batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): Promise<ItemResourceItemIdMap>;
     batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
     createStatusResource(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;
     fetch(itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntry>;
     getCachedEntryStatus(collectionEntry: CollectionEntry, options: any): ENTRY_STATUS;
-    getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: any): {
+    getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: CollectionCache): {
         entry: CollectionEntry;
         isDeferred: boolean;
     };

package/dist/dist/classes/ItemAdministrator.d.ts

@@ -22,6 +22,7 @@ export declare class ItemAdministrator {
     private promiseInterface;
     private queryService;
     constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, collectionResourceService: CollectionResourceService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseInterface, queryService: QueryService);
+    invalidateCache(): void;
     getItemDefinition(itemType: ItemType, stateKey: number | string, options: ItemOptions): ItemDefinition;
     getCollectionMatcher(itemEntries: ItemEntry[], addToTab: boolean): CollectionMatcher;
     fetchTitle(itemType: any, itemId: any, deferRequest: any): Promise<any>;

package/dist/dist/classes/ItemCache.d.ts

@@ -13,12 +13,12 @@ export declare class ItemCache {
     getByItemType(itemType: ItemType): ItemEntry[];
     getByQuery(itemType: ItemType, query: any): ItemEntry[];
     getLocalByQuery(itemType: ItemType, query: any): ItemEntry[];
+    getByParent(parentType: ItemType, parentId: ItemId, itemType: ItemType): ItemEntry[];
     forEach(callback: (itemEntry: ItemEntry) => void): void;
     toArray(): ItemEntry[];
     add(itemEntry: ItemEntry): ItemEntry;
     get(itemType: ItemType, itemId: ItemId | string): any;
     contains(itemType: ItemType, itemId: ItemId | string): boolean;
-    getByParent(parentType: ItemType, parentId: ItemId, itemType: ItemType): ItemEntry[];
     updateItemId(itemEntry: ItemEntry, oldItemId: any): ItemEntry;
     clear(itemEntry: ItemEntry): boolean;
     matchQuery(itemEntry: ItemEntry, query: any): boolean;

package/dist/dist/classes/ItemEntryService.d.ts

@@ -1,11 +1,13 @@
 import { KeyService } from '../classes';
+import { AuthInterface } from '../interfaces';
 import { ItemEntry } from '../models';
-import { ApiResponse, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ApiResponse, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
 export declare class ItemEntryService {
+    private authInterface;
     private keyService;
     undefinedItemError: string;
     ALL_PERMISSIONS: number;
-    constructor(keyService: KeyService);
+    constructor(authInterface: AuthInterface, keyService: KeyService);
     processOptions(options: any): any;
     createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
     expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
@@ -15,4 +17,5 @@ export declare class ItemEntryService {
     batchClone(itemEntries: ItemEntry[], conversionMap?: ItemIdConversionMap): ItemEntry[];
     getFullName(firstName: any, infix: any, lastName: any): any;
     getTitleField(itemType: any): "serienummer" | "nummer" | "friendlyname" | "naamintern" | "omschrijving" | "code" | "naam" | "displayname";
+    getLocalDefaultValues(): FieldMap;
 }

package/dist/dist/classes/ItemHandler.d.ts

@@ -1,11 +1,9 @@
-import { ApiResponseProcessor, BatchStatus, ColumnHandler, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnSet, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { ItemEntry } from '../models';
-import { ApiResponse, ApiTemplateItemTypeMap, EntryStatus, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
-import { ColumnExpansion } from './ColumnExpansion';
-import { ColumnSet } from './ColumnSet';
+import { ApiResponse, ApiTemplateItemTypeMap, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
 export declare class ItemHandler {
     private apiRequestService;
     private errorHandler;
@@ -38,6 +36,11 @@ export declare class ItemHandler {
     resolveLocal(itemEntry: ItemEntry, parent: any, template: any, localItemCache: ItemCache): TemplateResponseItemEntryMap;
     resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
     resolveRemote(itemEntry: ItemEntry, columnSet: ColumnSet, response: ApiResponse): ItemEntry | null;
+    resolveRemoteValues(itemEntry: ItemEntry, response: ApiResponse): ItemEntry | null;
+    getResponseFields(itemEntry: ItemEntry, columnSet: any, response: ApiResponse): {
+        initial: FieldMap;
+        derived: FieldMap;
+    } | null;
     fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
     getEntryStatus(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): EntryStatus<ItemEntry>;
     isColumnSuperset(itemEntry: ItemEntry, columns: RequestColumns): any;
@@ -53,8 +56,9 @@ export declare class ItemHandler {
      * for every type of entry status there is in this batch request make sure the entries get resolved.
      * then return a array of the resulting ItemEntryArray
      */
-    batchResolve(itemType: any, batchStatus: BatchStatus, requestColumns: any, resolved: any, localItemCache: ItemCache): ItemEntry[] | Promise<any>;
+    batchResolve(itemType: ItemType, batchStatus: BatchStatus, requestColumns: RequestColumns, resolved: any, localItemCache: ItemCache): ItemEntry[] | Promise<any>;
     createLocalEntries(parentType: ItemType, localParentId: ItemId, template: any, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, excludeItemTypes?: ItemType[]): TemplateResponseLinkedItemEntryMap[];
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): Promise<any>;
-    requestItems(itemType: string, itemIds: ItemId[], columns: any): Promise<ApiResponseProcessor>;
+    requestItem(itemEntry: ItemEntry, requestColumns?: RequestColumns): Promise<ApiResponseProcessor>;
+    requestItems(itemType: ItemType, itemIds: ItemId[], columns: RequestColumns): Promise<ApiResponseProcessor>;
 }

package/dist/dist/classes/ItemRequestService.d.ts

@@ -2,7 +2,7 @@ import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QuerySer
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry, ItemEntry } from '../models';
-import { ApiResponse, EntryParentNull, ItemId, ItemType } from '../types';
+import { ApiResponse, EntryParentNull, ItemId, ItemType, RequestColumns } from '../types';
 export declare class ItemRequestService {
     private apiRequestService;
     private errorHandler;
@@ -16,8 +16,8 @@ export declare class ItemRequestService {
     requestItem(itemType: any, itemId: any, columns: any): Promise<ApiResponseProcessor>;
     requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): Promise<ApiResponseProcessor>;
     requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): Promise<ApiResponseProcessor>;
-    processExpansion(requestColumns: any, response: any, itemType: string, itemEntries: ItemEntry[]): ColumnExpansion;
+    processExpansion(requestColumns: RequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
     processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): Promise<ItemEntry[]>;
-    handleCachedItem(itemEntry: any, response: any, columnExpansion: ColumnExpansion): any;
+    handleCachedItem(itemEntry: ItemEntry, response: ApiResponse, columnExpansion: ColumnExpansion): ItemEntry;
     processLinkResponse(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any): Promise<any>;
 }

package/dist/dist/constants.d.ts

@@ -4,6 +4,7 @@ export declare enum ENTRY_STATUS {
     EXPAND = "expand",
     PROMISED_EXPAND = "promised-expand",
     RESOLVE = "resolve",
+    RESOLVE_VALUES = "resolve-values",
     LOCAL = "local",
 }
 export declare const ALL_PERMISSIONS = "7";

package/dist/dist/models/CollectionEntry.d.ts

@@ -19,11 +19,13 @@ export declare class CollectionEntry {
     hasEditResources: boolean;
     hasItemEditResources: boolean;
     constructor(factory: CollectionEntryFactory, itemType: ItemType, options: any);
+    defer(): void;
     isDeferred(): boolean;
+    _resolve(): this;
     resolve(itemEntryCompound: {
         columns: ColumnSet;
         items: ItemEntry[];
-    }): CollectionEntry;
+    }): this;
     isLocal(): boolean;
     matchParent(itemType: ItemType, itemId: ItemId): boolean;
     forEach(callback: (itemEntry: ItemEntry) => void): void;
@@ -35,7 +37,7 @@ export declare class CollectionEntry {
     clear(resultResource?: CollectionResource | null, updateInitial?: boolean, callOnRemove?: boolean): ItemResource[] | null;
     handleRemovedItems(filterFunction: (itemEntry: ItemEntry) => boolean, resultResource?: CollectionResource | null, updateInitial?: boolean, callOnRemove?: boolean): ItemResource[] | null;
     private handleRemovedItemCallbacks(removedFromInitial, removedFromModified, resultResource?, callOnRemove?);
-    expand(newColumns: any): Promise<any>;
+    expand(newColumns: RequestColumns): Promise<this>;
     extendQuery(callback: any): any;
     extend(queryCallback: any, collectionResource: any, callOnAdd?: any, updateInitial?: any): Promise<any>;
     queueReload(): void;

package/dist/dist/models/ItemEntry.d.ts

@@ -1,13 +1,14 @@
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
 import { ItemResource } from '../models';
-import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap } from '../types';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, ResponseColumn } from '../types';
 export declare class ItemEntry {
     private factory;
     itemType: string;
     itemId: ItemId;
     columns: ColumnSet;
     id: number;
+    reloadQueued: boolean;
     deferRequest: boolean;
     deferred: any;
     parent: EntryParentNull;
@@ -16,41 +17,45 @@ export declare class ItemEntry {
     derived: FieldMap;
     resources: ItemResource[];
     constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
-    defer(deferRequest: any): this;
+    queueReload(): this;
+    defer(deferRequest?: boolean): this;
     resolve(): this;
     resolveDeferred(initial: any, derived: any, columns: any): this;
     isDeferred(): boolean;
     reject(error?: any): this;
-    process(initial: any, derived: any): this;
-    processLocal(initial: any, modified: any, derived: any, conversionMap: ItemIdConversionMap): this;
-    setCreator(): this;
+    setFields(initial: FieldMap, derived: FieldMap): this;
+    setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap): this;
     clone(conversionMap?: ItemIdConversionMap): ItemEntry;
     resetDerived(columnIds: any): this;
     clearResources(): this;
     deactivateResources(): this;
     getFields(): FieldMap;
-    expand(main: any, derived: any, columnExpansionResult: any): this;
-    updateFields(source: any, overwrite?: boolean): this;
-    updateItemValue(fields: any, apiColumn: any, conversionMap: any): this;
-    updateItemFields(conversionMap: any): this;
-    formatRequest(): {};
+    expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
+    /**
+     * This function assumes the initial, modified, derived properties are already set. It will update the values
+     * themselves to preserve references in existing item resources.
+     */
+    updateFields(fields: FieldMap, derived?: FieldMap | null, overwrite?: boolean): this;
+    updateItemValue(fields: FieldMap, apiColumn: ResponseColumn, conversionMap: ItemIdConversionMap): this;
+    updateItemFields(conversionMap: ItemIdConversionMap): this;
+    formatRequest(): FieldMap;
     setDisplayName(): this;
-    getDisplayName(): any;
+    getDisplayName(): string;
     /**
      * @param {Boolean} returnAll Returns all initial values if true
      * @returns {Object}
      */
-    getChanges(returnAll?: boolean): object[];
+    getChanges(returnAll?: boolean): FieldMap;
     isLocal(): boolean;
     isLockable(): boolean;
     hasChanges(): boolean;
     resetModified(): this;
-    setInitial(values: any, enableCallbacks?: any): this;
+    setInitial(values: FieldMap, enableCallbacks?: boolean): this;
     /**
      * Does a shallow copy of values!
      */
-    setModified(values?: any): this;
-    setDerived(values: any): this;
-    setParent(parentType: any, parentId: any): this;
-    callOnChange(previous: any): this;
+    setModified(values?: FieldMap): this;
+    setDerived(values: FieldMap): this;
+    setParent(parentType: ItemType, parentId: ItemId): this;
+    callOnChange(previous: FieldMap): this;
 }

package/dist/dist/types/ItemTypesCollection.d.ts

@@ -1,4 +1,4 @@
-import { CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
+import { ApiResponseProcessor, CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
 export declare type EntryParent = {
@@ -76,7 +76,7 @@ export declare type ColumnExpansionResult = {
     merged: ColumnSet;
     difference: ColumnSet;
 };
-export declare type ApiResponse = any;
+export declare type ApiResponse = ApiResponseProcessor;
 export interface ApiTemplate {
     fields: any;
     columns: any;