nylas 5.8.0

package/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+----
+
+Copyright (c) 2014-2015 InboxApp, Inc. and Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# Nylas Node.js SDK  
+
+[![Travis build status](https://travis-ci.org/nylas/nylas-nodejs.svg?branch=master)](https://travis-ci.org/nylas/nylas-nodejs)
+
+This is the GitHub repository for the Nylas Node SDK and this repo is primarily for anyone who wants to make contributions to the SDK or install it from source. If you are looking to use Node to access the Nylas Email, Calendar, or Contacts API you should refer to our official [Node SDK Quickstart Guide](https://developer.nylas.com/docs/developer-tools/sdk/node-sdk/).
+
+The Nylas Communications Platform provides REST APIs for [Email](https://developer.nylas.com/docs/connectivity/email/), [Calendar](https://developer.nylas.com/docs/connectivity/calendar/), and [Contacts](https://developer.nylas.com/docs/connectivity/contacts/), and the Node SDK is the quickest way to build your integration using JavaScript.
+
+Here are some resources to help you get started:
+
+- [Nylas SDK Tutorials](https://developer.nylas.com/docs/the-basics/tutorials/nodejs/)
+- [Quickstart](https://developer.nylas.com/docs/the-basics/quickstart/)
+- [Nylas API Reference](https://developer.nylas.com/docs/api/)
+
+
+# Install
+
+To run the Nylas Node SDK, you will first need to have [Node](https://nodejs.org/en/download/) and [npm](https://www.npmjs.com/get-npm) installed on your machine.
+
+Then, head to the nearest command line and run the following:
+`npm install nylas`
+
+Alternatively, if you prefer to use [Yarn](https://yarnpkg.com/en/), you can install the Nylas Node SDK with `yarn add nylas`
+
+To install this package from source, clone this repo and run `npm install` from inside the project directory.
+
+```bash
+git clone https://github.com/nylas/nylas-nodejs.git
+cd nylas-nodejs
+npm install
+```
+
+# Usage
+
+Every resource (i.e., messages, events, contacts) is accessed via an instance of `Nylas`. Before making any requests, be sure to call `config` and initialize the `Nylas` instance with your `clientId` and `clientSecret`. Then, call `with` and pass it your `accessToken`. The `accessToken` allows `Nylas` to make requests for a given account's resources.
+
+```javascript
+const Nylas = require('nylas');
+
+Nylas.config({
+  clientId: CLIENT_ID,
+  clientSecret: CLIENT_SECRET,
+});
+
+const nylas = Nylas.with(ACCESS_TOKEN);
+```
+
+Then, you can use Nylas to access information about a user's account:
+```javascript
+nylas.threads.list({}).then(threads => {
+  console.log(threads.length);
+});
+```
+
+For more information about how to use the Nylas Node SDK, [take a look at our quickstart guide](https://developer.nylas.com/docs/developer-tools/sdk/node-sdk/).
+
+# Contributing
+
+Please refer to [Contributing](Contributing.md) for information about how to make contributions to this project. We welcome questions, bug reports, and pull requests.
+
+# License
+
+This project is licensed under the terms of the MIT license. Please refer to [LICENSE](LICENSE.txt) for the full terms. 
+
+

package/lib/config.d.ts

@@ -0,0 +1,4 @@
+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;

package/lib/config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setClientSecret = exports.clientSecret = exports.setApiServer = exports.apiServer = void 0;
+exports.apiServer = null;
+function setApiServer(newApiServer) {
+    exports.apiServer = newApiServer;
+}
+exports.setApiServer = setApiServer;
+exports.clientSecret = '';
+function setClientSecret(newClientSecret) {
+    exports.clientSecret = newClientSecret;
+}
+exports.setClientSecret = setClientSecret;

package/lib/models/account.d.ts

@@ -0,0 +1,10 @@
+import RestfulModel from './restful-model';
+export default class Account extends RestfulModel {
+    name?: string;
+    emailAddress?: string;
+    provider?: string;
+    organizationUnit?: string;
+    syncState?: string;
+    billingState?: string;
+    linkedAt?: Date;
+}

package/lib/models/account.js

@@ -0,0 +1,61 @@
+"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 });
+var restful_model_1 = __importDefault(require("./restful-model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var Account = /** @class */ (function (_super) {
+    __extends(Account, _super);
+    function Account() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Account;
+}(restful_model_1.default));
+exports.default = Account;
+Account.collectionName = 'accounts';
+Account.endpointName = 'account';
+Account.attributes = __assign(__assign({}, restful_model_1.default.attributes), { name: attributes_1.default.String({
+        modelKey: 'name',
+    }), emailAddress: attributes_1.default.String({
+        modelKey: 'emailAddress',
+        jsonKey: 'email_address',
+    }), provider: attributes_1.default.String({
+        modelKey: 'provider',
+    }), organizationUnit: attributes_1.default.String({
+        modelKey: 'organizationUnit',
+        jsonKey: 'organization_unit',
+    }), syncState: attributes_1.default.String({
+        modelKey: 'syncState',
+        jsonKey: 'sync_state',
+    }), billingState: attributes_1.default.String({
+        modelKey: 'billingState',
+        jsonKey: 'billing_state',
+    }), linkedAt: attributes_1.default.DateTime({
+        modelKey: 'linkedAt',
+        jsonKey: 'linked_at',
+    }) });

package/lib/models/attributes.d.ts

@@ -0,0 +1,104 @@
+import RestfulModel from './restful-model';
+export declare class Attribute {
+    modelKey: string;
+    jsonKey: string;
+    readOnly: boolean;
+    constructor({ modelKey, jsonKey, readOnly, }: {
+        modelKey: string;
+        jsonKey?: string;
+        readOnly?: boolean;
+    });
+    toJSON(val: any): any;
+    fromJSON(val: any, _parent: any): any;
+}
+declare class AttributeObject extends Attribute {
+    itemClass?: typeof RestfulModel;
+    constructor({ modelKey, jsonKey, itemClass, readOnly, }: {
+        modelKey: string;
+        jsonKey?: string;
+        itemClass?: typeof RestfulModel;
+        readOnly?: boolean;
+    });
+    toJSON(val: any): any;
+    fromJSON(val: any, _parent: any): any;
+}
+declare class AttributeNumber extends Attribute {
+    toJSON(val: any): any;
+    fromJSON(val: any, _parent: any): number | null;
+}
+declare class AttributeBoolean extends Attribute {
+    toJSON(val: any): any;
+    fromJSON(val: any, _parent: any): boolean;
+}
+declare class AttributeString extends Attribute {
+    toJSON(val: any): any;
+    fromJSON(val: any, _parent: any): any;
+}
+declare class AttributeStringList extends Attribute {
+    toJSON(val: any): any;
+    fromJSON(val: any, _parent: any): any;
+}
+declare class AttributeDate extends Attribute {
+    toJSON(val: any): any;
+    fromJSON(val: any, _parent: any): Date | null;
+}
+declare class AttributeDateTime extends Attribute {
+    toJSON(val: any): number | null;
+    fromJSON(val: any, _parent: any): Date | null;
+}
+declare class AttributeCollection extends Attribute {
+    itemClass: typeof RestfulModel;
+    constructor({ modelKey, jsonKey, itemClass, readOnly, }: {
+        modelKey: string;
+        jsonKey?: string;
+        itemClass: typeof RestfulModel;
+        readOnly?: boolean;
+    });
+    toJSON(vals: any): any[];
+    fromJSON(json: any, _parent: any): RestfulModel[];
+}
+declare const Attributes: {
+    Number(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        readOnly?: boolean | undefined;
+    }): AttributeNumber;
+    String(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        readOnly?: boolean | undefined;
+    }): AttributeString;
+    StringList(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        readOnly?: boolean | undefined;
+    }): AttributeStringList;
+    DateTime(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        readOnly?: boolean | undefined;
+    }): AttributeDateTime;
+    Date(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        readOnly?: boolean | undefined;
+    }): AttributeDate;
+    Collection(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        itemClass: typeof RestfulModel;
+        readOnly?: boolean | undefined;
+    }): AttributeCollection;
+    Boolean(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        readOnly?: boolean | undefined;
+    }): AttributeBoolean;
+    Object(__0: {
+        modelKey: string;
+        jsonKey?: string | undefined;
+        itemClass?: typeof RestfulModel | undefined;
+        readOnly?: boolean | undefined;
+    }): AttributeObject;
+};
+export default Attributes;

package/lib/models/attributes.js

@@ -0,0 +1,266 @@
+"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 __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attribute = void 0;
+// The Attribute class represents a single model attribute, like 'namespace_id'
+// Subclasses of Attribute like AttributeDateTime know how to covert between
+// the JSON representation of that type and the javascript representation.
+// The Attribute class also exposes convenience methods for generating Matchers.
+var Attribute = /** @class */ (function () {
+    function Attribute(_a) {
+        var modelKey = _a.modelKey, jsonKey = _a.jsonKey, readOnly = _a.readOnly;
+        this.modelKey = modelKey;
+        this.jsonKey = jsonKey || modelKey;
+        this.readOnly = readOnly || false;
+    }
+    Attribute.prototype.toJSON = function (val) {
+        return val;
+    };
+    Attribute.prototype.fromJSON = function (val, _parent) {
+        return val || null;
+    };
+    return Attribute;
+}());
+exports.Attribute = Attribute;
+var AttributeObject = /** @class */ (function (_super) {
+    __extends(AttributeObject, _super);
+    function AttributeObject(_a) {
+        var modelKey = _a.modelKey, jsonKey = _a.jsonKey, itemClass = _a.itemClass, readOnly = _a.readOnly;
+        var _this = _super.call(this, { modelKey: modelKey, jsonKey: jsonKey, readOnly: readOnly }) || this;
+        _this.itemClass = itemClass;
+        return _this;
+    }
+    AttributeObject.prototype.toJSON = function (val) {
+        if (!val) {
+            return val;
+        }
+        if (val.toJSON != null) {
+            return val.toJSON();
+        }
+        return val;
+    };
+    AttributeObject.prototype.fromJSON = function (val, _parent) {
+        if (!val || !this.itemClass) {
+            return val;
+        }
+        return new this.itemClass(_parent.connection, val);
+    };
+    return AttributeObject;
+}(Attribute));
+var AttributeNumber = /** @class */ (function (_super) {
+    __extends(AttributeNumber, _super);
+    function AttributeNumber() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AttributeNumber.prototype.toJSON = function (val) {
+        return val;
+    };
+    AttributeNumber.prototype.fromJSON = function (val, _parent) {
+        if (!isNaN(val)) {
+            return Number(val);
+        }
+        else {
+            return null;
+        }
+    };
+    return AttributeNumber;
+}(Attribute));
+var AttributeBoolean = /** @class */ (function (_super) {
+    __extends(AttributeBoolean, _super);
+    function AttributeBoolean() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AttributeBoolean.prototype.toJSON = function (val) {
+        return val;
+    };
+    AttributeBoolean.prototype.fromJSON = function (val, _parent) {
+        return val === 'true' || val === true || false;
+    };
+    return AttributeBoolean;
+}(Attribute));
+var AttributeString = /** @class */ (function (_super) {
+    __extends(AttributeString, _super);
+    function AttributeString() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AttributeString.prototype.toJSON = function (val) {
+        return val;
+    };
+    AttributeString.prototype.fromJSON = function (val, _parent) {
+        return val || '';
+    };
+    return AttributeString;
+}(Attribute));
+var AttributeStringList = /** @class */ (function (_super) {
+    __extends(AttributeStringList, _super);
+    function AttributeStringList() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AttributeStringList.prototype.toJSON = function (val) {
+        return val;
+    };
+    AttributeStringList.prototype.fromJSON = function (val, _parent) {
+        return val || [];
+    };
+    return AttributeStringList;
+}(Attribute));
+var AttributeDate = /** @class */ (function (_super) {
+    __extends(AttributeDate, _super);
+    function AttributeDate() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AttributeDate.prototype.toJSON = function (val) {
+        if (!val) {
+            return val;
+        }
+        if (!(val instanceof Date)) {
+            throw new Error("Attempting to toJSON AttributeDate which is not a date:\n          " + this.modelKey + "\n         = " + val);
+        }
+        return val.toISOString();
+    };
+    AttributeDate.prototype.fromJSON = function (val, _parent) {
+        if (!val) {
+            return null;
+        }
+        return new Date(val);
+    };
+    return AttributeDate;
+}(Attribute));
+var AttributeDateTime = /** @class */ (function (_super) {
+    __extends(AttributeDateTime, _super);
+    function AttributeDateTime() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AttributeDateTime.prototype.toJSON = function (val) {
+        if (!val) {
+            return null;
+        }
+        if (!(val instanceof Date)) {
+            throw new Error("Attempting to toJSON AttributeDateTime which is not a date:\n          " + this.modelKey + "\n        = " + val);
+        }
+        return val.getTime() / 1000.0;
+    };
+    AttributeDateTime.prototype.fromJSON = function (val, _parent) {
+        if (!val) {
+            return null;
+        }
+        return new Date(val * 1000);
+    };
+    return AttributeDateTime;
+}(Attribute));
+var AttributeCollection = /** @class */ (function (_super) {
+    __extends(AttributeCollection, _super);
+    function AttributeCollection(_a) {
+        var modelKey = _a.modelKey, jsonKey = _a.jsonKey, itemClass = _a.itemClass, readOnly = _a.readOnly;
+        var _this = _super.call(this, { modelKey: modelKey, jsonKey: jsonKey, readOnly: readOnly }) || this;
+        _this.itemClass = itemClass;
+        return _this;
+    }
+    AttributeCollection.prototype.toJSON = function (vals) {
+        if (!vals) {
+            return [];
+        }
+        var json = [];
+        for (var _i = 0, vals_1 = vals; _i < vals_1.length; _i++) {
+            var val = vals_1[_i];
+            if (val.toJSON != null) {
+                json.push(val.toJSON());
+            }
+            else {
+                json.push(val);
+            }
+        }
+        return json;
+    };
+    AttributeCollection.prototype.fromJSON = function (json, _parent) {
+        if (!json || !(json instanceof Array)) {
+            return [];
+        }
+        var objs = [];
+        for (var _i = 0, json_1 = json; _i < json_1.length; _i++) {
+            var objJSON = json_1[_i];
+            var obj = new this.itemClass(_parent.connection, objJSON);
+            objs.push(obj);
+        }
+        return objs;
+    };
+    return AttributeCollection;
+}(Attribute));
+var Attributes = {
+    Number: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeNumber.bind.apply(AttributeNumber, __spreadArrays([void 0], args)))();
+    },
+    String: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeString.bind.apply(AttributeString, __spreadArrays([void 0], args)))();
+    },
+    StringList: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeStringList.bind.apply(AttributeStringList, __spreadArrays([void 0], args)))();
+    },
+    DateTime: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeDateTime.bind.apply(AttributeDateTime, __spreadArrays([void 0], args)))();
+    },
+    Date: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeDate.bind.apply(AttributeDate, __spreadArrays([void 0], args)))();
+    },
+    Collection: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeCollection.bind.apply(AttributeCollection, __spreadArrays([void 0], args)))();
+    },
+    Boolean: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeBoolean.bind.apply(AttributeBoolean, __spreadArrays([void 0], args)))();
+    },
+    Object: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new (AttributeObject.bind.apply(AttributeObject, __spreadArrays([void 0], args)))();
+    },
+};
+exports.default = Attributes;