@rentman/rm-core 1.1.6 → 1.1.7

package/changelog.md

@@ -1,6 +1,9 @@
 #Changelog
 Contains new features, breaking changes and their reasoning
 
+##v1.1.7
+- Fixed issue where cached item entries or collection entries wouldn't be added to the local cache.
+
 ##v1.1.6
 - Fixed issue with deferred item entries.
 - Re-enable changes watcher after save.

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

@@ -27,7 +27,7 @@ export declare class ApiFormatter {
     formatRequestDate(value: any): any;
     formatRequestDuration(value: any): any;
     formatRequestColor(value: any): any;
-    getDefaultValue(columnType: any): false | "" | 0 | moment.Moment | moment.Duration | "0" | "#000000" | null;
+    getDefaultValue(columnType: any): false | 0 | "" | moment.Moment | moment.Duration | "0" | "#000000" | null;
     isDefaultValue(columnType: any, value: any): any;
     clone(columnType: any, value: any): any;
     getCloneFunction(columnType: any): (date: any) => any;

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

@@ -1,24 +1,24 @@
-import { CollectionCache, CollectionEntryService, CollectionMatcher, ColumnHandler, ColumnUtil, ItemCache, ItemRequestService, KeyService, QueryService } from '../classes';
+import { CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemRequestService, KeyService, QueryService } from '../classes';
+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, ItemResourceItemIdMap } from '../types';
+import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType } from '../types';
 export declare class CollectionHandler {
     private errorHandler;
     private itemRequestService;
     private columnHandler;
+    private columnSetFactory;
     private collectionEntryFactory;
     private collectionCacheFactory;
     private queryParserFactory;
     private collectionEntryService;
-    private columnSetFactory;
     private keyService;
     private promiseService;
     private queryService;
-    private columnUtil;
     private collectionMatcherFactory;
     entries: CollectionCache;
-    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, columnHandler: ColumnHandler, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, columnUtil: ColumnUtil, collectionMatcherFactory: CollectionMatcherFactory);
+    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, collectionMatcherFactory: CollectionMatcherFactory);
     getPromises(statusResource: CollectionEntryBatchStatusMap): CollectionEntry[];
     getRequestIds(statusResource: any): number[];
     /**
@@ -36,14 +36,21 @@ export declare class CollectionHandler {
     addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
     batchExpand(parentType: string, itemType: string, collections: CollectionResource[], newColumns: any): Promise<CollectionResource[]>;
     batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): Promise<ItemResourceItemIdMap>;
-    batchFetch(parentType: string, parentIdArray: number[], itemType: string, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
-    createStatusResource(parentType: string, parentIdArray: number[], itemType: string, options: any, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;
-    fetch(itemType: string, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntry>;
-    getDeferredEntryStatus(collectionEntry: CollectionEntry, options: any): EntryStatus<CollectionEntry>;
-    getEntryStatus(itemType: string, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
-    getNewEntryStatus(itemType: string, query: any, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
-    handleBatchResponse(statusResource: any, itemEntryResource: any, itemCache: ItemCache): CollectionEntryParentIdMap;
-    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): Promise<CollectionEntry>;
-    resolveRemote(collectionEntry: any, itemCache: any): Promise<CollectionEntry>;
+    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): {
+        entry: CollectionEntry;
+        isDeferred: boolean;
+    };
+    getEntryStatus(itemType: ItemType, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
+    handleBatchResponse(statusResource: any, itemEntryCompound: {
+        columns: ColumnSet;
+        columnExpansion?: ColumnExpansion;
+        items?: ItemEntryParentIdMap;
+    }, itemCache: ItemCache): CollectionEntryParentIdMap;
+    resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): Promise<CollectionEntry>;
+    resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): Promise<CollectionEntry>;
     isLocal(options: any): boolean;
 }

package/dist/dist/classes/CollectionMatcher.d.ts

@@ -18,7 +18,7 @@ export declare class CollectionMatcher {
         };
     };
     constructor(queryMatcherFactory: QueryMatcherFactory, collectionCaches: CollectionCache[], updateInitial: boolean, callOnActivate: boolean);
-    expand(itemEntry: ItemEntry): Window;
+    expand(itemEntry: ItemEntry): this;
     getCollectionsWithFittingItems(): CollectionEntry[];
     addToCollections(resultResource?: CollectionResource | null): ItemResource[] | null;
     removeFromCollections(resultResource?: CollectionResource | null): ItemResource[] | null;

package/dist/dist/classes/ColumnExpansion.d.ts

@@ -1,14 +1,17 @@
-import { ColumnUtil } from '../classes';
+import { ColumnSet, ColumnUtil } from '../classes';
 import { ColumnSetFactory } from '../factories';
+import { ColumnExpansionResult, ItemType, RequestColumns, ResponseColumnMap } from '../types';
 export declare class ColumnExpansion {
     private columnSetFactory;
     private columnUtil;
-    itemType: string;
-    requestColumns: any | boolean;
-    responseColumns: any;
-    expansionMap: any;
+    itemType: ItemType;
+    requestColumns: RequestColumns;
+    responseColumns: ResponseColumnMap;
+    expansionMap: {
+        [columnSetId: number]: ColumnExpansionResult;
+    };
     requestColumnsTrue: boolean;
-    constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, itemType: string, requestColumns: any | boolean, responseColumns: any);
-    run(columnInfo: any, returnExpansionResult: boolean): any;
+    constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, itemType: ItemType, requestColumns: RequestColumns, responseColumns: ResponseColumnMap);
+    run(columnSet: ColumnSet): ColumnExpansionResult | null;
     private expandColumnInfo(columnSet);
 }

package/dist/dist/classes/ColumnSet.d.ts

@@ -27,6 +27,8 @@ export declare class ColumnSet {
     enableCaching: boolean;
     constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, itemType: any, request: RequestColumns);
     resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
+    expandRequestColumns(columns: RequestColumns): void;
+    isSupersetOf(columns: RequestColumns): any;
     private processResponseColumns(responseColumns);
     private processRequestColumns(responseColumns, includeIdColumn);
     private getRequestColumnInfo(requestColumn, itemType, parent, responseColumns);

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

@@ -1,9 +1,11 @@
-import { ApiResponseProcessor, BatchStatus, ColumnHandler, ColumnSet, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ApiResponseProcessor, BatchStatus, ColumnHandler, 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 { ApiTemplateItemTypeMap, EntryStatus, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
+import { ApiResponse, ApiTemplateItemTypeMap, EntryStatus, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
+import { ColumnExpansion } from './ColumnExpansion';
+import { ColumnSet } from './ColumnSet';
 export declare class ItemHandler {
     private apiRequestService;
     private errorHandler;
@@ -34,12 +36,11 @@ export declare class ItemHandler {
     fetchItems(itemType: any, itemIds: any, options: any, localItemCache: ItemCache): Promise<ItemEntry[]>;
     resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): Promise<ItemEntry>;
     resolveLocal(itemEntry: ItemEntry, parent: any, template: any, localItemCache: ItemCache): TemplateResponseItemEntryMap;
-    resolveExpansion(itemEntry: any, columnExpansion: any, response: any): ItemEntry;
-    resolveRemote(itemEntry: any, columnInfo: any, response: any): any;
+    resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
+    resolveRemote(itemEntry: ItemEntry, columnSet: ColumnSet, response: ApiResponse): ItemEntry | null;
     fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
     getEntryStatus(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): EntryStatus<ItemEntry>;
-    isColumnSubset(itemEntry: ItemEntry, columns: RequestColumns): any;
-    expandColumnSetStub(columnSet: ColumnSet, columns: RequestColumns): void;
+    isColumnSuperset(itemEntry: ItemEntry, columns: RequestColumns): any;
     getCachedEntryStatus(itemEntry: ItemEntry, options: any): ENTRY_STATUS;
     /**
      *

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

@@ -1,7 +1,8 @@
-import { ApiResponseProcessor, ColumnExpansion, ItemHandler, QueryService } from '../classes';
+import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QueryService } from '../classes';
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry, ItemEntry } from '../models';
+import { ApiResponse, EntryParentNull, ItemId, ItemType } from '../types';
 export declare class ItemRequestService {
     private apiRequestService;
     private errorHandler;
@@ -16,7 +17,7 @@ export declare class ItemRequestService {
     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;
-    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): Promise<ItemEntry[]>;
+    processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): Promise<ItemEntry[]>;
     handleCachedItem(itemEntry: any, response: any, columnExpansion: ColumnExpansion): any;
-    processLinkResponse(response: any, parentType: any, parentIdArray: any, itemType: any, options: any): Promise<any>;
+    processLinkResponse(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any): Promise<any>;
 }

package/dist/dist/factories/CollectionEntryFactory.d.ts

@@ -1,14 +1,16 @@
 import { CollectionEntryService, ItemEntryService, ItemRequestService, KeyService, QueryService } from '../classes';
+import { ColumnSetFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry } from '../models/';
 export declare class CollectionEntryFactory {
     private collectionEntryService;
+    private columnSetFactory;
     private errorHandler;
     private itemEntryService;
     private itemRequestService;
     private keyService;
     private promiseService;
     private queryService;
-    constructor(collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService);
+    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService);
     construct(itemType: string, options: any): CollectionEntry;
 }

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

@@ -1,11 +1,12 @@
-import { CollectionEntryService, ColumnInfo, ColumnSet, ItemEntryService, ItemRequestService, KeyService, QueryService } from '../classes';
-import { CollectionEntryFactory } from '../factories';
+import { CollectionEntryService, ColumnExpansion, ColumnInfo, ColumnSet, ItemEntryService, ItemRequestService, KeyService, QueryService } from '../classes';
+import { CollectionEntryFactory, ColumnSetFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionResource, ItemEntry, ItemResource } from '../models';
-import { EntryParentNull, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { EntryParentNull, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
 export declare class CollectionEntry {
     private collectionEntryFactory;
     private collectionEntryService;
+    private columnSetFactory;
     private errorHandler;
     private itemEntryService;
     private itemRequestService;
@@ -24,9 +25,12 @@ export declare class CollectionEntry {
     deferred: any;
     promise: Promise<CollectionEntry>;
     reloadQueued: boolean;
-    constructor(collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, itemType: ItemType, options: any);
+    constructor(collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, itemType: ItemType, options: any);
     isDeferred(): boolean;
-    resolve(itemEntryCompound: any): CollectionEntry;
+    resolve(itemEntryCompound: {
+        columns: ColumnSet;
+        items: ItemEntry[];
+    }): CollectionEntry;
     isLocal(): boolean;
     matchParent(itemType: any, itemId: any): boolean;
     forEach(callback: (itemEntry: ItemEntry) => void): void;
@@ -40,7 +44,8 @@ export declare class CollectionEntry {
     extendQuery(callback: any): any;
     extend(queryCallback: any, collectionResource: any, callOnAdd?: any, updateInitial?: any): Promise<any>;
     queueReload(): void;
-    updateColumns(columnExpansion: any): void;
+    expandColumns(columnExpansion: ColumnExpansion): void;
+    expandRequestColumns(requestColumns: RequestColumns): void;
     getAddedItems(returnItemIds?: boolean): (number | ItemEntry)[];
     getRemovedItems(returnItemIds?: boolean): (number | ItemEntry)[];
     getUpdatedItems(): ItemEntry[];

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

@@ -1,4 +1,4 @@
-import { CollectionMatcher, RequestColumnExpansion } from '../classes';
+import { CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
 export declare type EntryParent = {
@@ -20,6 +20,9 @@ export declare type ItemType = string;
 export declare type ItemEntryEntryStatusMap = {
     [entryStatus: string]: ItemEntry[];
 };
+export declare type ItemEntryParentIdMap = {
+    [parentId: number]: ItemEntry[];
+};
 export declare type ItemIdConversionMap = {
     [itemType: string]: {
         [itemId: number]: number;
@@ -50,6 +53,10 @@ export declare type ResponseColumnMap = {
     };
 };
 export declare type LocalColumn = object;
+export declare type ColumnExpansionResult = {
+    merged: ColumnSet;
+    difference: ColumnSet;
+};
 export declare type ApiResponse = any;
 export interface ApiTemplate {
     fields: any;