@olympeio/runtime-node 8.7.2 → 9.0.2

package/types/legacy.d.ts

@@ -0,0 +1,284 @@
+// @ts-ignore
+import Observable from 'rxjs';
+import {CloudObject, Direction, HasTag, Property, Relation, Tag} from "./base";
+import {Brick, VisualBrick} from "./runtime";
+/**
+ * The entry of a brick is a static object linked to the brick class itself that is used to make the link between the
+ * code and the database. It stores tags linked to a specific brick :
+ * - tag of the brick itself
+ * - tags of properties that can be used as constants.
+ *
+ * @deprecated
+ */
+declare interface Entry extends HasTag {
+
+    /**
+     * Register a property on the brick with the specified tag.
+     *
+     * @deprecated use {@link defineProperty} instead
+     * @param tag
+     * @return the property descriptor
+     */
+    addProperty<T>(tag: string): Property<T>;
+
+    /**
+     * Register a new relation type with the specified tag and direction
+     *
+     * @deprecated use {@link defineRelation} instead
+     * @param tag
+     * @param direction
+     */
+    addRelation(tag: string, direction: Direction): transformers.Related<any, any>;
+}
+
+/** @deprecated use {@link VisualBrick} instead */
+export class UIBrick extends VisualBrick {}
+
+/** @deprecated use {@link Brick} instead */
+export type FunctionBrick = Brick;
+
+/* ======================
+       DATACLOUD
+====================== */
+
+export type InstanceTag = Tag | Entry;
+
+/** @deprecated */
+export function instanceToTag(instance: InstanceTag): string;
+/** @deprecated */
+export function onDestroy(callback: () => void): string;
+/** @deprecated */
+export function offDestroy(id: string);
+/** @deprecated */
+export function registerSync(tag: string, brick: new () => Sync, ...args: any): Entry;
+
+/** @deprecated */
+export class Sync extends CloudObject {
+    /** @deprecated use static method {@link CloudObject#get} instead */
+    static getInstance(instance: InstanceTag): Sync;
+    /** @deprecated use static method {@link CloudObject#instancesOf} instead */
+    static getInstancesOf(model: InstanceTag): ListDef;
+
+    /** @deprecated use {@link CloudObject#name} instead */
+    getName(): string;
+    /** @deprecated use {@link CloudObject#observe} instead */
+    observeProperty<T>(property: Property<T>): Observable<T>;
+    /** @deprecated use {@link CloudObject#get} instead */
+    getProperty<T>(property: Property<T>): T | null;
+}
+
+/** @deprecated */
+export class DBView {
+    static get(): DBView;
+
+    exist(tag: InstanceTag): boolean;
+    name(tag: InstanceTag): string;
+    model(tag: InstanceTag): string | null;
+    extension(tag: InstanceTag): string | null;
+    isModel(tag: InstanceTag): boolean;
+    instanceOf(tag: InstanceTag, modelTag: InstanceTag): boolean;
+    isPersisted(tag: InstanceTag): boolean;
+    getProperty<T>(tag: InstanceTag, property: Property<T>, ownOnly?: boolean): T | null;
+    // @ts-ignore
+    getProperties(tag: InstanceTag, ownOnly?: boolean): Map<string, any>;
+    getRelated(tag: InstanceTag, relation: Relation<any, any>): string[];
+    isRelated(tag: InstanceTag, relation: Relation<any, any>, related: InstanceTag): boolean;
+    getMultiRelated(startTag: InstanceTag, relations: Relation<any, any>[]): string[];
+    getUniqueRelated(tag: InstanceTag, relation: Relation<any, any>): string | null;
+    getRecursiveRelated(startTag: InstanceTag, relation: Relation<any, any>, endTag: InstanceTag): string[];
+    findRecursive(startTag: InstanceTag, relation: Relation<any, any>, predicate: (string) => boolean): string | null;
+    findRelated(startTag: InstanceTag, relations: Relation<any, any>[], predicate: (string) => boolean): string | null;
+    findAllRelated(startTag: InstanceTag, relations: Relation<any, any>[], predicate: (string) => boolean): string[];
+    getExtendedModels(modelTag: InstanceTag, endTag?: InstanceTag): string[];
+    isExtending(modelTag: InstanceTag, extendedTag: InstanceTag): boolean;
+    getInstances(modelTag: InstanceTag): string[];
+}
+
+/** @deprecated */
+export class ListDef {
+    constructor(root: InstanceTag, transformers?: Transformer | Transformer[]);
+    getBaseTag(): string;
+    onReady(callback: (list: ListDef) => void): string;
+    offReady(id: string);
+    observeFirst(): Observable<Sync>;
+    observeAt(rank: number): Observable<Sync>;
+    getCurrentAt(rank: number): Sync | null;
+    observeRank(id: string): Observable<number>;
+    getCurrentRank(id: string): number | null;
+    observeSize(): Observable<number>;
+    getCurrentSize(): number;
+    forEach(onAdd: (item: Sync, index: string, list: ListDef) => void, onRemove: (itemTag: string) => void);
+    forEachCurrentValue(callback: (item: Sync, index: string, list: ListDef) => void);
+    transform(...transformers: Transformer[]): ListDef;
+    union(otherListDef: ListDef): ListDef;
+    filter(predicate: ListDefPredicate): ListDef;
+}
+
+
+/* *************************
+        Transformers
+************************* */
+declare abstract class Transformer { }
+
+export namespace transformers {
+    /** @deprecated */
+    export class Related<O extends CloudObject, D extends CloudObject> extends Transformer {
+        constructor(relation: InstanceTag, direction: Direction);
+        getTag(): string;
+        getDirection(): Direction;
+        getInverse(): transformers.Related<D, O>;
+    }
+
+    /** @deprecated */
+    export class RecursiveRelated extends Transformer {
+        constructor(relation: InstanceTag, direction: Direction, minHops: number, maxHops: number);
+    }
+
+    /** @deprecated */
+    export class Distinct extends Transformer {
+        constructor();
+    }
+
+    /** @deprecated */
+    export class Filter extends Transformer {
+        constructor(predicate: ListDefPredicate);
+    }
+
+    /** @deprecated */
+    export class Limit extends Transformer {
+        constructor(limit: number, offset: number);
+    }
+
+    /** @deprecated */
+    export class Sort extends Transformer {
+        constructor(comparator: Comparator, ascending?: boolean);
+    }
+
+    /** @deprecated */
+    export class Union extends Transformer {
+        constructor(base: ListDef | InstanceTag, ...transformers: Transformer[]);
+    }
+}
+
+/* *************************
+         Predicates
+************************* */
+/** @deprecated */
+export abstract class ListDefPredicate {
+    static create(predicate: (object: Sync) => Observable<boolean>): ListDefPredicate;
+}
+
+export namespace predicates {
+    /** @deprecated */
+    export class And extends ListDefPredicate {
+        constructor(...predicates: ListDefPredicate[]);
+    }
+
+    /** @deprecated */
+    export class Or extends ListDefPredicate {
+        constructor(...predicates: ListDefPredicate[]);
+    }
+
+    /** @deprecated */
+    export class Not extends ListDefPredicate {
+        constructor(predicate: ListDefPredicate);
+    }
+
+    /** @deprecated */
+    export class Equals extends ListDefPredicate {
+        constructor(left: ValueDef, right: ValueDef);
+    }
+
+    /** @deprecated */
+    export class Contains extends ListDefPredicate {
+        constructor(source: ValueDef, value: ValueDef);
+    }
+
+    /** @deprecated */
+    export class Greater extends ListDefPredicate {
+        constructor(left: ValueDef, right: ValueDef);
+    }
+
+    /** @deprecated */
+    export class Smaller extends ListDefPredicate {
+        constructor(left: ValueDef, right: ValueDef);
+    }
+
+    /** @deprecated */
+    export class HasRelated extends ListDefPredicate {
+        constructor(relations: InstanceTag[], directions: Direction[], tag?: InstanceTag);
+    }
+
+    /** @deprecated */
+    export class InstanceOf extends ListDefPredicate {
+        constructor(models: InstanceTag[]);
+    }
+
+    /** @deprecated */
+    export class Regex extends ListDefPredicate {
+        constructor(source: ValueDef, regex: string, caseSensitive?: boolean);
+    }
+}
+
+/* *************************
+         ValueDefs
+************************* */
+declare abstract class ValueDef { }
+
+/** @deprecated */
+export namespace valuedefs {
+    /** @deprecated */
+    export class BooleanProperty extends ValueDef {
+        constructor(property: Property<boolean>, transformers?: Transformer[], baseTag?: string);
+    }
+
+    /** @deprecated */
+    export class DateTimeProperty extends ValueDef {
+        constructor(property: Property<Date>, transformers?: Transformer[], baseTag?: string);
+    }
+
+    /** @deprecated */
+    export class NumberProperty extends ValueDef {
+        constructor(property: Property<number>, transformers?: Transformer[], baseTag?: string);
+    }
+
+    /** @deprecated */
+    export class StringProperty extends ValueDef {
+        constructor(property: Property<string>, transformers?: Transformer[], baseTag?: string);
+    }
+
+    /** @deprecated */
+    export class Tag extends ValueDef {
+        constructor();
+    }
+
+    /** @deprecated */
+    export class Constant extends ValueDef {
+        constructor(value: any);
+    }
+}
+
+/* *************************
+         Comparator
+************************* */
+/** @deprecated */
+export abstract class Comparator {
+    static create(comparator: (object1: Sync, object2: Sync) => Observable<number>): Comparator;
+}
+
+export namespace comparators {
+    /** @deprecated */
+    export class Number extends Comparator {
+        constructor(value: ValueDef);
+    }
+
+    /** @deprecated */
+    export class String extends Comparator {
+        constructor(value: ValueDef);
+    }
+
+    /** @deprecated */
+    export class DateTime extends Comparator {
+        constructor(value: ValueDef);
+    }
+}

package/types/runtime.d.ts

@@ -0,0 +1,281 @@
+// **********************************
+// Runtime classes
+// **********************************
+// @ts-ignore
+import Observable from 'rxjs';
+import {CloudObject, Context, Property} from "./base";
+import {Entry} from "./legacy";
+
+/**
+ * Label of global properties used by convention through bricks and applications.
+ * Example of use:
+ *
+ *    const transaction = context.get(TRANSACTION).
+ *
+ * The brick "Begin Transaction" push a transaction inside the context so it can be reused by other bricks before the "End Transaction" brick.
+ */
+export enum GlobalProperties {
+    EDITION_MODE = '__editionMode',
+    PRODUCTION = '__production',
+    TRANSACTION = '__transaction'
+}
+
+export class BrickContext extends Context {
+    /**
+     * Returns a boolean indicating whether a property has a value or not.
+     *
+     * @param key the property or key string
+     * @param global [=false] whether or not the method checks parent contexts
+     * @return whether `property` has a value or not
+     */
+    has<T>(key: string | Property<T>, global?: boolean): boolean;
+
+    /**
+     * Return the current value of the specified property. If there is currently no value, return null.
+     *
+     * @param key the property or key string
+     * @param global [=false] whether or not the method checks parent contexts
+     * @return the current value
+     */
+    get<T>(key: string | Property<T>, global?: boolean): T | null;
+
+    /**
+     * Return an observable to subscribe to value updates of the specified property.
+     * If `waitForValue` is set to FALSE (TRUE by default), the first value received by the observable is null
+     * if there is no value at subscription time.
+     * If `global` is set to TRUE (FALSE by default), it observes values coming from other contexts accessible from the current one.
+     *
+     * @param key the property or key string
+     * @param waitForValue [=true] whether or not the observable wait for a first value to get a value.
+     * @param global [=false] whether or not listen to a value coming from other contexts.
+     * @return the observable
+     */
+    observe<T>(key: string | Property<T>, waitForValue?: boolean, global?: boolean): Observable<T>;
+
+    /**
+     * Wait for the property to get a new value, wrapped in a promise.
+     *
+     * @param key the property
+     * @param global [=false] whether or not the method checks parent contexts
+     * @return a promise of the next value of property
+     */
+    waitFor<T>(key: string | Property<T>, global?: boolean): Promise<T>;
+
+    /**
+     * Set the specified property value and propagate the update to anyone observing it.
+     *
+     * @param key the property or key string
+     * @param value the new value to set
+     * @return this
+     */
+    set<T>(key: string | Property<T>, value: T): this;
+
+    /**
+     * Clear the value of the specified property and propagate that event.
+     *
+     * @param key the property or key string
+     */
+    remove<T>(key: string | Property<T>): boolean;
+
+    /**
+     * Subscribe to the specified observable and set its values to the context with the provided key.
+     *
+     * @param key the key used to set the values coming from the observable
+     * @param observable the observable providing values
+     * @return this context
+     */
+    repeat<T>(key: string | Property<T>, observable: Observable<T>): this;
+
+    /**
+     * Trigger the specified event and propagate the update to anyone observing it.
+     *
+     * @param key the event or key event
+     * @return this
+     */
+    trigger<T>(key: string | Property<T>): this;
+
+    /**
+     * Run a runnable property and returns its context.
+     *
+     * @param key the runnable property or the runnable itself
+     * @return the child context or null if the runner was not found
+     */
+    runner<T>(key: string | Property<T> | Brick): BrickContext | null;
+
+    /**
+     * Set the parent element for visual brick to be rendered.
+     *
+     * @param parent the parent container
+     * @return this
+     */
+    setParentElement(parent: Element): this;
+
+    /**
+     * Create and return a new context, child of the current one.
+     * Mainly used to run other bricks within the current one (e.g.: the iterator of the brick For Each).
+     *
+     * @param debugName a name to give to the context for debugging purpose.
+     */
+    createChild(debugName?: string): BrickContext;
+
+
+    // Methods to get other contexts accessible form this specific one.
+    /**
+     * Return the context with the specified id if accessible (in the hierarchy) from this context.
+     * Otherwise, return null.
+     *
+     * @param id the context id we want to retrieve
+     */
+    getOtherContext(id: string): BrickContext | null;
+
+    /**
+     * Return the parent context if it exists.
+     */
+    getParent(): BrickContext | null;
+
+    /**
+     * Listen to the creation of the context with the specified id.
+     * Executes the callback when that context becomes accessible by this current context.
+     * Return a function to unregister the listener.
+     *
+     * @param id the context id, which corresponds to the tag of the brick to be retrieved.
+     * @param callback the function to execute when the specified brick context is available
+     */
+    onContext(id: string, callback: (context: BrickContext) => void): () => void;
+}
+
+/**
+ * Static function that must be called for every brick used in an application.
+ * It registers the brick code in the registry with the specified tag and return the Entry for that brick.
+ *
+ * @param tag the brick unique id
+ * @param brick the brick class
+ * @param args Extra arguments
+ */
+export function registerBrick(tag: string, brick: new () => Brick, ...args: any);
+
+export abstract class Brick extends CloudObject {
+
+    /**
+     * Return the list of inputs tags as an ordered array.
+     */
+    readonly getInputs: () => string[];
+
+    /**
+     * Return the list of outputs tags as an ordered array
+     */
+    readonly getOutputs: () => string[];
+
+    /**
+     * Run the brick itself using the specified context.
+     *
+     * @param $ the brick context
+     */
+    run($: BrickContext) : void;
+
+    /**
+     * Called when the brick starts its lifecycle and gets initialized.
+     *
+     * @param $ the brick context
+     */
+    protected init($: BrickContext): void;
+
+    /**
+     * Observe the context to define when the brick `update` method should be called.
+     *
+     * @param $ the brick context
+     * @return an observable that emit a value anytime the brick `update` method should be called.
+     */
+    protected setupExecution($: BrickContext): Observable<any>;
+
+    /**
+     * Called whenever the conditions to update the brick are satisfied (as defined by method `configCoreUpdate`).
+     * By default, a function updates whenever an input gets a new value, but only if all inputs have a value.
+     *
+     * @param $ the brick context
+     * @param inputs array of input values
+     * @param outputs array of output setter functions. A setter updates a specific output value of the brick.
+     */
+    protected update($: BrickContext, inputs: any[], outputs: ((any) => void)[]): void;
+
+    /**
+     * Called every time the context is cleared.
+     *
+     * @param $ the brick context
+     */
+    protected clear($: BrickContext): void;
+
+    /**
+     * Called when the brick ends its lifecycle and gets destroyed.
+     *
+     * @param $ the brick context
+     */
+    protected destroy($: BrickContext): void;
+
+    /**
+     * @deprecated use {@link BrickContext#init} instead
+     * @param $ the brick context
+     */
+    protected onInit($: BrickContext): void;
+
+    /**
+     * @deprecated use {@link BrickContext#update} instead
+     * @param $ the brick context
+     * @param inputs array of input values
+     * @param outputs array of output setter functions.
+     */
+    protected onUpdate($: BrickContext, inputs: Array<any>, outputs: Array<(value: any) => void>): void;
+
+    /**
+     * @deprecated use {@link BrickContext#destroy} instead
+     * @param $ the brick context
+     */
+    protected onDestroy($: BrickContext): void;
+}
+
+
+export abstract class ActionBrick extends Brick { }
+
+// **********************
+// Runtime Visual classes
+// **********************
+
+export abstract class VisualBrick extends Brick {
+    /**
+     * Return the list of properties tags as an ordered array
+     */
+    readonly getProperties: () => string[];
+
+    /**
+     * Attach the `element` rendered by `render()` to its `parent` (in the DOM).
+     * Must return the function to clear the parent from that element.
+     * That function is called just before the next call to updateParent.
+     *
+     * If the `render()` method returns null, only the clear function of previous call to `updateParent()` will be called.
+     *
+     * @param parent the parent element
+     * @param element the element to attach
+     * @return the function to clear the element from its parent.
+     */
+    protected updateParent(parent: Element, element: Element): () => void;
+
+    /**
+     * Render an element for the given `context`.
+     * Can return `null` if no element is rendered.
+     *
+     * @param $ the brick context
+     * @param properties property values that have been s
+     * @return the rendered element
+     */
+    protected render($: BrickContext, properties: any[]): Element | null;
+
+    /**
+     * Called when the DOM Element associated to that brick has been added to the document and is ready to be drawn.
+     *
+     * @deprecated override {@link VisualBrick#render} and {@link VisualBrick#updateParent} instead.
+     * @param $ the brick context
+     * @param domElement the associated DOM Element
+     */
+    protected draw($: BrickContext, domElement: Element);
+}
+