@olympeio/runtime-node 8.7.1 → 9.0.1

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@olympeio/runtime-node",
-  "version": "8.7.1",
+  "version": "9.0.1",
   "description": "Olympe Node Runtime Environment",
-  "types": "index.d.ts",
+  "types": "types/index.d.ts",
   "dependencies": {
     "ws": "~8.2.3",
     "bufferutil": "~4.0.5",
     "utf-8-validate": "~5.0.7",
     "cross-blob": "~2.0.0",
     "lowdb": "~1.0.0",
-    "rxjs": "~7.1.0"
+    "rxjs": "7.5.4",
+    "knex": "1.0.3",
+    "pg": "8.7.3",
+    "fastify": "~3.27.0",
+    "fastify-cors": "~6.0.2"
   },
   "dcInitConfig": "import/dcInitConfig.json",
   "author": "Olympe S.A. <dev@olympe.ch>",

package/types/base.d.ts

@@ -0,0 +1,116 @@
+// @ts-ignore
+import Observable from 'rxjs';
+import {Empty, PropertyModel, Query, QueryResult, QuerySingle} from "./cloud";
+
+// **********************************
+// Primitives
+// **********************************
+
+declare type Class<T> = { new (): T };
+
+export type Tag = string | HasTag | Class<CloudObject>;
+export type List<T> = Array<T> | QueryResult<T>;
+
+export function generateTag(): string;
+export function tagToString(tag: Tag): string;
+
+export interface HasTag {
+    getTag(): string;
+}
+
+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;
+}
+
+export abstract class CloudObject implements HasTag {
+    static getProperties(): Property<any>[];
+    static getRelations<O extends CloudObject, D extends CloudObject>(this: Class<O>): Relation<O, D>[];
+    static instancesOf<T extends CloudObject>(this: Class<T>): Query<T, Empty>;
+
+    static get<T extends CloudObject>(tag: Tag): T;
+    static createWith<T>(this: Class<T>, properties: Map<Tag, any>, model?: Tag): T;
+    static asInstance<T>(this: Class<T>): T;
+
+    getTag(): string;
+    name(): string;
+    getModelTag(): string;
+    getModel(): CloudObject;
+    query(): Query<this, Empty>;
+    isPersisted(): boolean;
+
+    follow<D extends CloudObject>(relation: Relation<this, D>): Query<D, Empty>;
+    followSingle<D extends CloudObject>(relation: Relation<this, D>): QuerySingle<D>;
+
+    // Properties getters
+    get<T>(property: Property<T>): T | null;
+    observe<T>(context: Context, property: Property<T>): Observable<T>;
+
+    // Properties and Relations
+    static nameProp: Property<string>;
+    static instanceRel: Relation<CloudObject, CloudObject>;
+    static modelRel: Relation<CloudObject, CloudObject>;
+    static containsRel: Relation<CloudObject, CloudObject>;
+    static extendRel: Relation<CloudObject, CloudObject>;
+    static extendedByRel: Relation<CloudObject, CloudObject>;
+    static propertyRel: Relation<CloudObject, PropertyModel>;
+}
+
+export interface Property<T> extends HasTag {}
+
+export enum Direction {
+    ORIGIN = '<',
+    DESTINATION = '>'
+}
+
+export class Relation<O extends CloudObject, D extends CloudObject> implements HasTag {
+    constructor(tag: Tag, direction?: Direction, origin?: Class<O>, destination?: Class<D>);
+    getTag(): string;
+    getDirection(): Direction;
+    type(): Class<D>;
+    originType(): Class<O>;
+    getInverse(): Relation<D, O>;
+}
+
+export function register(tag: Tag, object: Class<CloudObject>): void;
+export function defineProperty<T>(tag: Tag, type?: Class<T>): Property<T>;
+export function defineRelation<O extends CloudObject, D extends CloudObject>(tag: Tag, origin?: Class<O>, destination?: Class<D>, direction?: Direction): Relation<O, D>;
+export function defineRelation(tag: Tag, direction?: Direction): Relation<CloudObject, CloudObject>;
+export function defineInverseRelation<O extends CloudObject, D extends CloudObject>(relation: Relation<O, D>): Relation<D, O>;

package/types/cloud.d.ts

@@ -0,0 +1,303 @@
+// *********************************************
+//
+//     Olympe Data cloud objects Public API
+//
+// *********************************************
+
+// @ts-ignore
+import Observable from 'rxjs';
+import {Context, CloudObject, Relation, Property, Tag, Class} from "./base";
+import { BrickContext } from './runtime';
+import {Color} from "./utils";
+
+// --------------------------
+// -- Primitive data types --
+// --------------------------
+export class PropertyModel extends CloudObject {
+    static definingModelRel: Relation<PropertyModel, CloudObject>;
+    static typeRel: Relation<PropertyModel, CloudObject>;
+}
+
+export class RelationModel extends CloudObject {
+    static originModelRel: Relation<CloudObject, RelationModel>;
+    static destinationModelRel: Relation<RelationModel, CloudObject>;
+    static dumpFollowRuleProp: Property<number>;
+    static deleteFollowRuleProp: Property<number>;
+    static runtimeFollowRuleProp: Property<number>;
+}
+
+export class StringModel extends CloudObject {
+    static valueProp: Property<string>;
+}
+
+export class NumberModel extends CloudObject {
+    static valueProp: Property<number>;
+}
+
+export class BooleanModel extends CloudObject {
+    static valueProp: Property<boolean>;
+}
+
+export class DatetimeModel extends CloudObject {
+    static valueProp: Property<Date>;
+}
+
+export class ColorModel extends CloudObject {
+    static valueProp: Property<Color>;
+}
+
+export class File extends CloudObject {
+    static nameProp: Property<string>;
+    static creationDateProp: Property<Date>;
+    static modificationDateProp: Property<Date>;
+    static mimeTypeProp: Property<string>;
+    static urlProp: Property<string>;
+    static createFromContent(transaction: Transaction, name: string, content: ArrayBuffer, mimeType?: string, source?: string, tag?: string): string;
+    static createFromURL(transaction: Transaction, name: string, url: string, mimeType?: string, source?: string, tag?: string): string;
+
+    getContentAsBinary(onSuccess: (content: ArrayBuffer) => void, onFailure?: (string) => void): void;
+    getContentAsString(onSuccess: (content: string) => void, onFailure?: (string) => void): void;
+    getContentUrl(onSuccess: (content: string) => void, onFailure?: () => void): void;
+    saveAs(name: string): void;
+}
+
+export class User extends CloudObject {
+    static loginProp: Property<string>;
+    static saltProp: Property<string>;
+    static verifierProp: Property<string>;
+    static SAMLNameIdProp: Property<string>;
+}
+
+export class Enum extends CloudObject {
+    create(transaction: Transaction, name?: string): string;
+    getValues(): QueryResult<EnumValue>;
+}
+
+export class EnumValue extends CloudObject {
+    static createValue(transaction: Transaction, enumModel: Tag, value: string, name?: string, rank?: number): string;
+
+    static nameProp: Property<string>;
+    static valueProp: Property<string>;
+    static rankProp: Property<number>;
+}
+
+// ---------------------------
+// -- Database transactions --
+// ---------------------------
+
+/**
+ * Transactions are the unique way to apply a list of operations to the datacloud.
+ * A transaction can be merged into another transaction to be executed as a single set of operations.
+ *
+ * There are 5 types of basic operations :
+ * - Create instance: create a node in the database with specified properties.
+ * - Update instance property: update an existing node in the database.
+ * - Delete instance: delete a node from the database. Delete only works if all the relations are removed too. Cascade delete can be activated.
+ * - Create relation: create a relation of a specific type between 2 existing node.
+ * - Delete relation: remove the specified relation between 2 specified nodes.
+ *
+ * Classical transactions are executed using "execute()" method. The transaction size is limited but real-time but
+ * all the changes applied on data "observed" by queries will be notified.
+ *
+ * Transactions with big set of operations (batch updates) can be executed using "executeAsLarge()" method. However no notification will be generated.
+ *
+ * Callbacks can be registered on transaction using "afterExecution()" method. They are executed once the transaction is applied.
+ *
+ * Concurrency transactions do not guarantee their execution order.
+ */
+export class Transaction {
+    constructor(persist?: boolean);
+
+    getId(): string;
+
+    // Operations
+    create(model: Tag, properties?: Map<Tag, any>, source?: string, tag?: string): string;
+    update<T>(instance: Tag, property?: Property<T>, value?: T): this;
+    multiUpdate(instance: Tag, properties: Map<string, any>): this;
+    delete(instance: Tag): this;
+    createRelation(relation: Tag, from: Tag, to: Tag): this;
+    deleteRelation(relation: Tag, from: Tag, to: Tag): this;
+    deleteAllRelations(relation: Relation<any, any>, origin: Tag): this;
+
+    // Change persistence of instances
+    persist(persist?: boolean): this;
+    persistInstance(instance: Tag, persist?: boolean): this;
+
+    // Set source of all instances created in this transaction
+    setSource(source: string): this;
+    model(tag: Tag): string;
+
+    merge(otherTransaction: Transaction): this;
+
+    // Execution methods
+    afterExecution(callback: (success: boolean, message?: string) => void): this;
+    execute(): Promise<void>;
+    executeAsLarge(): Promise<void>;
+
+    // Begin/End shared transaction helpers
+    static from($: BrickContext): Transaction;
+    static process($: BrickContext, transaction: Transaction): Promise<boolean>;
+}
+
+/**
+ * BurstTransactions are designed to apply updates of properties continuously with the matter of the order.
+ * The only operation supported by BurstTransactions is to update properties of an instance.
+ *
+ * Unlike classical Transactions, a burst transaction preserves the order of update operations and
+ * is designed to handle many updates per second for smooth shared animations.
+ *
+ * Example of use:
+ * A marker representing a red dot on the screen which coordinate properties are controlled by motion sensors of an IoT device
+ * should use BurstTransaction instead of a bunch of continuous classical Transaction to have fluid movements on the screen.
+ */
+export class BurstTransaction {
+    constructor();
+
+    // Push all the property values from the specified Observable to update the specified object.
+    push<T>(object: CloudObject, values: Observable<Map<Property<T>, T>>): void;
+
+    // Commit and close the burst transaction.
+    complete(): Promise<void>;
+}
+
+// ----------------------
+// -- Database queries --
+// ----------------------
+type Empty = [];
+
+/**
+ * A CloudArray (type: QueryResult) is a array of tuple of CloudObjects that has been generated by a Query. It contains the result of a query at a specific time.
+ *
+ * When a query is subscribed, it generates multiple CloudArrays along time and got via an observable.
+ * Difference between CloudArrays from a Query is accessible using methods getAdded() and getRemoved().
+ *
+ * A CloudArray can be easily manipulated and transformed to a standard Array.
+ *
+ * Keys of CloudObject tuples follow the rule: 'tag1.tag2.tag3' : [cloudObj1, cloudObj2, cloudObj3]
+ */
+export class QueryResult<T> {
+    static empty(): QueryResult<any>;
+
+    [Symbol.iterator](): IterableIterator<[string, T]>;
+    entries(): IterableIterator<[string, T]>;
+    values(): IterableIterator<T>
+    keys(): IterableIterator<string>
+
+    toArray(): T[];
+    size(): number;
+    has(key: T | string): boolean;
+    indexOf(key: T | string): number;
+    get(key: string): T | null;
+    getFirst(): T | null;
+    getAt(index: number): T | null;
+
+    push(...object: T[]): T[];
+    pop(): T[];
+    shift(): T[];
+
+    // Gives the difference between last cloud array => what instances added, and what where removed.
+    getAdded(): T[];
+    getRemoved(): string[] | string[][];
+
+    filter(predicate: (entry: T) => boolean): T[];
+    find(predicate: (entry: T) => boolean): T | null;
+
+    forEach(callback: (entry: T) => void): void;
+    map<S>(callback: (entry: T) => S): S[];
+    sort(comparator: (b1: T, b2: T) => number): QueryResult<T>;
+    reduce<S>(reducer: (accumulator: S, entry: T) => S, initial: S): S;
+    concat(...others: QueryResult<T>[]): QueryResult<T>;
+}
+
+/**
+ * A Query is an immutable object used to build queries on the datacloud. It is a graph query builder.
+ * Starting from an origin Tag (CloudObject or its unique id), it follows specified relations:
+ *
+ *  origin --a--> X --b--> Y --c--> Z
+ *
+ * At each level, "andReturn()" method can be called to add the current level to the result.
+ * Example:
+ *
+ *  Query.from(origin)
+ *      .follow(a).andReturn()
+ *      .follow(b)
+ *      .follow(c).andReturn()
+ *      .execute();
+ *
+ *  This will return a Promise of a of tuple [X, Z]: Promise<CloudArray<[X, Z]>>.
+ *
+ * A query can be executed with 3 different ways:
+ * - execute(): it runs the query on the datacloud and return the result as a QueryResult.
+ * - observe(): it runs the query on the datacloud and subscribes to updates. It returns an Observable which provides a new QueryResult every time the result changes.
+ * - executeFromCache(): it runs the query on the *local* datacloud which may be incomplete view of the datacloud (it is the local cache). It is executed synchronously.
+ */
+export class Query<T extends CloudObject, R extends any[]> {
+    static from<T extends CloudObject>(tag: Tag): Query<T, Empty>;
+    static instancesOf<T extends CloudObject>(model: Class<T>, source?: string): Query<T, Empty>;
+
+    follow<D extends CloudObject>(relation: Relation<T, D>): Query<D, R>; //
+    followRecursively<D extends CloudObject>(relation: Relation<T, D>, includeSelf?: boolean): Query<D, R>;
+
+    andReturn(): Query<T, [...R, T]>; // Add the current level of the query to the result. (Listdefs only support the last level to be returned).
+
+    filter(predicate: Predicate): Query<T, R>;
+    cast<S extends CloudObject>(type: Class<S>): Query<S, R>;
+
+    // Methods for which only the last call matters
+    limit(max: number, offset?: number): Query<T, R>;
+    sortBy(property: Property<any>, order?: Order): Query<T, R>;
+
+    execute(context: Context): Promise<QueryResult<R>>; // Execute the query on the datacloud (as a listdef) and deletes it afterwards.
+    observe(context: Context): Observable<QueryResult<R>>; // Generate a subscription and get a new CloudArray for every update.
+
+    executeFromCache(): QueryResult<R>; // Execute the query locally, using the DBView.
+}
+
+/**
+ * A QuerySingle is a Query which follows relations that should be unique between CloudObjects (0..1 and 1..1 cardinalities).
+ * It returns the CloudObjects related to the origin, following the specified relation(s).
+ *
+ * It acts as a syntactic sugar to avoid having a CloudArray and get the first value.
+ *
+ * A QuerySingle is immutable.
+ */
+export class QuerySingle<T extends CloudObject> {
+    static from<T extends CloudObject>(object: Tag): QuerySingle<T>;
+
+    follow<D extends CloudObject>(relation: Relation<T, D>): QuerySingle<D>;
+    cast<S extends CloudObject>(type: Class<S>): QuerySingle<S>;
+
+    execute(context: Context): Promise<T | null>; // Execute the query on the datacloud (as a listdef) and deletes it afterwards.
+
+    executeFromCache(): T | null; // Execute the query locally, using the DBView.
+}
+
+/**
+ * Predicates are used to filter queries.
+ */
+export class Predicate {
+    static equals<T>(property: Property<T>, value: T): Predicate;
+    static contains(property: Property<string>, value: string, caseSensitive?: boolean): Predicate;
+    static regex(property: Property<string>, value: RegExp, caseSensitive?: boolean): Predicate;
+
+    static greaterThan(property: Property<number>, value: number, strict?: boolean): Predicate;
+    static smallerThan(property: Property<number>, value: number, strict?: boolean): Predicate;
+
+    static greaterThan(property1: Property<number>, property2: Property<number>, strict?: boolean): Predicate;
+    static smallerThan(property1: Property<number>, property2: Property<number>, strict?: boolean): Predicate;
+
+    static and(...predicates: Predicate[]): Predicate;
+    static or(...predicates: Predicate[]): Predicate;
+    static not(predicate: Predicate): Predicate;
+}
+
+export class RelatedTo extends Predicate {
+    constructor(destination?: Tag);
+    follow(relation: Relation<any, any>): RelatedTo;
+    followRecursive(relation: Relation<any, any>): RelatedTo;
+}
+
+export enum Order {
+    ASC,
+    DESC
+}

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './runtime';
+export * from './cloud';
+export * from './utils';
+export * from './legacy';