@olympeio/runtime-node 9.10.4 → 9.11.0

package/types/models.d.ts

@@ -0,0 +1,203 @@
+import { Brick } from "./runtime";
+import { CloudObject } from "./data"
+import { FollowRule } from "./data-connector";
+import { Property, Relation } from "./composition"
+
+// -- Primitive types classes --
+export class Color {
+    static create(r: number, g: number, b: number, a?: number): Color;
+
+    getRed(): number;
+    getGreen(): number;
+    getBlue(): number;
+    getAlpha(): number;
+    toRGBString(): string;
+    toHexString(): string;
+    equals(obj: any): boolean;
+}
+
+
+// --------------------------
+// -- Primitive data types --
+// --------------------------
+/**
+ * A property model defines a property of a data type.
+ * A property is defined by its type and the model it defines a property for.
+ * */
+export class PropertyModel extends CloudObject {
+    /**
+     * Relation from the property model to the data type (model)
+     * to which that property is attached.
+     *
+     * Example:
+     *
+     * ` myNumberPropertyModel --definingModelRel-> myDataTypeObject`
+     */
+    static definingModelRel: Relation<PropertyModel, CloudObject>;
+
+    /**
+     * Relation from the `PropertyModel` to its type.
+     *
+     * Example :
+     *
+     * `myNumberPropertyModel --typeRel-> Number`
+     */
+    static typeRel: Relation<PropertyModel, CloudObject>;
+}
+
+/**
+ * A relation model defines a relation between two data types.
+ * It defines what data types is the origin and the destination of the relation.
+ *
+ * It also defines follow rules properties on the relation.
+ * */
+export class RelationModel extends CloudObject {
+    /**
+     * Relation from the origin data type to the RelationModel
+     * */
+    static originModelRel: Relation<RelationModel, CloudObject>;
+    /**
+     * Relation from a RelationModel to the destination data type
+     * */
+    static destinationModelRel: Relation<RelationModel, CloudObject>;
+    /**
+     * Property for the *dump* follow rule
+     */
+    static dumpFollowRuleProp: FollowRule;
+    /**
+     * Property for the *delete* follow rule
+     */
+    static deleteFollowRuleProp: FollowRule;
+    /**
+     * Property for the *runtime* follow rule
+     */
+    static runtimeFollowRuleProp: FollowRule;
+}
+
+/**
+ * StringModel represents a {@link PropertyModel} for a string property of a data type.
+ */
+export class StringModel extends CloudObject {
+    static valueProp: Property<string>;
+}
+
+/**
+ * NumberModel represents a {@link PropertyModel} for a number property of a data type.
+ */
+export class NumberModel extends CloudObject {
+    static valueProp: Property<number>;
+}
+
+/**
+ * BooleanModel represents a {@link PropertyModel} for a boolean property of a data type.
+ */
+export class BooleanModel extends CloudObject {
+    static valueProp: Property<boolean>;
+}
+
+/**
+ * DatetimeModel represents a {@link PropertyModel} for a datetime property of a data type.
+ */
+export class DatetimeModel extends CloudObject {
+    static valueProp: Property<Date>;
+}
+
+/**
+ * ColorModel represents a {@link PropertyModel} for a color property of a data type.
+ */
+export class ColorModel extends CloudObject {
+    static valueProp: Property<Color>;
+}
+
+/**
+ * User object for authentication purposes
+ */
+export class User extends CloudObject {
+    static loginProp: Property<string>;
+    static saltProp: Property<string>;
+    static verifierProp: Property<string>;
+    static SAMLnameIdProp: Property<string>;
+}
+
+
+
+// -------------------------
+// -- Workflow data types --
+// -------------------------
+
+/**
+ * A `Workflow` is a sequence of {@link WorkflowState} in which instances of a model goes through.
+ * {@link WorkflowState} are linked by {@link WorkflowTransition} that can have an optional _process function_.
+ * The `Workflow` also historize the {@link WorkflowState} of the instance and optionally serialize the object itself in a {@link WorkflowObjectState}.
+ */
+export class Workflow extends CloudObject {
+    /** Is the instance serialization enabled or not */
+    static serializationEnabledProp: Property<boolean>;
+    /** The model to which the `Workflow` is associated */
+    static dataTypeRel: Relation<Workflow, CloudObject>;
+    /** The {@link WorkflowState} that are in the `Workflow` */
+    static statesRel: Relation<Workflow, WorkflowState>;
+    /** The initial {@link WorkflowState} of the `Workflow` */
+    static initialStateRel: Relation<Workflow, WorkflowState>;
+}
+
+/**
+ * A `WorkflowState` defines a state in a {@link Workflow}.
+ */
+export class WorkflowState extends CloudObject { /* empty */ }
+
+/**
+ * A `WorkflowTransition` defines a transition between 2 {@link WorkflowState}.
+ * It has a direction (`fromStateRel` to `toStateRel`) and can have an optional _process function_.
+ * The _process function_ (`processRefProp`) is automatically triggered when the transition occurs.
+ */
+export class WorkflowTransition extends CloudObject {
+    /**
+     * The `WorkflowTransition` optional _process function_.
+     * It has this signature: (ControlFlow, CloudObject, User, Map) -> (ControlFlow, ErrorFlow)
+     */
+    static processRefProp: Property<Brick>;
+    /** The {@link WorkflowState} from which this transition starts */
+    static fromStateRel: Relation<WorkflowTransition, WorkflowState>;
+    /** The {@link WorkflowState} to which this transition ends */
+    static toStateRel: Relation<WorkflowTransition, WorkflowState>;
+}
+
+/**
+ * A `WorkflowObjectState` represents the state of an instance at a certain point in time.
+ * It is automatically created when initializing a {@link Workflow} on an instance or when triggering a {@link WorkflowTransition}.
+ */
+export class WorkflowObjectState extends CloudObject {
+    /** The name of the {@link Workflow} associated */
+    static workflowProp: Property<string>;
+    /** The name of the {@link WorkflowState} */
+    static stateProp: Property<string>;
+    /** The name (login) of the {@link User} */
+    static assigneeProp: Property<string>;
+    /** The point in time of this object state */
+    static dateTimeProp: Property<Date>;
+    /** If the {@link Workflow} has serialization enabled, the object's property are saved here in JSON */
+    static serializedObjectProp: Property<string>;
+    /** The related instance this object state represents */
+    static objectRel: Relation<WorkflowObjectState, CloudObject>;
+    /** The related instance this object state represents. This relation only reference the current state */
+    static currentObjectRel: Relation<WorkflowObjectState, CloudObject>;
+}
+
+// -------------------------
+// -- Theme data types --
+// -------------------------
+
+/**
+ * Theme object describing the main visual properties used by components
+ */
+export class Theme extends CloudObject {
+    static nameProp: Property<string>;
+    static primaryColorProp: Property<string>;
+    static secondaryColorProp: Property<string>;
+    static errorColorProp: Property<string>;
+    static warningColorProp: Property<string>;
+    static infoColorProp: Property<string>;
+    static successColorProp: Property<string>;
+    static fontFamilyProp: Property<string>;
+}

package/types/{utils.d.ts → other.d.ts}

@@ -1,294 +1,33 @@
-// **********************************
-// Olympe Utils public API
-// **********************************
-
+import { CloudObject } from "./data";
+import { QueryResult } from "./query";
 // @ts-ignore
-import {Observable} from 'rxjs';
-// @ts-ignore
-import {Error} from 'es5';
-import {Context} from "./base";
-
-// -- Configuration --
-export class Config {
-    /**
-     * Return the value of the specified parameter.
-     * Parameters can get their values from the oConfig.json file or be overridden from the URL / command that opened the application.
-     *
-     * @param id the parameter id
-     */
-    static getParameter(id: string): unknown | undefined;
-}
+import { Observable } from "rxjs";
 
 /**
- * Types of probe that can be used to check the health of the process:
- * - LIVENESS: used to check if the process is alive
- * - READINESS: used to check if the process is ready to operate
- * - ALL: used to check both liveness and readiness
+ * 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 ProbeType {
-    LIVENESS = 'liveness',
-    READINESS = 'readiness',
-    ALL = 'all'
-}
-
-// Health check and shutdown
-export class Process {
-
-    /**
-     * Static method to register a callback that is used to check the health status of the process.
-     * This is typically used by kubernetes environment to maintain backend healthy
-     *
-     * The callback must return a Promise which returns a string as valid message.
-     * The process is considered by the runtime as unhealthy if the promise is rejected.
-     *
-     * The options parameter can be used to specify the type of probe to register:
-     * - LIVENESS: used to check if the process is alive
-     * - READINESS: used to check if the process is ready to operate
-     * - ALL: used to check both liveness and readiness
-     *
-     * @param callback the callback executed each time the runtime check the health of the process.
-     * @param options options to specify the type of probe to register
-     */
-    static onHealthCheck(callback: () => Promise<string>, options?: {type: ProbeType}): () => void;
-
-    /**
-     * Static method to register a callback called by the runtime when it receives the signal to be terminated.
-     * This is typically used to graceful shutdown some connections or drivers to external processes.
-     *
-     * The callback must return a Promise which is resolved when the shutdown process is done.
-     *
-     * @param callback the callback executed when the runtime terminates.
-     * @param shutdownId optional id to name the shutdown hook, mainly for debug purpose
-     */
-    static onShutdown(callback: () => Promise<void>, shutdownId?: string): () => void;
-
-    /**
-     * Static method that manually triggers a connection attempt to the server to go ONLINE.
-     * If you have called {@apilink Process.disconnect()} before, it will cancel the OFFLINE mode,
-     * next time the app will be opened, it will try to go ONLINE on its own.
-     *
-     * Returns a promise that resolves when the server connection is established. If it fails, the promise is rejected.
-     */
-    static connect(): Promise<void>;
-
-    /**
-     * Static method that manually close the connection to the server to go OFFLINE.
-     * Persists the offline status so the app restart offline after being closed.
-     * The only way to clean that status is to call {@apilink Process.connect()}.
-     *
-     * Returns a promise that resolves when the server connection is indeed disconnected and the state is OFFLINE.
-     * If the flag `offline.enabled` is not set to true, the promise is rejected.
-     */
-    static disconnect(): Promise<void>;
-
-    /**
-     * Static method that returns an observable on the connection state: the observable send TRUE if the process is considered
-     * as ONLINE and false if not.
-     *
-     * @param context the context of the brick to garbage collect the observable when not needed anymore.
-     */
-    static isOnline(context: Context): Observable<boolean>;
-}
-
-// -- Primitive types classes --
-export class Color {
-    static create(r: number, g: number, b: number, a?: number): Color;
-
-    getRed(): number;
-    getGreen(): number;
-    getBlue(): number;
-    getAlpha(): number;
-    toRGBString(): string;
-    toHexString(): string;
-    equals(obj: any): boolean;
-}
-
-/**
- * Error type used to propagate errors through flows between bricks.
- */
-export class ErrorFlow extends Error {
-    /**
-     * Create a new Error object to be sent in an error flow
-     *
-     * @param message the error message
-     * @param code the code associated to the error
-     */
-    static create(message: string, code: number): ErrorFlow;
-
-    /**
-     * Return the message of this error
-     */
-    getMessage(): string;
-
-    /**
-     * Return the code associated to this error
-     */
-    getCode(): number;
-
-    /**
-     * Return the stack with the hierarchy of bricks that run the one having thrown the error.
-     */
-    getStack(): string;
-}
-
-/**
- * Types of requests that can be received in a Service.
- * This is used to know what method call on the request to answer the requester.
- */
-export enum ServiceRequestType {
-    PUBLISH,
-    SEND,
-    GET,
-    SUBSCRIBE
-}
-
-/**
- * A request consumed by a service.
- */
-export class ServiceRequest {
-
-    /**
-     * Get the requesting client's user tag.
-     *
-     * @return the user tag
-     */
-    userTag(): Promise<string>;
-
-    /**
-     * Return the type of this Service Request
-     *
-     * @return the type of this request.
-     */
-    requestType(): ServiceRequestType;
-
-    /**
-     * Get the request body.
-     *
-     * @return the request body
-     */
-    body(): Object;
-
-    /**
-     * Acknowledge the request. Used for SEND requests
-     *
-     * @return a Promise that completes once the ack is sent
-     */
-    ack(): Promise<void>;
-
-    /**
-     * Send a reply to the request with a content payload. Used for GET requests
-     *
-     * @param payload the payload of the reply
-     * @return a Promise that completes once the reply is sent
-     */
-    reply(payload: Object): Promise<void>;
-
-    /**
-     * Send the topic where the requester should listen to get notifications. Used for OBSERVE requests.
-     * The string returned by the Promise is the id of that subscription. It can be used in parallel with
-     * the {@apilink Service.setUnsubscriptionHandler} method of the service to execute instructions when a subscription is removed.
-     *
-     * @param topic the topic where the client should
-     * @return a Promise that completes once the consumer has started to the listen to notifications. The
-     */
-    notifyOn(topic: string): Promise<string>;
-
-    /**
-     * Reply to the request with and error.
-     *
-     * @param error the error to send
-     * @return a Promise that completes once the error is sent
-     */
-    fail(error: Error): Promise<void>;
-}
-
-interface ServiceConfig {
-    /**
-     * After how much time (in ms) the message must be considered as timeout by the service.
-     */
-    timeout?: number
+export enum GlobalProperties {
+    EDITION = '__editionMode',
+    PRODUCTION = '__production',
+    TRANSACTION = '__transaction'
 }
 
-interface SubscriptionServiceConfig extends ServiceConfig {
-    /**
-     * A callback to be called in case the subscription to the service is re-sent to the service (eg: after a reconnection).
-     */
-    onRetry?: () => void;
-}
 
-/**
- * A service that processes requests coming from other VMs connected to the data cloud.
- */
-export class Service {
-
-    /**
-     * Create a new instance of the service with the specified id.
-     * It uses the context to make the lifecycle of the service related to the context one.
-     *
-     * @param serviceId the service id
-     * @param context the context of that service.
-     */
-    constructor(serviceId: string, context: Context);
-
-    /**
-     * Start and listen to incoming requests.
-     */
-    listen(): Observable<ServiceRequest>;
-
-    /**
-     * Set a function to be executed each time a subscription to that service is closed.
-     * The function receives the subscription id that has been closed.
-     * The subscription id is the one that has been set and returned by the {@apilink ServiceRequest.notifyOn} method.
-     *
-     * @param handler the handler function to be executed when a subscription is closed.
-     * @return this Service instance.
-     */
-    setUnsubscriptionHandler(handler: (subId: string) => void): this
+// **********************************
+// Primitives
+// **********************************
 
-    /**
-     * Stop the service.
-     */
-    stop(): void
 
-    /**
-     * Publish a message on the specified service without waiting for any acknowledge
-     *
-     * @param service the service id
-     * @param payload
-     */
-    static publish(service: string, payload: Object): Promise<void>;
+export type List<T> = Array<T> | (T extends CloudObject | CloudObject[] ? QueryResult<T> : never);
 
-    /**
-     * Send a request to a {@apilink Service} and wait for an ack.
-     *
-     * @param service the service id
-     * @param payload the message payload, optional
-     * @param config optional parameters for the message
-     * @return a Promise that completes when the call has been executed
-     */
-    static send(service: string, payload?: Object, config?: ServiceConfig): Promise<void>;
+export type Class<T> = {new (): T};
 
-    /**
-     * Send a request to a {@apilink Service} and wait for a reply with a payload..
-     *
-     * @param service the service id
-     * @param payload the message payload
-     * @param config optional parameters for the message
-     * @return a Promise wrapping the resulting value
-     */
-    static get(service: string, payload: Object, config?: ServiceConfig): Promise<Object>;
 
-    /**
-     * Send a request to a {@apilink Service} and subscribe to notifications published from that service.
-     *
-     * @param service the service id
-     * @param context the context used to link its lifecycle to this subscription
-     * @param payload the message payload, optional
-     * @param config optional parameters for the message
-     * @return an Observable emitting notifications
-     */
-    static observe(service: string, context: Context, payload?: Object, config?: SubscriptionServiceConfig): Observable<Object>;
-}
 
 // -- Authentication --
 
@@ -332,21 +71,21 @@ export class Auth {
     /**
      * Return the current state of the authentication manager
      *
-     * @deprecated use {@apilink Auth.isAuthenticated} instead
+     * @deprecated use {@link Auth.isAuthenticated} instead
      * @return the current state
      */
     static getState(): AuthState;
 
     /**
      * Return the token currently used to identify the current session.
-     * @deprecated see {@apilink Auth.getUserToken}
+     * @deprecated see {@link Auth.getUserToken}
      * @return The current token
      */
     static getToken(): string;
 
     /**
      * Return the IDP token (zipped & base64 encoded XML) for the current user.
-     * @deprecated use {@apilink Auth.getUserToken} instead
+     * @deprecated use {@link Auth.getUserToken} instead
      * @return The current IDP token
      */
     static getIDPToken(): string;
@@ -390,7 +129,7 @@ export class Auth {
     /**
      * Refresh the session token to keep it alive.
      *
-     * @deprecated use {@apilink Auth.refreshToken} instead
+     * @deprecated use {@link Auth.refreshToken} instead
      */
     static sendKeepAlive(): void;
 
@@ -417,7 +156,7 @@ export class Auth {
      * Try to login using SAML protocol with the specified username and password.
      * Returns a promise resolved when logged in or that catches an error if refused.
      *
-     * @deprecated use {@apilink Auth.loginSSO} instead
+     * @deprecated use {@link Auth.loginSSO} instead
      * @throws {Error} If the provider's configuration is incorrect.
      */
     static loginSAML(): Promise<void>;
@@ -426,7 +165,7 @@ export class Auth {
      * Try to login using the configured OpenID Provider.
      * Returns a promise resolved when logged in or that catches an error if the login is not valid.
      *
-     * @deprecated use {@apilink Auth.loginSSO} instead
+     * @deprecated use {@link Auth.loginSSO} instead
      * @throws {Error} If the provider's configuration is incorrect.
      */
     static loginOpenID(): Promise<void>;
@@ -533,3 +272,137 @@ declare type CacheStatus = {
         processed: number,
     }
 }
+
+/**
+ * Softcoded application context
+ *
+ * Contexts have parents and children, they represent the lifecycle of bricks.
+ * They contain callbacks executed at specific time of the brick lifespan.
+ *
+ * Each time a brick is updated with new inputs, {@link Context.clear} is called,
+ * executing all callbacks registered with {@link Context.onClear}.
+ *
+ * When a brick is destroyed, {@link Context.destroy} is called,
+ * executing all callbacks registered with {@link Context.onClear} and {@link Context.onDestroy}
+ */
+export abstract class Context {
+    /**
+     * Destroy the current context. It destroys all children context attached to this one and clear their values.
+     * The context cannot be reused after calling this function.
+     */
+    destroy(): void;
+
+    /**
+     * Clear the current context: detach and destroys all children context.
+     * The context can be reused.
+     */
+    clear(): void;
+
+    /**
+     * Register a callback to execute when the context is destroyed. Return the callback id.
+     *
+     * @param callback the callback function
+     * @return the callback id
+     */
+    onDestroy(callback: () => void): string;
+
+    /**
+     * Remove a previously registered callback with {@link Context.onDestroy} method using its id.
+     *
+     * @param callbackId the id of the callback to unregister
+     */
+    offDestroy(callbackId: string): boolean;
+
+    /**
+     * Register a callback to execute every time the context is cleared.
+     * This happens every time the brick is refreshed with new inputs and during the brick destruction.
+     * Return the callback id.
+     *
+     * @param callback the callback function
+     * @return the callback id
+     */
+    onClear(callback: () => void): string;
+
+    /**
+     * Remove a previously registered callback with {@link Context.onClear} method using its id.
+     *
+     * @param id the id of the callback to unregister
+     */
+    offClear(id: string): void;
+
+    /**
+     * Whether the context is destroyed.
+     */
+    isDestroyed(): boolean;
+}
+
+/**
+ * Types of probe that can be used to check the health of the process:
+ * - LIVENESS: used to check if the process is alive
+ * - READINESS: used to check if the process is ready to operate
+ * - ALL: used to check both liveness and readiness
+ */
+export enum ProbeType {
+    LIVENESS = 'liveness',
+    READINESS = 'readiness',
+    ALL = 'all'
+}
+
+// Health check and shutdown
+export class Process {
+
+    /**
+     * Static method to register a callback that is used to check the health status of the process.
+     * This is typically used by kubernetes environment to maintain backend healthy
+     *
+     * The callback must return a Promise which returns a string as valid message.
+     * The process is considered by the runtime as unhealthy if the promise is rejected.
+     *
+     * The options parameter can be used to specify the type of probe to register:
+     * - LIVENESS: used to check if the process is alive
+     * - READINESS: used to check if the process is ready to operate
+     * - ALL: used to check both liveness and readiness
+     *
+     * @param callback the callback executed each time the runtime check the health of the process.
+     * @param options options to specify the type of probe to register
+     */
+    static onHealthCheck(callback: () => Promise<string>, options?: {type: ProbeType}): () => void;
+
+    /**
+     * Static method to register a callback called by the runtime when it receives the signal to be terminated.
+     * This is typically used to graceful shutdown some connections or drivers to external processes.
+     *
+     * The callback must return a Promise which is resolved when the shutdown process is done.
+     *
+     * @param callback the callback executed when the runtime terminates.
+     * @param shutdownId optional id to name the shutdown hook, mainly for debug purpose
+     */
+    static onShutdown(callback: () => Promise<void>, shutdownId?: string): () => void;
+
+    /**
+     * Static method that manually triggers a connection attempt to the server to go ONLINE.
+     * If you have called {@link Process.disconnect()} before, it will cancel the OFFLINE mode,
+     * next time the app will be opened, it will try to go ONLINE on its own.
+     *
+     * Returns a promise that resolves when the server connection is established. If it fails, the promise is rejected.
+     */
+    static connect(): Promise<void>;
+
+    /**
+     * Static method that manually close the connection to the server to go OFFLINE.
+     * Persists the offline status so the app restart offline after being closed.
+     * The only way to clean that status is to call {@link Process.connect()}.
+     *
+     * Returns a promise that resolves when the server connection is indeed disconnected and the state is OFFLINE.
+     * If the flag `offline.enabled` is not set to true, the promise is rejected.
+     */
+    static disconnect(): Promise<void>;
+
+    /**
+     * Static method that returns an observable on the connection state: the observable send TRUE if the process is considered
+     * as ONLINE and false if not.
+     *
+     * @param context the context of the brick to garbage collect the observable when not needed anymore.
+     */
+    static isOnline(context: Context): Observable<boolean>;
+}