bm-webapp-sdk 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,63 +1,7 @@
-interface HandlerOptions {
-    sessionHash?: string;
-    scenarioCode?: string;
-    initVariables?: TData;
-    botTokenParamName?: string;
-    userApiToken?: string;
-    retryDelayOnTimeout?: number;
-    requestTimeout?: number;
-    responseVar?: string;
-    apiEndpoint?: string;
-}
-type TData = {
-    [key: string]: any;
-};
-interface INodeEventsDecl {
-    inbox: boolean;
-    outbox: boolean;
-    anyInbox: boolean;
-    dialogClosed: boolean;
-    invoicePaid: boolean;
-    externalRequest: boolean;
-    buttons: boolean;
-    customEvents: boolean;
-}
-interface INode {
-    id: number;
-    title: string;
-    typeName: "basic" | "event" | "eventListener" | "condition" | "conditionBranch";
-    waitingForEvents?: INodeEventsDecl;
-}
-type TScenarioSessionStatus = "active" | "stopped" | "ended" | "unknownError" | "tunnelDisabled" | "expired" | "userDisabled" | "stepDeleted" | "transitionsLimit" | "parentStopped";
-interface ScenarioSession {
-    id: number;
-    hash: string;
-    statusName: TScenarioSessionStatus;
-    ref: string | null;
-    variables: TData;
-    isTransitioning: boolean;
-    currentNode: INode | null;
-}
-export default class WebAppHandler {
-    readonly options: HandlerOptions;
-    data?: ScenarioSession;
-    private currentRequest?;
-    constructor(options: HandlerOptions);
-    isActive(): boolean;
-    init(): Promise<WebAppHandler>;
-    refreshData(): Promise<WebAppHandler>;
-    request(code: string, params?: TData, async?: boolean): Promise<WebAppHandler>;
-    abort(): void;
-    isTelegramInitAvailable(): boolean;
-    protected initNewSession(): Promise<WebAppHandler>;
-    protected makeRequest(method: string, path: string, json?: TData, signal?: AbortSignal): Promise<any>;
-    private waitUntilSessionFinishesTransition;
-}
-
+import WebAppHandler from './WebAppHandler';
 export { WebAppHandler };
 declare global {
     interface Window {
         Telegram: any;
     }
 }
-

package/esm/WebAppHandler.d.ts

@@ -0,0 +1,61 @@
+export interface HandlerOptions {
+    sessionHash?: string;
+    scenarioCode?: string;
+    initVariables?: TData;
+    botTokenParamName?: string;
+    userApiToken?: string;
+    retryDelayOnTimeout?: number;
+    requestTimeout?: number;
+    responseVar?: string;
+    apiEndpoint?: string;
+}
+export type TData = {
+    [key: string]: any;
+};
+export interface INodeEventsDecl {
+    inbox: boolean;
+    outbox: boolean;
+    anyInbox: boolean;
+    dialogClosed: boolean;
+    invoicePaid: boolean;
+    externalRequest: boolean;
+    buttons: boolean;
+    customEvents: boolean;
+}
+export interface INode {
+    id: number;
+    title: string;
+    typeName: "basic" | "event" | "eventListener" | "condition" | "conditionBranch";
+    waitingForEvents?: INodeEventsDecl;
+}
+export type TScenarioSessionStatus = "active" | "stopped" | "ended" | "unknownError" | "tunnelDisabled" | "expired" | "userDisabled" | "stepDeleted" | "transitionsLimit" | "parentStopped";
+export interface ScenarioSession {
+    id: number;
+    hash: string;
+    statusName: TScenarioSessionStatus;
+    ref: string | null;
+    variables: TData;
+    isTransitioning: boolean;
+    currentNode: INode | null;
+}
+export interface ICurrentRequest {
+    controller: AbortController | null;
+    timeoutId: number;
+    retryTimeoutId?: number;
+    reject?: (reason?: any) => void;
+}
+export default class WebAppHandler {
+    readonly options: HandlerOptions;
+    data?: ScenarioSession;
+    private currentRequest?;
+    constructor(options: HandlerOptions);
+    isActive(): boolean;
+    init(): Promise<WebAppHandler>;
+    refreshData(): Promise<WebAppHandler>;
+    request(code: string, params?: TData, async?: boolean): Promise<WebAppHandler>;
+    abort(): void;
+    isTelegramInitAvailable(): boolean;
+    protected initNewSession(): Promise<WebAppHandler>;
+    protected makeRequest(method: string, path: string, json?: TData, signal?: AbortSignal): Promise<any>;
+    private waitUntilSessionFinishesTransition;
+}

package/esm/WebAppHandler.js

@@ -0,0 +1,138 @@
+const DEFAULTS = {
+    retryDelayOnTimeout: 2000,
+    requestTimeout: 60000,
+    responseVar: 'response',
+    apiEndpoint: 'https://console.bot-marketing.com/api/public',
+};
+export default class WebAppHandler {
+    constructor(options) {
+        this.options = { ...DEFAULTS, ...options };
+    }
+    isActive() {
+        return this.data?.statusName === "active";
+    }
+    async init() {
+        if (this.data)
+            throw new Error("Handler already initialized");
+        if (this.options.sessionHash) {
+            await this.refreshData();
+            if (!this.isActive() && this.isTelegramInitAvailable())
+                return this.initNewSession();
+            return this;
+        }
+        else if (this.isTelegramInitAvailable()) {
+            return this.initNewSession();
+        }
+        else {
+            throw new Error('Failed to init handler. You must specify `sessionId`, or `scenarioId` when working with Telegram');
+        }
+    }
+    async refreshData() {
+        const sessionId = this.data?.hash || this.options.sessionHash;
+        if (!sessionId)
+            throw new Error('Cannot refresh data: session id is missing');
+        try {
+            this.data = await this.makeRequest("GET", `tunnelSessions/${sessionId}`);
+            return this;
+        }
+        catch (error) {
+            throw new Error(`Failed to get session data: ${error.message}`);
+        }
+    }
+    async request(code, params, async) {
+        if (this.currentRequest)
+            throw new Error('Please wait until pending request is finished');
+        if (!this.data)
+            await this.init();
+        if (!this.isActive())
+            throw new Error('Cannot make request: session is not active');
+        if (async) {
+            // noinspection ES6MissingAwait
+            this.makeRequest("POST", `tunnelSessions/${this.data.hash}/request`, { code, params });
+            return this;
+        }
+        try {
+            this.currentRequest = {
+                controller: new AbortController(),
+                timeoutId: setTimeout(() => this.abort(), this.options.requestTimeout),
+            };
+            this.data = await this.makeRequest("POST", `tunnelSessions/${this.data.hash}/request`, { code, params, }, this.currentRequest.controller.signal);
+            this.currentRequest = null;
+            return this;
+        }
+        catch (error) {
+            if (error.message === 'request_timeout')
+                return this.waitUntilSessionFinishesTransition();
+            this.currentRequest = null;
+            throw error;
+        }
+    }
+    abort() {
+        if (!this.currentRequest)
+            return;
+        // Main request is still running, we can just abort it
+        // The rest is done inside request method
+        if (this.currentRequest.controller) {
+            this.currentRequest.controller.abort('Request timeout');
+        }
+        else {
+            // At this point we are trying to wait until session is finished transitioning
+            clearTimeout(this.currentRequest.retryTimeoutId);
+            this.currentRequest.reject('Request timeout');
+            this.currentRequest = null;
+        }
+    }
+    isTelegramInitAvailable() {
+        return window.Telegram !== undefined && this.options.scenarioCode !== undefined;
+    }
+    async initNewSession() {
+        try {
+            this.data = await this.makeRequest("POST", `tunnel/${this.options.scenarioCode}/initWebApp`, {
+                initData: Telegram.WebApp.initData,
+                botTokenParamName: this.options.botTokenParamName,
+                variables: this.options.initVariables,
+            });
+            return this;
+        }
+        catch (error) {
+            throw new Error(`Failed to init new session: ${error.message}`);
+        }
+    }
+    async makeRequest(method, path, json, signal) {
+        const resp = await fetch(`${this.options.apiEndpoint}/${path}`, {
+            method: method,
+            signal,
+            ...(method === "POST" ? {
+                body: JSON.stringify(json),
+                headers: {
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                },
+            } : {
+                headers: { "Accept": "application/json" },
+            }),
+        });
+        if (resp.status >= 400) {
+            const data = await resp.json();
+            throw new Error(data.message || `Http Error ${resp.status}`);
+        }
+        return resp.json();
+    }
+    waitUntilSessionFinishesTransition() {
+        return new Promise((resolve, reject) => {
+            this.currentRequest.reject = reject;
+            const resetTimeout = () => {
+                this.currentRequest.retryTimeoutId = setTimeout(async () => {
+                    await this.refreshData();
+                    if (this.data.isTransitioning) {
+                        resetTimeout();
+                    }
+                    else {
+                        resolve(this);
+                    }
+                }, this.options.retryDelayOnTimeout);
+            };
+            resetTimeout();
+        });
+    }
+}

package/esm/index.d.ts

@@ -0,0 +1,7 @@
+import WebAppHandler from './WebAppHandler';
+export { WebAppHandler };
+declare global {
+    interface Window {
+        Telegram: any;
+    }
+}

package/esm/index.js

@@ -0,0 +1,2 @@
+import WebAppHandler from './WebAppHandler';
+export { WebAppHandler };

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "bm-webapp-sdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "",
-  "main": "dist/bundle.js",
-  "types": "dist/index.d.ts",
+  "main": "esm/index.js",
+  "types": "esm/index.d.ts",
   "scripts": {
     "develop": "webpack-dev-server --mode development",
     "build": "webpack --mode production"
   },
   "repository": "https://gitlab.com/b4494/bm-webapp-sdk",
   "files": [
-    "/dist"
+    "/dist",
+    "/esm"
   ],
   "keywords": [],
   "author": "lazychaser@gmail.com",