nylas 5.8.0

package/lib/models/contact.js

@@ -0,0 +1,245 @@
+"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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contact = exports.Group = exports.WebPage = exports.PhoneNumber = exports.EmailAddress = void 0;
+var restful_model_1 = __importDefault(require("./restful-model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var EmailAddress = /** @class */ (function (_super) {
+    __extends(EmailAddress, _super);
+    function EmailAddress() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EmailAddress.prototype.toJSON = function () {
+        return {
+            type: this.type,
+            email: this.email,
+        };
+    };
+    return EmailAddress;
+}(restful_model_1.default));
+exports.EmailAddress = EmailAddress;
+EmailAddress.collectionName = 'email_addresses';
+EmailAddress.attributes = __assign(__assign({}, restful_model_1.default.attributes), { type: attributes_1.default.String({
+        modelKey: 'type',
+    }), email: attributes_1.default.String({
+        modelKey: 'email',
+    }) });
+var IMAddress = /** @class */ (function (_super) {
+    __extends(IMAddress, _super);
+    function IMAddress() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    IMAddress.prototype.toJSON = function () {
+        return {
+            type: this.type,
+            im_address: this.imAddress,
+        };
+    };
+    return IMAddress;
+}(restful_model_1.default));
+IMAddress.collectionName = 'im_addresses';
+IMAddress.attributes = __assign(__assign({}, restful_model_1.default.attributes), { type: attributes_1.default.String({
+        modelKey: 'type',
+    }), imAddress: attributes_1.default.String({
+        modelKey: 'imAddress',
+        jsonKey: 'im_address',
+    }) });
+var PhysicalAddress = /** @class */ (function (_super) {
+    __extends(PhysicalAddress, _super);
+    function PhysicalAddress() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PhysicalAddress.prototype.toJSON = function () {
+        var json = {
+            type: this.type,
+            format: this.format,
+        };
+        if (this.format == 'unstructured') {
+            json.address = this.address;
+        }
+        else {
+            json.street_address = this.streetAddress;
+            json.postal_code = this.postalCode;
+            json.state = this.state;
+            json.city = this.city;
+            json.country = this.country;
+        }
+        return json;
+    };
+    return PhysicalAddress;
+}(restful_model_1.default));
+PhysicalAddress.collectionName = 'physical_addresses';
+PhysicalAddress.attributes = __assign(__assign({}, restful_model_1.default.attributes), { type: attributes_1.default.String({
+        modelKey: 'type',
+    }), format: attributes_1.default.String({
+        modelKey: 'format',
+    }), address: attributes_1.default.String({
+        modelKey: 'address',
+    }), streetAddress: attributes_1.default.String({
+        modelKey: 'streetAddress',
+        jsonKey: 'street_address',
+    }), city: attributes_1.default.String({
+        modelKey: 'city',
+    }), postalCode: attributes_1.default.String({
+        modelKey: 'postalCode',
+        jsonKey: 'postal_code',
+    }), state: attributes_1.default.String({
+        modelKey: 'state',
+    }), country: attributes_1.default.String({
+        modelKey: 'country',
+    }) });
+var PhoneNumber = /** @class */ (function (_super) {
+    __extends(PhoneNumber, _super);
+    function PhoneNumber() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PhoneNumber.prototype.toJSON = function () {
+        return {
+            type: this.type,
+            number: this.number,
+        };
+    };
+    return PhoneNumber;
+}(restful_model_1.default));
+exports.PhoneNumber = PhoneNumber;
+PhoneNumber.collectionName = 'phone_numbers';
+PhoneNumber.attributes = __assign(__assign({}, restful_model_1.default.attributes), { type: attributes_1.default.String({
+        modelKey: 'type',
+    }), number: attributes_1.default.String({
+        modelKey: 'number',
+    }) });
+var WebPage = /** @class */ (function (_super) {
+    __extends(WebPage, _super);
+    function WebPage() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WebPage.prototype.toJSON = function () {
+        var json = {
+            type: this.type,
+            url: this.url,
+        };
+        return json;
+    };
+    return WebPage;
+}(restful_model_1.default));
+exports.WebPage = WebPage;
+WebPage.collectionName = 'web_pages';
+WebPage.attributes = __assign(__assign({}, restful_model_1.default.attributes), { type: attributes_1.default.String({
+        modelKey: 'type',
+    }), url: attributes_1.default.String({
+        modelKey: 'url',
+    }) });
+var Group = /** @class */ (function (_super) {
+    __extends(Group, _super);
+    function Group() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Group;
+}(restful_model_1.default));
+exports.Group = Group;
+Group.collectionName = 'groups';
+Group.attributes = __assign(__assign({}, restful_model_1.default.attributes), { name: attributes_1.default.String({
+        modelKey: 'name',
+    }), path: attributes_1.default.String({
+        modelKey: 'path',
+    }) });
+var Contact = /** @class */ (function (_super) {
+    __extends(Contact, _super);
+    function Contact() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Contact.prototype.save = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        return this._save(params, callback);
+    };
+    Contact.prototype.getPicture = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        return this._get(params, callback, '/picture');
+    };
+    return Contact;
+}(restful_model_1.default));
+exports.Contact = Contact;
+Contact.collectionName = 'contacts';
+Contact.attributes = __assign(__assign({}, restful_model_1.default.attributes), { givenName: attributes_1.default.String({
+        modelKey: 'givenName',
+        jsonKey: 'given_name',
+    }), middleName: attributes_1.default.String({
+        modelKey: 'middleName',
+        jsonKey: 'middle_name',
+    }), surname: attributes_1.default.String({
+        modelKey: 'surname',
+    }), suffix: attributes_1.default.String({
+        modelKey: 'suffix',
+    }), nickname: attributes_1.default.String({
+        modelKey: 'nickname',
+    }), birthday: attributes_1.default.String({
+        modelKey: 'birthday',
+    }), companyName: attributes_1.default.String({
+        modelKey: 'companyName',
+        jsonKey: 'company_name',
+    }), jobTitle: attributes_1.default.String({
+        modelKey: 'jobTitle',
+        jsonKey: 'job_title',
+    }), managerName: attributes_1.default.String({
+        modelKey: 'managerName',
+        jsonKey: 'manager_name',
+    }), officeLocation: attributes_1.default.String({
+        modelKey: 'officeLocation',
+        jsonKey: 'office_location',
+    }), notes: attributes_1.default.String({
+        modelKey: 'notes',
+    }), pictureUrl: attributes_1.default.String({
+        modelKey: 'pictureUrl',
+        jsonKey: 'picture_url',
+    }), emailAddresses: attributes_1.default.Collection({
+        modelKey: 'emailAddresses',
+        jsonKey: 'emails',
+        itemClass: EmailAddress,
+    }), imAddresses: attributes_1.default.Collection({
+        modelKey: 'imAddresses',
+        jsonKey: 'im_addresses',
+        itemClass: IMAddress,
+    }), physicalAddresses: attributes_1.default.Collection({
+        modelKey: 'physicalAddresses',
+        jsonKey: 'physical_addresses',
+        itemClass: PhysicalAddress,
+    }), phoneNumbers: attributes_1.default.Collection({
+        modelKey: 'phoneNumbers',
+        jsonKey: 'phone_numbers',
+        itemClass: PhoneNumber,
+    }), webPages: attributes_1.default.Collection({
+        modelKey: 'webPages',
+        jsonKey: 'web_pages',
+        itemClass: WebPage,
+    }), groups: attributes_1.default.Collection({
+        modelKey: 'groups',
+        itemClass: Group,
+    }), source: attributes_1.default.String({
+        modelKey: 'source',
+    }) });

package/lib/models/delta-stream.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import NylasConnection from '../nylas-connection';
+import { Request } from 'node-fetch';
+import AbortController from 'abort-controller';
+import backoff from 'backoff';
+export default class DeltaStream extends EventEmitter {
+    static MAX_RESTART_RETRIES: number;
+    connection: NylasConnection;
+    cursor?: string;
+    params: {
+        includeTypes?: string[];
+        excludeTypes?: string[];
+        expanded?: boolean;
+    };
+    requestInfo?: {
+        request: Request;
+        controller: AbortController;
+    };
+    restartBackoff: backoff.Backoff;
+    timeoutId?: number;
+    constructor(connection: NylasConnection, cursor: string, params?: {
+        [key: string]: any;
+    });
+    close(): void;
+    open(): Promise<any>;
+    _onDataReceived(): void;
+    _onError(err: Error): void;
+    _restartConnection(n: number): Promise<any>;
+}

package/lib/models/delta-stream.js

@@ -0,0 +1,225 @@
+"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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+A connection to the Nylas delta streaming API.
+
+Emits the following events:
+- `response` when the connection is established, with one argument, a `http.IncomingMessage`
+- `delta` for each delta received
+- `error` when an error occurs in the connection
+- `info` when the connection status changes
+*/
+var events_1 = require("events");
+var nylas_connection_1 = __importDefault(require("../nylas-connection"));
+var node_fetch_1 = __importDefault(require("node-fetch"));
+var abort_controller_1 = __importDefault(require("abort-controller"));
+var backoff_1 = __importDefault(require("backoff"));
+var JSONStream_1 = __importDefault(require("JSONStream"));
+var delta_1 = __importDefault(require("./delta"));
+var DeltaStream = /** @class */ (function (_super) {
+    __extends(DeltaStream, _super);
+    // @param {string} cursor Nylas delta API cursor
+    // @param {Object} params object contianing query string params to be passed to  the request
+    // @param {Array<string>} params.excludeTypes object types to not return deltas for (e.g., {excludeTypes: ['thread']})
+    // @param {Array<string>} params.includeTypes object types to exclusively return deltas for (e.g., {includeTypes: ['thread']})
+    // @param {boolean} params.expanded boolean to specify wether to request the expanded view
+    function DeltaStream(connection, cursor, params) {
+        if (params === void 0) { params = {}; }
+        var _this = _super.call(this) || this;
+        _this.restartBackoff = backoff_1.default.exponential({
+            randomisationFactor: 0.5,
+            initialDelay: 250,
+            maxDelay: 30000,
+            factor: 4,
+        });
+        _this.connection = connection;
+        _this.cursor = cursor;
+        _this.params = params;
+        if (!(_this.connection instanceof nylas_connection_1.default)) {
+            throw new Error('Connection object not provided');
+        }
+        _this.restartBackoff.failAfter(DeltaStream.MAX_RESTART_RETRIES);
+        _this.restartBackoff
+            .on('backoff', _this._restartConnection.bind(_this))
+            .on('fail', function () {
+            return _this.emit('error', "Nylas DeltaStream failed to reconnect after\n          " + DeltaStream.MAX_RESTART_RETRIES + "\n          retries.");
+        });
+        return _this;
+    }
+    DeltaStream.prototype.close = function () {
+        clearTimeout(this.timeoutId);
+        delete this.timeoutId;
+        this.restartBackoff.reset();
+        if (this.requestInfo) {
+            this.requestInfo.controller.abort();
+        }
+        delete this.requestInfo;
+    };
+    DeltaStream.prototype.open = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var path, _a, _b, excludeTypes, _c, includeTypes, params, queryObj, request, controller, response, error_1;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this.close();
+                        path = '/delta/streaming';
+                        _a = this.params, _b = _a.excludeTypes, excludeTypes = _b === void 0 ? [] : _b, _c = _a.includeTypes, includeTypes = _c === void 0 ? [] : _c, params = __rest(_a, ["excludeTypes", "includeTypes"]);
+                        queryObj = __assign(__assign({}, params), { cursor: this.cursor });
+                        if (excludeTypes.length > 0) {
+                            queryObj.exclude_types = excludeTypes.join(',');
+                        }
+                        if (includeTypes.length > 0) {
+                            queryObj.include_types = includeTypes.join(',');
+                        }
+                        request = this.connection.newRequest({
+                            method: 'GET',
+                            path: path,
+                            qs: queryObj,
+                        });
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        controller = new abort_controller_1.default();
+                        this.requestInfo = {
+                            request: request,
+                            controller: controller,
+                        };
+                        return [4 /*yield*/, node_fetch_1.default(request, { signal: controller.signal })];
+                    case 2:
+                        response = _d.sent();
+                        if (response.status !== 200) {
+                            response.body.on('data', function (data) {
+                                var err = data;
+                                try {
+                                    err = JSON.parse(err);
+                                }
+                                catch (e) {
+                                    // Do nothing
+                                }
+                                // Do nothing, keep err as string.
+                                return _this._onError(err);
+                            });
+                            return [2 /*return*/];
+                        }
+                        // Successfully established connection
+                        this.emit('response', response);
+                        this._onDataReceived();
+                        return [2 /*return*/, (response.body
+                                .on('data', this._onDataReceived.bind(this))
+                                // Each data block received may not be a complete JSON object. Pipe through
+                                // JSONStream.parse(), which handles converting data blocks to JSON objects.
+                                .pipe(JSONStream_1.default.parse())
+                                .on('data', function (obj) {
+                                if (obj.cursor) {
+                                    _this.cursor = obj.cursor;
+                                }
+                                return _this.emit('delta', obj);
+                            }))];
+                    case 3:
+                        error_1 = _d.sent();
+                        this._onError(error_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DeltaStream.prototype._onDataReceived = function () {
+        // Nylas sends a newline heartbeat in the raw data stream once every 5 seconds.
+        // Automatically restart the connection if we haven't gotten any data in
+        // Delta.streamingTimeoutMs. The connection will restart with the last
+        // received cursor.
+        clearTimeout(this.timeoutId);
+        this.restartBackoff.reset();
+        this.timeoutId = setTimeout(this.restartBackoff.backoff.bind(this.restartBackoff), delta_1.default.streamingTimeoutMs);
+    };
+    DeltaStream.prototype._onError = function (err) {
+        this.emit('error', err);
+        return this.restartBackoff.reset();
+    };
+    DeltaStream.prototype._restartConnection = function (n) {
+        this.emit('info', "Restarting Nylas DeltaStream connection (attempt " + (n + 1) + "): " + (this.requestInfo != null ? this.requestInfo.request.url : undefined));
+        this.close();
+        return this.open();
+    };
+    // Max number of times to retry a connection if we receive no data heartbeats
+    // from the Nylas server.
+    DeltaStream.MAX_RESTART_RETRIES = 5;
+    return DeltaStream;
+}(events_1.EventEmitter));
+exports.default = DeltaStream;