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

package/lib/esm/models/response.js

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

package/lib/esm/models/webhooks.js

@@ -0,0 +1,15 @@
+export var WebhookTriggers;
+(function (WebhookTriggers) {
+    WebhookTriggers["CalendarCreated"] = "calendar.created";
+    WebhookTriggers["CalendarUpdated"] = "calendar.updated";
+    WebhookTriggers["CalendarDeleted"] = "calendar.deleted";
+    WebhookTriggers["EventCreated"] = "event.created";
+    WebhookTriggers["EventUpdated"] = "event.updated";
+    WebhookTriggers["EventDeleted"] = "event.deleted";
+    WebhookTriggers["GrantCreated"] = "grant.created";
+    WebhookTriggers["GrantUpdated"] = "grant.updated";
+    WebhookTriggers["GrantDeleted"] = "grant.deleted";
+    WebhookTriggers["GrantExpired"] = "grant.expired";
+    WebhookTriggers["MessageSendSuccess"] = "message.send_success";
+    WebhookTriggers["MessageSendFailed"] = "message.send_failed";
+})(WebhookTriggers || (WebhookTriggers = {}));

package/lib/esm/nylas.js

@@ -0,0 +1,31 @@
+import APIClient from './apiClient.js';
+import { DEFAULT_SERVER_URL } from './config.js';
+import { Calendars } from './resources/calendars.js';
+import { Events } from './resources/events.js';
+import { Auth } from './resources/auth.js';
+import { Webhooks } from './resources/webhooks.js';
+import { Applications } from './resources/applications.js';
+/**
+ * The entry point to the Node SDK
+ *
+ * A Nylas instance holds a configured http client pointing to a base URL and is intended to be reused and shared
+ * across threads and time.
+ */
+export default class Nylas {
+    /**
+     * @param config Configuration options for the Nylas SDK
+     */
+    constructor(config) {
+        this.apiClient = new APIClient({
+            apiKey: config.apiKey,
+            apiUri: config.apiUri || DEFAULT_SERVER_URL,
+            timeout: config.timeout || 30,
+        });
+        this.applications = new Applications(this.apiClient);
+        this.auth = new Auth(this.apiClient);
+        this.calendars = new Calendars(this.apiClient);
+        this.events = new Events(this.apiClient);
+        this.webhooks = new Webhooks(this.apiClient);
+        return this;
+    }
+}

package/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/esm/resources/applications.js

@@ -0,0 +1,26 @@
+import { Resource } from './resource.js';
+import { RedirectUris } from './redirectUris.js';
+/**
+ * Nylas Applications API
+ *
+ * This endpoint allows for getting application details as well as redirect URI operations.
+ */
+export class Applications extends Resource {
+    /**
+     * @param apiClient client The configured Nylas API client
+     */
+    constructor(apiClient) {
+        super(apiClient);
+        this.redirectUris = new RedirectUris(apiClient);
+    }
+    /**
+     * Get application details
+     * @returns The application details
+     */
+    getDetails({ overrides } = {}) {
+        return super._find({
+            path: `/v3/applications`,
+            overrides,
+        });
+    }
+}

package/lib/esm/resources/auth.js

@@ -0,0 +1,149 @@
+import { v4 as uuid } from 'uuid';
+import sha256 from 'sha256';
+import { Resource } from './resource.js';
+import { Grants } from './grants.js';
+/**
+ * A collection of authentication related API endpoints
+ *
+ * These endpoints allow for various functionality related to authentication.
+ * Also contains the Grants API and collection of provider API endpoints.
+ */
+export class Auth extends Resource {
+    /**
+     * @param apiClient The configured Nylas API client
+     */
+    constructor(apiClient) {
+        super(apiClient);
+        this.apiClient = apiClient;
+        this.grants = new Grants(apiClient);
+    }
+    /**
+     * Build the URL for authenticating users to your application with OAuth 2.0
+     * @param config The configuration for building the URL
+     * @return The URL for hosted authentication
+     */
+    urlForOAuth2(config) {
+        return this.urlAuthBuilder(config).toString();
+    }
+    /**
+     * Exchange an authorization code for an access token
+     * @param request The request parameters for the code exchange
+     * @return Information about the Nylas application
+     */
+    exchangeCodeForToken(request) {
+        const body = {
+            ...request,
+            grantType: 'authorization_code',
+        };
+        if (request.codeVerifier) {
+            body.codeVerifier = request.codeVerifier;
+        }
+        return this.apiClient.request({
+            method: 'POST',
+            path: `/v3/connect/token`,
+            body,
+        });
+    }
+    /**
+     * Refresh an access token
+     * @param request The refresh token request
+     * @return The response containing the new access token
+     */
+    refreshAccessToken(request) {
+        return this.apiClient.request({
+            method: 'POST',
+            path: `/v3/connect/token`,
+            body: {
+                ...request,
+                grantType: 'refresh_token',
+            },
+        });
+    }
+    /**
+     * Build the URL for authenticating users to your application with OAuth 2.0 and PKCE
+     * IMPORTANT: YOU WILL NEED TO STORE THE 'secret' returned to use it inside the CodeExchange flow
+     * @param config The configuration for building the URL
+     * @return The URL for hosted authentication
+     */
+    urlForOAuth2PKCE(config) {
+        const url = this.urlAuthBuilder(config);
+        // Add code challenge to URL generation
+        url.searchParams.set('code_challenge_method', 's256');
+        const secret = uuid();
+        const secretHash = this.hashPKCESecret(secret);
+        url.searchParams.set('code_challenge', secret);
+        // Return the url with secret & hashed secret
+        return { secret, secretHash, url: url.toString() };
+    }
+    /**
+     * Build the URL for admin consent authentication for Microsoft
+     * @param config The configuration for building the URL
+     * @return The URL for admin consent authentication
+     */
+    urlForAdminConsent(config) {
+        const configWithProvider = { ...config, provider: 'microsoft' };
+        const url = this.urlAuthBuilder(configWithProvider);
+        url.searchParams.set('response_type', 'adminconsent');
+        url.searchParams.set('credential_id', config.credentialId);
+        return url.toString();
+    }
+    /**
+     * Revoke a token (and the grant attached to the token)
+     * @param token The token to revoke
+     * @return True if the token was revoked successfully
+     */
+    async revoke(token) {
+        await this.apiClient.request({
+            method: 'POST',
+            path: `/v3/connect/revoke`,
+            queryParams: {
+                token,
+            },
+        });
+        return true;
+    }
+    /**
+     * Detect provider from email address
+     * @param params The parameters to include in the request
+     * @return The detected provider, if found
+     */
+    async detectProvider(params) {
+        return this.apiClient.request({
+            method: 'POST',
+            path: `/v3/grants/providers/detect`,
+            queryParams: params,
+        });
+    }
+    urlAuthBuilder(config) {
+        const url = new URL(`${this.apiClient.serverUrl}/v3/connect/auth`);
+        url.searchParams.set('client_id', config.clientId);
+        url.searchParams.set('redirect_uri', config.redirectUri);
+        url.searchParams.set('access_type', config.accessType ? config.accessType : 'online');
+        url.searchParams.set('response_type', 'code');
+        if (config.provider) {
+            url.searchParams.set('provider', config.provider);
+        }
+        if (config.loginHint) {
+            url.searchParams.set('login_hint', config.loginHint);
+            if (config.includeGrantScopes) {
+                url.searchParams.set('include_grant_scopes', config.includeGrantScopes.toString());
+            }
+        }
+        if (config.scope) {
+            url.searchParams.set('scope', config.scope.join(' '));
+        }
+        if (config.prompt) {
+            url.searchParams.set('prompt', config.prompt);
+        }
+        if (config.metadata) {
+            url.searchParams.set('metadata', config.metadata);
+        }
+        if (config.state) {
+            url.searchParams.set('state', config.state);
+        }
+        return url;
+    }
+    hashPKCESecret(secret) {
+        return Buffer.from(sha256(secret)).toString('base64');
+    }
+}

package/lib/esm/resources/calendars.js

@@ -0,0 +1,74 @@
+import { Resource } from './resource.js';
+/**
+ * Nylas Calendar API
+ *
+ * The Nylas calendar API allows you to create new calendars or manage existing ones.
+ * A calendar can be accessed by one, or several people, and can contain events.
+ */
+export class Calendars extends Resource {
+    /**
+     * Return all Calendars
+     * @return A list of calendars
+     */
+    list({ identifier, queryParams, overrides, }) {
+        return super._list({
+            queryParams,
+            overrides,
+            path: `/v3/grants/${identifier}/calendars`,
+        });
+    }
+    /**
+     * Return a Calendar
+     * @return The calendar
+     */
+    find({ identifier, calendarId, overrides, }) {
+        return super._find({
+            path: `/v3/grants/${identifier}/calendars/${calendarId}`,
+            overrides,
+        });
+    }
+    /**
+     * Create a Calendar
+     * @return The created calendar
+     */
+    create({ identifier, requestBody, overrides, }) {
+        return super._create({
+            path: `/v3/grants/${identifier}/calendars`,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Update a Calendar
+     * @return The updated Calendar
+     */
+    update({ calendarId, identifier, requestBody, overrides, }) {
+        return super._update({
+            path: `/v3/grants/${identifier}/calendars/${calendarId}`,
+            requestBody,
+            overrides,
+        });
+    }
+    /**
+     * Delete a Calendar
+     * @return The deleted Calendar
+     */
+    destroy({ identifier, calendarId, overrides, }) {
+        return super._destroy({
+            path: `/v3/grants/${identifier}/calendars/${calendarId}`,
+            overrides,
+        });
+    }
+    /**
+     * Get Availability for a given account / accounts
+     * @return The availability response
+     */
+    getAvailability({ requestBody, overrides, }) {
+        return this.apiClient.request({
+            method: 'POST',
+            path: `/v3/calendars/availability`,
+            body: requestBody,
+            overrides,
+        });
+    }
+}

package/lib/esm/resources/events.js

@@ -0,0 +1,65 @@
+import { Resource } from './resource.js';
+/**
+ * Nylas Events API
+ *
+ * The Nylas Events API allows you to create, update, and delete events on user calendars.
+ */
+export class Events extends 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,
+        });
+    }
+}

package/lib/esm/resources/grants.js

@@ -0,0 +1,61 @@
+import { Resource } from './resource.js';
+/**
+ * Nylas Grants API
+ *
+ * The Nylas Grants API allows for the management of grants.
+ */
+export class Grants extends 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,
+        });
+    }
+}

package/lib/esm/resources/redirectUris.js

@@ -0,0 +1,60 @@
+import { Resource } from './resource.js';
+/**
+ * A collection of redirect URI related API endpoints.
+ *
+ * These endpoints allows for the management of redirect URIs.
+ */
+export class RedirectUris extends 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}`,
+        });
+    }
+}

package/lib/esm/resources/resource.js

@@ -0,0 +1,107 @@
+/**
+ * Base class for Nylas API resources
+ *
+ * @ignore No public constructor or functions
+ */
+export 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,
+        });
+    }
+}

package/lib/esm/resources/webhooks.js

@@ -0,0 +1,94 @@
+import { Resource } from './resource.js';
+/**
+ * Nylas Webhooks API
+ *
+ * The Nylas Webhooks API allows your application to receive notifications in real-time when certain events occur.
+ */
+export class Webhooks extends 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;
+    }
+}