nylas 5.8.0

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

@@ -0,0 +1,11 @@
+import NylasConnection from '../nylas-connection';
+import RestfulModel from './restful-model';
+export default class RestfulModelInstance<T extends RestfulModel> {
+    connection: NylasConnection;
+    modelClass: typeof RestfulModel;
+    constructor(modelClass: typeof RestfulModel, connection: NylasConnection);
+    path(): string;
+    get(params?: {
+        [key: string]: any;
+    }): Promise<T>;
+}

package/lib/models/restful-model-instance.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var nylas_connection_1 = __importDefault(require("../nylas-connection"));
+var RestfulModelInstance = /** @class */ (function () {
+    function RestfulModelInstance(modelClass, connection) {
+        this.modelClass = modelClass;
+        this.connection = connection;
+        if (!(this.connection instanceof nylas_connection_1.default)) {
+            throw new Error('Connection object not provided');
+        }
+        if (!this.modelClass) {
+            throw new Error('Model class not provided');
+        }
+    }
+    RestfulModelInstance.prototype.path = function () {
+        return "/" + this.modelClass.endpointName;
+    };
+    RestfulModelInstance.prototype.get = function (params) {
+        var _this = this;
+        if (params === void 0) { params = {}; }
+        return this.connection
+            .request({
+            method: 'GET',
+            path: this.path(),
+            qs: params,
+        })
+            .then(function (json) {
+            var model = new _this.modelClass(_this.connection, json);
+            return Promise.resolve(model);
+        });
+    };
+    return RestfulModelInstance;
+}());
+exports.default = RestfulModelInstance;

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

@@ -0,0 +1,48 @@
+import { Attribute } from './attributes';
+import NylasConnection from '../nylas-connection';
+export declare type SaveCallback = (error: Error | null, result?: RestfulModel) => void;
+interface RestfulModelJSON {
+    id: string;
+    object: string;
+    accountId: string;
+    [key: string]: any;
+}
+export default class RestfulModel {
+    static endpointName: string;
+    static collectionName: string;
+    static attributes: {
+        [key: string]: Attribute;
+    };
+    accountId?: string;
+    connection: NylasConnection;
+    id?: string;
+    object?: string;
+    constructor(connection: NylasConnection, json?: Partial<RestfulModelJSON>);
+    attributes(): {
+        [key: string]: Attribute;
+    };
+    isEqual(other: RestfulModel): boolean;
+    fromJSON(json?: Partial<RestfulModelJSON>): this;
+    toJSON(enforceReadOnly?: boolean): any;
+    pathPrefix(): string;
+    saveEndpoint(): string;
+    saveRequestBody(): any;
+    deleteRequestQueryString(_params: {
+        [key: string]: any;
+    }): {};
+    deleteRequestBody(_params: {
+        [key: string]: any;
+    }): {};
+    deleteRequestOptions(params: {
+        [key: string]: any;
+    }): {
+        body: {};
+        qs: {};
+    };
+    toString(): string;
+    _save(params?: {} | SaveCallback, callback?: SaveCallback): Promise<this>;
+    _get(params?: {
+        [key: string]: any;
+    }, callback?: (error: Error | null, result?: any) => void, pathSuffix?: string): Promise<any>;
+}
+export {};

package/lib/models/restful-model.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var attributes_1 = __importDefault(require("./attributes"));
+var nylas_connection_1 = __importDefault(require("../nylas-connection"));
+var RestfulModel = /** @class */ (function () {
+    function RestfulModel(connection, json) {
+        this.connection = connection;
+        if (!(this.connection instanceof nylas_connection_1.default)) {
+            throw new Error('Connection object not provided');
+        }
+        if (json) {
+            this.fromJSON(json);
+        }
+    }
+    RestfulModel.prototype.attributes = function () {
+        return this.constructor.attributes;
+    };
+    RestfulModel.prototype.isEqual = function (other) {
+        return ((other ? other.id : undefined) === this.id &&
+            (other ? other.constructor : undefined) === this.constructor);
+    };
+    RestfulModel.prototype.fromJSON = function (json) {
+        if (json === void 0) { json = {}; }
+        var attributes = this.attributes();
+        for (var attrName in attributes) {
+            var attr = attributes[attrName];
+            if (json[attr.jsonKey] !== undefined) {
+                this[attrName] = attr.fromJSON(json[attr.jsonKey], this);
+            }
+        }
+        return this;
+    };
+    RestfulModel.prototype.toJSON = function (enforceReadOnly) {
+        var json = {};
+        var attributes = this.attributes();
+        for (var attrName in attributes) {
+            if (!attributes[attrName].readOnly || enforceReadOnly !== true) {
+                var attr = attributes[attrName];
+                json[attr.jsonKey] = attr.toJSON(this[attrName]);
+            }
+        }
+        return json;
+    };
+    // Subclasses should override this method.
+    RestfulModel.prototype.pathPrefix = function () {
+        return '';
+    };
+    RestfulModel.prototype.saveEndpoint = function () {
+        var collectionName = this.constructor.collectionName;
+        return this.pathPrefix() + "/" + collectionName;
+    };
+    // saveRequestBody is used by save(). It returns a JSON dict containing only the
+    // fields the API allows updating. Subclasses should override this method.
+    RestfulModel.prototype.saveRequestBody = function () {
+        return this.toJSON(true);
+    };
+    // deleteRequestQueryString is used by delete(). Subclasses should override this method.
+    RestfulModel.prototype.deleteRequestQueryString = function (_params) {
+        return {};
+    };
+    // deleteRequestBody is used by delete(). Subclasses should override this method.
+    RestfulModel.prototype.deleteRequestBody = function (_params) {
+        return {};
+    };
+    // deleteRequestOptions is used by delete(). Subclasses should override this method.
+    RestfulModel.prototype.deleteRequestOptions = function (params) {
+        return {
+            body: this.deleteRequestBody(params),
+            qs: this.deleteRequestQueryString(params),
+        };
+    };
+    RestfulModel.prototype.toString = function () {
+        return JSON.stringify(this.toJSON());
+    };
+    // Not every model needs to have a save function, but those who
+    // do shouldn't have to reimplement the same boilerplate.
+    // They should instead define a save() function which calls _save.
+    RestfulModel.prototype._save = function (params, callback) {
+        var _this = this;
+        if (params === void 0) { params = {}; }
+        if (typeof params === 'function') {
+            callback = params;
+            params = {};
+        }
+        return this.connection
+            .request({
+            method: this.id ? 'PUT' : 'POST',
+            body: this.saveRequestBody(),
+            qs: params,
+            path: this.id
+                ? this.saveEndpoint() + "/" + this.id
+                : "" + this.saveEndpoint(),
+        })
+            .then(function (json) {
+            _this.fromJSON(json);
+            if (callback) {
+                callback(null, _this);
+            }
+            return Promise.resolve(_this);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    RestfulModel.prototype._get = function (params, callback, pathSuffix) {
+        if (params === void 0) { params = {}; }
+        if (pathSuffix === void 0) { pathSuffix = ''; }
+        var collectionName = this.constructor.collectionName;
+        return this.connection
+            .request({
+            method: 'GET',
+            path: "/" + collectionName + "/" + this.id + pathSuffix,
+            qs: params,
+        })
+            .then(function (response) {
+            if (callback) {
+                callback(null, response);
+            }
+            return Promise.resolve(response);
+        })
+            .catch(function (err) {
+            if (callback) {
+                callback(err);
+            }
+            return Promise.reject(err);
+        });
+    };
+    RestfulModel.endpointName = ''; // overrridden in subclasses
+    RestfulModel.collectionName = ''; // overrridden in subclasses
+    return RestfulModel;
+}());
+exports.default = RestfulModel;
+RestfulModel.attributes = {
+    id: attributes_1.default.String({
+        modelKey: 'id',
+        readOnly: true,
+    }),
+    object: attributes_1.default.String({
+        modelKey: 'object',
+        readOnly: true,
+    }),
+    accountId: attributes_1.default.String({
+        modelKey: 'accountId',
+        jsonKey: 'account_id',
+        readOnly: true,
+    }),
+};

package/lib/models/thread.d.ts

@@ -0,0 +1,30 @@
+import Message from './message';
+import RestfulModel, { SaveCallback } from './restful-model';
+import EmailParticipant from './email-participant';
+import { Label, Folder } from './folder';
+export default class Thread extends RestfulModel {
+    subject?: string;
+    participants?: EmailParticipant[];
+    lastMessageTimestamp?: Date;
+    lastMessageReceivedTimestamp?: Date;
+    lastMessageSentTimestamp?: Date;
+    firstMessageTimestamp?: Date;
+    snippet?: string;
+    unread?: boolean;
+    starred?: boolean;
+    hasAttachments?: boolean;
+    version?: string;
+    folders?: Folder[];
+    labels?: Label[];
+    messageIds?: string[];
+    draftIds?: string[];
+    messages?: Message[];
+    drafts?: Message[];
+    fromJSON(json: {
+        [key: string]: any;
+    }): this;
+    saveRequestBody(): {
+        [key: string]: any;
+    };
+    save(params?: {} | SaveCallback, callback?: SaveCallback): Promise<this>;
+}

package/lib/models/thread.js

@@ -0,0 +1,112 @@
+"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 message_1 = __importDefault(require("./message"));
+var restful_model_1 = __importDefault(require("./restful-model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var email_participant_1 = __importDefault(require("./email-participant"));
+var folder_1 = require("./folder");
+var Thread = /** @class */ (function (_super) {
+    __extends(Thread, _super);
+    function Thread() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Thread.prototype.fromJSON = function (json) {
+        _super.prototype.fromJSON.call(this, json);
+        return this;
+    };
+    Thread.prototype.saveRequestBody = function () {
+        var json = {};
+        if (this.labels) {
+            json['label_ids'] = this.labels.map(function (label) { return label.id; });
+        }
+        else if (this.folders && this.folders.length === 1) {
+            json['folder_id'] = this.folders[0].id;
+        }
+        json['starred'] = this.starred;
+        json['unread'] = this.unread;
+        return json;
+    };
+    Thread.prototype.save = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        return this._save(params, callback);
+    };
+    return Thread;
+}(restful_model_1.default));
+exports.default = Thread;
+Thread.collectionName = 'threads';
+Thread.attributes = __assign(__assign({}, restful_model_1.default.attributes), { subject: attributes_1.default.String({
+        modelKey: 'subject',
+    }), participants: attributes_1.default.Collection({
+        modelKey: 'participants',
+        itemClass: email_participant_1.default,
+    }), lastMessageTimestamp: attributes_1.default.DateTime({
+        modelKey: 'lastMessageTimestamp',
+        jsonKey: 'last_message_timestamp',
+    }), lastMessageReceivedTimestamp: attributes_1.default.DateTime({
+        modelKey: 'lastMessageReceivedTimestamp',
+        jsonKey: 'last_message_received_timestamp',
+    }), lastMessageSentTimestamp: attributes_1.default.DateTime({
+        modelKey: 'lastMessageSentTimestamp',
+        jsonKey: 'last_message_sent_timestamp',
+    }), firstMessageTimestamp: attributes_1.default.DateTime({
+        modelKey: 'firstMessageTimestamp',
+        jsonKey: 'first_message_timestamp',
+    }), snippet: attributes_1.default.String({
+        modelKey: 'snippet',
+    }), unread: attributes_1.default.Boolean({
+        modelKey: 'unread',
+    }), starred: attributes_1.default.Boolean({
+        modelKey: 'starred',
+    }), hasAttachments: attributes_1.default.Boolean({
+        modelKey: 'has_attachments',
+    }), version: attributes_1.default.String({
+        modelKey: 'version',
+        jsonKey: 'version',
+    }), folders: attributes_1.default.Collection({
+        modelKey: 'folders',
+        itemClass: folder_1.Folder,
+        jsonKey: 'folders',
+    }), labels: attributes_1.default.Collection({
+        modelKey: 'labels',
+        itemClass: folder_1.Label,
+        jsonKey: 'labels',
+    }), messageIds: attributes_1.default.StringList({
+        modelKey: 'messageIds',
+        jsonKey: 'message_ids',
+    }), draftIds: attributes_1.default.StringList({
+        modelKey: 'draftIds',
+        jsonKey: 'draft_ids',
+    }), messages: attributes_1.default.Collection({
+        modelKey: 'messages',
+        itemClass: message_1.default,
+    }), drafts: attributes_1.default.Collection({
+        modelKey: 'drafts',
+        itemClass: message_1.default,
+    }) });

package/lib/models/webhook.d.ts

@@ -0,0 +1,15 @@
+import ManagementModel from './management-model';
+import { SaveCallback } from './restful-model';
+export default class Webhook extends ManagementModel {
+    id?: string;
+    applicationId?: string;
+    callbackUrl?: string;
+    state?: string;
+    triggers?: string[];
+    version?: string;
+    pathPrefix(): string;
+    saveRequestBody(): {
+        [key: string]: any;
+    };
+    save(params?: {} | SaveCallback, callback?: SaveCallback): Promise<this>;
+}

package/lib/models/webhook.js

@@ -0,0 +1,71 @@
+"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 management_model_1 = __importDefault(require("./management-model"));
+var attributes_1 = __importDefault(require("./attributes"));
+var Webhook = /** @class */ (function (_super) {
+    __extends(Webhook, _super);
+    function Webhook() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Webhook.prototype.pathPrefix = function () {
+        return "/a/" + this.clientId;
+    };
+    Webhook.prototype.saveRequestBody = function () {
+        var json = {};
+        // We can only update the state of an existing webhook
+        if (this.id) {
+            json['state'] = this.state;
+        }
+        else {
+            json['callback_url'] = this.callbackUrl;
+            json['state'] = this.state ? this.state : 'active';
+            json['triggers'] = Webhook.attributes.triggers.toJSON(this.triggers);
+        }
+        return json;
+    };
+    Webhook.prototype.save = function (params, callback) {
+        if (params === void 0) { params = {}; }
+        return this._save(params, callback);
+    };
+    return Webhook;
+}(management_model_1.default));
+exports.default = Webhook;
+Webhook.collectionName = 'webhooks';
+Webhook.attributes = {
+    id: attributes_1.default.String({
+        modelKey: 'id',
+    }),
+    applicationId: attributes_1.default.String({
+        modelKey: 'applicationId',
+        jsonKey: 'application_id',
+    }),
+    callbackUrl: attributes_1.default.String({
+        modelKey: 'callbackUrl',
+        jsonKey: 'callback_url',
+    }),
+    state: attributes_1.default.String({
+        modelKey: 'state',
+    }),
+    triggers: attributes_1.default.StringList({
+        modelKey: 'triggers',
+    }),
+    version: attributes_1.default.String({
+        modelKey: 'version',
+    }),
+};