@ibm-aspera/sdk 0.2.29 → 0.2.30

package/dist/commonjs/helpers/ws.d.ts

@@ -0,0 +1,62 @@
+import { WebsocketTopics } from '../models/models';
+export declare class WebsocketService {
+    /** The main websocket connection to Aspera App*/
+    private globalSocket;
+    /** A map of requested subscription names and the callback for them */
+    private sockets;
+    /** The callback for websocket events */
+    private eventListener;
+    /** Indicator if the websocket is already connected */
+    private isConnected;
+    /** Global promise object that resolves when init completes */
+    private initPromise;
+    /** Log call for not being ready */
+    private handleNotReady;
+    /**
+     * This function handles when a connection is opened
+     */
+    private handleOpen;
+    /**
+     * This function handles completed subscription
+     */
+    private handleClose;
+    /**
+     * This function handles errors received from the websocket
+     */
+    private handleError;
+    /**
+     * This function handles messages received from the websocket
+     */
+    private handleMessage;
+    /**
+     * This function joins the channel to be able to subscribe to events
+     */
+    private joinChannel;
+    /**
+     * This function registers clients to listen to a certain message name. Returns any to allow functions to declare proper type
+     *
+     * @param messageName - the name of messages to listen to (one message name per subscription)
+     * @param callback - the callback function
+     */
+    registerMessage(messageName: WebsocketTopics, callback: Function): void;
+    /**
+     *
+     * @param callback This function registers clients to a certain WebSocket event.
+     *
+     * @param callback - the callback function to call with the event name.
+     */
+    registerEvent(callback: Function): void;
+    /**
+     * This function starts the websocket subscription with the websocket provider
+     *
+     * @returns a promise that resolves when the websocket connection is established
+     */
+    init(): Promise<unknown>;
+    private connect;
+    private reconnect;
+    private getWebSocketConnection;
+    private notifyEvent;
+    private updateRpcPort;
+}
+export declare const websocketService: WebsocketService;
+export default WebsocketService;

package/dist/commonjs/helpers/ws.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.websocketService = exports.WebsocketService = void 0;
+var helpers_1 = require("./helpers");
+var messages_1 = require("../constants/messages");
+var index_1 = require("../index");
+var WebsocketService = /** @class */ (function () {
+    function WebsocketService() {
+        var _this = this;
+        /** A map of requested subscription names and the callback for them */
+        this.sockets = new Map();
+        /** Indicator if the websocket is already connected */
+        this.isConnected = false;
+        /** Global promise object that resolves when init completes */
+        this.initPromise = (0, helpers_1.generatePromiseObjects)();
+        /**
+         * This function handles when a connection is opened
+         */
+        this.handleOpen = function () {
+            if (_this.isConnected || !_this.joinChannel()) {
+                return;
+            }
+            _this.isConnected = true;
+            _this.updateRpcPort();
+            _this.notifyEvent('RECONNECT');
+        };
+        /**
+         * This function handles completed subscription
+         */
+        this.handleClose = function () {
+            if (_this.isConnected) {
+                _this.isConnected = false;
+                _this.notifyEvent('CLOSED');
+            }
+            if (!_this.globalSocket) {
+                _this.handleNotReady();
+                return;
+            }
+            _this.reconnect();
+        };
+        /**
+         * This function handles errors received from the websocket
+         */
+        this.handleError = function () {
+            (0, helpers_1.errorLog)(messages_1.messages.websocketClosedError);
+        };
+        /**
+         * This function handles messages received from the websocket
+         */
+        this.handleMessage = function (message) {
+            var data = (0, helpers_1.safeJsonParse)(message.data);
+            // Message we get on subscription
+            if (data && data.id === 1) {
+                _this.initPromise.resolver(data);
+                return;
+            }
+            var socket = _this.sockets.get(data.method);
+            if (typeof socket === 'function' && data.params) {
+                socket(data.params);
+            }
+        };
+    }
+    /** Log call for not being ready */
+    WebsocketService.prototype.handleNotReady = function () {
+        (0, helpers_1.errorLog)(messages_1.messages.websocketNotReady);
+    };
+    /**
+     * This function joins the channel to be able to subscribe to events
+     */
+    WebsocketService.prototype.joinChannel = function () {
+        if (!this.globalSocket) {
+            this.handleNotReady();
+            return false;
+        }
+        this.globalSocket.send((0, helpers_1.safeJsonString)({ jsonrpc: '2.0', method: 'subscribe_transfer_activity', params: [index_1.asperaSdk.globals.appId], id: 1 }));
+        return true;
+    };
+    /**
+     * This function registers clients to listen to a certain message name. Returns any to allow functions to declare proper type
+     *
+     * @param messageName - the name of messages to listen to (one message name per subscription)
+     * @param callback - the callback function
+     */
+    WebsocketService.prototype.registerMessage = function (messageName, callback) {
+        if (!this.sockets.get(messageName)) {
+            this.sockets.set(messageName, function (data) {
+                callback(data.result);
+            });
+        }
+    };
+    /**
+     *
+     * @param callback This function registers clients to a certain WebSocket event.
+     *
+     * @param callback - the callback function to call with the event name.
+     */
+    WebsocketService.prototype.registerEvent = function (callback) {
+        this.eventListener = callback;
+        this.eventListener(this.isConnected ? 'RECONNECT' : 'CLOSED');
+    };
+    /**
+     * This function starts the websocket subscription with the websocket provider
+     *
+     * @returns a promise that resolves when the websocket connection is established
+     */
+    WebsocketService.prototype.init = function () {
+        this.connect();
+        return this.initPromise.promise;
+    };
+    WebsocketService.prototype.connect = function () {
+        var _this = this;
+        this.getWebSocketConnection(index_1.asperaSdk.globals.rpcPort)
+            .then(function (webSocket) {
+            _this.globalSocket = webSocket;
+            _this.globalSocket.onerror = _this.handleError;
+            _this.globalSocket.onclose = _this.handleClose;
+            _this.globalSocket.onopen = _this.handleOpen;
+            _this.globalSocket.onmessage = _this.handleMessage;
+            _this.handleOpen();
+        }).catch(function () {
+            _this.reconnect();
+        });
+    };
+    WebsocketService.prototype.reconnect = function () {
+        var _this = this;
+        if (this.globalSocket) {
+            this.globalSocket.close();
+        }
+        setTimeout(function () {
+            _this.connect();
+        }, 1000);
+    };
+    WebsocketService.prototype.getWebSocketConnection = function (port) {
+        var webSocketUrl = (0, helpers_1.getWebsocketUrl)(index_1.asperaSdk.globals.asperaAppUrl);
+        return new Promise(function (resolve, reject) {
+            var webSocket = new WebSocket("".concat(webSocketUrl, ":").concat(port));
+            webSocket.onopen = function () {
+                resolve(webSocket);
+            };
+            webSocket.onerror = function () {
+                reject("Connection failed on port ".concat(port));
+            };
+        });
+    };
+    WebsocketService.prototype.notifyEvent = function (event) {
+        if (typeof this.eventListener === 'function') {
+            this.eventListener(event);
+        }
+    };
+    WebsocketService.prototype.updateRpcPort = function () {
+        if (!this.globalSocket) {
+            return;
+        }
+        var url = new URL(this.globalSocket.url);
+        index_1.asperaSdk.globals.rpcPort = Number(url.port);
+    };
+    return WebsocketService;
+}());
+exports.WebsocketService = WebsocketService;
+exports.websocketService = new WebsocketService();
+exports.default = WebsocketService;

package/dist/commonjs/http-gateway/core.d.ts

@@ -0,0 +1,76 @@
+import { FileDialogOptions, DataTransferResponse, TransferSpec, AsperaSdkTransfer } from '../models/models';
+/**
+ * HTTP Gateway Core Logic
+ * - File/Folder picking
+ * - Starting and testing
+ *
+ * @remarks
+ * Most logic is called directly by Desktop SDK functions
+ * You may not need to import anything from this file.
+ */
+/**
+ * Remove a transfer from HTTP Gateway systems
+ * @param id - ID of the transfer
+ *
+ * @returns Promise indicating success
+ */
+export declare const httpRemoveTransfer: (id: string) => Promise<any>;
+/**
+ * Get the list of http gateway transfers
+ *
+ * @returns list of HTTP Gateway
+ */
+export declare const httpGetAllTransfers: () => AsperaSdkTransfer[];
+/**
+ * Get a HTTP Gateway transfer by ID
+ *
+ * @returns a transfer or null
+ */
+export declare const httpGetTransfer: (id: string) => AsperaSdkTransfer | null;
+/**
+ * Create HTML input element for file picking
+ */
+export declare const createHtmlInputElement: () => HTMLInputElement;
+/**
+ * Handle drop events and store files for HTTP Gateway
+ * This works on top of desktop.
+ */
+export declare const handleHttpGatewayDrop: (items: DataTransferItemList, callback: (data: {
+    event: DragEvent;
+    files: DataTransferResponse;
+}) => void, event: DragEvent) => void;
+/**
+ * Open native browser file or folder picker for files
+ *
+ * @param options - File picker options
+ * @param folder - Indicate if choosing folders
+ *
+ * @returns Promise that resolves with info about the files picked
+ */
+export declare const httpGatewaySelectFileFolderDialog: (options?: FileDialogOptions, folder?: boolean) => Promise<DataTransferResponse>;
+/**
+ * Get a generic transfer object for HTTP Gateway transfers.
+ *
+ * @param transferSpec - TransferSpec being provided for the HTTP Gateway transfer
+ *
+ * @returns a transfer object to track status and send to consumers
+ */
+export declare const getSdkTransfer: (transferSpec: TransferSpec) => AsperaSdkTransfer;
+/**
+ * Send a transfer update through the SDK
+ *
+ * @param transfer - Transsfer object to send to consumers
+ */
+export declare const sendTransferUpdate: (transfer: AsperaSdkTransfer) => void;
+/**
+ * Try to parse and get a useful string from API calls for HTTP Gateway
+ *
+ * @param error - Error from API call for Gateway
+ *
+ * @returns a string to use for errors
+ */
+export declare const getMessageFromError: (error: any) => {
+    message: string;
+    code: number;
+};
+export declare const base64Encoding: (jsonString: string) => string;

package/dist/commonjs/http-gateway/core.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Encoding = exports.getMessageFromError = exports.sendTransferUpdate = exports.getSdkTransfer = exports.httpGatewaySelectFileFolderDialog = exports.handleHttpGatewayDrop = exports.createHtmlInputElement = exports.httpGetTransfer = exports.httpGetAllTransfers = exports.httpRemoveTransfer = void 0;
+var messages_1 = require("../constants/messages");
+var helpers_1 = require("../helpers/helpers");
+var index_1 = require("../index");
+var http_gateway_sdk_js_1 = require("@ibm-aspera/http-gateway-sdk-js");
+/**
+ * HTTP Gateway Core Logic
+ * - File/Folder picking
+ * - Starting and testing
+ *
+ * @remarks
+ * Most logic is called directly by Desktop SDK functions
+ * You may not need to import anything from this file.
+ */
+/**
+ * Remove a transfer from HTTP Gateway systems
+ * @param id - ID of the transfer
+ *
+ * @returns Promise indicating success
+ */
+var httpRemoveTransfer = function (id) {
+    if (index_1.asperaSdk.useOldHttpGateway) {
+        (0, http_gateway_sdk_js_1.removeTransfer)(id);
+        return Promise.resolve({ removed: true });
+    }
+    var transfer = index_1.asperaSdk.httpGatewayTransferStore.get(id);
+    if (transfer) {
+        index_1.asperaSdk.httpGatewayTransferStore.delete(id);
+        return Promise.resolve({ removed: true });
+    }
+    else {
+        return Promise.reject((0, helpers_1.generateErrorBody)(messages_1.messages.removeTransferFailed, { reason: 'Not found' }));
+    }
+};
+exports.httpRemoveTransfer = httpRemoveTransfer;
+/**
+ * Get the list of http gateway transfers
+ *
+ * @returns list of HTTP Gateway
+ */
+var httpGetAllTransfers = function () {
+    if (index_1.asperaSdk.useOldHttpGateway) {
+        return (0, http_gateway_sdk_js_1.getAllTransfers)().transfers;
+    }
+    return Array.from(index_1.asperaSdk.httpGatewayTransferStore.values());
+};
+exports.httpGetAllTransfers = httpGetAllTransfers;
+/**
+ * Get a HTTP Gateway transfer by ID
+ *
+ * @returns a transfer or null
+ */
+var httpGetTransfer = function (id) {
+    if (index_1.asperaSdk.useOldHttpGateway) {
+        return (0, http_gateway_sdk_js_1.getTransferById)(id);
+    }
+    return index_1.asperaSdk.httpGatewayTransferStore.get(id);
+};
+exports.httpGetTransfer = httpGetTransfer;
+/**
+ * Create HTML input element for file picking
+ */
+var createHtmlInputElement = function () {
+    var element = window.document.createElement('input');
+    element.type = 'file';
+    element.style = 'display: none;';
+    window.document.body.appendChild(element);
+    return element;
+};
+exports.createHtmlInputElement = createHtmlInputElement;
+/**
+ * Handle drop events and store files for HTTP Gateway
+ * This works on top of desktop.
+ */
+var handleHttpGatewayDrop = function (items, callback, event) {
+    var files = [];
+    var callbackCount = 0;
+    var callbackFinishCount = 0;
+    var finalCallback = function () {
+        if (callbackFinishCount >= callbackCount) {
+            var finalFiles = files.map(function (file) {
+                index_1.asperaSdk.httpGatewaySelectedFiles.set(file.name, file);
+                return {
+                    lastModified: file.lastModified,
+                    name: file.name,
+                    size: file.size,
+                    type: file.type
+                };
+            });
+            callback({ event: event, files: { dataTransfer: { files: finalFiles } } });
+        }
+    };
+    var traverse = function (item) {
+        if (item.isFile) {
+            item.file(function (file) {
+                files.push(file);
+                callbackFinishCount++;
+                finalCallback();
+            });
+        }
+        else if (item.isDirectory) {
+            var dirReader = item.createReader();
+            dirReader.readEntries(function (entries) {
+                for (var k = 0; k < entries.length; k++) {
+                    callbackCount++;
+                    traverse(entries[k]);
+                }
+            });
+            callbackFinishCount++;
+        }
+        else {
+            callbackFinishCount++;
+            finalCallback();
+        }
+    };
+    for (var i = 0; i < items.length; i++) {
+        var item = items[i].webkitGetAsEntry();
+        if (item) {
+            callbackCount++;
+            traverse(item);
+        }
+    }
+};
+exports.handleHttpGatewayDrop = handleHttpGatewayDrop;
+/**
+ * Open native browser file or folder picker for files
+ *
+ * @param options - File picker options
+ * @param folder - Indicate if choosing folders
+ *
+ * @returns Promise that resolves with info about the files picked
+ */
+var httpGatewaySelectFileFolderDialog = function (options, folder) {
+    if (index_1.asperaSdk.useOldHttpGateway) {
+        return (folder ? (0, http_gateway_sdk_js_1.getFoldersForUploadPromise)((options === null || options === void 0 ? void 0 : options.http_gateway_v2_transfer_id) || '') : (0, http_gateway_sdk_js_1.getFilesForUploadPromise)((options === null || options === void 0 ? void 0 : options.http_gateway_v2_transfer_id) || ''));
+    }
+    var _a = (0, helpers_1.generatePromiseObjects)(), promise = _a.promise, rejecter = _a.rejecter, resolver = _a.resolver;
+    var element = (0, exports.createHtmlInputElement)();
+    element.multiple = !!(options === null || options === void 0 ? void 0 : options.multiple);
+    if (folder) {
+        element.webkitdirectory = true;
+    }
+    element.oncancel = function () {
+        rejecter({ debugData: { code: -32002, message: messages_1.messages.filePickerCancel } });
+    };
+    element.onchange = function () {
+        var returnFiles = [];
+        for (var i = 0; i < element.files.length; i++) {
+            var file = element.files[i];
+            returnFiles.push(file);
+            index_1.asperaSdk.httpGatewaySelectedFiles.set(file.name, file);
+        }
+        resolver({
+            dataTransfer: {
+                files: returnFiles.map(function (file) {
+                    return {
+                        size: file.size,
+                        lastModified: file.lastModified,
+                        name: file.webkitRelativePath || file.name,
+                        type: file.type,
+                    };
+                })
+            }
+        });
+    };
+    element.click();
+    return promise;
+};
+exports.httpGatewaySelectFileFolderDialog = httpGatewaySelectFileFolderDialog;
+/**
+ * Get a generic transfer object for HTTP Gateway transfers.
+ *
+ * @param transferSpec - TransferSpec being provided for the HTTP Gateway transfer
+ *
+ * @returns a transfer object to track status and send to consumers
+ */
+var getSdkTransfer = function (transferSpec) {
+    return {
+        uuid: (0, helpers_1.randomUUID)(),
+        transfer_spec: transferSpec,
+        current_file: '',
+        add_time: new Date().toISOString(),
+        file_counts: {
+            attempted: 0,
+            completed: 0,
+            failed: 0,
+            skipped: 0,
+        },
+        end_time: '',
+        explorer_path: '',
+        status: 'queued',
+        bytes_written: 0,
+        bytes_expected: 0,
+        calculated_rate_kbps: 0,
+        elapsed_usec: 0,
+        percentage: 0,
+        title: '',
+        remaining_usec: 0,
+        httpGatewayTransfer: true,
+        httpDownloadExternalHandle: false,
+    };
+};
+exports.getSdkTransfer = getSdkTransfer;
+/**
+ * Send a transfer update through the SDK
+ *
+ * @param transfer - Transsfer object to send to consumers
+ */
+var sendTransferUpdate = function (transfer) {
+    index_1.asperaSdk.httpGatewayTransferStore.set(transfer.uuid, transfer);
+    index_1.asperaSdk.activityTracking.handleTransferActivity({
+        type: 'transferUpdated',
+        data: { transfers: [transfer] },
+    });
+};
+exports.sendTransferUpdate = sendTransferUpdate;
+/**
+ * Try to parse and get a useful string from API calls for HTTP Gateway
+ *
+ * @param error - Error from API call for Gateway
+ *
+ * @returns a string to use for errors
+ */
+var getMessageFromError = function (error) {
+    var data = (0, helpers_1.safeJsonParse)(error);
+    var message = messages_1.messages.httpNetworkFail;
+    var code = 500;
+    if (data && typeof data === 'object') {
+        message = data.message || data.description || messages_1.messages.httpNetworkFail;
+        code = data.code || 500;
+    }
+    else if (error && typeof error === 'object') {
+        message = error.message || error.description || messages_1.messages.httpNetworkFail;
+        code = error.code || 500;
+    }
+    else if (typeof error === 'string') {
+        message = error;
+    }
+    return {
+        message: message,
+        code: code,
+    };
+};
+exports.getMessageFromError = getMessageFromError;
+var base64Encoding = function (jsonString) {
+    var bytes = new TextEncoder().encode(jsonString);
+    var binString = Array.from(bytes, function (byte) {
+        return String.fromCodePoint(byte);
+    }).join('');
+    return btoa(binString);
+};
+exports.base64Encoding = base64Encoding;

package/dist/commonjs/http-gateway/download.d.ts

@@ -0,0 +1,14 @@
+import { AsperaSdkSpec, AsperaSdkTransfer, TransferSpec } from '../models/models';
+/**
+ * HTTP Gateway Download Logic
+ *
+ * @param transferSpec - TransferSpec for the download
+ * @param asperaSdkSpec IBM Aspera settings when starting a transfer.
+ *
+ * @returns Promise that resolves on success invoke or rejects if unable to start
+ *
+ * @remarks
+ * Most logic is called directly by Desktop SDK functions
+ * You may not need to import anything from this file.
+ */
+export declare const httpDownload: (transferSpec: TransferSpec, asperaSdkSpec?: AsperaSdkSpec) => Promise<AsperaSdkTransfer>;