@rentman/rm-core 66.1.10 → 66.2.0-RM4-48655

package/dist/types/src/classes/cache/CachedQueryHandlerBase.d.ts

@@ -1,22 +1,34 @@
 import { ApiItemType, ItemId } from '@rentman/backend-types';
 import { GraphQueryParserFactory } from '../../factories/GraphQueryParserFactory';
-import { AbstractCache, ApiQuery, ApiRequestColumns, ApiRequestService, CachedQueryItem, CachedQueryOptions, CachedQueryOptionsWithColumns, ChangesDeltaBase, CollectionOptions, CollectionQuery, CollectionResourceOrder, ErrorHandlerInterface, ItemEntry, LinkTreeServiceInterface, MatchesAccumulatorMap, MatchingResultsAccumulatorMapType, MatchingResultsAccumulatorTuple, ParentChangesDelta, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, RequestColumnsTuple } from '../../internal';
+import { AbstractCache, ApiQuery, ApiRequestColumns, ApiRequestService, CachedQueryItem, ChangesDeltaBase, ChildCollectionsOption, ChildrenQueryFunction, CollectionQuery, CollectionResourceOrder, EntryParent, ErrorHandlerInterface, ItemEntry, LinkTreeServiceInterface, MatchesAccumulatorMap, MatchingResultsAccumulatorMapType, MatchingResultsAccumulatorTuple, ParentChangesDelta, PreventCachingCollectionOption, ProcessedChildCollectionOptions, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, RequestColumnsTuple, RootCollectionOptions } from '../../internal';
 import { RootQueryNode } from '../matcher/RootQueryNode';
+/**
+ * We're not including columns here, because whenever we access the columns, we'd want to do it through the columns
+ * operations cache. Similarly, the query should be accessed through a separate `CollectionQuery` parameter.
+ */
+export interface CachedQueryOptions<ItemType extends ApiItemType> extends PreventCachingCollectionOption {
+    parent?: EntryParent;
+    order?: CollectionResourceOrder<ItemType>;
+}
+export interface CachedQueryOptionsWithChildren<ItemType extends ApiItemType> extends CachedQueryOptions<ItemType> {
+    children?: ChildCollectionsOption;
+}
 export interface LinkCollectionBatchQueryTuple<ItemTypeType extends ApiItemType> {
-    batchQuery: CollectionQuery<ItemTypeType>;
-    batchQueryGraph?: RootQueryNode<ItemTypeType>;
+    readonly batchQuery: CollectionQuery<ItemTypeType>;
+    readonly batchQueryGraph?: RootQueryNode<ItemTypeType>;
 }
-export interface ParentCachedQueryItemTuple<ItemTypeType extends ApiItemType> {
+/**
+ * Represents a cached query item resulting from a `getCollection` / `getItemsByQuery` call.
+ */
+export interface CachedQueryItemTypeTuple<ItemTypeType extends ApiItemType, OptionsType> {
     readonly cachedQueryItem: CachedQueryItem<ItemTypeType>;
-    readonly options: CollectionOptions<ItemTypeType>;
-    children: CachedQueryItemsItemTypeTuple<ApiItemType>[] | null;
-}
-export interface CachedQueryItemTuple<ItemTypeType extends ApiItemType> extends ParentCachedQueryItemTuple<ItemTypeType> {
-    children: null;
+    readonly options: OptionsType;
+    children: CachedQueryItemsItemTypeTuple<any>[] | null;
 }
+export type ChildCachedQueryItemTypeTuple<ItemTypeType extends ApiItemType> = CachedQueryItemTypeTuple<ItemTypeType, ProcessedChildCollectionOptions<ItemTypeType>>;
 export interface CachedQueryItemsItemTypeTuple<ItemTypeType extends ApiItemType> {
     itemType: ItemTypeType;
-    cachedQueryItemTuples: ParentCachedQueryItemTuple<ItemTypeType>[];
+    cachedQueryItemTuples: ChildCachedQueryItemTypeTuple<ItemTypeType>[];
 }
 export interface CachedQueryHandlerCollectionTuple<ItemTypeType extends ApiItemType> {
     cachedQueryItem?: CachedQueryItem<ItemTypeType>;
@@ -69,7 +81,7 @@ export declare abstract class CachedQueryHandlerBase {
      * @description
      * Fetches a {@link CollectionEntry CollectionEntry} with the given options
      */
-    __fetchCachedQueryItem<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CachedQueryOptionsWithColumns<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    __fetchCachedQueryItem<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: RootCollectionOptions<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
     getCachedQueryItemsByItemType<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType): CachedQueryItem<ItemTypeType>[];
     cloneCachedQuery<ItemTypeType extends ApiItemType>(cachedQueryItem: CachedQueryItem<ItemTypeType>, resolve?: boolean): CachedQueryItem<ItemTypeType>;
     clearCachedQueryItem(itemType: ApiItemType, queryString: string): void;
@@ -99,7 +111,15 @@ export declare abstract class CachedQueryHandlerBase {
     abstract __fetchItemEntriesByQueryData<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CachedQueryOptions<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>, linkCollectionBatchQueryTuple?: LinkCollectionBatchQueryTuple<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
     abstract __maybeExpandCachedQuery<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, batchedLinkedToQuery?: CollectionQuery<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
     queryIsCacheable<ItemTypeType extends ApiItemType>(options: CachedQueryOptions<ItemTypeType>, query: CollectionQuery<ItemTypeType>): boolean;
-    protected createQueryFromOptions<ItemTypeType extends ApiItemType>(options: CachedQueryOptions<ItemTypeType>): CollectionQuery<ItemTypeType>;
+    createBatchQuery<ItemTypeType extends ApiItemType>(parentItemType: ApiItemType, parentItemIds: ItemId[], queryOption: ApiQuery<ItemTypeType> | ChildrenQueryFunction<ItemTypeType> | undefined): CollectionQuery<ItemTypeType>;
+    protected createQueryFromChildOptions<ItemTypeType extends ApiItemType>(parentItemType: ApiItemType, parentItemIds: ItemId[], queryOption: ApiQuery<ItemTypeType> | ChildrenQueryFunction<ItemTypeType> | undefined): ApiQuery<ItemTypeType>;
+    /**
+     * Root collection options can contain a `query` and a `parent` property.
+     */
+    protected createQueryFromRootOptions<ItemTypeType extends ApiItemType>(options: {
+        query?: ApiQuery<ItemTypeType>;
+        parent?: EntryParent;
+    }): CollectionQuery<ItemTypeType>;
     /**
      * @description
      * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CacheSyncer CacheSyncer} to function.
@@ -140,5 +160,5 @@ export declare abstract class CachedQueryHandlerBase {
      * Every time a cached query item is created, either 'resolve' or 'reject' has to be called on the cached query item.
      */
     protected constructCachedQuery<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>, itemEntries: ItemEntry<ItemTypeType>[], requestColumnsTuple: RequestColumnsTuple<ItemTypeType>, queryGraph?: RootQueryNode<ItemTypeType>): CachedQueryItem<ItemTypeType>;
-    private createQueryGraph;
+    protected createQueryGraph<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery<ItemTypeType>): RootQueryNode<ItemTypeType>;
 }

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

@@ -84,6 +84,13 @@ export declare class TransactionCache extends AbstractCache {
      */
     tabRequestParameters: {};
     hasChangesSignal: WritableSignal<boolean>;
+    aiChanges: WritableSignal<{
+        created: Set<ItemEntry['id']>;
+        deleted: Set<ItemEntry['id']>;
+        fields: {
+            [itemEntryId: number]: Set<string>;
+        };
+    }>;
     /**
      * @description
      * The transaction's parent
@@ -159,7 +166,7 @@ export declare class TransactionCache extends AbstractCache {
      * Note that the transaction can *not* be mutated while it is pending. If you need to apply changes on the
      * transaction while it is pending, use the `applyChangesDelta` parameter passed to the promise function.
      */
-    setPending<Result>(promise: Promise<Result> | ((applyChangesDelta: (changesDelta: ChangesDelta) => Promise<ChangesDeltaResult>) => Promise<Result>)): Promise<Result>;
+    setPending<Result>(promise: Promise<Result> | ((applyChangesDelta: (changesDelta: ChangesDelta) => Promise<ChangesDeltaResult>) => Promise<Result>), isDoneByAi: boolean): Promise<Result>;
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
     createBusinessLogicChild(): TransactionCache;
     destroy(): void;
@@ -216,7 +223,7 @@ export declare class TransactionCache extends AbstractCache {
      *
      * This method waits for other transaction processes to complete, see {@link enqueueAction}.
      */
-    applyChangesDelta(changesDelta: ChangesDelta): Promise<ChangesDeltaResult>;
+    applyChangesDelta(changesDelta: ChangesDelta, isDoneByAi?: boolean): Promise<ChangesDeltaResult>;
     /**
      * See {@link applyChangesDelta}. We're introducing a separate method here to facilitate handling the resulting
      * promise.

package/dist/types/src/classes/cache/transaction/TransactionCachedQueryHandler.d.ts

@@ -1,17 +1,19 @@
 import { ApiItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, CachedQueryHandlerBase, CachedQueryHandlerCollectionTuple, CachedQueryItem, CachedQueryItemsItemTypeTuple, CachedQueryItemTuple, CachedQueryOptions, ChangesDeltaBase, ChildCollectionsOption, CollectionItemResourceChanges, CollectionOptions, CollectionQuery, CollectionResource, EntryParent, ItemIdConversionMap, LinkCollectionBatchQueryTuple, MatchesAccumulatorMap, MatchingResultsAccumulatorMapType, MatchingResultsAccumulatorTuple, ParentCachedQueryItemTuple, RequestColumnsOperationsCache, RequireOnly, TransactionCache, TransactionCollectionHandlerDependencyInterface } from '../../../internal';
+import { ApiQuery, ApiRequestColumnArray, CachedQueryHandlerBase, CachedQueryHandlerCollectionTuple, CachedQueryItem, CachedQueryItemsItemTypeTuple, CachedQueryItemTypeTuple, CachedQueryOptions, CachedQueryOptionsWithChildren, ChangesDeltaBase, ChildCachedQueryItemTypeTuple, ChildCollectionOptions, ChildCollectionsOption, CollectionItemResourceChanges, CollectionQuery, CollectionResource, EntryParent, ItemIdConversionMap, LinkCollectionBatchQueryTuple, MatchesAccumulatorMap, MatchingResultsAccumulatorMapType, MatchingResultsAccumulatorTuple, ProcessedChildCollectionOptions, RequestColumnsOperationsCache, RequireOnly, TransactionCache, TransactionCollectionHandlerDependencyInterface } from '../../../internal';
 import { RootQueryNode } from '../../matcher/RootQueryNode';
+/**
+ * The result of {@link processCollectionOptions}, where we create a separate set of options for each child collection.
+ */
+interface LinkCollectionOptionsTuple<ItemTypeType extends ApiItemType> extends LinkCollectionBatchQueryTuple<ItemTypeType> {
+    collectionQueryTuples: {
+        parsedQuery: CollectionQuery<ItemTypeType>;
+        options: ProcessedChildCollectionOptions<ItemTypeType>;
+    }[];
+}
 export interface LinkCollectionOptionsItemTypeTuple<ItemTypeType extends ApiItemType> {
     itemType: ItemTypeType;
     linkCollectionOptions: LinkCollectionOptionsTuple<ItemTypeType>;
 }
-interface CollectionQueryTuple<ItemTypeType extends ApiItemType> {
-    parsedQuery: CollectionQuery<ItemTypeType>;
-    options: CollectionOptions<ItemTypeType>;
-}
-interface LinkCollectionOptionsTuple<ItemTypeType extends ApiItemType> extends LinkCollectionBatchQueryTuple<ItemTypeType> {
-    collectionQueryTuples: CollectionQueryTuple<ItemTypeType>[];
-}
 interface TransactionCachedQueryHandlerCollectionTuple<ItemTypeType extends ApiItemType> extends CachedQueryHandlerCollectionTuple<ItemTypeType> {
     collectionResources?: WeakRef<CollectionResource<ItemTypeType, any, any>>[];
 }
@@ -61,14 +63,15 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
      * Fetches collections linked to the passed parents
      * @returns An array of cached query items. The items are in the same order as the parent IDs.
      */
-    __fetchLinkedCachedQueryItems<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, linkCollectionOptionsTuple: LinkCollectionOptionsTuple<ItemTypeType>): Promise<CachedQueryItemTuple<ItemTypeType>[]>;
-    createBatchLinkedToQuery<ItemTypeType extends ApiItemType>(parentItemType: ApiItemType, parentItemIds: ItemId[], additionalQuery?: ApiQuery<ItemTypeType>): CollectionQuery<ItemTypeType>;
+    __fetchChildCachedQueryItemsByItemType<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, linkCollectionOptionsTuple: LinkCollectionOptionsTuple<ItemTypeType>): Promise<ChildCachedQueryItemTypeTuple<ItemTypeType>[]>;
     /**
      * The order of the `collectionQueryTuples` property of the result will be the same as the order of
      * `parentItemIds`.
      */
-    processLinkCollectionOptions<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parentItemType: ApiItemType, parentItemIds: ItemId[], options: CollectionOptions<ItemTypeType>): LinkCollectionOptionsTuple<ItemTypeType>;
-    __fetchParentCachedQueryItem<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>): Promise<ParentCachedQueryItemTuple<ItemTypeType>>;
+    processChildCollectionOptions<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, parentItemType: ApiItemType, parentItemIds: ItemId[], childOptions: ChildCollectionOptions<ItemTypeType>): LinkCollectionOptionsTuple<ItemTypeType>;
+    __fetchParentCachedQueryItem<const ItemTypeType extends ApiItemType, OptionsType extends CachedQueryOptionsWithChildren<ItemTypeType> & {
+        columns: ApiRequestColumnArray<ItemTypeType>;
+    }>(itemType: ItemTypeType, options: OptionsType): Promise<CachedQueryItemTypeTuple<ItemTypeType, OptionsType>>;
     __fetchChildCachedQueryItems(parentItemType: ApiItemType, parentItemIds: ItemId[], childCollectionOptions: ChildCollectionsOption): Promise<CachedQueryItemsItemTypeTuple<ApiItemType>[]>;
     /**
      * Fetches a cached query, respecting children. Like {@link __fetchItemEntriesByQueryData}, assumes the options are
@@ -76,9 +79,8 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
      *
      * todo: Rename this method and {@link __fetchItemEntriesByQueryData} to something that's easier to understand.
      */
-    __fetchParentItemEntriesByQueryData<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>): Promise<ParentCachedQueryItemTuple<ItemTypeType>>;
-    private cloneOptions;
-    fetchChildCachedQueryItems(linkCollectionOptionsItemTypeTuples: LinkCollectionOptionsItemTypeTuple<ApiItemType>[]): Promise<CachedQueryItemsItemTypeTuple<ApiItemType>[]>;
+    __fetchParentItemEntriesByQueryData<ItemTypeType extends ApiItemType, OptionsType extends CachedQueryOptionsWithChildren<ItemTypeType>>(itemType: ItemTypeType, options: OptionsType, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>): Promise<CachedQueryItemTypeTuple<ItemTypeType, OptionsType>>;
+    private fetchChildCachedQueryItems;
     /**
      * Updates the items included in cached queries and collection resources based on query matcher results. Note that
      * method does not clear child collection resources of removed item resources.
@@ -94,7 +96,7 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
      * Sets the `children` property for each of the cached queries in `cachedQueryItemTuples`. Assumes the `children`
      * *options* property is the same for all cached query items.
      *
-     * The `children` property will remain `null` if  the children option is unset.
+     * The `children` property will remain `null` if the children option is unset.
      */
     private resolveParentCachedQueryItems;
     private resolveLocalCachedQueryItem;

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

@@ -56,7 +56,7 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      */
     processUpdatesFromDelta(updated: {
         [itemEntryId: number]: ChangesDeltaBaseItemUpdateDelta<any>;
-    }, createItemChangesIfNoneExist: boolean, parentChangesDelta: ParentChangesDelta): void;
+    }, createItemChangesIfNoneExist: boolean, parentChangesDelta: ParentChangesDelta): Map<ItemEntry['id'], Set<string>>;
     updateLocalItemIdReferences(itemType: ApiItemType, oldItemId: ItemId, newItemId: ItemId, changesDelta: ChangesDeltaBase): void;
     registerFieldChangeCallback<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, callback: ItemChangesListener<ItemTypeType>): DeregFunction;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;

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

@@ -1,5 +1,5 @@
 import { ApiItemType } from '@rentman/backend-types';
-import { CachedQueryItemsItemTypeTuple, ChildCollectionResources, CollectionResource, ColumnCache, ColumnSet, ColumnSetFactory, ErrorHandlerInterface, ItemEntryService, OptionsToCollectionResource, ParentCachedQueryItemTuple, ParentIdMap, QueryService, RequestColumnsOperationsCacheFactory, RootCollectionOptions, TransactionCache } from '../internal';
+import { ApiRequestColumnArray, CachedQueryItemsItemTypeTuple, CachedQueryItemTypeTuple, ChildCollectionResources, CollectionOptionsBase, CollectionResource, ColumnCache, ColumnSet, ColumnSetFactory, ErrorHandlerInterface, ItemEntryService, OptionsToCollectionResource, ParentIdMap, QueryService, RequestColumnsOperationsCacheFactory, TransactionCache } from '../internal';
 export type ColumnSetMap<ItemTypeType extends ApiItemType> = {
     [ColumnSetItemType in ItemTypeType]: ColumnSet<ColumnSetItemType>;
 };
@@ -14,7 +14,9 @@ export declare class CollectionResourceFactory {
     /**
      * @internal
      */
-    construct<ItemTypeType extends ApiItemType, OptionsType extends RootCollectionOptions<ItemTypeType>>(parentCachedQueryItemTuple: ParentCachedQueryItemTuple<ItemTypeType>, parentCollectionResource: CollectionResource<any, any, any> | null, transaction: TransactionCache, columnSetMap?: ColumnSetMap<ItemTypeType>): OptionsToCollectionResource<ItemTypeType, OptionsType>;
+    construct<ItemTypeType extends ApiItemType, OptionsType extends CollectionOptionsBase<ItemTypeType>>(parentCachedQueryItemTuple: CachedQueryItemTypeTuple<ItemTypeType, OptionsType>, parentCollectionResource: CollectionResource<any, any, any> | null, transaction: TransactionCache, columnSetMap?: ColumnSetMap<ItemTypeType>): OptionsToCollectionResource<ItemTypeType, OptionsType>;
     constructChildCollectionResources<Children extends ChildCollectionResources | undefined>(cachedQueryItemTypeTuples: CachedQueryItemsItemTypeTuple<ApiItemType>[] | null, parentCollectionResource: CollectionResource<any, any, any> | null, transaction: TransactionCache, columnSetMap?: Partial<ColumnSetMap<ApiItemType>>): ParentIdMap<Children>;
-    constructColumnSet<ItemTypeType extends ApiItemType>(cachedQueryItemTuple: ParentCachedQueryItemTuple<ItemTypeType>): ColumnSet<ItemTypeType>;
+    constructColumnSet<ItemTypeType extends ApiItemType>(cachedQueryItemTuple: CachedQueryItemTypeTuple<ItemTypeType, {
+        columns: ApiRequestColumnArray<ItemTypeType>;
+    }>): ColumnSet<ItemTypeType>;
 }

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

@@ -1,5 +1,24 @@
-import { ApiItemType } from '@rentman/backend-types';
-import { AggregatedChangesListener, ApiQuery, ApiRequestColumnArray, ApiRequestColumns, ChildCollectionResources, CollectionItemChangesListener, CollectionResource, EntryParent, ItemEntry, ItemResource, ItemTypeColumnId } from '../internal';
+import { ApiItemType, ItemId } from '@rentman/backend-types';
+import { AggregatedChangesListener, ApiQuery, ApiQueryConditionSimple, ApiRequestColumnArray, ChildCollectionResources, CollectionItemChangesListener, CollectionResource, EntryParent, ItemEntry, ItemResource, ItemTypeColumnId } from '../internal';
+export type ChildrenQuery<ItemTypeType extends ApiItemType> = ApiQueryConditionSimple<ItemTypeType> | {
+    operator?: 'and' | 'AND';
+    conditions: ApiQueryConditionSimple<ItemTypeType>[];
+};
+/**
+ * Note that we're using a limited query format here. This has multiple reasons:
+ * - the parent item ID should always be expressed in the type (we could further constrain it using an *and* query),
+ * as we don't want the child collection to contain items unrelated to the parent;
+ * - the query itself should be locally matchable.
+ *
+ * These constraints could be relaxed in the future, but do so at your own risk.
+ *
+ * As we haven't implemented query condition ordering yet, the condition containing the parent item ID should preferably
+ * come last. This will generate the most efficient query graph.
+ *
+ * The children query function currently accepts an array only in order facilitate creating a batch query. We can change
+ * this to a single value once we've implemented generating an API query from a query graph (RM4-48176).
+ */
+export type ChildrenQueryFunction<ItemTypeType extends ApiItemType> = (parentItemIds: ItemId[]) => ChildrenQuery<ItemTypeType>;
 export interface CollectionResourceOrder<ItemTypeType extends ApiItemType> {
     field: ItemTypeColumnId<ItemTypeType>;
     order?: 'desc' | 'asc';
@@ -17,38 +36,25 @@ type OnRemoveCollectionOption<ItemTypeType extends ApiItemType, RequestColumns e
  * 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>>;
+    [ChildItemType in ApiItemType]?: ChildCollectionOptions<ChildItemType, ApiRequestColumnArray<ChildItemType>, {
+        [GrandChildItemType in ApiItemType]?: ChildCollectionOptions<GrandChildItemType, ApiRequestColumnArray<GrandChildItemType>, {
+            [GrandGrandChildItemType in ApiItemType]?: ChildCollectionOptions<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>;
+export interface PreventCachingCollectionOption {
     /**
      * 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}.
+ * Does not include `query` / `parent` properties.
  */
-export interface CollectionOptions<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends CachedQueryOptions<ItemType> {
+export interface CollectionOptionsBase<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends PreventCachingCollectionOption {
     columns: RequestColumns;
+    children?: Children;
+    order?: CollectionResourceOrder<ItemType>;
     /**
      * @deprecated
      */
@@ -61,16 +67,21 @@ export interface CollectionOptions<ItemType extends ApiItemType, RequestColumns
      * @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> {
+export interface ChildCollectionOptions<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends CollectionOptionsBase<ItemType, RequestColumns, Children> {
+    query?: ApiQuery<ItemType> | ChildrenQueryFunction<ItemType>;
+}
+/**
+ * When we process child collections options, we create a separate set of options for each child collection. The
+ * `parent` property is determined now.
+ */
+export interface ProcessedChildCollectionOptions<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends ChildCollectionOptions<ItemType, RequestColumns, Children> {
+    parent: EntryParent;
+}
+export interface RootCollectionOptionsBase<ItemType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemType> = ApiRequestColumnArray<ItemType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends CollectionOptionsBase<ItemType, RequestColumns, Children> {
+    query?: ApiQuery<ItemType>;
+    parent?: EntryParent;
     /**
      * Note: When using the `changesListener` option the `context` parameter is untyped. (This would require self
      * reference.)
@@ -80,6 +91,12 @@ export interface RootCollectionOptionsBase<ItemType extends ApiItemType, Request
      */
     changesListener?: AggregatedChangesListener<CollectionResource<ItemType, any, any>, any>;
     immediatelyCallChangesListener?: boolean;
+    abortSignal?: AbortSignal;
+    /**
+     * This allows us to add custom data to the options. See: https://rentman.atlassian.net/browse/RM4-19122
+     * @deprecated
+     */
+    custom?: any;
 }
 /**
  * Used in {@link OrderedCollectionResource}.
@@ -93,19 +110,11 @@ export interface RootCollectionOptionsWithOrder<ItemTypeType extends ApiItemType
 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> {
+export 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

@@ -1,7 +1,7 @@
 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, ChildCollectionResources, CollectionEntry, CollectionItemChangesListenerContext, CollectionOptions, CollectionQuery, CollectionResourceFactory, ColumnSet, DeregFunction, ItemEntry, ItemIdConversionMap, ItemResource, ItemTypeColumnIds, ParentChangesDelta, ParentIdMap, ResponseColumnItemTypeMap, RootCollectionOptionsBase, TransactionCache } from '../internal';
+import { AbstractCache, AggregatedChangesByListener, AggregatedChangesListener, AggregatedChangesListenerFunction, ApiRequestColumnArray, CachedQueryItem, CachedQueryOptionsWithChildren, ChildCollectionResources, CollectionEntry, CollectionItemChangesListenerContext, CollectionQuery, CollectionResourceFactory, ColumnSet, DeregFunction, ItemEntry, ItemIdConversionMap, ItemResource, ItemTypeColumnIds, ParentChangesDelta, ParentIdMap, ResponseColumnItemTypeMap, RootCollectionOptionsBase, TransactionCache } from '../internal';
 export type CollectionToItemResource<CollectionResourceType extends {
     items: any[];
 }> = CollectionResourceType['items'][number];
@@ -168,7 +168,7 @@ export declare class CollectionResource<ItemTypeType extends ApiItemType, Reques
      * @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>>;
+    protected fetchCachedQuery(options?: CachedQueryOptionsWithChildren<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
     private registerOptionsChangesListeners;
     private __registerCallback;
 }

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

@@ -1,5 +1,5 @@
 import { ApiItemType } from '@rentman/backend-types';
-import { ApiRequestColumnArray, ChildCollectionsOption, EntryParent, FieldMap, ItemAggregatedChangesListener, ItemResource, RequestParameters } from '../internal';
+import { ApiRequestColumnArray, ChildCollectionsOption, EntryParent, FieldMap, ItemAggregatedChangesListener, ItemResource, PreventCachingCollectionOption, RequestParameters } from '../internal';
 export interface ItemOptions<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType> = ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionsOption = ChildCollectionsOption> {
     columns: RequestColumns;
     children?: Children;
@@ -19,7 +19,6 @@ export interface NewItemOptions<ItemTypeType extends ApiItemType, RequestColumns
     templateOptions?: Partial<RequestParameters<ItemTypeType>>;
     defaultValues?: Partial<FieldMap<ItemTypeType>>;
 }
-export interface ItemsByQueryOptions<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType> = ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends ItemOptions<ItemTypeType, RequestColumns, Children> {
+export interface ItemsByQueryOptions<ItemTypeType extends ApiItemType, RequestColumns extends ApiRequestColumnArray<ItemTypeType> = ApiRequestColumnArray<ItemTypeType>, Children extends ChildCollectionsOption = ChildCollectionsOption> extends ItemOptions<ItemTypeType, RequestColumns, Children>, PreventCachingCollectionOption {
     parent?: EntryParent;
-    preventCaching?: boolean;
 }

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

@@ -40,7 +40,7 @@ type ApiQueryConditionSubQueryUnion<ItemTypeType extends ApiItemType> = {
     [ColumnId in keyof ItemApiFields<ItemTypeType>]: ApiQueryConditionSubQuery<ItemTypeType, ColumnId> | ApiQueryConditionExtendedSubQuery<ItemTypeType, ColumnId, ApiItemType, any>;
 }[keyof ItemApiFields<ItemTypeType>];
 type ApiFieldToQueryConditionSimple<ColumnId extends string | number | symbol, ApiFieldType> = ApiFieldType extends QueryableApiField ? ApiQueryConditionBaseSimple<ColumnId, ApiFieldToValueComparatorTuple<ApiFieldType>, ApiFieldToNullType<ApiFieldType>> : never;
-type ApiQueryConditionSimple<ItemTypeType extends ApiItemType> = {
+export type ApiQueryConditionSimple<ItemTypeType extends ApiItemType> = {
     [ColumnId in keyof ApiFields[ItemTypeType]]: ApiFieldToQueryConditionSimple<ColumnId, ApiFields[ItemTypeType][ColumnId]>;
 }[keyof ApiFields[ItemTypeType]];
 /**

package/package.json

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