@rentman/rm-core 0.0.0-RM4-44763

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

@@ -0,0 +1,7 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumns, ChildCollectionResources, ErrorHandlerInterface, ItemEntry, ItemResource, TransactionCache } from '../internal';
+export declare class ItemResourceFactory {
+    errorHandler: ErrorHandlerInterface;
+    constructor(errorHandler: ErrorHandlerInterface);
+    construct<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumns<ItemTypeType>, Children extends ChildCollectionResources | undefined>(itemEntry: ItemEntry<ItemTypeType>, transaction: TransactionCache, isNew?: boolean, abortSignal?: AbortSignal): ItemResource<ItemTypeType, RequestColumns, Children>;
+}

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

@@ -0,0 +1,6 @@
+import { LinkTreeServiceInterface, ModuleChangesCompilation, TransactionCache } from '../internal';
+export declare class ModuleChangesCompilationFactory {
+    private linkTreeService;
+    constructor(linkTreeService: LinkTreeServiceInterface);
+    construct(transaction: TransactionCache): ModuleChangesCompilation;
+}

package/dist/types/src/factories/RequestColumnExpansionFactory.d.ts

@@ -0,0 +1,4 @@
+import { RequestColumnExpansion } from '../internal';
+export declare class RequestColumnExpansionFactory {
+    construct(): RequestColumnExpansion;
+}

package/dist/types/src/factories/RequestColumnsOperationsCacheFactory.d.ts

@@ -0,0 +1,7 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiRequestColumns, ColumnCache, RequestColumnsOperationsCache } from '../internal';
+export declare class RequestColumnsOperationsCacheFactory {
+    private columnCache;
+    constructor(columnCache: ColumnCache);
+    construct<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns<ItemTypeType>): RequestColumnsOperationsCache<ItemTypeType>;
+}

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

@@ -0,0 +1,12 @@
+import { ApiFieldsOnDeleteRule } from '@rentman/backend-types';
+import { RmCore, ServerCache, ServerCacheDependencyInterface, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../internal';
+export declare class TransactionCacheFactory {
+    private readonly serverCache;
+    constructor(serverCacheDependencies: ServerCacheDependencyInterface, apiFieldsOnDeleteRule: typeof ApiFieldsOnDeleteRule, core: RmCore);
+    /**
+     * Todo[cache] Store a map of all transactions by transaction id ?
+     */
+    getById(id: string): TransactionCache | undefined;
+    construct(id?: string, validatorFactory?: TransactionValidatorFactory, transactionOptions?: TransactionOptions): TransactionCache;
+    getServerCache(): ServerCache;
+}

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

@@ -0,0 +1,11 @@
+export * from './internal';
+export * from './classes/BusinessLogicManager/Materiaal/MateriaalIsCombinationBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Materiaal/MateriaalBulkToSerialBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Materiaal/MateriaalSerialToBulkBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Materiaal/MateriaalToPhysicalBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Materiaal/MateriaalToVirtualBusinessLogicRule';
+export * from './classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/LinkedTimeItemSubprojectBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Project/ProjectClientChangedBusinessLogicRule';
+export * from './classes/BusinessLogicManager/PurchaseOrder/PurchaseOrderOwnerBusinessLogicRule';
+export * from './classes/BusinessLogicManager/Subproject/SubprojectInPlanningBusinessLogicRule';
+export * from './services/rm-holidays.service';

package/dist/types/src/interfaces/AbstractCacheDependencyInterface.d.ts

@@ -0,0 +1,46 @@
+import { ApiRequestService } from '../classes/ApiRequestService';
+import { BusinessLogicManager } from '../classes/BusinessLogicManager/BusinessLogicManager';
+import { ColumnCache } from '../classes/ColumnCache';
+import { ColumnHandler } from '../classes/ColumnHandler';
+import { ConversionMapService } from '../classes/ConversionMapService';
+import { ItemCreateService } from '../classes/ItemCreateService';
+import { ItemEntryService } from '../classes/ItemEntryService';
+import { LockService } from '../classes/LockService';
+import { QueryService } from '../classes/QueryService';
+import { TemplateCache } from '../classes/TemplateCache';
+import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
+import { CollectionResourceFactory } from '../factories/CollectionResourceFactory';
+import { ColumnExpansionFactory } from '../factories/ColumnExpansionFactory';
+import { ColumnSetFactory } from '../factories/ColumnSetFactory';
+import { GraphQueryParserFactory } from '../factories/GraphQueryParserFactory';
+import { ItemCacheFactory } from '../factories/ItemCacheFactory';
+import { ItemResourceFactory } from '../factories/ItemResourceFactory';
+import { ModuleChangesCompilationFactory } from '../factories/ModuleChangesCompilationFactory';
+import { RequestColumnExpansionFactory } from '../factories/RequestColumnExpansionFactory';
+import { RequestColumnsOperationsCacheFactory } from '../factories/RequestColumnsOperationsCacheFactory';
+import { ErrorHandlerInterface } from './ErrorHandlerInterface';
+import { LinkTreeServiceInterface } from './LinkTreeServiceInterface';
+export interface AbstractCacheDependencyInterface {
+    apiRequestService: ApiRequestService;
+    businessLogicManager: BusinessLogicManager;
+    changesDeltaFactory: ChangesDeltaFactory;
+    collectionResourceFactory: CollectionResourceFactory;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnSetFactory: ColumnSetFactory;
+    conversionMapService: ConversionMapService;
+    errorHandler: ErrorHandlerInterface;
+    graphQueryParserFactory: GraphQueryParserFactory;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
+    linkTreeService: LinkTreeServiceInterface;
+    lockService: LockService;
+    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    queryService: QueryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    templateCache: TemplateCache;
+}

package/dist/types/src/interfaces/ApiRequestServiceInterface.d.ts

@@ -0,0 +1,14 @@
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiRequestColumns, ApiRequestItemMap, ApiRequestLimit } from '../internal';
+export interface ApiRequestServiceInterface {
+    template(itemType: ApiItemType, params: any): Promise<any>;
+    create(itemType: ApiItemType, itemId: ItemId, values: any, columns: ApiRequestColumnMap, parentType?: ApiItemType, parentId?: ItemId, uniqueTransactionId?: string): Promise<any>;
+    delete(itemType: ApiItemType, itemIds: ItemId[], uniqueTransactionId?: string): Promise<any>;
+    updateItems(itemType: ApiItemType, items: ApiRequestItemMap, columns: ApiRequestColumnMap, uniqueTransactionId?: string): Promise<any>;
+    requestSkeleton(params: any, requestCanceler?: Promise<any>): Promise<any>;
+    columns(itemType: ApiItemType, columns: {
+        [itemType: string]: ApiRequestColumns | true;
+    }, params?: any): Promise<any>;
+    query(itemType: ApiItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): Promise<any>;
+    _module(module: string, method: string, params: Record<string, unknown>): Promise<any>;
+}

package/dist/types/src/interfaces/ErrorHandlerInterface.d.ts

@@ -0,0 +1,6 @@
+export interface ErrorHandlerInterface {
+    notifyError(error?: any): void;
+    logError(error: Error): void;
+    logWarning(message: string, data?: any): void;
+    logDebug(message: string): void;
+}

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

@@ -0,0 +1,6 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { ApiLinkTree, ApiRequestColumnArray } from '../internal';
+export interface LinkTreeServiceInterface {
+    get: () => ApiLinkTree;
+    getColumnsFromLink<ParentItemType extends ApiItemType, ChildItemType extends ApiItemType>(parentType: ParentItemType, itemType: ChildItemType): ApiRequestColumnArray<ChildItemType>;
+}

package/dist/types/src/interfaces/ServerCacheDependencyInterface.d.ts

@@ -0,0 +1,6 @@
+import { AbstractCacheDependencyInterface, ApiRequestService, ChangesCompilationFactory, ItemCreateService } from '../internal';
+export interface ServerCacheDependencyInterface extends AbstractCacheDependencyInterface {
+    apiRequestService: ApiRequestService;
+    itemCreateService: ItemCreateService;
+    changesCompilationFactory: ChangesCompilationFactory;
+}

package/dist/types/src/interfaces/SocketMessageInterface.d.ts

@@ -0,0 +1,3 @@
+export interface SocketMessageInterface {
+    on(event: string, messageHandler: (message: any) => void): () => boolean;
+}

package/dist/types/src/interfaces/TransactionCollectionHandlerDependencyInterface.d.ts

@@ -0,0 +1,15 @@
+import { GraphQueryParserFactory } from '../factories/GraphQueryParserFactory';
+import { ApiRequestService, ChangesDeltaFactory, ColumnCache, ColumnExpansionFactory, ColumnHandler, ErrorHandlerInterface, LinkTreeServiceInterface, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory } from '../internal';
+export interface TransactionCollectionHandlerDependencyInterface {
+    apiRequestService: ApiRequestService;
+    changesDeltaFactory: ChangesDeltaFactory;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    errorHandler: ErrorHandlerInterface;
+    linkTreeService: LinkTreeServiceInterface;
+    queryService: QueryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    graphQueryParserFactory: GraphQueryParserFactory;
+}

package/dist/types/src/interfaces/TransactionItemHandlerDependencyInterface.d.ts

@@ -0,0 +1,16 @@
+import { ChangesDeltaFactory, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnSetFactory, ConversionMapService, ErrorHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryService, RequestColumnExpansionFactory, RequestColumnsOperationsCacheFactory, TemplateCache } from '../internal';
+export interface TransactionItemHandlerDependencyInterface {
+    changesDeltaFactory: ChangesDeltaFactory;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnCache: ColumnCache;
+    columnSetFactory: ColumnSetFactory;
+    conversionMapService: ConversionMapService;
+    errorHandler: ErrorHandlerInterface;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryService: ItemEntryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    requestColumnsOperationsCacheFactory: RequestColumnsOperationsCacheFactory;
+    templateCache: TemplateCache;
+}

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

@@ -0,0 +1,110 @@
+/**
+ * This is the only place where things should be exported. *All files* should import from this file.
+ * Exports here should be ordered by inheritance.
+ */
+export * from './constants';
+export * from './types/ItemTypesCollection';
+export * from './types/ApiQuery';
+export * from './types/AggregatedChangesListener';
+export * from './models/ItemOptions';
+export * from './models/ItemEntry';
+export * from './models/ItemResource';
+export * from './models/CachedQueryItem';
+export * from './models/CollectionOptions';
+export * from './models/CollectionEntry';
+export * from './models/CollectionResource';
+export * from './models/OrderedCollectionResource';
+export * from './models/LimitedCollectionResource';
+export * from './models/Template';
+export * from './interfaces/ErrorHandlerInterface';
+export * from './interfaces/ApiRequestServiceInterface';
+export * from './interfaces/SocketMessageInterface';
+export * from './interfaces/LinkTreeServiceInterface';
+export * from './classes/Util';
+export * from './classes/ApiFormatter';
+export * from './classes/ApiRequestService';
+export * from './classes/ApiResponseProcessor';
+export * from './classes/ChangesCompilation';
+export * from './classes/ChangesProcessor';
+export * from './classes/ColumnCache';
+export * from './classes/ColumnExpansion';
+export * from './classes/ColumnHandler';
+export * from './classes/ColumnInfo';
+export * from './classes/ColumnSet';
+export * from './classes/RequestColumnsOperationsCache';
+export * from './classes/ColumnUtil';
+export * from './classes/ConversionMapService';
+export * from './classes/CreateRequest';
+export * from './classes/ItemCache';
+export * from './classes/ItemEntryService';
+export * from './classes/KeyService';
+export * from './classes/cache/transaction/TransactionEventHandler';
+export * from './classes/LockService';
+export * from './classes/ModuleChangesCompilation';
+export * from './classes/matcher/GraphQueryParser';
+export * from './classes/QueryParserBase';
+export * from './classes/QueryColumnExtractor';
+export * from './classes/QueryContainsLocalIdParser';
+export * from './classes/QueryParser';
+export * from './classes/QueryParserIdUpdater';
+export * from './classes/QueryService';
+export * from './classes/RequestColumnExpansion';
+export * from './classes/SocketMessageHandler';
+export * from './classes/cache/AbstractCache';
+export * from './classes/cache/server/ServerCache';
+export * from './classes/cache/ItemMatcherBase';
+export * from './classes/cache/ItemHandlerBase';
+export * from './classes/cache/server/ServerItemHandler';
+export * from './classes/cache/CachedQueryHandlerBase';
+export * from './classes/cache/server/ServerCachedQueryHandler';
+export * from './classes/cache/transaction/TransactionCache';
+export * from './classes/cache/transaction/TransactionItemHandler';
+export * from './classes/cache/transaction/TransactionCachedQueryHandler';
+export * from './classes/cache/transaction/TransactionEventHandler';
+export * from './classes/cache/transaction/TransactionValidator';
+export * from './classes/cache/transaction/TransactionValidatorWithDependencies';
+export * from './classes/ChangesDeltaBase';
+export * from './classes/ChangesDelta';
+export * from './classes/ChildChangesDelta';
+export * from './classes/ParentChangesDelta';
+export * from './classes/RequestBuffer/RequestBufferBase';
+export * from './classes/RequestBuffer/RequestBuffer';
+export * from './classes/RequestBuffer/SingleQueryRequestBuffer';
+export * from './classes/RequestBuffer/RequestBufferManager';
+export * from './classes/ItemCreateService';
+export * from './classes/CreatedChangesDelta';
+export * from './classes/TemplateCache';
+export * from './classes/changes/ItemChangesListenerContextBase';
+export * from './classes/changes/ItemChangesListenerContext';
+export * from './classes/changes/CollectionItemChangesListenerContext';
+export * from './classes/BusinessLogicManager/BusinessLogicRuleContextBase';
+export * from './classes/BusinessLogicManager/BusinessLogicRuleConditionContext';
+export * from './classes/BusinessLogicManager/BusinessLogicRuleApplyContext';
+export * from './classes/BusinessLogicManager/BusinessLogicRule';
+export * from './classes/BusinessLogicManager/businessLogicRule.decorator';
+export * from './classes/BusinessLogicManager/registeredBusinessLogicRules';
+export * from './classes/BusinessLogicManager/BusinessLogicManager';
+export * from './classes/BusinessLogicManager/MateriaalCatFunctieFunctiegroep/TimeColumnUtil';
+export * from './factories/ApiResponseProcessorFactory';
+export * from './factories/ChangesCompilationFactory';
+export * from './factories/CollectionResourceFactory';
+export * from './factories/ColumnExpansionFactory';
+export * from './factories/ColumnInfoFactory';
+export * from './factories/ColumnSetFactory';
+export * from './factories/RequestColumnsOperationsCacheFactory';
+export * from './factories/ItemCacheFactory';
+export * from './factories/ItemResourceFactory';
+export * from './factories/TransactionCacheFactory';
+export * from './factories/ModuleChangesCompilationFactory';
+export * from './factories/RequestColumnExpansionFactory';
+export * from './factories/ChangesDeltaFactory';
+export * from './interfaces/AbstractCacheDependencyInterface';
+export * from './interfaces/TransactionItemHandlerDependencyInterface';
+export * from './interfaces/TransactionCollectionHandlerDependencyInterface';
+export * from './interfaces/ServerCacheDependencyInterface';
+export * from './exceptions/ItemAlreadyExistsException';
+export * from './exceptions/ItemLockedException';
+export * from './exceptions/ItemNotFoundException';
+export * from './exceptions/SavingInProgressException';
+export * from './exceptions/CriticalBusinessLogicRuleException';
+export * from './core';

package/dist/types/src/models/CachedQueryItem.d.ts

@@ -0,0 +1,33 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { RootQueryNode } from '../classes/matcher/RootQueryNode';
+import { CollectionQuery, ItemEntry, RequestColumnsTuple } from '../internal';
+export declare class CachedQueryItem<ItemTypeType extends ApiItemType = any> {
+    readonly itemType: ItemTypeType;
+    readonly query: CollectionQuery<ItemTypeType>;
+    readonly queryGraph: RootQueryNode<ItemTypeType>;
+    items: ItemEntry<ItemTypeType>[];
+    requestColumnsTuple: RequestColumnsTuple<ItemTypeType>;
+    promise: Promise<this>;
+    creation: Date;
+    private deferred;
+    private outdated;
+    constructor(itemType: ItemTypeType, query: CollectionQuery<ItemTypeType>, queryGraph: RootQueryNode<ItemTypeType>, items: ItemEntry<ItemTypeType>[], requestColumnsTuple: RequestColumnsTuple<ItemTypeType>);
+    isOutdated(): boolean;
+    markOutdated(): void;
+    markUpToDate(): void;
+    itemsResolved(): boolean;
+    /**
+     * Resolve can be called on items that are already resolved. The request buffer might or might not combine
+     * requests together.
+     */
+    resolve(): void;
+    reject(reason: any): void;
+    /**
+     * Updates the items in the collection resource, given the results of a query matching cycle.
+     *
+     * Note: In order to reduce back-end requests for non-locally matchable queries, `fittingItemEntries` may contain item
+     * entries that are already present in the collection, and `nonFittingItemEntries` may contain item entries that
+     * are not present in the collection.
+     */
+    handleMatchedItemEntries(fittingItemEntries: Iterable<ItemEntry<ItemTypeType>>, nonFittingItemEntries: Set<ItemEntry<ItemTypeType>> | undefined): void;
+}

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

@@ -0,0 +1,16 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { CollectionQuery, ColumnExpansion, ColumnSet, EntryParentNull, QueryService, RootCollectionOptionsBase } from '../internal';
+export declare class CollectionEntry<ItemTypeType extends ApiItemType> {
+    private queryService;
+    options: Readonly<RootCollectionOptionsBase<ItemTypeType>>;
+    readonly query: CollectionQuery<ItemTypeType>;
+    columns: ColumnSet<ItemTypeType>;
+    private static currentId;
+    id: number;
+    itemType: ItemTypeType;
+    parent: EntryParentNull;
+    promise: Promise<this>;
+    constructor(queryService: QueryService, options: Readonly<RootCollectionOptionsBase<ItemTypeType>>, query: CollectionQuery<ItemTypeType>, columns: ColumnSet<ItemTypeType>);
+    isLocal(): boolean;
+    expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
+}

package/dist/types/src/models/CollectionOptions.d.ts

@@ -0,0 +1,111 @@
+import { ApiItemType } from '@rentman/backend-types';
+import { AggregatedChangesListener, ApiQuery, ApiRequestColumnArray, ApiRequestColumns, ChildCollectionResources, CollectionItemChangesListener, CollectionResource, EntryParent, ItemEntry, ItemResource, ItemTypeColumnId } from '../internal';
+export interface CollectionResourceOrder<ItemTypeType extends ApiItemType> {
+    field: ItemTypeColumnId<ItemTypeType>;
+    order?: 'desc' | 'asc';
+    limit?: number;
+}
+interface CollectionResourceOrderWithLimit<ItemTypeType extends ApiItemType> extends CollectionResourceOrder<ItemTypeType> {
+    limit: number;
+}
+type OnAddCollectionOption<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionResources> = (itemResources: ItemResource<ItemTypeType, RequestColumns, Children>[], collectionResource: CollectionResource<ItemTypeType, RequestColumns, Children>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
+type OnRemoveCollectionOption<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionResources> = (itemEntries: ItemEntry<ItemTypeType>[], collectionResource: CollectionResource<ItemTypeType, RequestColumns, Children>, isCalledAfterSocketUpdate: boolean, itemResources: ItemResource<ItemTypeType, RequestColumns, Children>[]) => void;
+/**
+ * We're not defining this type recursively to prevent TypeScript from chocking up. We're currently limiting the
+ * `children` property to three levels (four levels including the 'root' collection).
+ *
+ * TODO: We can type this property once we utilize the link tree type.
+ */
+export type ChildCollectionsOption = {
+    [ChildItemType in ApiItemType]?: CollectionOptions<ChildItemType, ApiRequestColumnArray<ChildItemType>, {
+        [GrandChildItemType in ApiItemType]?: CollectionOptions<GrandChildItemType, ApiRequestColumnArray<GrandChildItemType>, {
+            [GrandGrandChildItemType in ApiItemType]?: CollectionOptions<GrandGrandChildItemType, ApiRequestColumnArray<GrandGrandChildItemType>>;
+        }>;
+    }>;
+};
+/**
+ * We're not including columns here, because whenever we access the columns, we'd want to do it through the columns
+ * operations cache.
+ */
+export interface CachedQueryOptions<ItemType extends ApiItemType> {
+    query?: ApiQuery<ItemType>;
+    parent?: EntryParent;
+    order?: CollectionResourceOrder<ItemType>;
+    /**
+     * Prevents a CachedQueryItem from being cached (the CollectionResource will still be cached), you can use this when you fetch an Itemtype for which the backend doesn't send socket messages (so it never automatically updates)
+     */
+    preventCaching?: boolean;
+}
+export interface CachedQueryOptionsWithColumns<ItemType extends ApiItemType> extends CachedQueryOptions<ItemType> {
+    columns: ApiRequestColumns<ItemType>;
+}
+/**
+ * The main differences between {@link CollectionOptions} and {@link RootCollectionOptions} are:
+ * - {@link RootCollectionOptions} includes aggregated changes listener options;
+ * - {@link RootCollectionOptions} requires either `query` or `parent`.
+ *
+ * {@link RootCollectionOptions} is used for the `getCollection` method in the transaction cache. Generally, we should
+ * prefer the use of the less complex {@link CollectionOptions}.
+ */
+export interface CollectionOptions<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends CachedQueryOptions<ItemType> {
+    columns: RequestColumns;
+    /**
+     * @deprecated
+     */
+    onAdd?: OnAddCollectionOption<ItemType, any, any>;
+    /**
+     * @deprecated
+     */
+    onRemove?: OnRemoveCollectionOption<ItemType, any, any>;
+    /**
+     * @deprecated
+     */
+    onChange?: CollectionItemChangesListener<CollectionResource<ItemType, any, any>>;
+    /**
+     * This allows us to add custom data to the options. See: https://rentman.atlassian.net/browse/RM4-19122
+     * @deprecated
+     */
+    custom?: any;
+    callOnAddWithInitialItems?: boolean;
+    children?: Children;
+    abortSignal?: AbortSignal;
+}
+export interface RootCollectionOptionsBase<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends CollectionOptions<ItemType, RequestColumns, Children> {
+    /**
+     * Note: When using the `changesListener` option the `context` parameter is untyped. (This would require self
+     * reference.)
+     *
+     * If you need access to the context, you should: either declare (and explicitly type) a named changes listener
+     * or use the `registerChangesListener` method on the collection resource.
+     */
+    changesListener?: AggregatedChangesListener<CollectionResource<ItemType, any, any>, any>;
+    immediatelyCallChangesListener?: boolean;
+}
+/**
+ * Used in {@link OrderedCollectionResource}.
+ */
+export interface RootCollectionOptionsWithOrder<ItemTypeType extends ApiItemType> extends RootCollectionOptionsBase<ItemTypeType> {
+    order: CollectionResourceOrder<ItemTypeType>;
+}
+/**
+ * Used in {@link LimitedCollectionResource}.
+ */
+export interface RootCollectionOptionsWithLimit<ItemTypeType extends ApiItemType> extends RootCollectionOptionsWithOrder<ItemTypeType> {
+    order: CollectionResourceOrderWithLimit<ItemTypeType>;
+}
+interface RootCollectionOptionsWithQuery<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption> extends RootCollectionOptionsBase<ItemType, RequestColumns, Children> {
+    query: ApiQuery<ItemType>;
+}
+export interface RootCollectionOptionsWithParent<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption> extends RootCollectionOptionsBase<ItemType, RequestColumns, Children> {
+    parent: EntryParent;
+}
+/**
+ * The main differences between {@link CollectionOptions} and {@link RootCollectionOptions} are:
+ * - {@link RootCollectionOptions} includes aggregated changes listener options;
+ * - {@link RootCollectionOptions} requires either `query` or `parent`.
+ *
+ * {@link RootCollectionOptions} is used for the `getCollection` method in the transaction cache. Generally, we should
+ * prefer the use of the less complex {@link CollectionOptions}.
+ */
+export type RootCollectionOptions<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> = RootCollectionOptionsWithQuery<ItemType, RequestColumns, Children> | RootCollectionOptionsWithParent<ItemType, RequestColumns, Children>;
+export {};

package/dist/types/src/models/CollectionResource.d.ts

@@ -0,0 +1,175 @@
+import { WritableSignal } from '@angular/core';
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { RootQueryNode } from '../classes/matcher/RootQueryNode';
+import { AbstractCache, AggregatedChangesByListener, AggregatedChangesListener, AggregatedChangesListenerFunction, ApiRequestColumnArray, CachedQueryItem, ChangesDeltaResult, ChildCollectionResources, CollectionEntry, CollectionItemChangesListenerContext, CollectionOptions, CollectionQuery, CollectionResourceFactory, ColumnSet, DeregFunction, FieldMap, ItemEntry, ItemIdConversionMap, ItemResource, ItemTypeColumnIds, ParentChangesDelta, ParentIdMap, RequestColumnsFieldMap, ResponseColumnItemTypeMap, RootCollectionOptionsBase, TransactionCache } from '../internal';
+export type CollectionToItemResource<CollectionResourceType extends {
+    items: any[];
+}> = CollectionResourceType['items'][number];
+export interface AddedRemovedItemResources<ItemResourceType> {
+    addedItems: ItemResourceType[];
+    removedItems: ItemResourceType[];
+}
+/**
+ * Stores added, removed, and changed items for a collection resource. All properties are represented as item resources.
+ */
+export interface CollectionItemResourceChanges<CollectionResourceType extends {
+    items: any[];
+}> extends AddedRemovedItemResources<CollectionToItemResource<CollectionResourceType>> {
+    changedItems: CollectionToItemResource<CollectionResourceType>[];
+    collectionResource: CollectionResourceType;
+}
+/**
+ * Collection changes listeners have a single `CollectionResourceType` type variable (instead of separate item type /
+ * request columns / children variables) because there are multiple types of collection resources
+ * ({@link OrderedCollectionResource}, {@link LimitedCollectionResource}).
+ */
+export type CollectionItemChangesListener<CollectionResourceType extends CollectionResource<any, any, any>> = (context: CollectionItemChangesListenerContext<CollectionResourceType>) => void;
+export type OnAddCallback<CollectionResourceType extends CollectionResource<any, any, any>> = (args: {
+    itemResources: CollectionToItemResource<CollectionResourceType>[];
+    collectionResource: CollectionResourceType;
+    isInitialCall: boolean;
+    isCalledAfterSocketUpdate: boolean;
+}) => void;
+export type OnRemoveCallback<CollectionResourceType extends CollectionResource<any, any, any>> = (args: {
+    itemResources: CollectionToItemResource<CollectionResourceType>[];
+    itemEntries: CollectionToItemResource<CollectionResourceType>['entry'][];
+    collectionResource: CollectionResourceType;
+    isCalledAfterSocketUpdate: boolean;
+}) => void;
+export declare class CollectionResource<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>, Children extends ChildCollectionResources | undefined = undefined> {
+    protected readonly factory: CollectionResourceFactory;
+    readonly options: Readonly<RootCollectionOptionsBase<ItemTypeType>>;
+    readonly transaction: TransactionCache;
+    readonly queryGraph: RootQueryNode<ItemTypeType>;
+    parentCollection: CollectionResource<any, any, any> | null;
+    readonly itemType: ItemTypeType;
+    readonly entry: CollectionEntry<ItemTypeType>;
+    readonly columns: ResponseColumnItemTypeMap;
+    items: ItemResource<ItemTypeType, RequestColumns, Children>[];
+    readonly itemsSignal: WritableSignal<ItemResource<ItemTypeType, RequestColumns, Children>[]>;
+    parentItem: ItemResource<any, any, any> | null;
+    protected itemEntryIdMap: {
+        [itemEntryId: number]: ItemResource<ItemTypeType, RequestColumns, Children>;
+    };
+    private onChangeCallbacks;
+    private onAddCallbacks;
+    private onRemoveCallbacks;
+    /**
+     * We type this loosely to prevent TypeScript inferring a complex type when comparing collection resources.
+     */
+    private aggregatedChangesListeners;
+    constructor(factory: CollectionResourceFactory, options: Readonly<RootCollectionOptionsBase<ItemTypeType>>, transaction: TransactionCache, queryGraph: RootQueryNode<ItemTypeType>, query: CollectionQuery<ItemTypeType>, columnSet: ColumnSet<ItemTypeType>, parentCollection: CollectionResource<any, any, any> | null);
+    setParentItem(parentItem: ItemResource<any, any, any>): void;
+    initializeItems(initialItemEntries: ItemEntry<ItemTypeType>[], childCollectionResourceMap: ParentIdMap<Children>): void;
+    onConstruct(): void;
+    /**
+     * @internal
+     */
+    clearCachedQueryOnTransaction(transaction: AbstractCache): void;
+    /**
+     * @description
+     * Removes the query (if it's cached) from the TransactionCachedQueryHandler and redoes the query
+     *
+     * Fixme: This function does not work properly for other collections using the same query.
+     * While adds and updates are properly processed by the query matcher after we fetch the new data,
+     * the absense of items in the response is not handled as deletes. We've fixed that in the collection
+     * you call `refresh` on by manually comparing the items, but this doesn't remove it from other collections.
+     */
+    refresh(): Promise<CachedQueryItem<ItemTypeType>>;
+    deregisterChangesListener(listener: AggregatedChangesListenerFunction<any, any>): void;
+    registerChangesListener(listener: AggregatedChangesListener<this, any>): DeregFunction;
+    /**
+     * @deprecated
+     */
+    onAdd(callback: OnAddCallback<this>): DeregFunction;
+    /**
+     * @deprecated
+     */
+    onChange(callback: CollectionItemChangesListener<this>): DeregFunction;
+    /**
+     * @deprecated
+     */
+    onRemove(callback: OnRemoveCallback<this>): DeregFunction;
+    removeItems(idArray: ItemId[]): Promise<ChangesDeltaResult>;
+    removeItem(itemId: ItemId): Promise<ChangesDeltaResult>;
+    addItems(valuesArray: Partial<RequestColumnsFieldMap<ItemTypeType, RequestColumns>>[]): Promise<ChangesDeltaResult>;
+    addItem(values: Partial<FieldMap<ItemTypeType>>): Promise<ChangesDeltaResult>;
+    getIdArray(): ItemId[];
+    getItemById(itemId: ItemId): ItemResource<ItemTypeType, RequestColumns, Children>;
+    triggerCollectionChangesListeners(changedItemResources: AddedRemovedItemResources<ItemResource<ItemTypeType, RequestColumns, Children>> & {
+        changedItems?: undefined;
+    }, sourceChangesDelta: null, itemIdConversionMap: ItemIdConversionMap | undefined, isCalledAfterSocketUpdate: boolean, isInitialCall: boolean, collectionChangesAccumulator: AggregatedChangesByListener | null): void;
+    triggerCollectionChangesListeners(changedItemResources: AddedRemovedItemResources<ItemResource<ItemTypeType, RequestColumns, Children>> & {
+        changedItems: ItemResource<ItemTypeType, RequestColumns, Children>[];
+    }, sourceChangesDelta: ParentChangesDelta, itemIdConversionMap: ItemIdConversionMap | undefined, isCalledAfterSocketUpdate: boolean, isInitialCall: boolean, collectionChangesAccumulator: AggregatedChangesByListener | null): void;
+    forEach(callback: (itemResource: ItemResource<ItemTypeType, RequestColumns, Children>) => void): void;
+    filter(callback: (itemResource: ItemResource<ItemTypeType, RequestColumns, Children>) => boolean): ItemResource<ItemTypeType, RequestColumns, Children>[];
+    first(callback: (itemResource: ItemResource<ItemTypeType, RequestColumns, Children>) => boolean): ItemResource<ItemTypeType, RequestColumns, Children> | null;
+    some(callback: (itemResource: ItemResource<ItemTypeType, RequestColumns, Children>) => boolean): boolean;
+    groupBy(argument: string | ((itemResource: ItemResource<ItemTypeType, RequestColumns, Children>) => string | null)): {
+        [key: string]: ItemResource<ItemTypeType, RequestColumns, Children>[];
+    };
+    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType, RequestColumns, Children>) => U)): U[];
+    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType, RequestColumns, Children>, value: U) => U, value: U): U;
+    /**
+     * @description
+     * Removes the {@link CollectionResource CollectionResource} from the transaction, preventing the
+     * {@link CollectionResource.options.onAdd onAdd} and {@link CollectionResource.options.onRemove onRemove} callbacks
+     * from being called. You should call this function when the resource is no longer needed.
+     *
+     * @remark
+     * - Does not remove cached queries;
+     * - Does not revert changes on the items themselves.
+     */
+    clearResource(): void;
+    /**
+     * Updates the items in the collection resource, given the results of a query matching cycle.
+     *
+     * Note: In order to reduce back-end requests for non-locally matchable queries, `fittingItemEntries` may contain item
+     * entries that are already present in the collection, and `nonFittingItemEntries` may contain item entries that
+     * are not present in the collection.
+     *
+     * @returns A {@link CollectionResourceChanges} object, which can be used to trigger collection changes listeners.
+     */
+    handleMatchedItemEntries(fittingItemEntries: Iterable<ItemEntry<ItemTypeType>>, nonFittingItemEntries: Set<ItemEntry<ItemTypeType>> | undefined, clearChildCollectionResources: boolean): Promise<CollectionItemResourceChanges<CollectionResource<ItemTypeType, RequestColumns, Children>>>;
+    /**
+     * We type this loosely to prevent TypeScript inferring a complex type when comparing collection resources.
+     * @internal
+     */
+    getAggregatedChangesListeners<ChangesListeners extends Set<AggregatedChangesListenerFunction<any, any>>>(accumulator?: ChangesListeners): ChangesListeners;
+    protected getCollectionItemEntryChanges(fittingItemEntries: Iterable<ItemEntry<ItemTypeType>>, nonFittingItemEntries: Set<ItemEntry<ItemTypeType>> | undefined): {
+        itemEntriesToBeAdded: ItemEntry<ItemTypeType>[];
+        itemEntriesToBeRemovedSet: Set<ItemEntry<ItemTypeType>>;
+        changedItemResources: ItemResource<ItemTypeType, RequestColumns, Children>[];
+    };
+    /**
+     * Removes the item resources associated with the passed item entries from the `items` array, while keeping the
+     * reference intact.
+     *
+     * Note: This method does not call any listeners, nor does it re-order the items.
+     *
+     * @param itemEntriesToBeRemovedSet May also contain item entries that are not included in the collection at all.
+     * @returns The {@link ItemResource ItemResources} that were removed from the {@link CollectionResource collection}.
+     */
+    protected removeItemResources(itemEntriesToBeRemovedSet: Set<ItemEntry<ItemTypeType>>, clearChildCollectionResources: boolean): ItemResource<ItemTypeType, RequestColumns, Children>[];
+    /**
+     * Updates the `items` property of the collection resource, consisting of item resources representing the items in
+     * the collection.
+     *
+     * Note that for some added item entries, no item resource might be returned, as some of the items might already
+     * have been added while the child collections where requested.
+     */
+    protected updateItemsProperty(itemEntriesToBeAdded: ItemEntry<ItemTypeType>[], itemEntriesToBeRemovedSet: Set<ItemEntry<ItemTypeType>>, clearChildCollectionResources: boolean): Promise<AddedRemovedItemResources<ItemResource<ItemTypeType, RequestColumns, Children>>>;
+    /**
+     * Creates item resources and adds them to the `items` array. This function is also called when the collection
+     * resource is constructed.
+     *
+     * Note: This method does not call any listeners.
+     *
+     * @param itemEntriesToBeAdded - The item entries are assumed not to be in the collection yet.
+     */
+    protected addItemResources(itemEntriesToBeAdded: Iterable<ItemEntry<ItemTypeType>>, childCollections: ParentIdMap<Children>): ItemResource<ItemTypeType, RequestColumns, Children>[];
+    protected fetchCachedQuery(options?: CollectionOptions<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    private registerOptionsChangesListeners;
+    private __registerCallback;
+}