entropic-bond 1.48.1 → 1.50.0

package/lib/persistent/persistent.d.ts

@@ -1,281 +0,0 @@
-import { ClassPropNames, SomeClassProps, UnderscoredProp } from '../types/utility-types';
-export type PersistentConstructor = new () => Persistent;
-/**
- * The corresponding type of the plain object of a persistent class.
- */
-export type PersistentObject<T extends Persistent> = Omit<SomeClassProps<T>, 'className'> & Partial<DocumentReference> & {
-    __className: string;
-    __rootCollections?: Collections;
-};
-export type PersistentObjectWithId<T extends Persistent> = PersistentObject<T> & {
-    id: string;
-};
-/**
- * The type of the plain object of a persistent class for all the nested properties.
- */
-export type MakePersistentObjects<T> = {
-    [A in keyof T]: T[A] extends Persistent ? PersistentObject<T[A]> : MakePersistentObjects<T[A]>;
-};
-/**
- * A collection of document objects typically returned by Persistent.toObject()
- * @see Persistent.toObject
- */
-export type Collections = {
-    [collectionPath: string]: PersistentObjectWithId<Persistent>[] | undefined;
-};
-/**
- * Stores information about a reference in another collection.
- */
-export interface DocumentReference {
-    id: string;
-    __className: string;
-    __documentReference: {
-        storedInCollection: string;
-    };
-}
-/**
- * A class that provides several methods to serialize and deserialize objects.
- */
-export declare class Persistent {
-    /**
-     * Registers a class to be used by the persistence engine.
-     * @param className the name of the class to be registered
-     * @param factory the constructor of the registered class
-     * @param annotation an annotation associated with the class
-     */
-    static registerFactory(className: string, factory: PersistentConstructor, annotation?: unknown): void;
-    /**
-     * Returns the constructor of a registered class
-     * @param className the name of the class to be retrieved
-     * @returns the constructor of the class
-     * @throws an error if the class is not registered
-     * @see registerFactory
-     * @see registeredClasses
-     * @see classesExtending
-     * @see annotations
-     */
-    static classFactory(className: string | undefined): PersistentConstructor;
-    /**
-     * Returns the names of all registered classes
-     * @returns the names of all registered classes
-     * @see registerFactory
-     * @see classFactory
-     */
-    static registeredClasses(): string[];
-    /**
-     * Returns the names of all registered classes that extend a given class
-     * @param derivedFrom the class to be extended
-     * @returns the names of all registered classes that extend the given class
-     * @see registerFactory
-     * @see classFactory
-     */
-    static classesExtending(derivedFrom: PersistentConstructor | Function): string[];
-    /**
-     * Returns the annotation associated with a registered class
-     * @param className the name of the class to be retrieved
-     * @returns the annotation associated with the class
-     * @throws an error if the class is not registered
-     * @see registerFactory
-     */
-    static annotations(className: string | Persistent | PersistentConstructor): unknown;
-    /**
-     * Returns a new instance of Persistent class.
-     * @param className the initial id of this instance. If not provided, a new id will be generated
-     */
-    constructor(id?: string);
-    /**
-     * Gets the class name of this instance.
-     */
-    get className(): string;
-    /**
-     * Sets the id of this instance.
-     * @param value the id of this instance
-     */
-    protected setId(value: string): void;
-    /**
-     * Returns the id of this instance.
-     * @returns the id of this instance
-     */
-    get id(): string;
-    /**
-     * This method is called by the persistence engine when the instance has been
-     * just serialized. It is called after the properties are initialized with
-     * serialized data.
-     */
-    protected afterDeserialize(): void;
-    /**
-     * This method is called by the persistence engine before the instance is
-     * serialized.
-     */
-    protected beforeSerialize(): void;
-    /**
-     * Returns an array of the persistent properties of this instance.
-     * @returns an array of the persistent properties of this instance
-     */
-    getPersistentProperties(): readonly PersistentProperty[];
-    /**
-     * Get the property information of this instance
-     * @param propName the persistent property name
-     * @returns the property information
-     */
-    getPropInfo<T extends this>(propName: ClassPropNames<T>): PersistentProperty;
-    /**
-     * Query if the property is required
-     * To mark a property as required, use the @required decorator
-     * @param propName the persistent property name
-     * @returns true if the property is required
-     * @see required
-     */
-    isRequired<T extends this>(propName: ClassPropNames<T>): boolean;
-    /**
-     * Query if the property value is valid
-     * Define the validator function using the @required decorator
-     * @param propName the persistent property name
-     * @returns true if the property value is valid using the validator function
-     * passed to the @required decorator
-     * @see required
-     */
-    isPropValueValid<T extends this>(propName: ClassPropNames<T>): boolean;
-    /**
-     * Copy the persistent properties of the given instance to this instance.
-     * The property `id` will be ignored.
-     * Only the properties that are not null or undefined will be copied.
-     * @param instance the instance to be copied
-     * @returns this instance
-     * @see fromObject
-     * @see toObject
-     */
-    clone(instance: Persistent): this;
-    /**
-     * Initializes the persistent properties of this instance from the properties
-     * of given object.
-     * @param obj the object to be copied
-     * @returns this instance
-     * @see clone
-     * @see toObject
-     */
-    fromObject(obj: Partial<PersistentObject<this>> | {}): this;
-    private fromObj;
-    /**
-     * Returns a plain object representation of this instance.
-     * Only the properties that are not null or undefined will be copied.
-     * @returns a plain object representation of this instance
-     * @see fromObject
-     * @see clone
-     */
-    toObject(): PersistentObject<this>;
-    private toObj;
-    static searchableArrayNameFor(propName: string): string;
-    private fromDeepObject;
-    private toDeepObj;
-    private toReferenceObj;
-    private buildRefObject;
-    private pushDocument;
-    private removeUnderscore;
-    static createReference<T extends Persistent>(obj: PersistentObject<T> | string): T;
-    static createInstance<T extends Persistent>(obj: PersistentObject<T> | string): T;
-    static propInfo<T extends Persistent>(registeredClassName: string, propName: ClassPropNames<T>): PersistentProperty;
-    private _id;
-    private _persistentProperties;
-    private static _factoryMap;
-}
-type CollectionPathCallback = (value: Persistent, prop: PersistentProperty) => string;
-type ValidatorFunction<T extends Persistent, P extends ClassPropNames<T>> = (value: T[P], property: PersistentProperty, persistentInstance: T) => boolean;
-interface PersistentProperty {
-    name: string;
-    isReference?: boolean;
-    isPureReference?: boolean;
-    storeInCollection?: string | CollectionPathCallback;
-    subCollection?: string;
-    forcedPersistentProps?: ClassPropNames<Persistent>[];
-    toObjectSpecial?: (classObj: any) => any;
-    fromObjectSpecial?: (obj: any) => any;
-    searchableArray?: boolean;
-    validator?: ValidatorFunction<any, any>;
-}
-/**
- * Decorator for a property that you want to persist.
- */
-export declare function persistent(target: Persistent, property: string): void;
-/**
- * Decorator for a property that is a reference to a persistent object and should be stored
- * in a specific collection.
- * @param collectionPath the path to the collection where the reference should be stored.
- * @returns
- */
-export declare function persistentReferenceAt(collectionPath: string | CollectionPathCallback): (target: Persistent, property: string) => void;
-/**
- * Decorator for a property that is a reference to a persistent object.
- * The reference content is automatically stored in a collection. The collection
- * is determined by the class name of the decorated property.
- * @see persistentPureReference
- */
-export declare function persistentReference(target: Persistent, property: string): void;
-/**
- * Decorator to declare a persistent reference (see @persistentReference) that stores
- * the values in forcedPersistentProps as values in the reference object. This is useful
- * when you are not able to wait for population of referenced properties.
- * @param forcedPersistentProps the properties whose values should be stored in the reference object
- * @param storedInCollection indicates the path of the collection where this reference is stored
- */
-export declare function persistentReferenceWithPersistentProps<T extends Persistent>(forcedPersistentProps: ClassPropNames<T>[], storeInCollection?: string | CollectionPathCallback): (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
- * contents is not stored even it has been changed. Only the reference information
- * is stored.
- * @see persistentReference
- */
-export declare function persistentPureReference(target: Persistent, property: string, storeInCollection?: string | CollectionPathCallback): void;
-/**
- * Decorator to declare a persistent property as a pure reference (see @persistentPureReference) that stores
- * the values of the properties listed in forcedPersistentProps 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 forcedPersistentProps the properties whose values should be stored in the reference object
- * @param storedInCollection indicates the path of the collection where this reference is stored
- * @see persistentReferenceWithPersistentProps
- * @see persistentPureReference
- * @sample
- * class User extends Persistent {
- * 	@persistentPureReferenceWithPersistentProps( ['name', 'email'] ) 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 persistentPureReferenceWithPersistentProps<T extends Persistent>(forcedPersistentProps: ClassPropNames<T>[], storeInCollection?: string | CollectionPathCallback): (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
- * all persistent classes that you want to use in any persistent stream.
- * @param className the name of the class
- * @param annotation an optional annotation that can be used to store additional information
- */
-export declare function registerPersistentClass(className: string, annotation?: unknown): (constructor: PersistentConstructor) => void;
-/**
- * Decorator to register a legacy name for a persistent class. This is useful when you want to
- * be able to load old data that was stored with a different class name.
- * @param legacyName the legacy name of the class
- */
-export declare function registerLegacyClassName(legacyName: string): (constructor: PersistentConstructor) => void;
-/**
- * Decorator to make a `Persistent` array property searchable by the
- * persistance engine.
- * When a property is marked as searchable, the persistance engine will
- * generate internally a new property with the same name but with the suffix `_searchable`
- * and prefixed with the `_` character. This new property will contain an array
- * with the `id` of the persistent elements in the original array.
- */
-export declare function searchableArray(target: Persistent, property: string): void;
-/**
- * Decorator to mark the property as required.
- * @see requiredWithValidator
- */
-export declare function required(target: Persistent, property: string): void;
-/**
- * Decorator to mark the property as required.
- * @param validator a function that returns true if the property value is valid.
- * By default, the property is valid if it is not undefined and not null.
- * @see required
- */
-export declare function requiredWithValidator<T extends Persistent, P extends ClassPropNames<T>>(validator?: ValidatorFunction<T, P>): (target: T, property: UnderscoredProp<P>) => void;
-export {};