@rentman/rm-core 63.0.1 → 63.1.0

package/dist/types/src/classes/LockService.d.ts

@@ -12,6 +12,9 @@ export declare class LockService {
     private promises;
     constructor(apiRequestService: ApiRequestService);
     getLocksSignal(): Signal<ItemMap<LockToken>>;
+    /**
+     * @deprecated use getLocksSignal instead
+     */
     getLocks(): ItemMap<LockToken>;
     hasLock(lockTokenId: ItemId): boolean;
     isLocked(itemEntry: ItemEntry): boolean;

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

@@ -21,7 +21,7 @@ export interface CachedQueryItemsItemTypeTuple<ItemTypeType extends ApiItemType>
 export interface CachedQueryHandlerCollectionTuple<ItemTypeType extends ApiItemType> {
     cachedQueryItem?: CachedQueryItem<ItemTypeType>;
 }
-type RequireOnly<ObjectType, Keys extends keyof ObjectType> = ObjectType & {
+export type RequireOnly<ObjectType, Keys extends keyof ObjectType> = ObjectType & {
     [Key in Keys]-?: ObjectType[Key];
 };
 export declare abstract class CachedQueryHandlerBase {
@@ -135,11 +135,10 @@ export declare abstract class CachedQueryHandlerBase {
      * @param changesDelta - When doing a back-end request for `maybeMatchedItemEntries`, the resulting item IDs are
      * stored in this changes delta.
      */
-    protected processMaybeMatches<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, matchingResultsTuple: RequireOnly<MatchingResultsAccumulatorTuple<any>, 'maybe'>, changesDelta: ChangesDeltaBase): Promise<void>;
+    protected abstract processMaybeMatches<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, matchingResultsTuple: RequireOnly<MatchingResultsAccumulatorTuple<any>, 'maybe'>, changesDelta: ChangesDeltaBase): void | Promise<void>;
     /**
      * 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;
 }
-export {};

package/dist/types/src/classes/cache/server/ServerCachedQueryHandler.d.ts

@@ -1,6 +1,6 @@
 import { ApiItemType } from '@rentman/backend-types';
 import { GraphQueryParserFactory } from '../../../factories/GraphQueryParserFactory';
-import { ApiRequestService, CachedQueryHandlerBase, CachedQueryItem, CachedQueryOptions, CollectionQuery, CollectionResource, ErrorHandlerInterface, LinkCollectionBatchQueryTuple, LinkTreeServiceInterface, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, ServerCache } from '../../../internal';
+import { ApiRequestService, CachedQueryHandlerBase, CachedQueryItem, CachedQueryOptions, CollectionQuery, CollectionResource, ErrorHandlerInterface, LinkCollectionBatchQueryTuple, LinkTreeServiceInterface, MatchingResultsAccumulatorTuple, QueryService, RequestColumnExpansionFactory, RequestColumnsOperationsCache, RequestColumnsOperationsCacheFactory, RequireOnly, ServerCache } from '../../../internal';
 export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
     protected transaction: ServerCache;
     constructor(dependencies: {
@@ -26,4 +26,5 @@ export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
      * Will create a new {@link CollectionEntry CollectionEntry} if the CollectionEntry didn't exist yet
      */
     __fetchItemEntriesByQueryData<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, options: CachedQueryOptions<ItemTypeType>, columnsOperationsCache: RequestColumnsOperationsCache<ItemTypeType>, collectionQuery: CollectionQuery<ItemTypeType>, linkCollectionBatchQueryTuple?: LinkCollectionBatchQueryTuple<ItemTypeType>): Promise<CachedQueryItem<ItemTypeType>>;
+    protected processMaybeMatches<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, matchingResultsTuple: RequireOnly<MatchingResultsAccumulatorTuple<any>, 'maybe'>): void;
 }

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

@@ -107,11 +107,15 @@ export declare class TransactionCache extends AbstractCache {
      */
     id?: string | undefined, validatorFactory?: TransactionValidatorFactory, options?: Partial<TransactionOptions>);
     /**
+     * @deprecated use rootItemSignal instead
+     *
      * @description
      * Stores the 'root' {@link ItemEntry ItemEntry}, this {@link ItemEntry ItemEntry} can be used as request parent to store the whole transaction at once
      */
     get rootItem(): ItemEntry | undefined;
     /**
+     * @deprecated use hasChangesSignal instead
+     *
      * @description
      * Is true when the current transaction has:
      * - Newly created items
@@ -120,18 +124,27 @@ export declare class TransactionCache extends AbstractCache {
      */
     get hasChanges(): boolean;
     /**
+     * @deprecated use isSavingSignal instead
+     *
      * @description
      * Is true while the {@link TransactionCache TransactionCache} is applying changes to the parent (can either be through a merge or an Api save)
      */
     get isSaving(): boolean;
     /**
+     * @deprecated use isReadySignal instead
+     *
      * @description
      * Is true while the {@link TransactionCache TransactionCache} is ready to handle new saves
      */
     get isReady(): boolean;
+    /**
+     * @deprecated use isValidSignal instead
+     */
     get isValid(): boolean;
     attachValidator(validator: TransactionValidatorWithDependencies<any>): void;
     /**
+     * @deprecated use isPendingSignal instead
+     *
      * @description
      * Checks if the transaction is pending (or saving) on itself and on all of its children recursively
      * This can be used to block a transaction if one of the children is still loading (for instance for a file upload)
@@ -146,6 +159,9 @@ export declare class TransactionCache extends AbstractCache {
     setPending(promise: Promise<any>): Promise<any>;
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
     destroy(): void;
+    /**
+     * @deprecated use isDestroyedSignal instead
+     */
     isDestroyed(): boolean;
     expandCollectionResource<ItemTypeType extends ApiItemType>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns<ItemTypeType>): Promise<CollectionResource<ItemTypeType>>;
     /**
@@ -156,6 +172,9 @@ export declare class TransactionCache extends AbstractCache {
     expandCollectionResources<const ItemTypeType extends ApiItemType, CollectionResourceType extends CollectionResource<ItemTypeType, any, any>>(itemType: ItemTypeType, collections: ParentIdMap<CollectionResourceType>, newColumns: ApiRequestColumnArray<ItemTypeType>): Promise<ParentIdMap<CollectionResourceType>>;
     registerFieldChangeCallback<const ItemTypeType extends ApiItemType>(itemType: ItemTypeType, itemId: ItemId, callback: ItemChangesListener<ItemTypeType>): DeregFunction;
     createChangesDelta(logMissingColumnErrors?: boolean): ChangesDelta;
+    /**
+     * @deprecated use firstErrorString instead
+     */
     getFirstErrorString(): undefined | string;
     /**
      * @description

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

@@ -1,5 +1,5 @@
 import { ApiItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, CachedQueryHandlerBase, CachedQueryHandlerCollectionTuple, CachedQueryItem, CachedQueryItemsItemTypeTuple, CachedQueryItemTuple, CachedQueryOptions, ChildCollectionsOption, CollectionItemResourceChanges, CollectionOptions, CollectionQuery, CollectionResource, EntryParent, ItemIdConversionMap, LinkCollectionBatchQueryTuple, MatchesAccumulatorMap, MatchingResultsAccumulatorMapType, ParentCachedQueryItemTuple, RequestColumnsOperationsCache, TransactionCache, TransactionCollectionHandlerDependencyInterface } from '../../../internal';
+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 { RootQueryNode } from '../../matcher/RootQueryNode';
 export interface LinkCollectionOptionsItemTypeTuple<ItemTypeType extends ApiItemType> {
     itemType: ItemTypeType;
@@ -87,6 +87,7 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
     protected clearCollectionTupleIfEmpty<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, didAlreadyClearResourceRefs?: boolean): void;
     protected getQueryGraphsForItemType<ItemTypeType extends ApiItemType>(itemType: ItemTypeType): Set<RootQueryNode<ItemTypeType>>;
     protected getCollectionQueries<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string): Set<CollectionQuery<ItemTypeType>>;
+    protected processMaybeMatches<ItemTypeType extends ApiItemType>(itemType: ItemTypeType, queryString: string, matchingResultsTuple: RequireOnly<MatchingResultsAccumulatorTuple<any>, 'maybe'>, changesDelta: ChangesDeltaBase): Promise<void>;
     private getCollectionResourcesByTuple;
     private updateQueryLocalItemIdReferences;
     /**

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

@@ -6,6 +6,8 @@ export declare abstract class TransactionValidatorBase {
     protected _lastCallId: number;
     constructor(transaction: TransactionCache);
     /**
+     * @deprecated use isPendingSignal instead
+     *
      * @description
      * Will return `true` if there are any validators pending
      */

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

@@ -45,6 +45,9 @@ export declare class CollectionResource<ItemTypeType extends ApiItemType, Reques
     readonly itemType: ItemTypeType;
     readonly entry: CollectionEntry<ItemTypeType>;
     readonly columns: ResponseColumnItemTypeMap;
+    /**
+     * @deprecated Use itemsSignal instead
+     */
     items: ItemResource<ItemTypeType, RequestColumns, Children>[];
     readonly itemsSignal: WritableSignal<ItemResource<ItemTypeType, RequestColumns, Children>[]>;
     parentItem: ItemResource<any, any, any> | null;

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

@@ -2,13 +2,19 @@ import { ApiItemType, ItemId } from '@rentman/backend-types';
 import { ColumnSet } from '../internal';
 export declare class ItemEntry<ItemTypeType extends ApiItemType = any> {
     itemType: ItemTypeType;
-    itemId: ItemId;
     columns: ColumnSet<ItemTypeType>;
     private static currentId;
     id: number;
     isLockableSignal: import("@angular/core").WritableSignal<boolean>;
     isLocalSignal: import("@angular/core").WritableSignal<boolean>;
     private outdated;
+    /**
+     * Use {@link updateId} to set this value
+     *
+     * This is necessary to support the signals based on this value.
+     */
+    get itemId(): ItemId;
+    private _itemId;
     constructor(itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
     updateId(newItemId: number): void;
     isOutdated(): boolean;

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

@@ -24,6 +24,9 @@ export declare class ItemResource<ItemTypeType extends ApiItemType = ApiItemType
     readonly transaction: TransactionCache;
     private readonly _isNew;
     columns: ResponseColumnMap<ItemTypeType, RequestToItemColumns<ItemTypeType, RequestColumns>>;
+    /**
+     * @deprecated Use fieldSignals instead
+     */
     fields: Readonly<RequestColumnsFieldMap<ItemTypeType, RequestColumns>>;
     initial: Readonly<RequestColumnsFieldMap<ItemTypeType, RequestColumns>>;
     fieldSignals: Readonly<RequestColumnsSignalFieldMap<ItemTypeType, RequestColumns>>;
@@ -100,6 +103,9 @@ export declare class ItemResource<ItemTypeType extends ApiItemType = ApiItemType
      * 'isNew' means that the {@link ItemEntry ItemEntry} is a local item and that this resource was created when the {@link ItemEntry ItemEntry} was first created
      */
     isNew(): boolean;
+    /**
+     * @deprecated use `entry.isLocalSignal` instead
+     */
     isLocal(): boolean;
     toJSON(): {
         columns: string[];
@@ -109,6 +115,8 @@ export declare class ItemResource<ItemTypeType extends ApiItemType = ApiItemType
     getDerivedSignal<const T extends RequestColumnsToDerivedStringPaths<RequestColumns>, DefaultValue = unknown>(pathInput: T, defaultValue?: DefaultValue): Signal<MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, DerivedStringToRequestColumnPath<T>>, DefaultValue>>;
     getDerivedSignal<const T extends RequestColumnsToDerivedArrayPaths<RequestColumns>, DefaultValue = unknown>(pathInput: T, defaultValue?: DefaultValue): Signal<MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, T>, DefaultValue>>;
     /**
+     * @deprecated Use getDerivedSignal instead
+     *
      * @description
      * Returns the value of the columnPath, or undefined when the path couldn't be traversed
      *
@@ -117,6 +125,8 @@ export declare class ItemResource<ItemTypeType extends ApiItemType = ApiItemType
     getDerivedValue<const T extends RequestColumnsToDerivedStringPaths<RequestColumns>, DefaultValue = unknown>(columnPath: T, defaultValue?: DefaultValue): MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, DerivedStringToRequestColumnPath<T>>, DefaultValue>;
     getDerivedValue<const T extends RequestColumnsToDerivedArrayPaths<RequestColumns>, DefaultValue = unknown>(columnPath: T, defaultValue?: DefaultValue): MaybeDefaultValue<ResolveDerivedValue<ItemTypeType, T>, DefaultValue>;
     /**
+     * @deprecated Use signal version instead
+     *
      * @description
      * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
      *

package/package.json

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