nylas 6.7.0 → 6.9.0

package/lib/config.d.ts

@@ -1,11 +1,19 @@
+import { WebhookTriggers } from './models/webhook';
 export declare let apiServer: string | null;
 export declare function setApiServer(newApiServer: string | null): void;
 export declare let clientSecret: string;
 export declare function setClientSecret(newClientSecret: string): void;
+export declare let timeout: number;
+export declare function setTimeout(newTimeout: number): void;
 export declare type NylasConfig = {
+    /** Nylas application client ID */
     clientId: string;
+    /** Nylas application client secret */
     clientSecret: string;
+    /** API Server base URL */
     apiServer?: string;
+    /** Timeout for outgoing API calls, in milliseconds */
+    timeout?: number;
 };
 export declare enum ResponseType {
     CODE = "code",
@@ -20,3 +28,25 @@ export declare type AuthenticateUrlConfig = {
     scopes?: string[];
     responseType?: ResponseType;
 };
+export declare enum Region {
+    Us = "us",
+    Ireland = "ireland"
+}
+export declare const DEFAULT_REGION = Region.Us;
+export declare const regionConfig: {
+    us: {
+        nylasAPIUrl: string;
+        dashboardApiUrl: string;
+        callbackDomain: string;
+        websocketDomain: string;
+        telemetryApiUrl: string;
+    };
+    ireland: {
+        nylasAPIUrl: string;
+        dashboardApiUrl: string;
+        callbackDomain: string;
+        websocketDomain: string;
+        telemetryApiUrl: string;
+    };
+};
+export declare const DEFAULT_WEBHOOK_TRIGGERS: WebhookTriggers[];

package/lib/config.js

@@ -1,5 +1,7 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+var webhook_1 = require("./models/webhook");
 exports.apiServer = null;
 function setApiServer(newApiServer) {
     exports.apiServer = newApiServer;
@@ -10,8 +12,36 @@ function setClientSecret(newClientSecret) {
     exports.clientSecret = newClientSecret;
 }
 exports.setClientSecret = setClientSecret;
+exports.timeout = 0;
+function setTimeout(newTimeout) {
+    exports.timeout = newTimeout;
+}
+exports.setTimeout = setTimeout;
 var ResponseType;
 (function (ResponseType) {
     ResponseType["CODE"] = "code";
     ResponseType["TOKEN"] = "token";
 })(ResponseType = exports.ResponseType || (exports.ResponseType = {}));
+var Region;
+(function (Region) {
+    Region["Us"] = "us";
+    Region["Ireland"] = "ireland";
+})(Region = exports.Region || (exports.Region = {}));
+exports.DEFAULT_REGION = Region.Us;
+exports.regionConfig = (_a = {},
+    _a[Region.Us] = {
+        nylasAPIUrl: 'https://api.nylas.com',
+        dashboardApiUrl: 'https://dashboard-api.nylas.com',
+        callbackDomain: 'cb.nylas.com',
+        websocketDomain: 'tunnel.nylas.com',
+        telemetryApiUrl: 'https://cli.nylas.com',
+    },
+    _a[Region.Ireland] = {
+        nylasAPIUrl: 'https://ireland.api.nylas.com',
+        dashboardApiUrl: 'https://ireland.dashboard.nylas.com',
+        callbackDomain: 'cb.nylas.com',
+        websocketDomain: 'tunnel.nylas.com',
+        telemetryApiUrl: 'https://cli.nylas.com',
+    },
+    _a);
+exports.DEFAULT_WEBHOOK_TRIGGERS = Object.values(webhook_1.WebhookTriggers);

package/lib/models/event.d.ts

@@ -47,6 +47,7 @@ export declare type EventProperties = {
     jobStatusId?: string;
     organizerEmail?: string;
     organizerName?: string;
+    hideParticipants?: boolean;
     visibility?: string;
     customerEventId?: string;
     reminderMinutes?: string;
@@ -84,6 +85,7 @@ export default class Event extends RestfulModel {
     jobStatusId?: string;
     organizerEmail?: string;
     organizerName?: string;
+    hideParticipants?: boolean;
     visibility?: string;
     customerEventId?: string;
     static collectionName: string;

package/lib/models/event.js

@@ -294,6 +294,9 @@ var Event = /** @class */ (function (_super) {
             modelKey: 'organizerName',
             jsonKey: 'organizer_name',
             readOnly: true,
+        }), hideParticipants: attributes_1.default.Boolean({
+            modelKey: 'hideParticipants',
+            jsonKey: 'hide_participants',
         }), visibility: attributes_1.default.String({
             modelKey: 'visibility',
         }), customerEventId: attributes_1.default.String({

package/lib/models/nylas-api-error.js

@@ -42,6 +42,7 @@ var NylasApiError = /** @class */ (function (_super) {
             403: 'Forbidden',
             404: 'Not Found',
             405: 'Method Not Allowed',
+            409: 'Conflict',
             410: 'Gone',
             418: "I'm a Teapot",
             422: 'Sending Error',

package/lib/models/restful-model-collection.d.ts

@@ -2,7 +2,7 @@ import NylasConnection from '../nylas-connection';
 import RestfulModel from './restful-model';
 import ModelCollection from './model-collection';
 export declare type GetCallback = (error: Error | null, result?: RestfulModel) => void;
-export default class RestfulModelCollection<T extends RestfulModel> extends ModelCollection<any> {
+export default class RestfulModelCollection<T extends RestfulModel> extends ModelCollection<T> {
     modelClass: typeof RestfulModel;
     constructor(modelClass: typeof RestfulModel, connection: NylasConnection);
     count(params?: Record<string, unknown>, callback?: (err: Error | null, num?: number) => void): Promise<number>;

package/lib/models/webhook.d.ts

@@ -8,6 +8,7 @@ export declare enum WebhookTriggers {
     AccountStopped = "account.stopped",
     AccountInvalid = "account.invalid",
     AccountSyncError = "account.sync_error",
+    MessageBounced = "message.bounced",
     MessageCreated = "message.created",
     MessageOpened = "message.opened",
     MessageUpdated = "message.updated",

package/lib/models/webhook.js

@@ -25,6 +25,7 @@ var WebhookTriggers;
     WebhookTriggers["AccountStopped"] = "account.stopped";
     WebhookTriggers["AccountInvalid"] = "account.invalid";
     WebhookTriggers["AccountSyncError"] = "account.sync_error";
+    WebhookTriggers["MessageBounced"] = "message.bounced";
     WebhookTriggers["MessageCreated"] = "message.created";
     WebhookTriggers["MessageOpened"] = "message.opened";
     WebhookTriggers["MessageUpdated"] = "message.updated";

package/lib/models/when.d.ts

@@ -3,7 +3,10 @@ import { Attribute } from './attributes';
 export declare type WhenProperties = {
     startTime?: number;
     endTime?: number;
+    startTimezone?: string;
+    endTimezone?: string;
     time?: number;
+    timezone?: string;
     startDate?: string;
     endDate?: string;
     date?: string;
@@ -12,7 +15,10 @@ export declare type WhenProperties = {
 export default class When extends Model implements WhenProperties {
     startTime?: number;
     endTime?: number;
+    startTimezone?: string;
+    endTimezone?: string;
     time?: number;
+    timezone?: string;
     startDate?: string;
     endDate?: string;
     date?: string;

package/lib/models/when.js

@@ -41,9 +41,20 @@ var When = /** @class */ (function (_super) {
             modelKey: 'endTime',
             jsonKey: 'end_time',
         }),
+        startTimezone: attributes_1.default.String({
+            modelKey: 'startTimezone',
+            jsonKey: 'start_timezone',
+        }),
+        endTimezone: attributes_1.default.String({
+            modelKey: 'endTimezone',
+            jsonKey: 'end_timezone',
+        }),
         time: attributes_1.default.Number({
             modelKey: 'time',
         }),
+        timezone: attributes_1.default.String({
+            modelKey: 'timezone',
+        }),
         startDate: attributes_1.default.String({
             modelKey: 'startDate',
             jsonKey: 'start_date',

package/lib/nylas-connection.js

@@ -10,6 +10,9 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -17,12 +20,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     result["default"] = mod;
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 // TODO since node 10 URL is global
 var url_1 = require("url");
+// TODO since node 15 AbortController is global
+var abort_controller_1 = __importDefault(require("abort-controller"));
 var node_fetch_1 = __importStar(require("node-fetch"));
 var config = __importStar(require("./config"));
 var restful_model_collection_1 = __importDefault(require("./models/restful-model-collection"));
@@ -181,8 +183,16 @@ var NylasConnection = /** @class */ (function () {
     NylasConnection.prototype.request = function (options) {
         var _this = this;
         var req = this.newRequest(options);
+        var controller;
+        var timeout;
+        if (config.timeout && config.timeout !== 0) {
+            controller = new abort_controller_1.default();
+            timeout = setTimeout(function () {
+                controller.abort();
+            }, 150);
+        }
         return new Promise(function (resolve, reject) {
-            return node_fetch_1.default(req)
+            return node_fetch_1.default(req, { signal: controller === null || controller === void 0 ? void 0 : controller.signal })
                 .then(function (response) {
                 if (typeof response === 'undefined') {
                     return reject(new Error('No response'));
@@ -255,8 +265,15 @@ var NylasConnection = /** @class */ (function () {
                 }
             })
                 .catch(function (err) {
+                if (err && err.name && err.name === 'AbortError') {
+                    console.warn('Request timed out');
+                    return reject(err);
+                }
                 console.error("Error encountered during request:\n" + err.stack);
                 return reject(err);
+            })
+                .then(function () {
+                clearTimeout(timeout);
             });
         });
     };

package/lib/nylas.d.ts

@@ -14,6 +14,8 @@ declare class Nylas {
     static set clientSecret(newClientSecret: string);
     static get apiServer(): string | null;
     static set apiServer(newApiServer: string | null);
+    static get timeout(): number;
+    static set timeout(timeout: number);
     static accounts: ManagementModelCollection<ManagementAccount> | RestfulModelCollection<Account>;
     static connect: Connect;
     static webhooks: ManagementModelCollection<Webhook>;

package/lib/nylas.js

@@ -46,6 +46,17 @@ var Nylas = /** @class */ (function () {
         enumerable: true,
         configurable: true
     });
+    Object.defineProperty(Nylas, "timeout", {
+        get: function () {
+            return config.timeout;
+        },
+        // Timeout for outgoing API calls, in milliseconds
+        set: function (timeout) {
+            config.setTimeout(timeout);
+        },
+        enumerable: true,
+        configurable: true
+    });
     Nylas.config = function (config) {
         if (config.apiServer && config.apiServer.indexOf('://') === -1) {
             throw new Error('Please specify a fully qualified URL for the API Server.');
@@ -62,6 +73,7 @@ var Nylas = /** @class */ (function () {
         else {
             this.apiServer = 'https://api.nylas.com';
         }
+        this.timeout = config.timeout || 0;
         var conn = new nylas_connection_1.default(this.clientSecret, {
             clientId: this.clientId,
         });

package/lib/services/tunnel.d.ts

@@ -0,0 +1,28 @@
+import { client as WebSocketClient } from 'websocket';
+import { Region } from '../config';
+import Webhook, { WebhookTriggers } from '../models/webhook';
+import { WebhookDelta } from '../models/webhook-notification';
+export interface OpenWebhookTunnelOptions {
+    onMessage: (msg: WebhookDelta) => void;
+    onConnectFail?: (error: Error) => void;
+    onError?: (error: Error) => void;
+    onClose?: (wsClient: WebSocketClient) => void;
+    onConnect?: (wsClient: WebSocketClient) => void;
+    region?: Region;
+    triggers?: WebhookTriggers[];
+}
+/**
+ * Open a webhook tunnel and register it with the Nylas API
+ * 1. Creates a UUID
+ * 2. Opens a websocket connection to Nylas' webhook forwarding service,
+ *    with the UUID as a header
+ * 3. Creates a new webhook pointed at the forwarding service with the UUID as the path
+ *
+ * When an event is received by the forwarding service, it will push directly to this websocket
+ * connection
+ *
+ * @param config Configuration for the webhook tunnel, including callback functions,
+ * region, and events to subscribe to
+ * @return The webhook details response from the API
+ */
+export declare const openWebhookTunnel: (config: OpenWebhookTunnelOptions) => Promise<Webhook>;

package/lib/services/tunnel.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var websocket_1 = require("websocket");
+var uuid_1 = require("uuid");
+var config_1 = require("../config");
+var nylas_1 = __importDefault(require("../nylas"));
+var webhook_notification_1 = require("../models/webhook-notification");
+/**
+ * Create a webhook to the Nylas forwarding service which will pass messages to our websocket
+ * @param callbackDomain The domain name of the callback
+ * @param tunnelPath The path to the tunnel
+ * @param triggers The list of triggers to subscribe to
+ * @return The webhook details response from the API
+ */
+var buildTunnelWebhook = function (callbackDomain, tunnelPath, triggers) {
+    var callbackUrl = "https://" + callbackDomain + "/" + tunnelPath;
+    return nylas_1.default.webhooks
+        .build({
+        callbackUrl: callbackUrl,
+        state: 'active',
+        test: true,
+        triggers: triggers,
+    })
+        .save();
+};
+/**
+ * Open a webhook tunnel and register it with the Nylas API
+ * 1. Creates a UUID
+ * 2. Opens a websocket connection to Nylas' webhook forwarding service,
+ *    with the UUID as a header
+ * 3. Creates a new webhook pointed at the forwarding service with the UUID as the path
+ *
+ * When an event is received by the forwarding service, it will push directly to this websocket
+ * connection
+ *
+ * @param config Configuration for the webhook tunnel, including callback functions,
+ * region, and events to subscribe to
+ * @return The webhook details response from the API
+ */
+exports.openWebhookTunnel = function (config) {
+    var triggers = config.triggers || config_1.DEFAULT_WEBHOOK_TRIGGERS;
+    var region = config.region || config_1.DEFAULT_REGION;
+    var _a = config_1.regionConfig[region], websocketDomain = _a.websocketDomain, callbackDomain = _a.callbackDomain;
+    // This UUID will map our websocket to a webhook in the forwarding server
+    var tunnelId = uuid_1.v4();
+    var client = new websocket_1.client({ closeTimeout: 60000 });
+    client.on('connectFailed', function (error) {
+        config.onConnectFail && config.onConnectFail(error);
+    });
+    client.on('connect', function (connection) {
+        config.onConnect && config.onConnect(client);
+        connection.on('error', function (error) {
+            config.onError && config.onError(error);
+        });
+        connection.on('close', function () {
+            config.onClose && config.onClose(client);
+        });
+        connection.on('message', function (message) {
+            // This shouldn't happen. If any of these are seen, open an issue
+            if (message.type === 'binary') {
+                config.onError &&
+                    config.onError(new Error('Unknown binary message received'));
+                return;
+            }
+            try {
+                var req = JSON.parse(message.utf8Data);
+                var deltas = JSON.parse(req.body).deltas;
+                deltas.forEach(function (delta) {
+                    return config.onMessage(new webhook_notification_1.WebhookDelta().fromJSON(delta));
+                });
+            }
+            catch (e) {
+                config.onError &&
+                    config.onError(new Error("Error converting Nylas websocket event to JSON: " + (e &&
+                        e.message)));
+            }
+        });
+    });
+    client.connect("wss://" + websocketDomain, undefined, undefined, {
+        'Client-Id': nylas_1.default.clientId,
+        'Client-Secret': nylas_1.default.clientSecret,
+        'Tunnel-Id': tunnelId,
+        Region: region,
+    });
+    return buildTunnelWebhook(callbackDomain, tunnelId, triggers);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nylas",
-  "version": "6.7.0",
+  "version": "6.9.0",
   "description": "A NodeJS wrapper for the Nylas REST API for email, contacts, and calendar.",
   "main": "lib/nylas.js",
   "types": "lib/nylas.d.ts",
@@ -47,7 +47,9 @@
     "backoff": "^2.5.0",
     "form-data": "^4.0.0",
     "JSONStream": "^1.3.5",
-    "node-fetch": "^2.6.1"
+    "node-fetch": "^2.6.1",
+    "uuid": "^8.3.2",
+    "websocket": "^1.0.34"
   },
   "devDependencies": {
     "@babel/cli": "^7.13.16",
@@ -57,6 +59,8 @@
     "@types/backoff": "^2.5.1",
     "@types/jest": "^25.1.4",
     "@types/node-fetch": "^2.5.8",
+    "@types/uuid": "^8.3.4",
+    "@types/websocket": "^1.0.5",
     "@typescript-eslint/eslint-plugin": "^2.25.0",
     "@typescript-eslint/parser": "^2.25.0",
     "babel-eslint": "^10.0.1",