entropic-bond 1.53.1 → 1.53.3

package/lib/persistent/persistent.d.ts

@@ -33,6 +33,13 @@ export interface DocumentReference {
         storedInCollection: string;
     };
 }
+export interface DocumentChange {
+    before: Persistent | undefined;
+    after: Persistent;
+    params: {
+        [key: string]: any;
+    };
+}
 type PersistentPropertyCollection = {
     [className: string]: PersistentProperty[];
 };
@@ -190,18 +197,32 @@ export declare class Persistent {
 }
 type CollectionPathCallback = (value: Persistent, prop: PersistentProperty) => string;
 type ValidatorFunction<T extends Persistent, P extends ClassPropNames<T>> = (value: T[P], property: PersistentProperty, persistentInstance: T) => boolean;
+export type OwnerCollectionResolver = (ownerClassName: string, params: {}) => string;
+/**
+ * Cached properties configuration
+ * @param cachedProps an array of properties whose values should be stored in the reference object
+ * @param updater a function that is called when the referenced object is updated
+ * @param ownerCollectionResolver a function that returns the collection path where the reference is stored
+ * @see persistentReferenceWithCachedProps
+ * @see persistentPureReferenceWithCachedProps
+ */
+export type CachedPropsConfig<T extends Persistent> = {
+    cachedProps: ClassPropNamesOfType<T, Primitive>[];
+    updater?: (event: DocumentChange, property: PersistentProperty) => Promise<void>;
+    ownerCollectionResolver?: OwnerCollectionResolver;
+};
 export interface PersistentProperty {
     name: string;
     isReference?: boolean;
     isPureReference?: boolean;
     storeInCollection?: string | CollectionPathCallback;
     subCollection?: string;
-    cachedProps?: ClassPropNames<Persistent>[];
     toObjectSpecial?: (classObj: any) => any;
     fromObjectSpecial?: (obj: any) => any;
     searchableArray?: boolean;
     validator?: ValidatorFunction<any, any>;
     typeName?: string | string[];
+    cachedPropsConfig?: CachedPropsConfig<Persistent>;
 }
 /**
  * Decorator for a property that you want to persist.
@@ -225,10 +246,24 @@ export declare function persistentReference(target: Persistent, property: string
  * Decorator to declare a persistent reference (see @persistentReference) that stores
  * the values in cachedProps as values in the reference object. This is useful
  * when you are not able to wait for population of referenced properties.
- * @param cachedProps the properties whose values should be stored in the reference object
+ * @param cachedPropsConfig Pass an array of properties whose values should be stored in the reference object or an object
+ * with the cachedProps configuration.
  * @param storedInCollection indicates the path of the collection where this reference is stored
+ * @param propTypeName the accepted type name or type names of the property
+ * @see persistentReference
+ * @see CachedPropsConfig
+ * @see persistentPureReferenceWithCachedProps
+ * @sample
+ * class UserGroup extends Persistent {
+ * 	@persistentReferenceWithCachedProps( ['name', 'email'], 'Customer/Clients', 'User' ) private _friend: User
+ * }
+ *
+ * class SpecialUserGroup extends Persistent {
+ * 	@persistentReferenceWithCachedProps( { cachedProps: ['name', 'email'], updater: async ( event, prop ) => {
+ * 		// do something when the referenced user is updated
+ * 	}}, undefined, [ 'SpecialUser', 'User' ] ) private _friend: User
  */
-export declare function persistentReferenceWithCachedProps<T extends Persistent>(cachedProps: ClassPropNamesOfType<T, Primitive>[], storeInCollection?: string | CollectionPathCallback, propTypeName?: string | string[]): (target: Persistent, property: string) => void;
+export declare function persistentReferenceWithCachedProps<T extends Persistent>(cachedPropsConfig: CachedPropsConfig<T> | ClassPropNamesOfType<T, Primitive>[], storeInCollection?: string | CollectionPathCallback, propTypeName?: string | string[]): (target: Persistent, property: string) => void;
 /**
  * Decorator for a property that is a reference to a persistent object.
  * In this case, and contrary to the @persistentReference decorator, the reference
@@ -241,18 +276,28 @@ export declare function persistentPureReference(target: Persistent, property: st
  * Decorator to declare a persistent property as a pure reference (see @persistentPureReference) that stores
  * the values of the properties listed in cachedProps as values in the reference object. This is useful
  * when you only need a few properties to be available without needing to populate the referenced property.
- * @param cachedProps the properties whose values should be stored in the reference object
+ * @param cachedPropsConfig Pass an array of properties whose values should be stored in the reference object or an object
+ * with the cachedProps configuration.
  * @param storedInCollection indicates the path of the collection where this reference is stored
+ * @param propTypeName the accepted type name or type names of the property
  * @see persistentReferenceWithCachedProps
  * @see persistentPureReference
+ * @see CachedPropsConfig
+ * @see persistentReferenceWithCachedProps
  * @sample
- * class User extends Persistent {
- * 	@persistentPureReferenceWithCachedProps( ['name', 'email'] ) private _friend: User
+ * class UserGroup extends Persistent {
+ * 	@persistentPureReferenceWithCachedProps( ['name', 'email'], 'Customer/Clients', 'User' ) private _friend: User
+ * }
+ *
+ * class SpecialUserGroup extends Persistent {
+ * 	@persistentPureReferenceWithCachedProps( { cachedProps: ['name', 'email'], updater: async ( event, prop ) => {
+ * 		// do something when the referenced user is updated
+ * 	}}, undefined, [ 'SpecialUser', 'User' ] ) private _friend: User
  * }
  * // the reference object will contain the properties name and email of the referenced user
  * // without having to populate the _friend property
  */
-export declare function persistentPureReferenceWithCachedProps<T extends Persistent>(cachedProps: ClassPropNamesOfType<T, Primitive>[], storeInCollection?: string | CollectionPathCallback, propTypeName?: string | string[]): (target: Persistent, property: string) => void;
+export declare function persistentPureReferenceWithCachedProps<T extends Persistent>(cachedPropsConfig: CachedPropsConfig<T> | ClassPropNamesOfType<T, Primitive>[], storeInCollection?: string | CollectionPathCallback, propTypeName?: string | string[]): (target: Persistent, property: string) => void;
 export declare function persistentParser(options?: Partial<PersistentProperty>): (target: Persistent, property: string) => void;
 /**
  * Decorator to register a persistent class. Entropic Bond needs that you register

package/lib/store/data-source.d.ts

@@ -53,7 +53,7 @@ export type QueryObject<T> = {
     };
 };
 export type DocumentListenerUninstaller = () => void;
-interface DocumentChange {
+export interface DocumentChange {
     before: Persistent | undefined;
     after: Persistent;
     params: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "entropic-bond",
   "type": "module",
-  "version": "1.53.1",
+  "version": "1.53.3",
   "description": "Tidy up your messy components",
   "main": "./lib/entropic-bond.umd.cjs",
   "module": "./lib/entropic-bond.js",