nylas 7.0.0-beta.0 → 7.0.0-beta.2

package/lib/cjs/resources/events.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = void 0;
+const resource_js_1 = require("./resource.js");
+/**
+ * Nylas Events API
+ *
+ * The Nylas Events API allows you to create, update, and delete events on user calendars.
+ */
+class Events extends resource_js_1.Resource {
+    /**
+     * Return all Events
+     * @return The list of Events
+     */
+    list({ identifier, queryParams, overrides, }) {
+        return super._list({
+            queryParams,
+            path: `/v3/grants/${identifier}/events`,
+            overrides,
+        });
+    }
+    /**
+     * Return an Event
+     * @return The Event
+     */
+    find({ identifier, eventId, queryParams, overrides, }) {
+        return super._find({
+            path: `/v3/grants/${identifier}/events/${eventId}`,
+            queryParams,
+            overrides,
+        });
+    }
+    /**
+     * Create an Event
+     * @return The created Event
+     */
+    create({ identifier, requestBody, queryParams, overrides, }) {
+        return super._create({
+            path: `/v3/grants/${identifier}/events`,
+            queryParams,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Update an Event
+     * @return The updated Event
+     */
+    update({ identifier, eventId, requestBody, queryParams, overrides, }) {
+        return super._update({
+            path: `/v3/grants/${identifier}/events/${eventId}`,
+            queryParams,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Delete an Event
+     * @return The deletion response
+     */
+    destroy({ identifier, eventId, queryParams, overrides, }) {
+        return super._destroy({
+            path: `/v3/grants/${identifier}/events/${eventId}`,
+            queryParams,
+            overrides,
+        });
+    }
+}
+exports.Events = Events;

package/lib/cjs/resources/grants.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Grants = void 0;
+const resource_js_1 = require("./resource.js");
+/**
+ * Nylas Grants API
+ *
+ * The Nylas Grants API allows for the management of grants.
+ */
+class Grants extends resource_js_1.Resource {
+    /**
+     * Return all Grants
+     * @return The list of Grants
+     */
+    async list({ overrides } = {}, queryParams) {
+        return super._list({
+            queryParams,
+            path: `/v3/grants`,
+            overrides,
+        });
+    }
+    /**
+     * Return a Grant
+     * @return The Grant
+     */
+    find({ grantId, overrides, }) {
+        return super._find({
+            path: `/v3/grants/${grantId}`,
+            overrides,
+        });
+    }
+    /**
+     * Create a Grant
+     * @return The created Grant
+     */
+    create({ requestBody, overrides, }) {
+        return super._create({
+            path: `/v3/grants`,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Update a Grant
+     * @return The updated Grant
+     */
+    update({ grantId, requestBody, overrides, }) {
+        return super._updatePatch({
+            path: `/v3/grants/${grantId}`,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Delete a Grant
+     * @return The deletion response
+     */
+    destroy({ grantId, overrides, }) {
+        return super._destroy({
+            path: `/v3/grants/${grantId}`,
+            overrides,
+        });
+    }
+}
+exports.Grants = Grants;

package/lib/cjs/resources/redirectUris.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedirectUris = void 0;
+const resource_js_1 = require("./resource.js");
+/**
+ * A collection of redirect URI related API endpoints.
+ *
+ * These endpoints allows for the management of redirect URIs.
+ */
+class RedirectUris extends resource_js_1.Resource {
+    /**
+     * Return all Redirect URIs
+     * @return The list of Redirect URIs
+     */
+    list({ overrides } = {}) {
+        return super._list({
+            overrides,
+            path: '/v3/applications/redirect-uris',
+        });
+    }
+    /**
+     * Return a Redirect URI
+     * @return The Redirect URI
+     */
+    find({ redirectUriId, overrides, }) {
+        return super._find({
+            overrides,
+            path: `/v3/applications/redirect-uris/${redirectUriId}`,
+        });
+    }
+    /**
+     * Create a Redirect URI
+     * @return The created Redirect URI
+     */
+    create({ requestBody, overrides, }) {
+        return super._create({
+            overrides,
+            path: '/v3/applications/redirect-uris',
+            requestBody,
+        });
+    }
+    /**
+     * Update a Redirect URI
+     * @return The updated Redirect URI
+     */
+    update({ redirectUriId, requestBody, overrides, }) {
+        return super._update({
+            overrides,
+            path: `/v3/applications/redirect-uris/${redirectUriId}`,
+            requestBody,
+        });
+    }
+    /**
+     * Delete a Redirect URI
+     * @return The deleted Redirect URI
+     */
+    destroy({ redirectUriId, overrides, }) {
+        return super._destroy({
+            overrides,
+            path: `/v1/redirect_uris/${redirectUriId}`,
+        });
+    }
+}
+exports.RedirectUris = RedirectUris;

package/lib/cjs/resources/resource.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resource = void 0;
+/**
+ * Base class for Nylas API resources
+ *
+ * @ignore No public constructor or functions
+ */
+class Resource {
+    /**
+     * @param apiClient client The configured Nylas API client
+     */
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async fetchList({ queryParams, path, overrides, }) {
+        const res = await this.apiClient.request({
+            method: 'GET',
+            path,
+            queryParams,
+            overrides,
+        });
+        if (queryParams?.limit) {
+            let entriesRemaining = queryParams.limit;
+            while (res.data.length != queryParams.limit) {
+                entriesRemaining = queryParams.limit - res.data.length;
+                if (!res.nextCursor) {
+                    break;
+                }
+                const nextRes = await this.apiClient.request({
+                    method: 'GET',
+                    path,
+                    queryParams: {
+                        ...queryParams,
+                        limit: entriesRemaining,
+                        pageToken: res.nextCursor,
+                    },
+                    overrides,
+                });
+                res.data = res.data.concat(nextRes.data);
+                res.requestId = nextRes.requestId;
+                res.nextCursor = nextRes.nextCursor;
+            }
+        }
+        return res;
+    }
+    async *listIterator(listParams) {
+        const first = await this.fetchList(listParams);
+        yield first;
+        let pageToken = first.nextCursor;
+        while (pageToken) {
+            const res = await this.fetchList({
+                ...listParams,
+                queryParams: pageToken
+                    ? {
+                        ...listParams.queryParams,
+                        pageToken,
+                    }
+                    : listParams.queryParams,
+            });
+            yield res;
+            pageToken = res.nextCursor;
+        }
+        return undefined;
+    }
+    _list(listParams) {
+        const iterator = this.listIterator(listParams);
+        const first = iterator.next().then(res => ({
+            ...res.value,
+            next: iterator.next.bind(iterator),
+        }));
+        return Object.assign(first, {
+            [Symbol.asyncIterator]: this.listIterator.bind(this, listParams),
+        });
+    }
+    _find({ path, queryParams, overrides, }) {
+        return this.apiClient.request({
+            method: 'GET',
+            path,
+            queryParams,
+            overrides,
+        });
+    }
+    payloadRequest(method, { path, queryParams, requestBody, overrides }) {
+        return this.apiClient.request({
+            method,
+            path,
+            queryParams,
+            body: requestBody,
+            overrides,
+        });
+    }
+    _create(params) {
+        return this.payloadRequest('POST', params);
+    }
+    _update(params) {
+        return this.payloadRequest('PUT', params);
+    }
+    _updatePatch(params) {
+        return this.payloadRequest('PATCH', params);
+    }
+    _destroy({ path, queryParams, overrides, }) {
+        return this.apiClient.request({
+            method: 'DELETE',
+            path,
+            queryParams,
+            overrides,
+        });
+    }
+}
+exports.Resource = Resource;

package/lib/cjs/resources/webhooks.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhooks = void 0;
+const resource_js_1 = require("./resource.js");
+/**
+ * Nylas Webhooks API
+ *
+ * The Nylas Webhooks API allows your application to receive notifications in real-time when certain events occur.
+ */
+class Webhooks extends resource_js_1.Resource {
+    /**
+     * List all webhook destinations for the application
+     * @returns The list of webhook destinations
+     */
+    list({ overrides } = {}) {
+        return super._list({
+            overrides,
+            path: `/v3/webhooks`,
+        });
+    }
+    /**
+     * Return a webhook destination
+     * @return The webhook destination
+     */
+    find({ webhookId, overrides, }) {
+        return super._find({
+            path: `/v3/webhooks/${webhookId}`,
+            overrides,
+        });
+    }
+    /**
+     * Create a webhook destination
+     * @returns The created webhook destination
+     */
+    create({ requestBody, overrides, }) {
+        return super._create({
+            path: `/v3/webhooks`,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Update a webhook destination
+     * @returns The updated webhook destination
+     */
+    update({ webhookId, requestBody, overrides, }) {
+        return super._update({
+            path: `/v3/webhooks/${webhookId}`,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Delete a webhook destination
+     * @returns The deletion response
+     */
+    destroy({ webhookId, overrides, }) {
+        return super._destroy({
+            path: `/v3/webhooks/${webhookId}`,
+            overrides,
+        });
+    }
+    /**
+     * Update the webhook secret value for a destination
+     * @returns The updated webhook destination with the webhook secret
+     */
+    rotateSecret({ webhookId, overrides, }) {
+        return super._update({
+            path: `/v3/webhooks/${webhookId}/rotate-secret`,
+            requestBody: {},
+            overrides,
+        });
+    }
+    /**
+     * Get the current list of IP addresses that Nylas sends webhooks from
+     * @returns The list of IP addresses that Nylas sends webhooks from
+     */
+    ipAddresses({ overrides } = {}) {
+        return super._find({
+            path: `/v3/webhooks/ip-addresses`,
+            overrides,
+        });
+    }
+    /**
+     * Extract the challenge parameter from a URL
+     * @param url The URL sent by Nylas containing the challenge parameter
+     * @returns The challenge parameter
+     */
+    extractChallengeParameter(url) {
+        const urlObject = new URL(url);
+        const challengeParameter = urlObject.searchParams.get('challenge');
+        if (!challengeParameter) {
+            throw new Error('Invalid URL or no challenge parameter found.');
+        }
+        return challengeParameter;
+    }
+}
+exports.Webhooks = Webhooks;

package/lib/cjs/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objKeysToSnakeCase = exports.objKeysToCamelCase = void 0;
+const change_case_1 = require("change-case");
+/**
+ * A utility function that recursively converts all keys in an object to a given case.
+ * @param obj The object to convert
+ * @param casingFunction The function to use to convert the keys
+ * @param excludeKeys An array of keys to exclude from conversion
+ * @returns The converted object
+ * @ignore Not for public use.
+ */
+function convertCase(obj, casingFunction, excludeKeys) {
+    const newObj = {};
+    for (const key in obj) {
+        if (excludeKeys?.includes(key)) {
+            newObj[key] = obj[key];
+        }
+        else if (Array.isArray(obj[key])) {
+            newObj[casingFunction(key)] = obj[key].map(item => {
+                if (typeof item === 'object') {
+                    return convertCase(item, casingFunction);
+                }
+                else {
+                    return item;
+                }
+            });
+        }
+        else if (typeof obj[key] === 'object' && obj[key] !== null) {
+            newObj[casingFunction(key)] = convertCase(obj[key], casingFunction);
+        }
+        else {
+            newObj[casingFunction(key)] = obj[key];
+        }
+    }
+    return newObj;
+}
+/**
+ * A utility function that recursively converts all keys in an object to camelCase.
+ * @param obj The object to convert
+ * @param exclude An array of keys to exclude from conversion
+ * @returns The converted object
+ * @ignore Not for public use.
+ */
+function objKeysToCamelCase(obj, exclude) {
+    return convertCase(obj, change_case_1.camelCase, exclude);
+}
+exports.objKeysToCamelCase = objKeysToCamelCase;
+/**
+ * A utility function that recursively converts all keys in an object to snake_case.
+ * @param obj The object to convert
+ * @param exclude An array of keys to exclude from conversion
+ * @returns The converted object
+ */
+function objKeysToSnakeCase(obj, exclude) {
+    return convertCase(obj, change_case_1.snakeCase, exclude);
+}
+exports.objKeysToSnakeCase = objKeysToSnakeCase;

package/lib/cjs/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+// This file is generated by scripts/exportVersion.js
+exports.SDK_VERSION = '7.0.0-beta.2';

package/lib/esm/apiClient.js

@@ -0,0 +1,111 @@
+import fetch, { Request } from 'node-fetch';
+import { NylasApiError, NylasOAuthError, NylasSdkTimeoutError, } from './models/error.js';
+import { objKeysToCamelCase, objKeysToSnakeCase } from './utils.js';
+import { SDK_VERSION } from './version.js';
+/**
+ * The API client for communicating with the Nylas API
+ * @ignore Not for public use
+ */
+export default class APIClient {
+    constructor({ apiKey, apiUri, timeout }) {
+        this.apiKey = apiKey;
+        this.serverUrl = apiUri;
+        this.timeout = timeout * 1000; // fetch timeout uses milliseconds
+    }
+    setRequestUrl({ overrides, path, queryParams, }) {
+        const url = new URL(`${overrides?.apiUri || this.serverUrl}${path}`);
+        return this.setQueryStrings(url, queryParams);
+    }
+    setQueryStrings(url, queryParams) {
+        if (queryParams) {
+            const snakeCaseParams = objKeysToSnakeCase(queryParams, ['metadataPair']);
+            for (const [key, value] of Object.entries(snakeCaseParams)) {
+                if (key == 'metadataPair') {
+                    // The API understands a metadata_pair filter in the form of:
+                    // <key>:<value>
+                    const metadataPair = [];
+                    for (const item in value) {
+                        metadataPair.push(`${item}:${value[item]}`);
+                    }
+                    url.searchParams.set('metadata_pair', metadataPair.join(','));
+                }
+                else {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        return url;
+    }
+    setRequestHeaders({ headers, overrides, }) {
+        return {
+            Accept: 'application/json',
+            'User-Agent': `Nylas Node SDK v${SDK_VERSION}`,
+            Authorization: `Bearer ${overrides?.apiKey || this.apiKey}`,
+            ...headers,
+        };
+    }
+    requestOptions(optionParams) {
+        const requestOptions = {};
+        requestOptions.url = this.setRequestUrl(optionParams);
+        requestOptions.headers = this.setRequestHeaders(optionParams);
+        requestOptions.method = optionParams.method;
+        if (optionParams.body) {
+            requestOptions.body = JSON.stringify(objKeysToSnakeCase(optionParams.body));
+            requestOptions.headers['Content-Type'] = 'application/json';
+        }
+        return requestOptions;
+    }
+    newRequest(options) {
+        const newOptions = this.requestOptions(options);
+        return new Request(newOptions.url, {
+            method: newOptions.method,
+            headers: newOptions.headers,
+            body: newOptions.body,
+        });
+    }
+    async requestWithResponse(response) {
+        const text = await response.text();
+        try {
+            const responseJSON = JSON.parse(text);
+            return objKeysToCamelCase(responseJSON);
+        }
+        catch (e) {
+            throw new Error(`Could not parse response from the server: ${text}`);
+        }
+    }
+    async request(options) {
+        const req = this.newRequest(options);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort();
+            throw new NylasSdkTimeoutError(req.url, this.timeout);
+        }, this.timeout);
+        const response = await fetch(req, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (typeof response === 'undefined') {
+            throw new Error('Failed to fetch response');
+        }
+        // handle error response
+        if (response.status > 299) {
+            const authErrorResponse = options.path.includes('connect/token') ||
+                options.path.includes('connect/revoke');
+            const text = await response.text();
+            let error;
+            try {
+                const parsedError = JSON.parse(text);
+                const camelCaseError = objKeysToCamelCase(parsedError);
+                if (authErrorResponse) {
+                    error = new NylasOAuthError(camelCaseError, response.status);
+                }
+                else {
+                    error = new NylasApiError(camelCaseError, response.status);
+                }
+            }
+            catch (e) {
+                throw new Error(`Received an error but could not parse response from the server: ${text}`);
+            }
+            throw error;
+        }
+        return this.requestWithResponse(response);
+    }
+}

package/lib/esm/config.js

@@ -0,0 +1,29 @@
+/**
+ * Enum representing the available Nylas API regions.
+ */
+export var Region;
+(function (Region) {
+    Region["Us"] = "us";
+    Region["Eu"] = "eu";
+})(Region || (Region = {}));
+/**
+ * The default Nylas API region.
+ * @default Region.Us
+ */
+export const DEFAULT_REGION = Region.Us;
+/**
+ * The available preset configuration values for each Nylas API region.
+ */
+export const REGION_CONFIG = {
+    [Region.Us]: {
+        nylasAPIUrl: 'https://api.us.nylas.com',
+    },
+    [Region.Eu]: {
+        nylasAPIUrl: 'https://api.eu.nylas.com',
+    },
+};
+/**
+ * The default Nylas API URL.
+ * @default https://api.us.nylas.com
+ */
+export const DEFAULT_SERVER_URL = REGION_CONFIG[DEFAULT_REGION].nylasAPIUrl;

package/lib/esm/models/applicationDetails.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/models/auth.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/models/availability.js

@@ -0,0 +1,8 @@
+/**
+ * Enum representing the method used to determine availability for a meeting.
+ */
+export var AvailabilityMethod;
+(function (AvailabilityMethod) {
+    AvailabilityMethod["MaxFairness"] = "max-fairness";
+    AvailabilityMethod["MaxAvailability"] = "max-availability";
+})(AvailabilityMethod || (AvailabilityMethod = {}));

package/lib/esm/models/calendars.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/models/error.js

@@ -0,0 +1,45 @@
+/**
+ * Base class for all Nylas API errors.
+ */
+export class AbstractNylasApiError extends Error {
+}
+/**
+ * Base class for all Nylas SDK errors.
+ */
+export class AbstractNylasSdkError extends Error {
+}
+/**
+ * Class representation of a general Nylas API error.
+ */
+export class NylasApiError extends AbstractNylasApiError {
+    constructor(apiError, statusCode) {
+        super(apiError.error.message);
+        this.type = apiError.error.type;
+        this.requestId = apiError.requestId;
+        this.providerError = apiError.error.providerError;
+        this.statusCode = statusCode;
+    }
+}
+/**
+ * Class representing an OAuth error returned by the Nylas API.
+ */
+export class NylasOAuthError extends AbstractNylasApiError {
+    constructor(apiError, statusCode) {
+        super(apiError.errorDescription);
+        this.error = apiError.error;
+        this.errorCode = apiError.errorCode;
+        this.errorDescription = apiError.errorDescription;
+        this.errorUri = apiError.errorUri;
+        this.statusCode = statusCode;
+    }
+}
+/**
+ * Error thrown when the Nylas SDK times out before receiving a response from the server
+ */
+export class NylasSdkTimeoutError extends AbstractNylasSdkError {
+    constructor(url, timeout) {
+        super('Nylas SDK timed out before receiving a response from the server.');
+        this.url = url;
+        this.timeout = timeout;
+    }
+}

package/lib/esm/models/events.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/models/grants.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/models/listQueryParams.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/models/redirectUri.js

@@ -0,0 +1 @@
+export {};