@rentman/rm-core 1.9.0 → 2.0.1

package/dist/src/classes/index.d.ts

@@ -1,12 +1,10 @@
 export * from './ApiFormatter';
 export * from './ApiRequestService';
 export * from './ApiResponseProcessor';
-export * from './BatchStatus';
 export * from './ChangesCompilation';
 export * from './ChangesProcessor';
 export * from './CollectionCache';
 export * from './CollectionEntryService';
-export * from './CollectionHandler';
 export * from './CollectionMatcher';
 export * from './CollectionResourceService';
 export * from './ColumnCache';
@@ -17,14 +15,10 @@ export * from './ColumnSet';
 export * from './ColumnSubsetCache';
 export * from './ColumnUtil';
 export * from './CreateRequest';
-export * from './ItemAdministrator';
 export * from './ItemCache';
 export * from './ItemEntryService';
-export * from './ItemHandler';
-export * from './ItemRequestService';
 export * from './KeyService';
-export * from './LocalCache';
-export * from './LocalCacheEventHandler';
+export * from './cache/transaction/TransactionEventHandler';
 export * from './LockService';
 export * from './ModuleChangesCompilation';
 export * from './QueryMatcher';
@@ -33,3 +27,15 @@ export * from './QueryService';
 export * from './RequestColumnExpansion';
 export * from './SocketMessageHandler';
 export * from './Util';
+export * from './cache/AbstractCache';
+export * from './cache/server/ServerCache';
+export * from './cache/server/ServerItemHandler';
+export * from './cache/server/ServerCollectionHandler';
+export * from './cache/transaction/TransactionCache';
+export * from './cache/transaction/TransactionItemHandler';
+export * from './cache/transaction/TransactionCollectionHandler';
+export * from './cache/transaction/TransactionEventHandler';
+export * from './ChangesDelta';
+export * from './InternalChangesDelta';
+export * from './RequestBufferManager';
+export * from './RequestBuffer';

package/dist/src/constants.d.ts

@@ -1,14 +1,3 @@
-export declare enum ENTRY_STATUS {
-    CACHED = "cached",
-    LOCAL = "local",
-    PROMISED = "promised",
-    EXPAND = "expand",
-    PROMISED_EXPAND = "promised-expand",
-    EXPAND_LOCAL = "expand-local",
-    PROMISED_EXPAND_LOCAL = "promised-expand-local",
-    RESOLVE = "resolve",
-    RESOLVE_VALUES = "resolve-values"
-}
 export declare const ALL_PERMISSIONS = "7";
 export declare const COLUMN_SEPERATOR = ">";
 export declare const RENDER_AS_SEPERATOR = ":";

package/dist/src/core.d.ts

@@ -1,19 +1,21 @@
-import { ApiFormatter, ApiRequestService, ChangesProcessor, CollectionEntryService, CollectionHandler, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemAdministrator, ItemEntryService, ItemHandler, ItemRequestService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
-import { ApiResponseProcessorFactory, BatchStatusFactory, ChangesCompilationFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, LocalCacheFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory } from './factories';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from './interfaces';
+import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
+import { TemplateCache } from './classes/TemplateCache';
+import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
+import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
+import { ChangesProcessorFactory } from './factories/ChangesProcessorFactory';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from './interfaces';
+import { LinkTreeServiceInterface } from './interfaces/LinkTreeServiceInterface';
 export declare class RmCore {
     version: string;
     noop: typeof noop;
     apiFormatter: ApiFormatter;
     apiRequestService: ApiRequestService;
     apiResponseProcessorFactory: ApiResponseProcessorFactory;
-    batchStatusFactory: BatchStatusFactory;
     changesCompilationFactory: ChangesCompilationFactory;
-    changesProcessor: ChangesProcessor;
+    changesProcessorFactory: ChangesProcessorFactory;
     collectionCacheFactory: CollectionCacheFactory;
     collectionEntryFactory: CollectionEntryFactory;
     collectionEntryService: CollectionEntryService;
-    collectionHandler: CollectionHandler;
     collectionMatcherFactory: CollectionMatcherFactory;
     collectionResourceFactory: CollectionResourceFactory;
     collectionResourceService: CollectionResourceService;
@@ -25,15 +27,12 @@ export declare class RmCore {
     columnSubsetCacheFactory: ColumnSubsetCacheFactory;
     columnUtil: ColumnUtil;
     createRequestFactory: CreateRequestFactory;
-    itemAdministrator: ItemAdministrator;
     itemCacheFactory: ItemCacheFactory;
     itemEntryFactory: ItemEntryFactory;
     itemEntryService: ItemEntryService;
-    itemHandler: ItemHandler;
-    itemRequestService: ItemRequestService;
     itemResourceFactory: ItemResourceFactory;
     keyService: KeyService;
-    localCacheFactory: LocalCacheFactory;
+    transactionCacheFactory: TransactionCacheFactory;
     lockService: LockService;
     moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
     queryMatcherFactory: QueryMatcherFactory;
@@ -42,7 +41,9 @@ export declare class RmCore {
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
     socketMessageHandler: SocketMessageHandler;
     templateFactory: TemplateFactory;
-    constructor(apiRequestServiceInterface: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface, exceptionHandlerInterface: ExceptionHandlerInterface, localCacheManager: LocalCacheManagerInterface, promiseLibraryInterface: PromiseLibraryInterface);
+    changesDeltaFactory: ChangesDeltaFactory;
+    templateCache: TemplateCache;
+    constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
 }
 export declare function noop(): void;
 export declare function identity(value: any): any;

package/dist/src/factories/ChangesCompilationFactory.d.ts

@@ -1,10 +1,6 @@
-import { ChangesCompilation, KeyService } from '../classes';
-import { CollectionEntry, ItemEntry } from '../models';
-import { ItemType } from '../types';
-import { CollectionCacheFactory } from './';
+import { ChangesCompilation } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 export declare class ChangesCompilationFactory {
-    private collectionCacheFactory;
-    private keyService;
-    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService);
-    construct(singleItems: Array<ItemEntry<ItemType>>, collections: Array<CollectionEntry<ItemType>>): ChangesCompilation;
+    constructor();
+    construct(transaction: TransactionCache): ChangesCompilation;
 }

package/dist/src/factories/ChangesDeltaFactory.d.ts

@@ -0,0 +1,9 @@
+import { ItemEntryService } from '../classes';
+import { ChangesDelta } from '../classes/ChangesDelta';
+import { InternalChangesDelta } from '../classes/InternalChangesDelta';
+export declare class ChangesDeltaFactory {
+    private itemEntryService;
+    constructor(itemEntryService: ItemEntryService);
+    construct(): ChangesDelta;
+    constructInternalDelta(): InternalChangesDelta;
+}

package/dist/src/factories/ChangesProcessorFactory.d.ts

@@ -0,0 +1,22 @@
+import { ApiRequestService, ChangesProcessor, CollectionEntryService, ItemEntryService, OnAfterCreateCallback } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ChangesCompilationFactory } from './ChangesCompilationFactory';
+import { ChangesDeltaFactory } from './ChangesDeltaFactory';
+import { ColumnExpansionFactory } from './ColumnExpansionFactory';
+import { CreateRequestFactory } from './CreateRequestFactory';
+import { RequestColumnExpansionFactory } from './RequestColumnExpansionFactory';
+export declare class ChangesProcessorFactory {
+    private changesDeltaFactory;
+    private apiRequestService;
+    private changesCompilationFactory;
+    private columnExpansionFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    private collectionEntryService;
+    private itemEntryService;
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService);
+    construct(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): ChangesProcessor;
+}

package/dist/src/factories/CollectionCacheFactory.d.ts

@@ -1,7 +1,8 @@
 import { CollectionCache } from '../classes';
+import { AbstractCache } from '../classes/cache/AbstractCache';
 import { QueryMatcherFactory } from '../factories';
 export declare class CollectionCacheFactory {
     private queryMatcherFactory;
     constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(): CollectionCache;
+    construct(transaction: AbstractCache): CollectionCache;
 }

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

@@ -1,23 +1,11 @@
-import { CollectionEntryService, ColumnHandler, ItemEntryService, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes/';
-import { CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories/';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces/';
+import { CollectionEntryService, KeyService } from '../classes';
 import { CollectionEntry, CollectionEntryOptionsInterface } from '../models/';
 import { ItemType } from '../types/';
+import { ColumnSetFactory } from './ColumnSetFactory';
 export declare class CollectionEntryFactory {
-    collectionEntryService: CollectionEntryService;
-    collectionResourceFactory: CollectionResourceFactory;
-    columnExpansionFactory: ColumnExpansionFactory;
-    columnHandler: ColumnHandler;
-    columnSetFactory: ColumnSetFactory;
-    errorHandler: ErrorHandlerInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    itemEntryFactory: ItemEntryFactory;
-    itemEntryService: ItemEntryService;
-    itemHandler: ItemHandler;
-    itemRequestService: ItemRequestService;
-    keyService: KeyService;
-    promiseService: PromiseLibraryInterface;
-    queryService: QueryService;
-    constructor(collectionEntryService: CollectionEntryService, collectionResourceFactory: CollectionResourceFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService);
+    private collectionEntryService;
+    private columnSetFactory;
+    private keyService;
+    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService);
     construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptionsInterface): CollectionEntry<ItemTypeType>;
 }

package/dist/src/factories/CollectionMatcherFactory.d.ts

@@ -1,8 +1,9 @@
-import { CollectionCache, CollectionMatcher } from '../classes';
+import { CollectionMatcher, ServerCache, TransactionCache } from '../classes';
 import { QueryMatcherFactory } from '../factories';
+import { CollectionEntry } from '../models';
 import { ItemType } from '../types';
 export declare class CollectionMatcherFactory {
     private queryMatcherFactory;
     constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct<ItemTypeType extends ItemType>(collectionCaches: CollectionCache[], updateInitial: boolean, callOnAdd: boolean, callOnActivate: boolean): CollectionMatcher<ItemTypeType>;
+    construct(transaction: TransactionCache | ServerCache, getCollectionEntries: <ItemTypeType extends ItemType>(itemType: ItemTypeType) => Array<CollectionEntry<ItemTypeType>>): CollectionMatcher;
 }

package/dist/src/factories/CollectionResourceFactory.d.ts

@@ -1,32 +1,34 @@
-import { ChangesProcessor, KeyService, LocalCache } from '../classes';
+import { KeyService } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEditResource, CollectionEntry, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
 import { ItemType } from '../types';
+import { ChangesDeltaFactory } from './ChangesDeltaFactory';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     exceptionHandler: ExceptionHandlerInterface;
     itemResourceFactory: ItemResourceFactory;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    changesProcessor: ChangesProcessor;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    changesDeltaFactory: ChangesDeltaFactory;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory);
     construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
         editCollection: true;
-    }, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
     construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
         editCollection: true;
-    }, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
     construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         editCollection: true;
-    }, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
     construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
-    }, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
     construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
-    }, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, transaction: TransactionCache): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
 }

package/dist/src/factories/ColumnSetFactory.d.ts

@@ -11,6 +11,8 @@ export declare class ColumnSetFactory {
     construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
     constructFromResponse<ItemTypeType extends ItemType>(itemType: ItemType, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean): ColumnSet<ItemTypeType>;
     private processResponseColumns;
+    private constructRequestColumnsFromRootColumnMap;
+    private expandRootColumnMapFromResponseColumns;
     private processRequestColumns;
     private processColumnInfo;
     private expandRootColumnMap;

package/dist/src/factories/CreateRequestFactory.d.ts

@@ -1,11 +1,11 @@
-import { CollectionCache, CollectionHandler, CreateCompilation, CreateRequest, KeyService } from '../classes';
-import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestParameterMap, ItemType } from '../types';
+import { ApiFormatter, CreateCompilation, CreateRequest, KeyService } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { RequestColumnExpansionFactory } from '../factories';
+import { ItemType } from '../types';
 export declare class CreateRequestFactory {
-    private collectionHandler;
-    private collectionMatcherFactory;
+    private apiFormatter;
     private keyService;
     private requestColumnExpansionFactory;
-    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory);
-    construct<ItemTypeType extends ItemType>(compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean): CreateRequest<ItemTypeType>;
+    constructor(apiFormatter: ApiFormatter, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    construct<ItemTypeType extends ItemType>(compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean): CreateRequest<ItemTypeType>;
 }

package/dist/src/factories/ItemCacheFactory.d.ts

@@ -1,7 +1,8 @@
 import { ItemCache } from '../classes';
+import { AbstractCache } from '../classes/cache/AbstractCache';
 import { QueryMatcherFactory } from '../factories';
 export declare class ItemCacheFactory {
     private queryMatcherFactory;
     constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(): ItemCache;
+    construct(transaction: AbstractCache): ItemCache;
 }

package/dist/src/factories/ItemEntryFactory.d.ts

@@ -1,8 +1,8 @@
 import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
 import { ColumnSetFactory, ItemResourceFactory } from '../factories';
 import { AuthInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry, Template } from '../models';
-import { ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ItemEntry } from '../models';
+import { ItemId, ItemType } from '../types';
 export declare class ItemEntryFactory {
     authInterface: AuthInterface;
     apiFormatter: ApiFormatter;
@@ -13,9 +13,5 @@ export declare class ItemEntryFactory {
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
     constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    constructStub<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, columnSetStub: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
-    constructLocalLinked<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, initial: FieldMap<ItemTypeType>, parent: EntryParentNull, columnSet: ColumnSet<ItemTypeType>, conversionMap: ItemIdConversionMap): ItemEntry<ItemTypeType>;
-    constructLocal<ItemTypeType extends ItemType>(itemId: ItemId, template: Template<ItemTypeType>, modified: FieldMap<ItemTypeType>, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet<ItemTypeType>, conversionMap?: ItemIdConversionMap): ItemEntry<ItemTypeType>;
-    constructDeferred<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, requestColumns: ApiRequestColumns, deferRequest: boolean): ItemEntry<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemId: ItemId, initial: FieldMap<ItemTypeType>, derived: FieldMap, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemId: ItemId, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
 }

package/dist/src/factories/ItemResourceFactory.d.ts

@@ -1,5 +1,7 @@
-import { ApiFormatter, ChangesProcessor, LocalCache, LockService } from '../classes';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ApiFormatter, ColumnUtil, LockService } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
 import { EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
 import { ItemOptionsInterface, ItemType } from '../types';
 export declare type ResourceConstructor<ItemTypeType extends ItemType, T extends ItemResource<ItemTypeType>> = (itemEntry: ItemEntry<ItemTypeType>) => T;
@@ -8,21 +10,23 @@ export declare class ItemResourceFactory {
     lockService: LockService;
     errorHandler: ErrorHandlerInterface;
     promiseService: PromiseLibraryInterface;
-    changesProcessor: ChangesProcessor;
-    constructor(apiFormatter: ApiFormatter, lockService: LockService, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
+    exceptionHandler: ExceptionHandlerInterface;
+    columnUtil: ColumnUtil;
+    linkTreeService: LinkTreeServiceInterface;
+    constructor(apiFormatter: ApiFormatter, lockService: LockService, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil, linkTreeService: LinkTreeServiceInterface);
     getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
         edit: true;
-    }, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, EditResource<ItemTypeType>>;
+    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, EditResource<ItemTypeType>>;
     getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
         remote: true;
-    }, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, transaction: TransactionCache): ResourceConstructor<ItemTypeType, LocalViewResource<ItemTypeType>>;
     construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
         edit: true;
-    }, localCache?: LocalCache | null, isNew?: boolean): EditResource<ItemTypeType>;
+    }, transaction: TransactionCache, isNew?: boolean): EditResource<ItemTypeType>;
     construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
         remote: true;
-    }, localCache?: LocalCache | null, isNew?: boolean): LocalViewResource<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, localCache?: LocalCache | null, isNew?: boolean): RemoteViewResource<ItemTypeType>;
+    }, transaction: TransactionCache, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, transaction: TransactionCache, isNew?: boolean): RemoteViewResource<ItemTypeType>;
     private constructWithOptions;
 }

package/dist/src/factories/ModuleChangesCompilationFactory.d.ts

@@ -1,6 +1,5 @@
-import { CollectionCache, ItemCache, ModuleChangesCompilation } from '../classes';
-import { ItemEntry } from '../models';
-import { ItemType } from '../types';
+import { ModuleChangesCompilation } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 export declare class ModuleChangesCompilationFactory {
-    construct<ItemTypeType extends ItemType>(rootItem: ItemEntry<ItemTypeType>, singleItemCache: ItemCache, collectionCache: CollectionCache): ModuleChangesCompilation<ItemTypeType>;
+    construct(transaction: TransactionCache): ModuleChangesCompilation;
 }

package/dist/src/factories/TransactionCacheFactory.d.ts

@@ -0,0 +1,55 @@
+import { ApiFormatter, ApiRequestService, CollectionEntryService, ColumnCache, ColumnHandler, ColumnUtil, ItemEntryService, KeyService, LockService, QueryService } from '../classes';
+import { ServerCache } from '../classes/cache/server/ServerCache';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { RequestBufferManager } from '../classes/RequestBufferManager';
+import { TemplateCache } from '../classes/TemplateCache';
+import { RmCore } from '../core';
+import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../factories';
+import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
+import { ChangesDeltaFactory } from './ChangesDeltaFactory';
+import { ChangesProcessorFactory } from './ChangesProcessorFactory';
+export declare class TransactionCacheFactory {
+    private core;
+    private columnCache;
+    private requestBufferManager;
+    private requestColumnExpansionFactory;
+    private queryMatcherFactory;
+    private authInterface;
+    private changesDeltaFactory;
+    private changesProcessorFactory;
+    private lockService;
+    private moduleChangesCompilationFactory;
+    private collectionResourceFactory;
+    private itemResourceFactory;
+    private templateCache;
+    private itemCacheFactory;
+    private collectionCacheFactory;
+    private errorHandler;
+    private exceptionHandler;
+    private promiseService;
+    private apiFormatter;
+    private apiRequestService;
+    private columnExpansionFactory;
+    private columnHandler;
+    private columnSetFactory;
+    private columnSubsetCacheFactory;
+    private columnUtil;
+    private itemEntryFactory;
+    private itemEntryService;
+    private keyService;
+    private collectionEntryFactory;
+    private collectionEntryService;
+    private collectionMatcherFactory;
+    private queryParserFactory;
+    private queryService;
+    private linkTreeService;
+    private readonly serverCache;
+    constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, changesProcessorFactory: ChangesProcessorFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiFormatter: ApiFormatter, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, linkTreeService: LinkTreeServiceInterface);
+    /**
+     * Todo[cache] Store a map of all transactions by transaction id ?
+     */
+    getById(id: string): TransactionCache | undefined;
+    construct(id?: string): TransactionCache;
+    getServerCache(): ServerCache;
+}

package/dist/src/factories/index.d.ts

@@ -1,5 +1,4 @@
 export * from './ApiResponseProcessorFactory';
-export * from './BatchStatusFactory';
 export * from './ChangesCompilationFactory';
 export * from './CollectionCacheFactory';
 export * from './CollectionEntryFactory';
@@ -13,9 +12,11 @@ export * from './CreateRequestFactory';
 export * from './ItemCacheFactory';
 export * from './ItemEntryFactory';
 export * from './ItemResourceFactory';
-export * from './LocalCacheFactory';
+export * from './TransactionCacheFactory';
 export * from './ModuleChangesCompilationFactory';
 export * from './QueryMatcherFactory';
 export * from './QueryParserFactory';
 export * from './RequestColumnExpansionFactory';
 export * from './TemplateFactory';
+export * from './ChangesDeltaFactory';
+export * from './ChangesProcessorFactory';

package/dist/src/interfaces/LinkTreeServiceInterface.d.ts

@@ -0,0 +1,4 @@
+import { ApiLinkTree } from '../types';
+export interface LinkTreeServiceInterface {
+    get: () => ApiLinkTree;
+}

package/dist/src/interfaces/index.d.ts

@@ -1,7 +1,7 @@
 export * from './PromiseLibraryInterface';
-export * from './LocalCacheManagerInterface';
 export * from './ErrorHandlerInterface';
 export * from './ExceptionHandlerInterface';
 export * from './AuthInterface';
 export * from './ApiRequestServiceInterface';
 export * from './SocketMessageInterface';
+export * from './LinkTreeServiceInterface';

package/dist/src/models/CollectionEditResource.d.ts

@@ -1,14 +1,37 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ChangesDeltaResult } from '../classes/ChangesDeltaBase';
 import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
-import { FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
+import { FieldMap, ItemId, ItemType, PromiseInterface } from '../types';
 export declare class CollectionEditResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
-    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, localCache: LocalCache | null);
-    save(): PromiseInterface<ItemIdConversionMap>;
-    moveItems(idArray: ItemId[], destination: CollectionResource<ItemTypeType>, enableCallbacks?: boolean): T[];
-    removeItems(idArray: ItemId[], callOnRemove?: boolean): PromiseInterface<T[]>;
-    removeItem(itemId: ItemId, callOnRemove?: boolean): PromiseInterface<T>;
-    addItems(valuesArray: Array<FieldMap<ItemTypeType>>, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T[]>;
-    addItem(values: FieldMap<ItemTypeType>, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T>;
-    clear(enableCallbacks: boolean): this["items"];
+    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transactionCache: TransactionCache);
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
+     */
+    moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemDeleted ChangesDelta.setItemDeleted}
+     */
+    removeItems(idArray: ItemId[]): void;
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemDeleted ChangesDelta.setItemDeleted}
+     */
+    removeItem(itemId: ItemId): void;
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemCreated ChangesDelta.setItemCreated}
+     *
+     * todo[cache] this will fetchCollectionEntry a template for you, make a convenience function ?
+     */
+    addItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemCreated ChangesDelta.setItemCreated}
+     *
+     * todo[cache] this will fetchCollectionEntry a template for you, make a convenience function ?
+     */
+    addItem(values: FieldMap<ItemTypeType>): PromiseInterface<ChangesDeltaResult>;
 }