@rentman/rm-core 2.1.1 → 2.2.0

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

@@ -1,7 +1,8 @@
 import { ItemEntry } from '../models';
-import { EntryParent, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
+import { EntryParent, EntryParentNull, FieldMap, ItemId, ItemType, PromiseInterface } from '../types';
 import { ChangesDeltaBase } from './ChangesDeltaBase';
 import { ColumnSet } from './ColumnSet';
+import { ItemCreateService } from './ItemCreateService';
 import { ItemEntryService } from './ItemEntryService';
 export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType = any> = {
     itemId: ItemId;
@@ -20,20 +21,39 @@ export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType =
  * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
  */
 export declare class ChangesDelta extends ChangesDeltaBase {
+    private itemCreateService;
     created: ChangesDeltaItemCreateDelta[];
-    constructor(itemEntryService: ItemEntryService);
+    constructor(itemCreateService: ItemCreateService, itemEntryService: ItemEntryService);
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemCreated<ItemTypeType extends ItemType>(itemType: ItemTypeType, values: FieldMap<ItemTypeType>): PromiseInterface<void>;
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemsCreated<ItemTypeType extends ItemType>(itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<void>;
     /**
      * @description
      * Will create an {@link ItemEntry ItemEntry} when the delta is applied
      * Does not always mean the item is local, just that it isn't cached yet
      *
-     * ------
-     *
      * @remark
-     * When the `parent` property is passed it will automatically set the proper fields to match the parent, this assumes the required parent columns are in the passed columns
-     * You can easily get the required columns by also passing the `parent` to the {@link TemplateCache.fetchTemplate template fetchCollectionEntry} call
+     * If you're calling this from the frontend you probably want to call `setItemCreated`, which will fetch a template and process the values for you
+     * If you don't, you have to make sure the values are all correct and all template items are processed
+     *
+     * @internal
      */
-    setItemCreated<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): void;
+    _setItemCreated<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): void;
     /**
      * @description
      * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally

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

@@ -0,0 +1,28 @@
+import { ColumnSetFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { Template } from '../models';
+import { EntryParentNull, FieldMap, FilterItemEntryCallback, ItemId, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../types';
+import { ApiFormatter } from './ApiFormatter';
+import { ChangesDelta } from './ChangesDelta';
+import { ColumnInfo } from './ColumnInfo';
+import { ItemEntryService } from './ItemEntryService';
+import { KeyService } from './KeyService';
+import { TemplateCache } from './TemplateCache';
+export declare class ItemCreateService {
+    private keyService;
+    private templateCache;
+    private promiseService;
+    private errorHandler;
+    private itemEntryService;
+    private apiFormatter;
+    private columnSetFactory;
+    constructor(keyService: KeyService, templateCache: TemplateCache, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory);
+    /**
+     * @description
+     * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
+     */
+    createItemsFromValues<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType>>, parent?: EntryParentNull): PromiseInterface<void>;
+    processTemplate<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+    processTemplateLinkItems<ParentItemType extends ItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+    updateItemValues<ItemTypeType extends ItemType>(changes: FieldMap<ItemTypeType>, parent: EntryParentNull, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap): FieldMap<ItemTypeType>;
+}

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

@@ -1,8 +1,7 @@
 import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { PromiseLibraryInterface } from '../interfaces';
 import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
-import { ApiResponseProcessor } from './ApiResponseProcessor';
 import { ServerCache } from './cache/server/ServerCache';
 import { KeyService } from './KeyService';
 import { RequestBufferResponse } from './RequestBuffer';
@@ -11,22 +10,15 @@ export declare class RequestBufferManager {
     private apiRequestService;
     private requestColumnExpansionFactory;
     private keyService;
-    private errorHandler;
     private changesDeltaFactory;
     private pendingBufferMap;
     private pendingTrueBufferMap;
-    private pendingQueryBufferMap;
-    private pendingTemplateBufferMap;
     private serverCache;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, errorHandler: ErrorHandlerInterface, changesDeltaFactory: ChangesDeltaFactory);
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
     setServerCache(serverCache: ServerCache): void;
-    containsId(itemType: ItemType, itemId: ItemId): boolean;
-    containsQuery(itemType: ItemType, queryString: string): boolean;
     fetchByIds(itemType: ItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     fetchById(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     fetchByQuery(itemType: ItemType, query: [object, string], // queryParser result
     requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchByLocalId(itemType: ItemType, itemId?: ItemId | string, templateOptions?: any): PromiseInterface<ApiResponseProcessor>;
     private constructBuffer;
-    private constructTemplateBuffer;
 }

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

@@ -2,21 +2,22 @@ import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { Template } from '../models';
 import { EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
 import { ColumnHandler } from './ColumnHandler';
 import { ColumnUtil } from './ColumnUtil';
-import { RequestBufferManager } from './RequestBufferManager';
 export declare class TemplateCache {
     private columnUtil;
     private promiseService;
-    private requestBufferFactory;
     private columnHandler;
     private templateFactory;
     private errorHandler;
     private requestColumnExpansionFactory;
+    private apiRequestService;
+    private pendingTemplateBufferMap;
     templates: {
         [itemType: string]: Template<any>;
     };
-    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, requestBufferFactory: RequestBufferManager, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
     /**
      * @description
      * Fetches a {@link Template template}, {@link TransactionItemHandler.createItems TransactionItemHandler.createItems} is a convenience function for this
@@ -60,4 +61,6 @@ export declare class TemplateCache {
      *  ```
      */
     fetchTemplate<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType>>;
+    private fetchTemplateById;
+    private constructTemplateBuffer;
 }

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

@@ -17,6 +17,7 @@ import { ColumnHandler } from '../ColumnHandler';
 import { ColumnUtil } from '../ColumnUtil';
 import { InternalChangesDelta } from '../InternalChangesDelta';
 import { ItemCache } from '../ItemCache';
+import { ItemCreateService } from '../ItemCreateService';
 import { ItemEntryService } from '../ItemEntryService';
 import { KeyService } from '../KeyService';
 import { LockService } from '../LockService';
@@ -64,11 +65,12 @@ export declare abstract class AbstractCache {
     protected queryService: QueryService;
     protected apiFormatter: ApiFormatter;
     protected linkTreeService: LinkTreeServiceInterface;
+    protected changesDeltaService: ItemCreateService;
     children: TransactionCache[];
     readonly itemHandler: TransactionItemHandler | ServerItemHandler;
     readonly collectionHandler: TransactionCollectionHandler | ServerCollectionHandler;
     parent: AbstractCache | null;
-    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);
+    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, changesDeltaService: ItemCreateService);
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
     abstract getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;

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

@@ -17,6 +17,7 @@ import { ColumnCache } from '../../ColumnCache';
 import { ColumnHandler } from '../../ColumnHandler';
 import { ColumnUtil } from '../../ColumnUtil';
 import { InternalChangesDelta } from '../../InternalChangesDelta';
+import { ItemCreateService } from '../../ItemCreateService';
 import { ItemEntryService } from '../../ItemEntryService';
 import { KeyService } from '../../KeyService';
 import { LockService } from '../../LockService';
@@ -39,7 +40,7 @@ export declare class ServerCache extends AbstractCache {
     readonly itemHandler: ServerItemHandler;
     readonly collectionHandler: ServerCollectionHandler;
     parent: null;
-    constructor(changesProcessorFactory: ChangesProcessorFactory, 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, 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);
+    constructor(changesProcessorFactory: ChangesProcessorFactory, 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, 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, changesDeltaService: ItemCreateService);
     getServerCache(): ServerCache;
     processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
     /**

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

@@ -12,6 +12,7 @@ import { ColumnHandler } from '../../ColumnHandler';
 import { ColumnUtil } from '../../ColumnUtil';
 import { ApiFormatter, ApiRequestService, ColumnCache, LockService, ModuleChangesCompilationResult, OnAfterCreateCallback, RequestBufferManager, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../../index';
 import { InternalChangesDelta } from '../../InternalChangesDelta';
+import { ItemCreateService } from '../../ItemCreateService';
 import { ItemEntryService } from '../../ItemEntryService';
 import { KeyService } from '../../KeyService';
 import { QueryService } from '../../QueryService';
@@ -96,7 +97,7 @@ export declare class TransactionCache extends AbstractCache {
     private readonly eventHandler;
     private changesInterval;
     private validator?;
-    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, parent: AbstractCache, 
+    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, changesDeltaService: ItemCreateService, parent: AbstractCache, 
     /**
      * @description
      * For debugging purposes

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

@@ -1,10 +1,11 @@
-import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../../factories';
+import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry, ItemEntryOptions, ItemResource, Template } from '../../../models';
-import { ApiQuery, ApiRequestColumns, EntryParentNull, FieldMap, FilterItemEntryCallback, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
+import { ApiQuery, ApiRequestColumns, FieldMap, 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';
+import { ApiFormatter, ColumnHandler, ColumnSubsetCache, ColumnUtil, ItemEntryService, KeyService } from '../../index';
+import { ItemCreateService } from '../../ItemCreateService';
 import { TemplateCache } from '../../TemplateCache';
 import { ItemHandlerBase } from '../ItemHandlerBase';
 import { TransactionCache } from './TransactionCache';
@@ -24,10 +25,10 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     private templateCache;
     private columnExpansionFactory;
     private columnHandler;
-    private columnSetFactory;
     private columnSubsetCacheFactory;
     private itemEntryService;
     private keyService;
+    private changesDeltaService;
     protected transaction: TransactionCache;
     private validator?;
     deletedItems: ItemTypeMap<ItemEntry[]>;
@@ -37,7 +38,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, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    constructor(changesDeltaFactory: ChangesDeltaFactory, exceptionHandler: ExceptionHandlerInterface, templateCache: TemplateCache, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, changesDeltaService: ItemCreateService, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, validator?: TransactionValidator | undefined);
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
@@ -45,11 +46,6 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * Gets the local {@link FieldMap changes} of the {@link ItemEntry entry} on the {@link TransactionCache transaction} in a formatted way the API accepts
      */
     formatRequest<ItemEntryType extends ItemEntry>(entry: ItemEntryType): FieldMap<ItemEntryType['itemType']>;
-    /**
-     * @description
-     * Fetches a new {@link Template template} and creates new {@link ItemEntry itemEntries} with the passed values
-     */
-    createItems<ItemTypeType extends ItemType>(itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType>>, parent: EntryParentNull): PromiseInterface<ChangesDeltaResult>;
     clearItemEntry(entry: ItemEntry): void;
     /**
      * @description
@@ -98,9 +94,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, 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>;
     /**
      * @description
      * Fetches the data for the passed ItemType/ItemId/columns, is able to fetchCollectionEntry non-local derived values.
@@ -111,7 +105,6 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     fetchLocalItemEntryData<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
     fetchLocalItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     private getColumnDifference;
-    private resolveLocal;
     private expandLocalItemEntry;
     private getLocalValues;
 }

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

@@ -40,3 +40,4 @@ export * from './ChangesDelta';
 export * from './InternalChangesDelta';
 export * from './RequestBufferManager';
 export * from './RequestBuffer';
+export * from './ItemCreateService';

package/dist/src/core.d.ts

@@ -1,4 +1,5 @@
 import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
+import { ItemCreateService } from './classes/ItemCreateService';
 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';
@@ -28,6 +29,7 @@ export declare class RmCore {
     columnUtil: ColumnUtil;
     createRequestFactory: CreateRequestFactory;
     itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
     itemEntryFactory: ItemEntryFactory;
     itemEntryService: ItemEntryService;
     itemResourceFactory: ItemResourceFactory;

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

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

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

@@ -1,4 +1,4 @@
-import { KeyService } from '../classes';
+import { ItemEntryService, KeyService } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
@@ -12,7 +12,8 @@ export declare class CollectionResourceFactory {
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
     changesDeltaFactory: ChangesDeltaFactory;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory);
+    itemEntryService: ItemEntryService;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory, itemEntryService: ItemEntryService);
     construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
         editCollection: true;

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

@@ -2,6 +2,7 @@ import { ApiFormatter, ApiRequestService, CollectionEntryService, ColumnCache, C
 import { ServerCache } from '../classes/cache/server/ServerCache';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { TransactionValidatorFactory } from '../classes/cache/transaction/TransactionValidator';
+import { ItemCreateService } from '../classes/ItemCreateService';
 import { RequestBufferManager } from '../classes/RequestBufferManager';
 import { TemplateCache } from '../classes/TemplateCache';
 import { RmCore } from '../core';
@@ -45,8 +46,9 @@ export declare class TransactionCacheFactory {
     private queryParserFactory;
     private queryService;
     private linkTreeService;
+    private changesDeltaService;
     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);
+    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, changesDeltaService: ItemCreateService);
     /**
      * Todo[cache] Store a map of all transactions by transaction id ?
      */

package/package.json

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