@rentman/rm-core 2.0.8 → 2.0.10

package/dist/src/classes/cache/AbstractCache.d.ts

@@ -70,6 +70,11 @@ export declare abstract class AbstractCache {
     protected constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, 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, apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface);
     createChild(id?: string): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
+    /**
+     * @description
+     * Returns this transaction and all parents
+     */
+    getTransactionChain(): AbstractCache[];
     /**
      * @description
      * Returns the {@link TransactionCollectionHandler.entries CollectionCache} of the transaction

package/dist/src/classes/cache/CollectionHandlerBase.d.ts

@@ -60,5 +60,5 @@ export declare abstract class CollectionHandlerBase {
      * Expands the option's {@link CollectionEntryOptions.columns columns} with the columns required for the {@link CollectionMatcher CollectionMatcher} to function.
      * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionEntryOptions.queryColumns queryColumns} should also be taken into account
      */
-    protected expandColumnsWithQueryColumns(itemType: ItemType, options: CollectionEntryOptions, query?: ApiQuery): void;
+    protected expandColumnsWithQueryColumns(itemType: ItemType, options: CollectionEntryOptions, query: ApiQuery): void;
 }

package/dist/src/classes/cache/ItemHandlerBase.d.ts

@@ -1,7 +1,7 @@
-import { ItemCacheFactory, ItemEntryFactory } from '../../factories';
+import { ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../models';
-import { ApiQuery, FieldMap, ItemId, ItemType, PromiseInterface } from '../../types';
+import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../types';
 import { ApiFormatter } from '../ApiFormatter';
 import { ChangesDeltaItemCreateDelta } from '../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
@@ -17,10 +17,11 @@ export declare abstract class ItemHandlerBase {
     protected itemEntryFactory: ItemEntryFactory;
     protected promiseService: PromiseLibraryInterface;
     protected errorHandler: ErrorHandlerInterface;
+    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
     protected transaction: AbstractCache;
     readonly entries: ItemCache;
     abstract itemChanges: ServerItemEntryChanges | TransactionItemEntryChanges;
-    protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
+    protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
     /**
      * @description
      * Copies the passed ItemEntryChanges into a format the implementing ItemHandler can put in his ItemChanges
@@ -90,4 +91,5 @@ export declare abstract class ItemHandlerBase {
      * Gets the value of the given column, will look into the current delta before attempting to read itemChanges
      */
     protected getItemIdByColumn<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, column: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): ItemId;
+    protected expandColumnsWithCollectionColumns(itemType: ItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
 }

package/dist/src/classes/cache/server/ServerItemHandler.d.ts

@@ -1,4 +1,4 @@
-import { ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, QueryParserFactory } from '../../../factories';
+import { ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../../models';
 import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../../types';
@@ -17,7 +17,7 @@ export declare class ServerItemHandler extends ItemHandlerBase {
     itemChanges: {
         [itemEntryId: number]: ServerItemEntryChanges;
     };
-    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, transaction: ServerCache);
+    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: ServerCache);
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description

package/dist/src/classes/cache/transaction/TransactionCache.d.ts

@@ -401,11 +401,6 @@ export declare class TransactionCache extends AbstractCache {
         remoteItems: true;
     }): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
     createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    /**
-     * @description
-     * Returns this transaction and all parents
-     */
-    getTransactionChain(): AbstractCache[];
     getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
     private createCollectionResources;
     /**

package/dist/src/classes/cache/transaction/TransactionItemHandler.d.ts

@@ -1,7 +1,7 @@
-import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory } from '../../../factories';
+import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { ItemEntry, ItemEntryOptions, ItemResource, Template } from '../../../models';
-import { ApiQuery, ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ApiQuery, ApiRequestColumns, EntryParentNull, FieldMap, FilterItemEntryCallback, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
 import { ChangesDelta, ChangesDeltaItemCreateDelta } from '../../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { ApiFormatter, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil, ItemEntryService, KeyService } from '../../index';
@@ -35,7 +35,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     itemResources: {
         [itemEntryId: number]: ItemResource[];
     };
-    constructor(changesDeltaFactory: ChangesDeltaFactory, exceptionHandler: ExceptionHandlerInterface, templateCache: TemplateCache, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, transaction: TransactionCache);
+    constructor(changesDeltaFactory: ChangesDeltaFactory, exceptionHandler: ExceptionHandlerInterface, templateCache: TemplateCache, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache);
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
@@ -83,8 +83,8 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * The previous changes {@link FieldMap FieldMap}
      */
     processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType> | null;
-    cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): PromiseInterface<ChangesDeltaResult>;
-    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): ItemId;
+    cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): PromiseInterface<ChangesDeltaResult>;
+    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**
@@ -95,8 +95,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
     resolveLocalItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    createLocalEntries(changesDelta: ChangesDelta, parentType: ItemType, localParentId: ItemId, template: Template<ItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntry?: <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>) => boolean, // return true to include item
-    modifyFieldsCallback?: <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>, itemIdConversionMap: ItemIdConversionMap) => void): void;
+    createLocalEntries(changesDelta: ChangesDelta, parentType: ItemType, localParentId: ItemId, template: Template<ItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
     expandLocalItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     updateItemValues<ItemTypeType extends ItemType>(changes: FieldMap<ItemTypeType>, parent: EntryParentNull, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap): FieldMap<ItemTypeType>;
     /**

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

@@ -1,10 +1,10 @@
 import { ColumnUtil } from '../classes';
 import { ColumnSetFactory } from '../factories';
 import { Template } from '../models';
-import { ApiResponse, ItemType, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumnMap, ApiResponse, ItemType, ResponseColumnItemTypeMap } from '../types';
 export declare class TemplateFactory {
     columnSetFactory: ColumnSetFactory;
     columnUtil: ColumnUtil;
     constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, response: ApiResponse, additionalColumns: ResponseColumnItemTypeMap): Template<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap): Template<ItemTypeType>;
 }

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

@@ -1,11 +1,11 @@
 import { ColumnSet } from '../classes';
 import { TemplateFactory } from '../factories';
-import { ApiResponse, FieldMap, ItemType, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumnMap, ApiResponse, FieldMap, ItemType, ResponseColumnItemTypeMap } from '../types';
 export declare class Template<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
     response: ApiResponse;
     fields: FieldMap<ItemTypeType>;
     responseColumns: ResponseColumnItemTypeMap;
     columns: ColumnSet<ItemTypeType>;
-    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalColumns: ResponseColumnItemTypeMap);
+    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap);
 }

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

@@ -254,3 +254,9 @@ export declare type ApiLinkTree = {
         [childType: string]: ApiLinkTreeEntry;
     };
 };
+/**
+ * @description
+ * Callback to determine if an item should be included in the create delta, return `false` to exclude the item
+ */
+export declare type FilterItemEntryCallback = <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>) => boolean;
+export declare type ModifyFieldsCallback = <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>, itemIdConversionMap?: ItemIdConversionMap) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/src/index.d.ts",