@verdocs/js-sdk 1.4.0 → 2.0.1

package/VerdocsEndpoint.js

@@ -0,0 +1,290 @@
+import axios from 'axios';
+import { decodeAccessTokenBody } from './Utils/Token';
+import globalThis from './Utils/globalThis';
+import * as Documents from './Documents';
+var requestLogger = function (r) {
+    // tslint:disable-next-line
+    console.debug("[JS-SDK] ".concat(r.method.toUpperCase(), " ").concat(r.baseURL).concat(r.url), r.data ? JSON.stringify(r.data) : '');
+    return r;
+};
+/**
+ * VerdocsEndpoint is a class wrapper for a specific connection and authorization context for calling the Verdocs APIs.
+ * Endpoints can be used for isolated session tasks.
+ *
+ * For instance, ephemeral signing sessions may be created independently of a caller's status as an authenticated user.
+ * In that case, an Endpoint can be created and authenticated, used for calls related to signing operations, then
+ * discarded once signing is complete.
+ *
+ * Note that endpoint configuration functions return the instance, so they can be chained, e.g.
+ *
+ * ```typescript
+ * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+ *
+ * const endpoint = new VerdocsEndpoint();
+ * endpoint
+ *     .setSessionType('signing')
+ *     .logRequests(true)
+ *     .setClientID('1234)
+ *     .setTimeout(5000);
+ * ```
+ */
+var VerdocsEndpoint = /** @class */ (function () {
+    /**
+     * Create a new VerdocsEndpoint to call Verdocs platform services.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     * const endpoint = new VerdocsEndpoint();
+     * ```
+     */
+    function VerdocsEndpoint(options) {
+        this.environment = 'verdocs';
+        this.sessionType = 'user';
+        this.baseURL = 'https://api.verdocs.com';
+        this.clientID = 'not-set';
+        this.timeout = 3000;
+        this.token = null;
+        this.nextListenerId = 0;
+        this.sessionListeners = new Map();
+        this.requestLoggerId = null;
+        /**
+         * The current user session, or null if not authenticated. May be either a User or Signing session. If set, the
+         * presence of the `document_id` field can be used to differentiate the types. Only signing sessions are associated
+         * with Documents.
+         */
+        this.session = null;
+        this.Documents = Documents;
+        this.baseURL = (options === null || options === void 0 ? void 0 : options.baseURL) || 'https://api.verdocs.com';
+        this.timeout = (options === null || options === void 0 ? void 0 : options.timeout) || 3000;
+        this.environment = (options === null || options === void 0 ? void 0 : options.environment) || 'verdocs';
+        this.sessionType = (options === null || options === void 0 ? void 0 : options.sessionType) || 'user';
+        this.clientID = (options === null || options === void 0 ? void 0 : options.clientID) || 'not-set';
+        this.api = axios.create({ baseURL: this.baseURL, timeout: this.timeout });
+    }
+    VerdocsEndpoint.prototype.setDefault = function () {
+        globalThis[ENDPOINT_KEY] = this;
+    };
+    VerdocsEndpoint.getDefault = function () {
+        return globalThis[ENDPOINT_KEY];
+    };
+    /**
+     * Get the current environment.
+     */
+    VerdocsEndpoint.prototype.getEnvironment = function () {
+        return this.environment;
+    };
+    /**
+     * Get the current session type.
+     */
+    VerdocsEndpoint.prototype.getSessionType = function () {
+        return this.sessionType;
+    };
+    /**
+     * Get the current base URL. This should rarely be anything other than 'https://api.verdocs.com'.
+     */
+    VerdocsEndpoint.prototype.getBaseURL = function () {
+        return this.baseURL;
+    };
+    /**
+     * Get the current client ID, if set.
+     */
+    VerdocsEndpoint.prototype.getClientID = function () {
+        return this.clientID;
+    };
+    /**
+     * Get the current timeout.
+     */
+    VerdocsEndpoint.prototype.getTimeout = function () {
+        return this.timeout;
+    };
+    /**
+     * Get the current session, if any.
+     */
+    VerdocsEndpoint.prototype.getSession = function () {
+        return this.session;
+    };
+    /**
+     * Set the operating environment. This should rarely be anything other than 'verdocs'.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setEnvironment('verdocs-stage');
+     * ```
+     */
+    VerdocsEndpoint.prototype.setEnvironment = function (environment) {
+        this.environment = environment;
+        return this;
+    };
+    /**
+     * Set the session type. In general this should be done immediately when the endpoint is created. Changing the
+     * session type may be done at any time, but may have unintended consequences if the endpoint is shared between
+     * multiple widgets.
+     *
+     * Changing the session type will clear/reload the action session. This may trigger notifications to session state
+     * observers. Apps that use observers to trigger UI updates such as logging the user out should be prepared to
+     * handle this event.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setEnvironment('verdocs-stage');
+     * ```
+     */
+    VerdocsEndpoint.prototype.setSessionType = function (sessionType) {
+        this.sessionType = sessionType;
+        return this;
+    };
+    /**
+     * Set the base URL for API calls. Should be called only upon direction from Verdocs Customer Solutions Engineering.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setBaseURL('https://api.verdocs.com');
+     * ```
+     */
+    VerdocsEndpoint.prototype.setBaseURL = function (url) {
+        this.api.defaults.baseURL = url;
+        return this;
+    };
+    /**
+     * Set the Client ID for Verdocs API calls.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setClientID('1234);
+     * ```
+     */
+    VerdocsEndpoint.prototype.setClientID = function (clientID) {
+        this.clientID = clientID;
+        this.api.defaults.headers.common['X-Client-ID'] = clientID;
+        return this;
+    };
+    /**
+     * Set the timeout for API calls in milliseconds. 2000-4000ms is recommended for most purposes. 3000ms is the default.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setTimeout(3000);
+     * ```
+     */
+    VerdocsEndpoint.prototype.setTimeout = function (timeout) {
+        this.timeout = timeout;
+        this.api.defaults.timeout = timeout;
+        return this;
+    };
+    /**
+     * Enable or disable request logging. This may expose sensitive data in the console log, so it should only be used for debugging.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.logRequests(true);
+     * ```
+     */
+    VerdocsEndpoint.prototype.logRequests = function (enable) {
+        if (enable && this.requestLoggerId === null) {
+            this.requestLoggerId = this.api.interceptors.request.use(requestLogger);
+        }
+        else if (!enable && this.requestLoggerId !== null) {
+            this.api.interceptors.request.eject(this.requestLoggerId);
+        }
+        return this;
+    };
+    /**
+     * Set the authorization token that will be used for Verdocs API calls. This will also set the session metadata
+     * and notify any listeners of the new data.
+     *
+     * If this Endpoint will be used for non-default purposes (e.g. signing, or in an alternate environment) those
+     * settings should be made before calling this. Sessions are persisted to localStorage, and the environment and
+     * type become part of the storage key.
+     *
+     * ```typescript
+     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
+     *
+     * const endpoint = new VerdocsEndpoint();
+     * endpoint.setToken(accessToken);
+     * ```
+     */
+    VerdocsEndpoint.prototype.setToken = function (token) {
+        if (!token) {
+            return this.clearSession();
+        }
+        var session = decodeAccessTokenBody(token);
+        if (session === null || (session.exp && session.exp * 1000 < new Date().getTime())) {
+            return this.clearSession();
+        }
+        this.token = token;
+        this.session = session;
+        this.api.defaults.headers.common.Authorization = "Bearer ".concat(token);
+        localStorage.setItem(this.sessionStorageKey(), token);
+        this.notifySessionListeners();
+        return this;
+    };
+    VerdocsEndpoint.prototype.sessionStorageKey = function () {
+        return "verdocs-session-".concat(this.getSessionType(), "-").concat(this.getEnvironment());
+    };
+    /**
+     * Clear the active session.
+     */
+    VerdocsEndpoint.prototype.clearSession = function () {
+        localStorage.removeItem(this.sessionStorageKey());
+        delete this.api.defaults.headers.common.Authorization;
+        this.session = null;
+        this.token = null;
+        this.notifySessionListeners();
+        return this;
+    };
+    VerdocsEndpoint.prototype.notifySessionListeners = function () {
+        var _this = this;
+        this.sessionListeners.forEach(function (listener) {
+            try {
+                listener(_this, _this.session);
+            }
+            catch (e) {
+                // NOOP
+            }
+        });
+    };
+    /**
+     * Subscribe to session state change events.
+     */
+    VerdocsEndpoint.prototype.onSessionChanged = function (listener) {
+        var _this = this;
+        // There's no value in randomizing this, a simple counter is fine
+        this.nextListenerId++;
+        var listenerSymbol = Symbol.for('' + this.nextListenerId);
+        this.sessionListeners.set(listenerSymbol, listener);
+        return function () {
+            _this.sessionListeners.delete(listenerSymbol);
+        };
+    };
+    /**
+     * Load a persisted session from localStorage. Typically called once after the endpoint is configured when the app
+     * or component starts.
+     */
+    VerdocsEndpoint.prototype.loadSession = function () {
+        var token = localStorage.getItem(this.sessionStorageKey());
+        if (!token) {
+            return this.clearSession();
+        }
+        return this.setToken(token);
+    };
+    return VerdocsEndpoint;
+}());
+export { VerdocsEndpoint };
+// @credit https://derickbailey.com/2016/03/09/creating-a-true-singleton-in-node-js-with-es6-symbols/
+// Also see globalThis for comments about why we're doing this in the first place.
+var ENDPOINT_KEY = Symbol.for('verdocs-default-endpoint');
+if (!globalThis[ENDPOINT_KEY]) {
+    globalThis[ENDPOINT_KEY] = new VerdocsEndpoint();
+}

package/index.d.ts

@@ -12,7 +12,7 @@
  */
 export * as Documents from './Documents';
 export * as Templates from './Templates';
-export * as HTTP from './HTTP';
 export * as Organizations from './Organizations';
 export * as Users from './Users';
 export * as Utils from './Utils';
+export * from './VerdocsEndpoint';

package/index.js

@@ -12,7 +12,7 @@
  */
 export * as Documents from './Documents';
 export * as Templates from './Templates';
-export * as HTTP from './HTTP';
 export * as Organizations from './Organizations';
 export * as Users from './Users';
 export * as Utils from './Utils';
+export * from './VerdocsEndpoint';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdocs/js-sdk",
-  "version": "1.4.0",
+  "version": "2.0.1",
   "private": false,
   "homepage": "https://github.com/Verdocs/js-sdk",
   "description": "Verdocs JS SDK",

package/Documents/Stars.d.ts

@@ -1,2 +0,0 @@
-import { ITemplateSummaryEntry } from './Types';
-export declare const toggleStar: (templateId: string) => Promise<ITemplateSummaryEntry>;

package/Documents/Stars.js

@@ -1,40 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { getEndpoint } from '../HTTP/Transport';
-export var toggleStar = function (templateId) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-    return [2 /*return*/, getEndpoint().api.post("/templates/".concat(templateId, "/stars/toggle")).then(function (r) { return r.data; })];
-}); }); };

package/HTTP/Transport.d.ts

@@ -1,34 +0,0 @@
-/**
- * The Transport is a global singleton used to call Verdocs APIs. There can only be one Transport per application, and
- * its configuration settings are shared for all callers. This is a simplified form of the Endpoint class where most
- * tasks such as general session-token-management are handled automatically for the caller.
- *
- * @module
- */
-import { VerdocsEndpoint } from './VerdocsEndpoint';
-/**
- * Helper to get the endpoint for direct access to HTTP functions.
- *
- * ```typescript
- * import {Transport} from '@verdocs/js-sdk/HTTP';
- *
- * console.log('Current timeout', Transport.getEndpoint().defaults.timeout);
- * ```
- */
-export declare const getEndpoint: () => VerdocsEndpoint;
-/**
- * Change the endpoint that will be used when making calls to Verdocs. Only one endpoint may be active at a time.
- * Authorization and other configuration data is specific to each endpoint, and will not be carried over when the
- * endpoint is changed. The typical use-case is to change to a sandboxed endpoint for signing sessions, then revert
- * to the global endpoint when the signing session is complete. To revert, pass `null` as the endpoint to use.
- *
- * ```typescript
- * import {Transport} from '@verdocs/js-sdk/HTTP';
- *
- * const mySigningEndpoint = new VerdocsEndpoint();
- * setActiveEndpoint(mySigningEndpoint);
- * ... [Perform signing operations]
- * setActiveEndpoint(null);
- * ```
- */
-export declare const setActiveEndpoint: (e: VerdocsEndpoint | null) => void;

package/HTTP/Transport.js

@@ -1,47 +0,0 @@
-/**
- * The Transport is a global singleton used to call Verdocs APIs. There can only be one Transport per application, and
- * its configuration settings are shared for all callers. This is a simplified form of the Endpoint class where most
- * tasks such as general session-token-management are handled automatically for the caller.
- *
- * @module
- */
-import { VerdocsEndpoint } from './VerdocsEndpoint';
-import globalThis from './globalThis';
-// @credit https://derickbailey.com/2016/03/09/creating-a-true-singleton-in-node-js-with-es6-symbols/
-// Also see globalThis for comments about why we're doing this in the first place.
-var ENDPOINT_KEY = Symbol.for('verdocs-api-endpoint');
-if (!globalThis[ENDPOINT_KEY]) {
-    globalThis[ENDPOINT_KEY] = new VerdocsEndpoint();
-}
-var globalEndpoint = globalThis[ENDPOINT_KEY];
-var activeEndpoint = globalEndpoint;
-/**
- * Helper to get the endpoint for direct access to HTTP functions.
- *
- * ```typescript
- * import {Transport} from '@verdocs/js-sdk/HTTP';
- *
- * console.log('Current timeout', Transport.getEndpoint().defaults.timeout);
- * ```
- */
-export var getEndpoint = function () {
-    return activeEndpoint;
-};
-/**
- * Change the endpoint that will be used when making calls to Verdocs. Only one endpoint may be active at a time.
- * Authorization and other configuration data is specific to each endpoint, and will not be carried over when the
- * endpoint is changed. The typical use-case is to change to a sandboxed endpoint for signing sessions, then revert
- * to the global endpoint when the signing session is complete. To revert, pass `null` as the endpoint to use.
- *
- * ```typescript
- * import {Transport} from '@verdocs/js-sdk/HTTP';
- *
- * const mySigningEndpoint = new VerdocsEndpoint();
- * setActiveEndpoint(mySigningEndpoint);
- * ... [Perform signing operations]
- * setActiveEndpoint(null);
- * ```
- */
-export var setActiveEndpoint = function (e) {
-    activeEndpoint = e || globalEndpoint;
-};

package/HTTP/Types.d.ts

@@ -1 +0,0 @@
-export declare type TRequestStatus = 'OK' | 'ERROR';

package/HTTP/Types.js

@@ -1 +0,0 @@
-export {};

package/HTTP/VerdocsEndpoint.d.ts

@@ -1,106 +0,0 @@
-import { AxiosInstance } from 'axios';
-/**
- * VerdocsEndpoint is a class wrapper for a specific connection and authorization context for calling the Verdocs APIs.
- * Endpoints can be used for isolated session tasks.
- * For instance, ephemeral signing sessions may be created independently of a caller's status as an authenticated user.
- * In that case, an Endpoint can be created and authenticated, used for calls related to signing operations, then
- * discarded once signing is complete.
- *
- * Note that endpoint configuration functions return the instance, so they can be chained, e.g.
- *
- * ```typescript
- * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
- *
- * const endpoint = new VerdocsEndpoint();
- * endpoint
- *     .logRequests(true)
- *     .setClientID('1234)
- *     .setTimeout(5000);
- * ```
- */
-export declare class VerdocsEndpoint {
-    /**
-     * Reference to the axios instance wrapped by this endpoint. This is exposed as a convenience to developers, but
-     * developers should generally use the convenience functions such as `setTimeout` to configure the connection.
-     * Although there are currently no plans to change from Axios to another XHR library, the less this property is
-     * directly accessed the easier future migrations will be.
-     */
-    api: AxiosInstance;
-    private requestLoggerId;
-    /**
-     * Create a new VerdocsEndpoint to call Verdocs platform services.
-     *
-     * ```typescript
-     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     * const endpoint = new VerdocsEndpoint();
-     * ```
-     */
-    constructor();
-    /**
-     * Set the timeout for API calls in milliseconds. 2000-4000ms is recommended for most purposes. 3000ms is the default.
-     *
-     * ```typescript
-     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     *
-     * const endpoint = new VerdocsEndpoint();
-     * endpoint.setTimeout(3000);
-     * ```
-     */
-    setTimeout(timeout: number): VerdocsEndpoint;
-    /**
-     * Set the Client ID for Verdocs API calls.
-     *
-     * ```typescript
-     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     *
-     * const endpoint = new VerdocsEndpoint();
-     * endpoint.setClientID('1234);
-     * ```
-     */
-    setClientID(clientID: string): VerdocsEndpoint;
-    /**
-     * Set the auth token that will be used for Verdocs API calls.
-     *
-     * ```typescript
-     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     *
-     * const endpoint = new VerdocsEndpoint();
-     * endpoint.setAuthorization(accessToken);
-     * ```
-     */
-    setAuthorization(accessToken: string | null): VerdocsEndpoint;
-    /**
-     * Set the auth token used for signing sessions. Separating user from signing auth allows the same endpoint to be
-     * used for multiple operations, although it is recommended that a separate endpoint be created for each operation.
-     *
-     * ```typescript
-     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     *
-     * const endpoint = new VerdocsEndpoint();
-     * endpoint.setSigningAuthorization(accessToken);
-     * ```
-     */
-    setSigningAuthorization(accessToken: string | null): VerdocsEndpoint;
-    /**
-     * Set the base URL for API calls. May also be set via the constructor.
-     *
-     * ```typescript
-     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     *
-     * const endpoint = new VerdocsEndpoint();
-     * endpoint.setBaseURL('https://api.verdocs.com');
-     * ```
-     */
-    setBaseURL(url: string): VerdocsEndpoint;
-    /**
-     * Enable or disable request logging. This may expose sensitive data in the console log, so it should only be used for debugging.
-     *
-     * ```typescript
-     * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     *
-     * const endpoint = new VerdocsEndpoint();
-     * endpoint.logRequests(true);
-     * ```
-     */
-    logRequests(enable: boolean): VerdocsEndpoint;
-}