@rentman/rm-core 2.0.19 → 2.1.1

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

@@ -1,3 +1,4 @@
+import { PromiseInterface } from '../types';
 export declare function instantiateOptions(options: {
     [key: string]: any;
 }, values: object): void;
@@ -19,6 +20,7 @@ export declare function isNumber(value: any): boolean;
 export declare function isDate(value: any): boolean;
 export declare const isArray: (arg: any) => arg is any[];
 export declare function isFunction<T>(value: any): value is T;
+export declare function isPromiseLike<T = any>(obj: any): obj is PromiseInterface<T>;
 export declare function isRegExp(value: any): boolean;
 export declare function isBoolean(value: any): boolean;
 export declare function isElement(node: any): boolean;

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

@@ -29,6 +29,7 @@ import { ServerItemEntryChanges, ServerItemHandler } from './server/ServerItemHa
 import { TransactionCache } from './transaction/TransactionCache';
 import { TransactionCollectionHandler } from './transaction/TransactionCollectionHandler';
 import { TransactionItemEntryChanges, TransactionItemHandler } from './transaction/TransactionItemHandler';
+import { TransactionValidatorFactory } from './transaction/TransactionValidator';
 export declare abstract class AbstractCache {
     core: RmCore;
     protected columnCache: ColumnCache;
@@ -68,7 +69,7 @@ export declare abstract class AbstractCache {
     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);
-    createChild(id?: string): TransactionCache;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
     abstract getLocalCollectionEntryByQueryString(itemType: ItemType, queryString: string): CollectionEntry | undefined;
     /**

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

@@ -1,5 +1,5 @@
 import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ApiRequestColumns, ApiRequestService, CollectionEntryOptions, CollectionMatcher, ColumnUtil, PromiseInterface } from '../../../index';
+import { ApiQuery, ApiRequestColumns, ApiRequestService, CollectionEntryOptions, CollectionMatcher, ColumnUtil, ItemEntryOptions, PromiseInterface } from '../../../index';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { CollectionEntry, ItemEntry } from '../../../models';
 import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
@@ -20,6 +20,7 @@ export declare class ServerCollectionHandler extends CollectionHandlerBase {
     private queryService;
     protected transaction: ServerCache;
     constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, columnExpansionFactory: ColumnExpansionFactory, apiRequestService: ApiRequestService, collectionCacheFactory: CollectionCacheFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, queryService: QueryService, columnUtil: ColumnUtil, transaction: ServerCache);
+    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     getCollectionMatcher(): CollectionMatcher;
     fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
     fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;

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

@@ -10,7 +10,7 @@ import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { CollectionEntryService } from '../../CollectionEntryService';
 import { ColumnHandler } from '../../ColumnHandler';
 import { ColumnUtil } from '../../ColumnUtil';
-import { ApiFormatter, ApiRequestService, ColumnCache, LockService, ModuleChangesCompilationResult, OnAfterCreateCallback, RequestBufferManager, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler } from '../../index';
+import { ApiFormatter, ApiRequestService, ColumnCache, LockService, ModuleChangesCompilationResult, OnAfterCreateCallback, RequestBufferManager, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../../index';
 import { InternalChangesDelta } from '../../InternalChangesDelta';
 import { ItemEntryService } from '../../ItemEntryService';
 import { KeyService } from '../../KeyService';
@@ -22,6 +22,10 @@ declare type EditResourceLinks<ItemTypeType extends ItemType> = {
     main: EditResource<ItemTypeType>;
     linked: ItemResourcesItemTypeMap;
 };
+export declare enum TransactionErrorLevel {
+    warning = "warning",
+    error = "error"
+}
 /**
  * @description
  * The {@link TransactionCache TransactionCache} is responsible for keeping track of newly created {@link ItemEntry ItemEntries}
@@ -35,6 +39,30 @@ export declare class TransactionCache extends AbstractCache {
      * For debugging purposes
      */
     id?: string | undefined;
+    /**
+     * @description
+     * A map of all item errors, can be populated using {@link TransactionValidator.setGlobalError TransactionValidator.setGlobalError} and {@link TransactionValidator.setItemError TransactionValidator.setItemError}.
+     * Contains a translation and level for every error
+     */
+    errors: {
+        item: {
+            [itemEntryId: string]: {
+                [columnId: string]: {
+                    [errorKey: string]: {
+                        string: string;
+                        level: TransactionErrorLevel;
+                    };
+                };
+            };
+        };
+        global: {
+            [key: string]: {
+                string: string;
+                level: TransactionErrorLevel;
+            };
+        };
+    };
+    isValid: boolean;
     /**
      * @description
      * Stores the 'root' {@link ItemEntry ItemEntry}, this {@link ItemEntry ItemEntry} can be used as request parent to store the whole transaction at once
@@ -67,14 +95,32 @@ export declare class TransactionCache extends AbstractCache {
     readonly collectionHandler: TransactionCollectionHandler;
     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, 
     /**
      * @description
      * For debugging purposes
      */
-    id?: string | undefined);
+    id?: string | undefined, validatorFactory?: TransactionValidatorFactory);
     destroy(): void;
     createChangesDelta(): ChangesDelta;
+    getFirstErrorString(): undefined | string;
+    /**
+     * @description
+     * Should only be called by {@link TransactionValidator TransactionValidator}
+     * @internal
+     */
+    _setGlobalError(key: string, isInvalid: boolean, errorTranslation: string, level: TransactionErrorLevel): void;
+    /**
+     * @description
+     * Should only be called by {@link TransactionValidator TransactionValidator}
+     * @internal
+     */
+    _setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean, errorTranslation: string, level: TransactionErrorLevel): void;
+    /**
+     * @internal
+     */
+    _setIsValid(): void;
     /**
      * @description
      * Merges the passed changes from the parent Transaction into this Transaction's own changes and then propagates
@@ -414,5 +460,7 @@ export declare class TransactionCache extends AbstractCache {
      * Fetches all required columns to match/fit in collections
      */
     private expandItemsFromDelta;
+    private clearGlobalError;
+    private clearItemError;
 }
 export {};

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

@@ -1,6 +1,6 @@
 import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
 import { ChangesDeltaFactory } from '../../../factories/ChangesDeltaFactory';
-import { ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ColumnUtil, ConversionMap, EntryParent, ExceptionHandlerInterface, ItemIdConversionMap, PromiseInterface } from '../../../index';
+import { ApiQuery, ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ColumnUtil, ConversionMap, EntryParent, ExceptionHandlerInterface, ItemEntryOptions, ItemIdConversionMap, PromiseInterface } from '../../../index';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { CollectionEntry, ItemEntry } from '../../../models';
 import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
@@ -23,6 +23,7 @@ export declare class TransactionCollectionHandler extends CollectionHandlerBase
         [collectionEntryId: number]: CollectionResource[];
     };
     constructor(requestColumnExpansionFactory: RequestColumnExpansionFactory, columnUtil: ColumnUtil, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnExpansionFactory: ColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, collectionCacheFactory: CollectionCacheFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, columnHandler: ColumnHandler, errorHandler: ErrorHandlerInterface, itemHandler: TransactionItemHandler, keyService: KeyService, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, transaction: TransactionCache);
+    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     getAllCollectionsByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): Array<CollectionEntry<ItemTypeType>>;
     createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
     /**
@@ -50,7 +51,7 @@ export declare class TransactionCollectionHandler extends CollectionHandlerBase
     expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
     addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
-    isLocal(options: CollectionEntryOptions): boolean;
+    isLocal(options: CollectionEntryOptions | ItemEntryOptions): boolean;
     expandCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
     /**
      * @description

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

@@ -8,6 +8,7 @@ import { ApiFormatter, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil,
 import { TemplateCache } from '../../TemplateCache';
 import { ItemHandlerBase } from '../ItemHandlerBase';
 import { TransactionCache } from './TransactionCache';
+import { TransactionValidator } from './TransactionValidator';
 export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType = any> = {
     initial: FieldMap<ItemTypeType>;
     changes: FieldMap<ItemTypeType>;
@@ -28,6 +29,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     private itemEntryService;
     private keyService;
     protected transaction: TransactionCache;
+    private validator?;
     deletedItems: ItemTypeMap<ItemEntry[]>;
     itemChanges: {
         [itemEntryId: number]: TransactionItemEntryChanges;
@@ -35,7 +37,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);
+    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);
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**

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

@@ -0,0 +1,28 @@
+import { ItemEntry } from '../../../models/index';
+import { FieldMap, ItemType, PromiseInterface } from '../../../types/index';
+import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
+export interface TransactionValidatorFactory {
+    construct(transaction: TransactionCache): TransactionValidator;
+}
+export declare abstract class TransactionValidator {
+    protected transaction: TransactionCache;
+    private lastCallId;
+    protected constructor(transaction: TransactionCache);
+    /**
+     * @description
+     * Will be called after {@link TransactionCache.applyChangesFromParent applyChangesFromParent}, {@link TransactionCache.applyChangesFromChild applyChangesFromChild} or {@link TransactionCache.applyChangesDelta applyChangesDelta} is called
+     * Allows you to set {@link TransactionCache.errors global errors}
+     */
+    abstract validateTransaction(): void;
+    /**
+     * @description
+     * Will be called whenever an item is changed, allows you to set errors on the transaction
+     * @param itemEntry
+     * @param fields
+     * @param previous
+     */
+    abstract validateItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): void;
+    protected setGlobalError(key: string, isInvalid: boolean | PromiseInterface<boolean>, errorTranslation: string, level: TransactionErrorLevel): void;
+    protected setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean | PromiseInterface<boolean>, errorTranslation: string, level: TransactionErrorLevel): void;
+    private getRandomId;
+}

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

@@ -35,6 +35,7 @@ export * from './cache/transaction/TransactionCache';
 export * from './cache/transaction/TransactionItemHandler';
 export * from './cache/transaction/TransactionCollectionHandler';
 export * from './cache/transaction/TransactionEventHandler';
+export * from './cache/transaction/TransactionValidator';
 export * from './ChangesDelta';
 export * from './InternalChangesDelta';
 export * from './RequestBufferManager';

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

@@ -1,6 +1,7 @@
 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 { TransactionValidatorFactory } from '../classes/cache/transaction/TransactionValidator';
 import { RequestBufferManager } from '../classes/RequestBufferManager';
 import { TemplateCache } from '../classes/TemplateCache';
 import { RmCore } from '../core';
@@ -50,6 +51,6 @@ export declare class TransactionCacheFactory {
      * Todo[cache] Store a map of all transactions by transaction id ?
      */
     getById(id: string): TransactionCache | undefined;
-    construct(id?: string): TransactionCache;
+    construct(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
     getServerCache(): ServerCache;
 }

package/package.json

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