nylas 5.8.0

package/lib/nylas-connection.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+import { URL } from 'url';
+import { Request } from 'node-fetch';
+import RestfulModelCollection from './models/restful-model-collection';
+import CalendarRestfulModelCollection from './models/calendar-restful-model-collection';
+import ContactRestfulModelCollection from './models/contact-restful-model-collection';
+import RestfulModelInstance from './models/restful-model-instance';
+import Account from './models/account';
+import Thread from './models/thread';
+import Message from './models/message';
+import Draft from './models/draft';
+import File from './models/file';
+import Event from './models/event';
+import JobStatus from './models/job-status';
+import Resource from './models/resource';
+import Delta from './models/delta';
+import { Folder, Label } from './models/folder';
+import { AppendOptions } from 'form-data';
+import Neural from './models/neural';
+export declare type RequestOptions = {
+    path: string;
+    method?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    qs?: {
+        [key: string]: any;
+    };
+    downloadRequest?: boolean;
+    json?: boolean;
+    formData?: {
+        [key: string]: FormDataType;
+    };
+    body?: any;
+    url?: URL;
+};
+export declare type FormDataType = {
+    value: any;
+    options?: {
+        [key: string]: any;
+    } | AppendOptions;
+};
+export default class NylasConnection {
+    accessToken: string | null | undefined;
+    clientId: string | null | undefined;
+    threads: RestfulModelCollection<Thread>;
+    contacts: ContactRestfulModelCollection;
+    messages: RestfulModelCollection<Message>;
+    drafts: RestfulModelCollection<Draft>;
+    files: RestfulModelCollection<File>;
+    calendars: CalendarRestfulModelCollection;
+    jobStatuses: RestfulModelCollection<JobStatus>;
+    events: RestfulModelCollection<Event>;
+    resources: RestfulModelCollection<Resource>;
+    deltas: Delta;
+    labels: RestfulModelCollection<Label>;
+    folders: RestfulModelCollection<Folder>;
+    account: RestfulModelInstance<Account>;
+    neural: Neural;
+    constructor(accessToken: string | null | undefined, { clientId }: {
+        clientId: string | null | undefined;
+    });
+    requestOptions(options: RequestOptions): RequestOptions;
+    newRequest(options: RequestOptions): Request;
+    _getWarningForVersion(sdkApiVersion?: string, apiVersion?: string): string;
+    request(options: RequestOptions): Promise<any>;
+}

package/lib/nylas-connection.js

@@ -0,0 +1,235 @@
+"use strict";
+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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, 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");
+var node_fetch_1 = __importStar(require("node-fetch"));
+var config = __importStar(require("./config"));
+var restful_model_collection_1 = __importDefault(require("./models/restful-model-collection"));
+var calendar_restful_model_collection_1 = __importDefault(require("./models/calendar-restful-model-collection"));
+var contact_restful_model_collection_1 = __importDefault(require("./models/contact-restful-model-collection"));
+var restful_model_instance_1 = __importDefault(require("./models/restful-model-instance"));
+var account_1 = __importDefault(require("./models/account"));
+var thread_1 = __importDefault(require("./models/thread"));
+var message_1 = __importDefault(require("./models/message"));
+var draft_1 = __importDefault(require("./models/draft"));
+var file_1 = __importDefault(require("./models/file"));
+var event_1 = __importDefault(require("./models/event"));
+var job_status_1 = __importDefault(require("./models/job-status"));
+var resource_1 = __importDefault(require("./models/resource"));
+var delta_1 = __importDefault(require("./models/delta"));
+var folder_1 = require("./models/folder");
+var form_data_1 = __importDefault(require("form-data"));
+var neural_1 = __importDefault(require("./models/neural"));
+var nylas_api_error_1 = __importDefault(require("./models/nylas-api-error"));
+var PACKAGE_JSON = require('../package.json');
+var SDK_VERSION = PACKAGE_JSON.version;
+var SUPPORTED_API_VERSION = '2.3';
+var NylasConnection = /** @class */ (function () {
+    function NylasConnection(accessToken, _a) {
+        var clientId = _a.clientId;
+        this.threads = new restful_model_collection_1.default(thread_1.default, this);
+        this.contacts = new contact_restful_model_collection_1.default(this);
+        this.messages = new restful_model_collection_1.default(message_1.default, this);
+        this.drafts = new restful_model_collection_1.default(draft_1.default, this);
+        this.files = new restful_model_collection_1.default(file_1.default, this);
+        this.calendars = new calendar_restful_model_collection_1.default(this);
+        this.jobStatuses = new restful_model_collection_1.default(job_status_1.default, this);
+        this.events = new restful_model_collection_1.default(event_1.default, this);
+        this.resources = new restful_model_collection_1.default(resource_1.default, this);
+        this.deltas = new delta_1.default(this);
+        this.labels = new restful_model_collection_1.default(folder_1.Label, this);
+        this.folders = new restful_model_collection_1.default(folder_1.Folder, this);
+        this.account = new restful_model_instance_1.default(account_1.default, this);
+        this.neural = new neural_1.default(this);
+        this.accessToken = accessToken;
+        this.clientId = clientId;
+    }
+    NylasConnection.prototype.requestOptions = function (options) {
+        var url = new url_1.URL("" + config.apiServer + options.path);
+        // map querystring to search params
+        if (options.qs) {
+            for (var _i = 0, _a = Object.entries(options.qs); _i < _a.length; _i++) {
+                var _b = _a[_i], key = _b[0], value = _b[1];
+                // For convenience, If `expanded` param is provided, convert to view:
+                // 'expanded' api option
+                if (key === 'expanded') {
+                    if (value === true) {
+                        url.searchParams.set('view', 'expanded');
+                    }
+                }
+                else if (key == 'metadata_pair') {
+                    // The API understands a metadata_pair filter in the form of:
+                    // <key>:<value>
+                    for (var item in value) {
+                        url.searchParams.set('metadata_pair', item + ":" + value[item]);
+                    }
+                }
+                else if (Array.isArray(value)) {
+                    for (var _c = 0, value_1 = value; _c < value_1.length; _c++) {
+                        var item = value_1[_c];
+                        url.searchParams.append(key, item);
+                    }
+                }
+                else {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        options.url = url;
+        var headers = __assign({}, options.headers);
+        var user = options.path.substr(0, 3) === '/a/'
+            ? config.clientSecret
+            : this.accessToken;
+        if (user) {
+            headers['authorization'] =
+                'Basic ' + Buffer.from(user + ":", 'utf8').toString('base64');
+        }
+        if (!headers['User-Agent']) {
+            headers['User-Agent'] = "Nylas Node SDK v" + SDK_VERSION;
+        }
+        headers['Nylas-API-Version'] = SUPPORTED_API_VERSION;
+        headers['Nylas-SDK-API-Version'] = SUPPORTED_API_VERSION;
+        if (this.clientId != null) {
+            headers['X-Nylas-Client-Id'] = this.clientId;
+        }
+        options.headers = headers;
+        if (options.formData) {
+            var fd = new form_data_1.default();
+            for (var _d = 0, _e = Object.entries(options.formData); _d < _e.length; _d++) {
+                var _f = _e[_d], key = _f[0], obj = _f[1];
+                if (obj.options) {
+                    fd.append(key, obj.value, obj.options);
+                }
+                else {
+                    fd.append(key, obj.value);
+                }
+            }
+            options.body = fd;
+        }
+        else if (options.body && options.json !== false) {
+            options.body = JSON.stringify(options.body);
+        }
+        return options;
+    };
+    NylasConnection.prototype.newRequest = function (options) {
+        var newOptions = this.requestOptions(options);
+        return new node_fetch_1.Request(newOptions.url || '', {
+            method: newOptions.method || 'GET',
+            headers: newOptions.headers,
+            body: newOptions.body,
+        });
+    };
+    NylasConnection.prototype._getWarningForVersion = function (sdkApiVersion, apiVersion) {
+        var warning = '';
+        if (sdkApiVersion != apiVersion) {
+            if (sdkApiVersion && apiVersion) {
+                warning +=
+                    "WARNING: SDK version may not support your Nylas API version." +
+                        (" SDK supports version " + sdkApiVersion + " of the API and your application") +
+                        (" is currently running on version " + apiVersion + " of the API.");
+                var apiNum = parseInt(apiVersion.split('-')[0]);
+                var sdkNum = parseInt(sdkApiVersion.split('-')[0]);
+                if (sdkNum > apiNum) {
+                    warning += " Please update the version of the API that your application is using through the developer dashboard.";
+                }
+                else if (apiNum > sdkNum) {
+                    warning += " Please update the sdk to ensure it works properly.";
+                }
+            }
+        }
+        return warning;
+    };
+    NylasConnection.prototype.request = function (options) {
+        var _this = this;
+        var req = this.newRequest(options);
+        return new Promise(function (resolve, reject) {
+            return node_fetch_1.default(req)
+                .then(function (response) {
+                if (typeof response === 'undefined') {
+                    return reject(new Error('No response'));
+                }
+                // node headers are lowercaser so this refers to `Nylas-Api-Version`
+                var apiVersion = response.headers.get('nylas-api-version');
+                var warning = _this._getWarningForVersion(SUPPORTED_API_VERSION, apiVersion);
+                if (warning) {
+                    console.warn(warning);
+                }
+                if (response.status > 299) {
+                    return response.json().then(function (body) {
+                        var error = new nylas_api_error_1.default(response.status, body.type, body.message);
+                        if (body.missing_fields) {
+                            error.missingFields = body.missing_fields;
+                        }
+                        if (body.server_error) {
+                            error.serverError = body.server_error;
+                        }
+                        return reject(error);
+                    });
+                }
+                else {
+                    if (options.downloadRequest) {
+                        response
+                            .buffer()
+                            .then(function (buffer) {
+                            // Return an object with the headers and the body as a buffer
+                            var fileDetails = {};
+                            response.headers.forEach(function (v, k) {
+                                fileDetails[k] = v;
+                            });
+                            fileDetails['body'] = buffer;
+                            return resolve(fileDetails);
+                        })
+                            .catch(function (e) {
+                            return reject(e);
+                        });
+                    }
+                    else if (response.headers.get('Content-Type') === 'message/rfc822') {
+                        return resolve(response.text());
+                    }
+                    else {
+                        return resolve(response.json());
+                    }
+                }
+            })
+                .catch(function (err) {
+                console.error("Error encountered during request:\n" + err.stack);
+                return reject(err);
+            });
+        });
+    };
+    return NylasConnection;
+}());
+exports.default = NylasConnection;

package/lib/nylas.d.ts

@@ -0,0 +1,38 @@
+import NylasConnection from './nylas-connection';
+import ManagementAccount from './models/management-account';
+import Account from './models/account';
+import Connect from './models/connect';
+import RestfulModelCollection from './models/restful-model-collection';
+import ManagementModelCollection from './models/management-model-collection';
+import Webhook from './models/webhook';
+declare class Nylas {
+    static clientId: string;
+    static get clientSecret(): string;
+    static set clientSecret(newClientSecret: string);
+    static get apiServer(): string | null;
+    static set apiServer(newApiServer: string | null);
+    static accounts?: ManagementModelCollection<ManagementAccount> | RestfulModelCollection<Account>;
+    static connect?: Connect;
+    static webhooks?: ManagementModelCollection<Webhook>;
+    static config({ clientId, clientSecret, apiServer, }: {
+        clientId: string;
+        clientSecret: string;
+        apiServer?: string;
+    }): typeof Nylas;
+    static clientCredentials(): boolean;
+    static with(accessToken: string): NylasConnection;
+    static application(options?: {
+        application_name?: string;
+        redirect_uris?: string[];
+        applicationName?: string;
+        redirectUris?: string[];
+    }): Promise<any>;
+    static exchangeCodeForToken(code: string, callback?: (error: Error | null, accessToken?: string) => void): Promise<any>;
+    static urlForAuthentication(options?: {
+        redirectURI?: string;
+        loginHint?: string;
+        state?: string;
+        scopes?: string[];
+    }): string;
+}
+export = Nylas;

package/lib/nylas.js

@@ -0,0 +1,178 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+// TODO since node 10 URL is global
+var url_1 = require("url");
+var node_fetch_1 = __importDefault(require("node-fetch"));
+var config = __importStar(require("./config"));
+var nylas_connection_1 = __importDefault(require("./nylas-connection"));
+var management_account_1 = __importDefault(require("./models/management-account"));
+var account_1 = __importDefault(require("./models/account"));
+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 Nylas = /** @class */ (function () {
+    function Nylas() {
+    }
+    Object.defineProperty(Nylas, "clientSecret", {
+        get: function () {
+            return config.clientSecret;
+        },
+        set: function (newClientSecret) {
+            config.setClientSecret(newClientSecret);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Nylas, "apiServer", {
+        get: function () {
+            return config.apiServer;
+        },
+        set: function (newApiServer) {
+            config.setApiServer(newApiServer);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Nylas.config = function (_a) {
+        var clientId = _a.clientId, clientSecret = _a.clientSecret, apiServer = _a.apiServer;
+        if (apiServer && apiServer.indexOf('://') === -1) {
+            throw new Error('Please specify a fully qualified URL for the API Server.');
+        }
+        if (clientId) {
+            this.clientId = clientId;
+        }
+        if (clientSecret) {
+            this.clientSecret = clientSecret;
+        }
+        if (apiServer) {
+            this.apiServer = apiServer;
+        }
+        else {
+            this.apiServer = 'https://api.nylas.com';
+        }
+        var conn = new nylas_connection_1.default(this.clientSecret, {
+            clientId: this.clientId,
+        });
+        this.connect = new connect_1.default(conn, this.clientId, this.clientSecret);
+        this.webhooks = new management_model_collection_1.default(webhook_1.default, conn, this.clientId);
+        if (this.clientCredentials()) {
+            this.accounts = new management_model_collection_1.default(management_account_1.default, conn, this.clientId);
+        }
+        else {
+            this.accounts = new restful_model_collection_1.default(account_1.default, conn);
+        }
+        return this;
+    };
+    Nylas.clientCredentials = function () {
+        return this.clientId != null && this.clientSecret != null;
+    };
+    Nylas.with = function (accessToken) {
+        if (!accessToken) {
+            throw new Error('This function requires an access token');
+        }
+        return new nylas_connection_1.default(accessToken, { clientId: this.clientId });
+    };
+    //TODO::Deprecate the camel case property in the next major release
+    Nylas.application = function (options) {
+        if (!this.clientId) {
+            throw new Error('This function requires a clientId');
+        }
+        if (!this.clientSecret) {
+            throw new Error('This function requires a clientSecret');
+        }
+        var connection = new nylas_connection_1.default(null, { clientId: this.clientId });
+        var requestOptions = {
+            path: "/a/" + this.clientId,
+        };
+        if (options) {
+            requestOptions.body = {
+                application_name: options.applicationName || options.application_name,
+                redirect_uris: options.redirectUris || options.redirect_uris,
+            };
+            requestOptions.method = 'PUT';
+        }
+        return connection.request(requestOptions);
+    };
+    Nylas.exchangeCodeForToken = function (code, callback) {
+        if (!this.clientId || !this.clientSecret) {
+            throw new Error('exchangeCodeForToken() cannot be called until you provide a clientId and secret via config()');
+        }
+        if (!code) {
+            throw new Error('exchangeCodeForToken() must be called with a code');
+        }
+        var url = new url_1.URL(this.apiServer + "/oauth/token");
+        url.searchParams.set('client_id', this.clientId);
+        url.searchParams.set('client_secret', this.clientSecret);
+        url.searchParams.set('grant_type', 'authorization_code');
+        url.searchParams.set('code', code);
+        return node_fetch_1.default(url)
+            .then(function (response) {
+            if (response.ok) {
+                return response.json();
+            }
+        })
+            .then(function (body) {
+            if (!body || !body['access_token']) {
+                var errorMessage = 'No access token in response';
+                if (body && body.message)
+                    errorMessage = body.message;
+                throw new Error(errorMessage);
+            }
+            if (callback) {
+                callback(null, body['access_token']);
+            }
+            return body['access_token'];
+        }, function (error) {
+            var newError = new Error(error.message);
+            if (callback) {
+                callback(newError);
+            }
+            throw newError;
+        });
+    };
+    Nylas.urlForAuthentication = function (options) {
+        if (options === void 0) { options = {}; }
+        if (!this.clientId) {
+            throw new Error('urlForAuthentication() cannot be called until you provide a clientId via config()');
+        }
+        if (!options.redirectURI) {
+            throw new Error('urlForAuthentication() requires options.redirectURI');
+        }
+        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;
+        if (options.state != null) {
+            url += "&state=" + options.state;
+        }
+        if (options.scopes != null) {
+            url += "&scopes=" + options.scopes.join(',');
+        }
+        return url;
+    };
+    Nylas.clientId = '';
+    return Nylas;
+}());
+module.exports = Nylas;