@codenotch/codenotch.react 1.0.81

package/dist/core/ProcessUtils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+/**
+ * static class mainly containing a method to start processes
+ */
+class ProcessUtils {
+    static async startProcess(subscribeFunc, clusterUrl, tenantName, projectName, processId, processInput, processInstanceId, startNodeId, token) {
+        let instanceId = processInstanceId ? processInstanceId : (0, uuid_1.v4)();
+        return new Promise(async (resolve, reject) => {
+            try {
+                // Another class/component is responsible for listening to processes' states and calling back when they finish
+                await subscribeFunc(instanceId, {
+                    onCallback: (callback) => {
+                        //TODO check redirect ?
+                    },
+                    onOver: (processResult) => {
+                        // The process has finished
+                        resolve(processResult);
+                    },
+                });
+                // Create a new process instance
+                await ProcessUtils.launchMainProcess(clusterUrl, tenantName, projectName, processId, processInput, instanceId, startNodeId, token);
+            }
+            catch (err) {
+                console.error(err);
+                let processResult = {
+                    isError: true,
+                    processInstanceId: instanceId,
+                    output: {},
+                    errorMessage: err.message
+                };
+                resolve(processResult);
+            }
+        });
+    }
+    static async launchMainProcess(clusterUrl, tenantName, projectName, processId, processInput, processInstanceId, startNodeId, token) {
+        console.log("launching main process");
+        let input = processInput ? processInput : {};
+        // We launch the process with an http request
+        let url = `${clusterUrl}/${projectName.toLowerCase()}/processes/${processId}/instances`;
+        let body = {
+            id: processInstanceId,
+            input: input,
+            startNode: startNodeId
+        };
+        let requestHeaders = new Headers();
+        requestHeaders.set('Content-Type', 'application/json');
+        if (token && token !== "") {
+            requestHeaders.set(`${tenantName}AccessToken`, token);
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            credentials: 'include', // forward auth cookiesbody
+            body: JSON.stringify(body),
+            headers: requestHeaders
+        });
+        if (!response.ok) {
+            // Something went wrong
+            let errorMessage = await response.text();
+            throw new Error(errorMessage);
+        }
+    }
+}
+exports.default = ProcessUtils;

package/dist/core/SignalR.d.ts

@@ -0,0 +1,30 @@
+import { IProcessCallbacks, ICodenotchSignal } from "../models/Misc";
+export declare class SignalR {
+    private _connection;
+    private _hubUrl;
+    private _accessToken;
+    private _signalCallbacks;
+    private _processCallbacks;
+    private _inactivityTimer;
+    private _unsubscribeTimers;
+    private _isConnecting;
+    private _pendingConnectionPromises;
+    private _keepAlive;
+    constructor(clusterUrl: string, serviceName: string, keepAlive: boolean, accessToken?: string);
+    connect(): Promise<void>;
+    private resolvePendingRequests;
+    private rejectPendingRequests;
+    private ensureConnected;
+    private onSignalReceived;
+    private getSignalPaths;
+    private onProcessCallbackReceived;
+    private onProcessOverReceived;
+    subscribeToProcessInstance(processInstanceId: string, callbacks: IProcessCallbacks): Promise<void>;
+    subscribeToSignal(signalId: string, callback: (signal: ICodenotchSignal) => void): Promise<() => Promise<void>>;
+    unsubscribeFromSignal(signalId: string, subscriptionId: string): Promise<void>;
+    private unsubscribeFromServerIfNoMoreSubscriptions;
+    private unsubscribeSignalServer;
+    private disconnectIfInactive;
+    disconnect(): void;
+}
+//# sourceMappingURL=SignalR.d.ts.map

package/dist/core/SignalR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignalR.d.ts","sourceRoot":"","sources":["../../src/core/SignalR.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAKrE,qBAAa,OAAO;IAEhB,OAAO,CAAC,WAAW,CAA+B;IAClD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAqB;IAIzC,OAAO,CAAC,gBAAgB,CAAwF;IAGhH,OAAO,CAAC,iBAAiB,CAAmD;IAE5E,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,kBAAkB,CAA4C;IAEtE,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,0BAA0B,CAAsE;IAGxG,OAAO,CAAC,UAAU,CAAU;gBAET,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM;IAY9F,OAAO;IAmEb,OAAO,CAAC,sBAAsB;IAa9B,OAAO,CAAC,qBAAqB;YAaf,eAAe;IA6B7B,OAAO,CAAC,gBAAgB;IAqCxB,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,yBAAyB;IASjC,OAAO,CAAC,qBAAqB;IAcvB,0BAA0B,CAAC,iBAAiB,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB;IAuBlF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IA4C/G,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAkBpE,OAAO,CAAC,0CAA0C;YAYpC,uBAAuB;IAOrC,OAAO,CAAC,oBAAoB;IAarB,UAAU,IAAI,IAAI;CAY5B"}

package/dist/core/SignalR.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalR = void 0;
+const signalr_1 = require("@microsoft/signalr");
+const uuid_1 = require("uuid");
+class SignalR {
+    constructor(clusterUrl, serviceName, keepAlive, accessToken) {
+        this._unsubscribeTimers = {};
+        this._isConnecting = false;
+        this._pendingConnectionPromises = [];
+        this._hubUrl = `${clusterUrl}/${serviceName}/exec`;
+        this._accessToken = accessToken;
+        this._connection = null;
+        this._signalCallbacks = {};
+        this._processCallbacks = {};
+        this._inactivityTimer = null;
+        this._keepAlive = keepAlive;
+    }
+    async connect() {
+        console.log(`SignalR establishing connection...`);
+        this._isConnecting = true;
+        // Here we inject the access token if defined
+        let options = this._accessToken ? { accessTokenFactory: () => this._accessToken } : {};
+        // Skip negotiation and only use websockets
+        // This allows us to have multiple SignalR server without sticky sessions
+        // But it won't work in the rare cases where websockets are not supported
+        options.skipNegotiation = true;
+        options.transport = signalr_1.HttpTransportType.WebSockets;
+        //TODO if the server has multi instances, and the one we are connected fails, do sticky sessions prevent us from connecting to a healthy instance ?
+        this._connection = new signalr_1.HubConnectionBuilder()
+            .withUrl(this._hubUrl, options)
+            .withAutomaticReconnect([0, 1000, 3000, 5000, 10000, 30000, 60000, 90000]) // If the server is a single instance and decide to change node, it might take a little while
+            .configureLogging(signalr_1.LogLevel.Error)
+            .build();
+        this._connection.off("ReceiveSignal");
+        this._connection.off("ReceiveLog");
+        this._connection.off("ReceiveCallback");
+        this._connection.off("ReceiveProcessOver");
+        // On Signal
+        this._connection.on("ReceiveSignal", (signal) => this.onSignalReceived(signal));
+        // On log
+        this._connection.on("ReceiveLog", (log) => {
+            console.log(log);
+        });
+        // On callback received from process
+        //TODO only used to set wec content and redirect, do we still need those ?
+        this._connection.on("ReceiveCallback", (callback) => this.onProcessCallbackReceived(callback));
+        // On process completed
+        this._connection.on("ReceiveProcessOver", (processResult) => this.onProcessOverReceived(processResult));
+        this._connection.onclose((error) => console.log(`disconnected: ${error ? error.message : "no error"}`));
+        this._connection.onreconnected(() => this.resolvePendingRequests());
+        try {
+            await this._connection.start();
+            console.log(`SignalR connection established`);
+            this.resolvePendingRequests();
+            this._isConnecting = false;
+        }
+        catch (err) {
+            console.log(`SignalR connection error: ${err}`);
+            this.rejectPendingRequests(err);
+            this._isConnecting = false;
+        }
+    }
+    resolvePendingRequests() {
+        if (this._pendingConnectionPromises.length > 0) {
+            console.log(`Resolving ${this._pendingConnectionPromises.length} pending connection promises`);
+        }
+        for (let p of this._pendingConnectionPromises) {
+            p?.resolve();
+        }
+    }
+    rejectPendingRequests(error) {
+        if (this._pendingConnectionPromises.length > 0) {
+            console.log(`Rejecting ${this._pendingConnectionPromises.length} pending connection promises`);
+        }
+        for (let p of this._pendingConnectionPromises) {
+            p?.reject(error);
+        }
+    }
+    async ensureConnected() {
+        if (this._inactivityTimer) {
+            // cancel disconnection
+            clearTimeout(this._inactivityTimer);
+            this._inactivityTimer = null;
+        }
+        if (this._connection && this._connection.state === signalr_1.HubConnectionState.Connected) {
+            return Promise.resolve();
+        }
+        console.log(`SignalR not currently connected, waiting on connection...`);
+        const connectionPromise = new Promise((resolve, reject) => {
+            this._pendingConnectionPromises.push({ resolve, reject });
+        });
+        if (!this._isConnecting) {
+            this.connect();
+        }
+        // Return a promise that will resolve when the connection is established
+        return connectionPromise;
+    }
+    onSignalReceived(signal) {
+        try {
+            console.log(`Received signal '${signal.signalId}'`);
+            console.log(signal);
+            // parse the eventual data in the signal
+            if (signal.data) {
+                try {
+                    signal.data = JSON.parse(signal.data);
+                }
+                catch {
+                    // Data is not json but might still be valid
+                }
+            }
+            // If signal id contains multiple paths, trigger each one
+            var signalPaths = this.getSignalPaths(signal.signalId);
+            for (let p of signalPaths) {
+                if (this._signalCallbacks[p]) {
+                    for (let callback of Object.values(this._signalCallbacks[p])) {
+                        callback(signal);
+                    }
+                }
+            }
+        }
+        catch (ex) {
+            console.log(`An exception occured during 'ReceiveSignal' callback:`);
+            console.log(ex);
+        }
+    }
+    getSignalPaths(signalId) {
+        // Signals can be segmented using '.', each segment corresponds to a more specific subject 
+        // Subscribers can subscribe to a very specific signal or to a more general topic
+        // eg. Signal ref : invoice.update.0000-1111-2222-3333, will be received by subscribers on:
+        //  -> 'invoice'
+        //  -> 'invoice.update'
+        //  -> 'invoice.update.0000-1111-2222-3333'
+        var signalPaths = [];
+        if (!signalId || signalId === '')
+            return signalPaths;
+        var segments = signalId.split('.');
+        for (let i = 0; i < segments.length; i++) {
+            signalPaths.push(segments.slice(0, i + 1).join('.')); // "path" from index 0 to i
+        }
+        return signalPaths;
+    }
+    onProcessCallbackReceived(callback) {
+        // Trigger the corresponding callback (set in ProcessUtils before launching the process)
+        if (this._processCallbacks[callback.processInstanceId]) {
+            this._processCallbacks[callback.processInstanceId].onCallback(callback);
+        }
+    }
+    onProcessOverReceived(processResult) {
+        // Trigger the corresponding callback (set in ProcessUtils before launching the process)
+        if (this._processCallbacks[processResult.processInstanceId]) {
+            this._processCallbacks[processResult.processInstanceId].onOver(processResult);
+            // Clean it, now that the process is over we should not receive anymore callbacks
+            delete this._processCallbacks[processResult.processInstanceId];
+            this.disconnectIfInactive();
+        }
+    }
+    async subscribeToProcessInstance(processInstanceId, callbacks) {
+        if (this._processCallbacks[processInstanceId]) {
+            // Already subscribed
+            return;
+        }
+        await this.ensureConnected();
+        try {
+            await this._connection.invoke("SubscribeToInstanceEvents", processInstanceId);
+            // Setup callbacks
+            this._processCallbacks[processInstanceId] = callbacks;
+        }
+        catch (err) {
+            console.error(`Couldn't subscribe to process '${processInstanceId}', : ${err}`);
+        }
+    }
+    async subscribeToSignal(signalId, callback) {
+        console.log(`subscribeToSignal: signalId:${signalId}`);
+        if (!signalId || signalId === "")
+            return () => Promise.resolve();
+        await this.ensureConnected();
+        if (this._unsubscribeTimers[signalId]) {
+            // cancel eventual unsubscription
+            clearTimeout(this._unsubscribeTimers[signalId]);
+            delete this._unsubscribeTimers[signalId];
+        }
+        if (!this._signalCallbacks[signalId]) {
+            // Create the subscription
+            try {
+                await this._connection.invoke("SubscribeToSignal", signalId);
+                // Remember which signals we are subscribed so we don't subscribe twice
+                if (!this._signalCallbacks[signalId]) {
+                    this._signalCallbacks[signalId] = {};
+                }
+            }
+            catch (err) {
+                throw `Couldn't subscribe to signal '${signalId}', : ${err}`;
+            }
+        }
+        // Generate a new id to keep track of each subscription
+        let subscriptionId = (0, uuid_1.v4)();
+        this._signalCallbacks[signalId][subscriptionId] = callback;
+        // Return the unsubscribe function
+        return async () => await this.unsubscribeFromSignal(signalId, subscriptionId);
+    }
+    async unsubscribeFromSignal(signalId, subscriptionId) {
+        console.log(`unsubscribeFromSignal: signalId:${signalId}, subscriptionId:${subscriptionId}`);
+        if (!this._signalCallbacks[signalId]) {
+            return;
+        }
+        delete this._signalCallbacks[signalId][subscriptionId];
+        // From this point we won't send events to the component who just unsubscribed, but we are still subscribed to the signal on the server so we'll recieve new signals
+        this.unsubscribeFromServerIfNoMoreSubscriptions(signalId);
+        // If no more subscriptions, we can disconnect from the server
+        this.disconnectIfInactive();
+    }
+    unsubscribeFromServerIfNoMoreSubscriptions(signalId) {
+        if (Object.keys(this._signalCallbacks[signalId]).length === 0) {
+            delete this._signalCallbacks[signalId];
+            // No more subscriptions for this signal, we can unsubscribe from the server
+            // but in order to not send too many requests, we will wait a little bit before actually unsubscribing, the client might come back to the tab that need this signal in a few seconds
+            this._unsubscribeTimers[signalId] = setTimeout(() => this.unsubscribeSignalServer(signalId), 1 * 60 * 1000);
+        }
+    }
+    async unsubscribeSignalServer(signalId) {
+        console.log(`unsubscribeSignalServer: signalId:${signalId}`);
+        await this._connection.invoke("UnsubscribeFromSignal", signalId);
+    }
+    disconnectIfInactive() {
+        if (this._keepAlive)
+            return;
+        if (Object.keys(this._signalCallbacks).length === 0 && Object.keys(this._processCallbacks).length === 0) {
+            // No more subscriptions, disconnect from the server after a little while (5 minutes) to save resources
+            this._inactivityTimer = setTimeout(() => this.disconnect(), 5 * 60 * 1000);
+            console.log("SignalR has no more active subscriptions, will disconnect in 5 minutes...");
+        }
+    }
+    disconnect() {
+        if (this._connection) {
+            this._connection.off("ReceiveCallback");
+            this._connection.off("ReceiveProcessOver");
+            this._connection.off("ReceiveSignal");
+            this._connection.off("ReceiveLog");
+            this._connection.stop();
+            this._connection = null;
+        }
+    }
+}
+exports.SignalR = SignalR;

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import { ICodenotchApi, ICodenotchEnv } from "./models/Codenotch";
+import CodeEditor from "./components/CodeEditor";
+/**
+ * The Codenotch runtime environment, populated by {@link init}.
+ * Prefer reading it through `useCodenotch().env`.
+ */
+declare const env: ICodenotchEnv;
+/**
+ * Initialize the Codenotch environment from the given key-value pairs.
+ *
+ * This is normally called once, by the page hosting the application, with the
+ * environment variables injected by the Codenotch runtime (URL parameters or
+ * any other source). It must be called before `useCodenotch()` is used.
+ *
+ * Recognized key formats:
+ * - `i18n.<key>.<language>` — a translation, stored in `env.i18n[language][key]`.
+ *   The first language found becomes the current language if none is set.
+ * - `GLOBAL.<name>` — JSON value assigned to `window[name]` (or `globalThis`).
+ * - `appManifest` / `projectManifest` — parsed as JSON into the environment.
+ * - anything else — copied as-is onto {@link env}.
+ *
+ * The UI theme is resolved from the `_theme` URL parameter, or from
+ * `prefers-color-scheme` as a fallback.
+ *
+ * @param envVariables An object containing the Codenotch environment variables as key-value pairs.
+ * @example
+ * import { init } from 'codenotch-react';
+ * init({
+ *     clusterUrl: 'https://cluster.example.com',
+ *     serviceName: 'myproject',
+ *     tenantName: 'acme',
+ *     'i18n.welcome.en': 'Welcome',
+ *     'i18n.welcome.fr': 'Bienvenue'
+ * });
+ */
+declare function init(envVariables: any): void;
+/**
+ * Return the Codenotch client API bound to the current environment.
+ *
+ * Despite its name this is NOT a React hook — it is a plain function with no
+ * hook rules attached: it can be called anywhere (components, handlers, plain
+ * modules). `init()` must have been called first, which the Codenotch runtime
+ * does automatically when serving the application.
+ *
+ * @returns The Codenotch API: BPMN processes, SioQL queries, i18n, signals, theme…
+ * @example
+ * import { useCodenotch } from 'codenotch-react';
+ *
+ * const MyApp: React.FC = () => {
+ *     const cn = useCodenotch();
+ *     return <h1>{cn.i18n('welcome')}</h1>;
+ * };
+ */
+declare function useCodenotch(): ICodenotchApi;
+export { env, useCodenotch, init, CodeEditor };
+export * from "./models/Codenotch";
+export * from "./models/Misc";
+export * from "./models/AppManifestModels";
+export * from "@codenotch/codenotch.core";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAoB,aAAa,EAAkB,MAAM,oBAAoB,CAAC;AAEpG,OAAO,UAAU,MAAM,yBAAyB,CAAC;AAIjD;;;GAGG;AACH,QAAA,MAAM,GAAG,EAAE,aAAkB,CAAC;AAM9B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iBAAS,IAAI,CAAC,YAAY,EAAE,GAAG,GAAG,IAAI,CAyFrC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,iBAAS,YAAY,IAAI,aAAa,CAsNrC;AAED,OAAO,EACH,GAAG,EACH,YAAY,EACZ,IAAI,EACJ,UAAU,EACb,CAAC;AAMF,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}