twilio 4.6.0 → 4.7.0

package/lib/jwt/ClientCapability.js

@@ -1,141 +1,122 @@
-'use strict';
-
-var _ = require('lodash');
-var jwt = require('jsonwebtoken');
-var qs = require('querystring');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutgoingClientScope = exports.IncomingClientScope = exports.EventStreamScope = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const querystring_1 = __importDefault(require("querystring"));
 /**
- * @constructor
  * @param filters
  */
-function EventStreamScope(filters) {
-  this.filters = filters || {};
-}
-
-_.extend(EventStreamScope.prototype, {
-  scope: 'scope:stream:subscribe',
-
-  payload: function() {
-    var queryArgs = ['path=/2010-04-01/Events'];
-
-    if (!_.isEmpty(this.filters)) {
-      var queryParams = _.map(this.filters, function(value, key) {
-        return _.join([qs.escape(key), qs.escape(value)], '=');
-      });
-      var filterParams = _.join(queryParams, '&');
-
-      queryArgs.push(_.join(['appParams', qs.escape(filterParams)], '='));
+class EventStreamScope {
+    constructor(filters) {
+        this.scope = "scope:stream:subscribe";
+        this.filters = filters || {};
+    }
+    payload() {
+        var queryArgs = ["path=/2010-04-01/Events"];
+        if (Object.keys(this.filters).length > 0) {
+            var queryParams = Object.entries(this.filters).map((filter) => {
+                return [querystring_1.default.escape(filter[0]), querystring_1.default.escape(filter[1])].join("=");
+            });
+            var filterParams = queryParams.join("&");
+            queryArgs.push(["appParams", querystring_1.default.escape(filterParams)].join("="));
+        }
+        var queryString = queryArgs.join("&");
+        return [this.scope, queryString].join("?");
     }
-
-    var queryString = _.join(queryArgs, '&');
-    return _.join([this.scope, queryString], '?');
-  }
-});
-
-/**
- * @constructor
- * @param clientName
- */
-function IncomingClientScope(clientName) {
-  this.clientName = clientName;
 }
-
-_.extend(IncomingClientScope.prototype, {
-  scope: 'scope:client:incoming',
-
-  payload: function() {
-    var query = _.join(['clientName', qs.escape(this.clientName)], '=');
-    return _.join([this.scope, query], '?');
-  }
-});
-
+exports.EventStreamScope = EventStreamScope;
 /**
- * @constructor
- * @param {object} options - ...
- * @param {string} options.applicationSid - the application sid
- * @param {string} [options.clientName] - the client name
- * @param {object} [options.params] - parameters
+ * @param clientName
  */
-function OutgoingClientScope(options) {
-  if (_.isUndefined(options)) {
-    throw new Error('Required parameter "options" missing.');
-  }
-  if (_.isUndefined(options.applicationSid)) {
-    throw new Error('Required parameter "options.applicationSid" missing.');
-  }
-
-  options = options || {};
-  this.applicationSid = options.applicationSid;
-  this.clientName = options.clientName;
-  this.params = options.params;
+class IncomingClientScope {
+    constructor(clientName) {
+        this.scope = "scope:client:incoming";
+        this.clientName = clientName;
+    }
+    payload() {
+        var query = ["clientName", querystring_1.default.escape(this.clientName)].join("=");
+        return [this.scope, query].join("?");
+    }
 }
-
-_.extend(OutgoingClientScope.prototype, {
-  scope: 'scope:client:outgoing',
-
-  payload: function() {
-    var queryArgs = [_.join(['appSid', qs.escape(this.applicationSid)], '=')];
-
-    if (_.isString(this.clientName)) {
-      queryArgs.push(_.join(['clientName', qs.escape(this.clientName)], '='));
+exports.IncomingClientScope = IncomingClientScope;
+class OutgoingClientScope {
+    /**
+     * @param options - ...
+     * @param options.applicationSid - the application sid
+     * @param options.clientName - the client name
+     * @param options.params - parameters
+     */
+    constructor(options) {
+        this.scope = "scope:client:outgoing";
+        if (!options) {
+            throw new Error('Required parameter "options" missing.');
+        }
+        if (typeof options !== "object") {
+            throw new TypeError('Parameter "options" must be a type Object');
+        }
+        if (!options.applicationSid) {
+            throw new Error('Required parameter "options.applicationSid" missing.');
+        }
+        this.applicationSid = options.applicationSid;
+        this.clientName = options.clientName;
+        this.params = options.params;
     }
-
-    if (_.isObject(this.params)) {
-      var queryParams = _.map(this.params, function(value, key) {
-        return _.join([qs.escape(key), qs.escape(value)], '=');
-      });
-      var filterParams = _.join(queryParams, '&');
-
-      queryArgs.push(_.join(['appParams', qs.escape(filterParams)], '='));
+    payload() {
+        var queryArgs = [["appSid", querystring_1.default.escape(this.applicationSid)].join("=")];
+        if (typeof this.clientName === "string") {
+            queryArgs.push(["clientName", querystring_1.default.escape(this.clientName)].join("="));
+        }
+        if (typeof this.params === "object") {
+            var queryParams = Object.entries(this.params).map((param) => {
+                return [querystring_1.default.escape(param[0]), querystring_1.default.escape(param[1])].join("=");
+            });
+            var filterParams = queryParams.join("&");
+            queryArgs.push(["appParams", querystring_1.default.escape(filterParams)].join("="));
+        }
+        var queryString = queryArgs.join("&");
+        return [this.scope, queryString].join("?");
     }
-
-    var queryString = _.join(queryArgs, '&');
-    return _.join([this.scope, queryString], '?');
-  }
-});
-
+}
+exports.OutgoingClientScope = OutgoingClientScope;
 /**
- * @constructor
  * @param options
  */
-function ClientCapability(options) {
-  if (_.isUndefined(options)) {
-    throw new Error('Required parameter "options" missing.');
-  }
-  if (_.isUndefined(options.accountSid)) {
-    throw new Error('Required parameter "options.accountSid" missing.');
-  }
-  if (_.isUndefined(options.authToken)) {
-    throw new Error('Required parameter "options.authToken" missing.');
-  }
-
-  options = options || {};
-  this.accountSid = options.accountSid;
-  this.authToken = options.authToken;
-  this.ttl = options.ttl || 3600;
-  this.scopes = [];
+class ClientCapability {
+    constructor(options) {
+        if (!options) {
+            throw new Error('Required parameter "options" missing.');
+        }
+        if (typeof options !== "object") {
+            throw new TypeError('Parameter "options" must be a type Object');
+        }
+        if (!options.accountSid) {
+            throw new Error('Required parameter "options.accountSid" missing.');
+        }
+        if (!options.authToken) {
+            throw new Error('Required parameter "options.authToken" missing.');
+        }
+        this.accountSid = options.accountSid;
+        this.authToken = options.authToken;
+        this.ttl = options.ttl || 3600;
+        this.scopes = [];
+    }
+    addScope(scope) {
+        this.scopes.push(scope);
+    }
+    toJwt() {
+        const scope = this.scopes.map((scope) => scope.payload()).join(" ");
+        var payload = {
+            scope: scope,
+            iss: this.accountSid,
+            exp: Math.floor(new Date().valueOf() / 1000) + this.ttl,
+        };
+        return jsonwebtoken_1.default.sign(payload, this.authToken);
+    }
 }
-
+exports.default = ClientCapability;
 ClientCapability.EventStreamScope = EventStreamScope;
 ClientCapability.IncomingClientScope = IncomingClientScope;
 ClientCapability.OutgoingClientScope = OutgoingClientScope;
-
-_.extend(ClientCapability.prototype, {
-  addScope: function(scope) {
-    this.scopes.push(scope);
-  },
-
-  toJwt: function() {
-    var payload = {
-      scope: _.join(_.map(this.scopes, function(scope) {
-        return scope.payload();
-      }), ' '),
-      iss: this.accountSid,
-      exp: Math.floor(new Date() / 1000) + this.ttl
-    };
-
-    return jwt.sign(payload, this.authToken);
-  }
-});
-
-module.exports = ClientCapability;

package/lib/jwt/taskrouter/TaskRouterCapability.d.ts

@@ -0,0 +1,74 @@
+export interface TaskRouterCapabilityOptions {
+    accountSid: string;
+    authToken: string;
+    workspaceSid: string;
+    channelId: string;
+    friendlyName?: string;
+    ttl?: number;
+    version?: string;
+}
+export interface PolicyOptions {
+    /** Policy URL */
+    url?: string;
+    /** HTTP Method */
+    method?: string;
+    /** Request query filter allowances */
+    queryFilter?: object;
+    /** Request post filter allowances */
+    postFilter?: object;
+    /** Allow the policy */
+    allow?: boolean;
+}
+export interface PolicyPayload {
+    url: string;
+    method: string;
+    query_filter: object;
+    post_filter: object;
+    allow: boolean;
+}
+/**
+ * Create a new Policy
+ */
+export declare class Policy {
+    url: string;
+    method: string;
+    queryFilter: object;
+    postFilter: object;
+    allow: boolean;
+    /**
+     * Create a new Policy instance
+     *
+     * @param options - ...
+     * @param options.url - Policy URL
+     * @param options.method - HTTP Method
+     * @param options.queryFilter - Request query filter allowances
+     * @param options.postFilter - Request post filter allowances
+     * @param options.allowed - Allow the policy
+     */
+    constructor(options?: PolicyOptions);
+    payload(): PolicyPayload;
+}
+export default class TaskRouterCapability {
+    accountSid: string;
+    authToken: string;
+    workspaceSid: string;
+    channelId: string;
+    ttl: number;
+    version: string;
+    policies: Policy[];
+    friendlyName?: string;
+    /**
+     * @param options - ...
+     * @param options.accountSid - account sid
+     * @param options.authToken - auth token
+     * @param options.workspaceSid - workspace sid
+     * @param options.channelId - taskrouter channel id
+     * @param options.friendlyName - friendly name for the jwt
+     * @param options.ttl - time to live
+     * @param options.version - taskrouter version
+     */
+    constructor(options: TaskRouterCapabilityOptions);
+    static Policy: typeof Policy;
+    addPolicy(policy: Policy): void;
+    toJwt(): string;
+}

package/lib/jwt/taskrouter/TaskRouterCapability.js

@@ -1,107 +1,101 @@
-'use strict';
-
-var jwt = require('jsonwebtoken');
-var _ = require('lodash');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Policy = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 /**
  * Create a new Policy
- *
- * @constructor
- * @param {object} options - ...
- * @param {string} [options.url] - Policy URL
- * @param {string} [options.method] - HTTP Method
- * @param {object} [options.queryFilter] - Request query filter allowances
- * @param {object} [options.postFilter] - Request post filter allowances
- * @param {boolean} [options.allowed] - Allow the policy
  */
-function Policy(options) {
-  options = options || {};
-  this.url = options.url;
-  this.method = options.method || 'GET';
-  this.queryFilter = options.queryFilter || {};
-  this.postFilter = options.postFilter || {};
-  this.allow = options.allow || true;
+class Policy {
+    /**
+     * Create a new Policy instance
+     *
+     * @param options - ...
+     * @param options.url - Policy URL
+     * @param options.method - HTTP Method
+     * @param options.queryFilter - Request query filter allowances
+     * @param options.postFilter - Request post filter allowances
+     * @param options.allowed - Allow the policy
+     */
+    constructor(options) {
+        options = options || {};
+        this.url = options.url || "";
+        this.method = options.method || "GET";
+        this.queryFilter = options.queryFilter || {};
+        this.postFilter = options.postFilter || {};
+        this.allow = options.allow || true;
+    }
+    payload() {
+        return {
+            url: this.url,
+            method: this.method,
+            query_filter: this.queryFilter,
+            post_filter: this.postFilter,
+            allow: this.allow,
+        };
+    }
 }
-
-_.extend(Policy.prototype, {
-  payload: function() {
-    return {
-      url: this.url,
-      method: this.method,
-      query_filter: this.queryFilter,
-      post_filter: this.postFilter,
-      allow: this.allow
-    };
-  }
-});
-
-/**
- * @constructor
- * @param {object} options - ...
- * @param {string} options.accountSid - account sid
- * @param {string} options.authToken - auth token
- * @param {string} options.workspaceSid - workspace sid
- * @param {string} options.channelId - taskrouter channel id
- * @param {string} [options.friendlyName] - friendly name for the jwt
- * @param {number} [options.ttl] - time to live
- * @param {string} [options.version] - taskrouter version
- */
-function TaskRouterCapability(options) {
-  if (_.isUndefined(options)) {
-    throw new Error('Required parameter "options" missing.');
-  }
-  if (_.isUndefined(options.accountSid)) {
-    throw new Error('Required parameter "options.accountSid" missing.');
-  }
-  if (_.isUndefined(options.authToken)) {
-    throw new Error('Required parameter "options.authToken" missing.');
-  }
-  if (_.isUndefined(options.workspaceSid)) {
-    throw new Error('Required parameter "options.workspaceSid" missing.');
-  }
-  if (_.isUndefined(options.channelId)) {
-    throw new Error('Required parameter "options.channelId" missing.');
-  }
-
-  this.accountSid = options.accountSid;
-  this.authToken = options.authToken;
-  this.workspaceSid = options.workspaceSid;
-  this.channelId = options.channelId;
-  this.friendlyName = options.friendlyName;
-  this.ttl = options.ttl || 3600;
-  this.version = options.version || 'v1';
-  this.policies = [];
+exports.Policy = Policy;
+class TaskRouterCapability {
+    /**
+     * @param options - ...
+     * @param options.accountSid - account sid
+     * @param options.authToken - auth token
+     * @param options.workspaceSid - workspace sid
+     * @param options.channelId - taskrouter channel id
+     * @param options.friendlyName - friendly name for the jwt
+     * @param options.ttl - time to live
+     * @param options.version - taskrouter version
+     */
+    constructor(options) {
+        if (!options) {
+            throw new Error('Required parameter "options" missing.');
+        }
+        if (!options.accountSid) {
+            throw new Error('Required parameter "options.accountSid" missing.');
+        }
+        if (!options.authToken) {
+            throw new Error('Required parameter "options.authToken" missing.');
+        }
+        if (!options.workspaceSid) {
+            throw new Error('Required parameter "options.workspaceSid" missing.');
+        }
+        if (!options.channelId) {
+            throw new Error('Required parameter "options.channelId" missing.');
+        }
+        this.accountSid = options.accountSid;
+        this.authToken = options.authToken;
+        this.workspaceSid = options.workspaceSid;
+        this.channelId = options.channelId;
+        this.friendlyName = options.friendlyName;
+        this.ttl = options.ttl || 3600;
+        this.version = options.version || "v1";
+        this.policies = [];
+    }
+    addPolicy(policy) {
+        this.policies.push(policy);
+    }
+    toJwt() {
+        var payload = {
+            iss: this.accountSid,
+            exp: Math.floor(new Date().valueOf() / 1000) + this.ttl,
+            version: this.version,
+            friendly_name: this.friendlyName,
+            account_sid: this.accountSid,
+            channel: this.channelId,
+            workspace_sid: this.workspaceSid,
+            policies: this.policies.map((policy) => policy.payload()),
+        };
+        if (this.channelId.startsWith("WK")) {
+            payload.worker_sid = this.channelId;
+        }
+        else if (this.channelId.startsWith("WQ")) {
+            payload.taskqueue_sid = this.channelId;
+        }
+        return jsonwebtoken_1.default.sign(payload, this.authToken);
+    }
 }
-
+exports.default = TaskRouterCapability;
 TaskRouterCapability.Policy = Policy;
-
-_.extend(TaskRouterCapability.prototype, {
-  addPolicy: function(policy) {
-    this.policies.push(policy);
-  },
-
-  toJwt: function() {
-    var payload = {
-      iss: this.accountSid,
-      exp: (Math.floor(new Date() / 1000)) + this.ttl,
-      version: this.version,
-      friendly_name: this.friendlyName,
-      account_sid: this.accountSid,
-      channel: this.channelId,
-      workspace_sid: this.workspaceSid,
-      policies: _.map(this.policies, function(policy) {
-        return policy.payload();
-      })
-    };
-
-    if (_.startsWith(this.channelId, 'WK')) {
-      payload.worker_sid = this.channelId;
-    } else if (_.startsWith(this.channelId, 'WQ')) {
-      payload.taskqueue_sid = this.channelId;
-    }
-
-    return jwt.sign(payload, this.authToken);
-  }
-});
-
-module.exports = TaskRouterCapability;

package/lib/jwt/taskrouter/util.d.ts

@@ -0,0 +1,66 @@
+import { Policy } from "./TaskRouterCapability";
+/**
+ * Build the default Policies for a worker
+ *
+ * @param version - TaskRouter version
+ * @param workspaceSid - workspace sid
+ * @param workerSid - worker sid
+ * @returns list of Policies
+ */
+export declare function defaultWorkerPolicies(version: string, workspaceSid: string, workerSid: string): Policy[];
+/**
+ * Build the default Event Bridge Policies
+ *
+ * @param accountSid - account sid
+ * @param channelId - channel id
+ * @returns list of Policies
+ */
+export declare function defaultEventBridgePolicies(accountSid: string, channelId: string): Policy[];
+/**
+ * Generate TaskRouter workspace url
+ *
+ * @param workspaceSid - workspace sid or '**' for all workspaces
+ * @returns generated url
+ */
+export declare function workspacesUrl(workspaceSid?: string): string;
+/**
+ * Generate TaskRouter task queue url
+ *
+ * @param workspaceSid - workspace sid
+ * @param taskQueueSid - task queue sid or '**' for all task queues
+ * @returns generated url
+ */
+export declare function taskQueuesUrl(workspaceSid: string, taskQueueSid?: string): string;
+/**
+ * Generate TaskRouter task url
+ *
+ * @param workspaceSid - workspace sid
+ * @param taskSid - task sid or '**' for all tasks
+ * @returns generated url
+ */
+export declare function tasksUrl(workspaceSid: string, taskSid?: string): string;
+/**
+ * Generate TaskRouter activity url
+ *
+ * @param workspaceSid - workspace sid
+ * @param activitySid - activity sid or '**' for all activities
+ * @returns generated url
+ */
+export declare function activitiesUrl(workspaceSid: string, activitySid?: string): string;
+/**
+ * Generate TaskRouter worker url
+ *
+ * @param workspaceSid - workspace sid
+ * @param workerSid - worker sid or '**' for all workers
+ * @returns generated url
+ */
+export declare function workersUrl(workspaceSid: string, workerSid?: string): string;
+/**
+ * Generate TaskRouter worker reservation url
+ *
+ * @param workspaceSid - workspace sid
+ * @param workerSid - worker sid
+ * @param reservationSid - reservation sid or '**' for all reservations
+ * @returns generated url
+ */
+export declare function reservationsUrl(workspaceSid: string, workerSid: string, reservationSid?: string): string;