nylas 6.6.1 → 6.8.0

package/lib/config.d.ts

@@ -1,3 +1,4 @@
+import { WebhookTriggers } from './models/webhook';
 export declare let apiServer: string | null;
 export declare function setApiServer(newApiServer: string | null): void;
 export declare let clientSecret: string;
@@ -7,6 +8,10 @@ export declare type NylasConfig = {
     clientSecret: string;
     apiServer?: string;
 };
+export declare enum ResponseType {
+    CODE = "code",
+    TOKEN = "token"
+}
 export declare type AuthenticateUrlConfig = {
     redirectURI: string;
     redirectOnError?: boolean;
@@ -14,4 +19,27 @@ export declare type AuthenticateUrlConfig = {
     state?: string;
     provider?: string;
     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,3 +12,31 @@ function setClientSecret(newClientSecret) {
     exports.clientSecret = newClientSecret;
 }
 exports.setClientSecret = setClientSecret;
+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,9 +294,11 @@ 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',
-            readOnly: true,
         }), customerEventId: attributes_1.default.String({
             modelKey: 'customerEventId',
             jsonKey: 'customer_event_id',

package/lib/models/rate-limit-error.d.ts

@@ -0,0 +1,26 @@
+import NylasApiError from './nylas-api-error';
+import { Headers } from 'node-fetch';
+/**
+ * This error class represents a 429 error response, with details on the rate limit
+ */
+export default class RateLimitError extends NylasApiError {
+    static RATE_LIMIT_STATUS_CODE: number;
+    static RATE_LIMIT_LIMIT_HEADER: string;
+    static RATE_LIMIT_RESET_HEADER: string;
+    /**
+     * The rate limit
+     */
+    rateLimit?: number;
+    /**
+     * The rate limit expiration time, in seconds
+     */
+    rateLimitReset?: number;
+    constructor(type: string, message: string, rateLimit?: number, rateLimitReset?: number);
+    /**
+     * Parses an API response and generates a 429 error with details filled in
+     * @param parsedApiError The response parsed as a JSON
+     * @param headers The response headers
+     * @return The error with the rate limit details filled in
+     */
+    static parseErrorResponse(parsedApiError: Record<string, string>, headers: Headers): RateLimitError;
+}

package/lib/models/rate-limit-error.js

@@ -0,0 +1,47 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var nylas_api_error_1 = __importDefault(require("./nylas-api-error"));
+/**
+ * This error class represents a 429 error response, with details on the rate limit
+ */
+var RateLimitError = /** @class */ (function (_super) {
+    __extends(RateLimitError, _super);
+    function RateLimitError(type, message, rateLimit, rateLimitReset) {
+        var _this = _super.call(this, RateLimitError.RATE_LIMIT_STATUS_CODE, type, message) || this;
+        _this.rateLimit = rateLimit;
+        _this.rateLimitReset = rateLimitReset;
+        return _this;
+    }
+    /**
+     * Parses an API response and generates a 429 error with details filled in
+     * @param parsedApiError The response parsed as a JSON
+     * @param headers The response headers
+     * @return The error with the rate limit details filled in
+     */
+    RateLimitError.parseErrorResponse = function (parsedApiError, headers) {
+        var rateLimit = Number(headers.get(this.RATE_LIMIT_LIMIT_HEADER)) || undefined;
+        var rateLimitReset = Number(headers.get(this.RATE_LIMIT_RESET_HEADER)) || undefined;
+        return new RateLimitError(parsedApiError.type, parsedApiError.message, rateLimit, rateLimitReset);
+    };
+    RateLimitError.RATE_LIMIT_STATUS_CODE = 429;
+    RateLimitError.RATE_LIMIT_LIMIT_HEADER = 'X-RateLimit-Limit';
+    RateLimitError.RATE_LIMIT_RESET_HEADER = 'X-RateLimit-Reset';
+    return RateLimitError;
+}(nylas_api_error_1.default));
+exports.default = RateLimitError;

package/lib/models/webhook-notification.d.ts

@@ -76,6 +76,8 @@ export declare class WebhookObjectAttributes extends Model implements WebhookObj
     extras?: WebhookObjectExtrasProperties;
     threadId?: string;
     receivedDate?: Date;
+    calendarId?: string;
+    createdBeforeAccountConnection?: boolean;
     static attributes: Record<string, Attribute>;
     constructor(props?: WebhookObjectAttributesProperties);
 }
@@ -84,7 +86,7 @@ export declare type WebhookObjectDataProperties = {
     accountId: string;
     namespaceId: string;
     object: string;
-    metadata?: MessageTrackingDataProperties;
+    metadata?: MessageTrackingDataProperties | Record<string, unknown>;
     objectAttributes?: WebhookObjectAttributesProperties;
 };
 export declare class WebhookObjectData extends Model implements WebhookObjectDataProperties {
@@ -92,10 +94,11 @@ export declare class WebhookObjectData extends Model implements WebhookObjectDat
     accountId: string;
     namespaceId: string;
     object: string;
-    metadata?: MessageTrackingData;
+    metadata?: MessageTrackingData | Record<string, unknown>;
     objectAttributes?: WebhookObjectAttributes;
     static attributes: Record<string, Attribute>;
     constructor(props?: WebhookObjectDataProperties);
+    fromJSON(json: Record<string, unknown>): this;
 }
 export declare type WebhookDeltaProperties = {
     object: string;

package/lib/models/webhook-notification.js

@@ -168,10 +168,18 @@ var WebhookObjectAttributes = /** @class */ (function (_super) {
             modelKey: 'threadId',
             jsonKey: 'thread_id',
         }),
+        calendarId: attributes_1.default.String({
+            modelKey: 'calendarId',
+            jsonKey: 'calendar_id',
+        }),
         receivedDate: attributes_1.default.DateTime({
             modelKey: 'receivedDate',
             jsonKey: 'received_date',
         }),
+        createdBeforeAccountConnection: attributes_1.default.Boolean({
+            modelKey: 'createdBeforeAccountConnection',
+            jsonKey: 'created_before_account_connection',
+        }),
         extras: attributes_1.default.Object({
             modelKey: 'extras',
             itemClass: WebhookObjectExtras,
@@ -189,8 +197,20 @@ var WebhookObjectData = /** @class */ (function (_super) {
         _this.namespaceId = '';
         _this.object = '';
         _this.initAttributes(props);
+        if (_this.metadata &&
+            (_this.object === 'message' || _this.object === 'thread')) {
+            _this.metadata = new MessageTrackingData(_this.metadata);
+        }
         return _this;
     }
+    WebhookObjectData.prototype.fromJSON = function (json) {
+        var notification = _super.prototype.fromJSON.call(this, json);
+        if (notification.metadata &&
+            (notification.object === 'message' || notification.object === 'thread')) {
+            notification.metadata = new MessageTrackingData().fromJSON(json['metadata']);
+        }
+        return notification;
+    };
     WebhookObjectData.attributes = {
         id: attributes_1.default.String({
             modelKey: 'id',
@@ -208,7 +228,6 @@ var WebhookObjectData = /** @class */ (function (_super) {
         }),
         metadata: attributes_1.default.Object({
             modelKey: 'metadata',
-            itemClass: MessageTrackingData,
         }),
         objectAttributes: attributes_1.default.Object({
             modelKey: 'objectAttributes',

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/nylas-connection.js

@@ -45,6 +45,7 @@ var message_restful_model_collection_1 = __importDefault(require("./models/messa
 var delta_collection_1 = __importDefault(require("./models/delta-collection"));
 var outbox_1 = __importDefault(require("./models/outbox"));
 var job_status_restful_model_collection_1 = __importDefault(require("./models/job-status-restful-model-collection"));
+var rate_limit_error_1 = __importDefault(require("./models/rate-limit-error"));
 var PACKAGE_JSON = require('../package.json');
 var SDK_VERSION = PACKAGE_JSON.version;
 var SUPPORTED_API_VERSION = '2.5';
@@ -196,7 +197,13 @@ var NylasConnection = /** @class */ (function () {
                     return response.text().then(function (body) {
                         try {
                             var parsedApiError = JSON.parse(body);
-                            var error = new nylas_api_error_1.default(response.status, parsedApiError.type, parsedApiError.message);
+                            var error = void 0;
+                            if (response.status === rate_limit_error_1.default.RATE_LIMIT_STATUS_CODE) {
+                                error = rate_limit_error_1.default.parseErrorResponse(parsedApiError, response.headers);
+                            }
+                            else {
+                                error = new nylas_api_error_1.default(response.status, parsedApiError.type, parsedApiError.message);
+                            }
                             if (parsedApiError.missing_fields) {
                                 error.missingFields = parsedApiError.missing_fields;
                             }

package/lib/nylas.js

@@ -20,6 +20,7 @@ var connect_1 = __importDefault(require("./models/connect"));
 var restful_model_collection_1 = __importDefault(require("./models/restful-model-collection"));
 var management_model_collection_1 = __importDefault(require("./models/management-model-collection"));
 var webhook_1 = __importDefault(require("./models/webhook"));
+var config_1 = require("./config");
 var access_token_1 = __importDefault(require("./models/access-token"));
 var application_details_1 = __importDefault(require("./models/application-details"));
 var Nylas = /** @class */ (function () {
@@ -153,7 +154,7 @@ var Nylas = /** @class */ (function () {
         if (!options.loginHint) {
             options.loginHint = '';
         }
-        var url = this.apiServer + "/oauth/authorize?client_id=" + this.clientId + "&response_type=code&login_hint=" + options.loginHint + "&redirect_uri=" + options.redirectURI;
+        var url = this.apiServer + "/oauth/authorize?client_id=" + this.clientId + "&response_type=" + (options.responseType || config_1.ResponseType.CODE) + "&login_hint=" + options.loginHint + "&redirect_uri=" + options.redirectURI;
         if (options.state != null) {
             url += "&state=" + options.state;
         }

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.6.1",
+  "version": "6.8.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",