@drawbridge/drawbridge-utils 0.0.112 → 0.0.114

package/dist/connections/oauth.js

@@ -1,11 +1,11 @@
 // lib/connections/oauth.js
 import { createHash, randomBytes } from "crypto";
-var credentials = ({ clientId, clientSecret, descriptor }) => (descriptor == null ? void 0 : descriptor.clientAuth) === "basic" ? {
-  headers: { authorization: "Basic " + Buffer.from(clientId + ":" + clientSecret).toString("base64") },
-  body: {}
+var credentials = ({ basic, clientId, clientSecret }) => basic ? {
+  body: {},
+  headers: { authorization: "Basic " + Buffer.from(clientId + ":" + clientSecret).toString("base64") }
 } : {
-  headers: {},
-  body: { client_id: clientId, client_secret: clientSecret }
+  body: { client_id: clientId, client_secret: clientSecret },
+  headers: {}
 };
 var pkcePair = () => {
   const verifier = randomBytes(32).toString("base64url");
@@ -16,10 +16,11 @@ var pkcePair = () => {
   };
 };
 var consentUrl = ({ challenge, clientId, descriptor, redirect, state } = {}) => {
+  var _a;
   if (!clientId) throw new Error("This deployment has no OAuth client configured, so there is nothing to consent through");
-  if (!(descriptor == null ? void 0 : descriptor.authorize)) throw new Error("This connection declares no authorize url");
+  if (!((_a = descriptor == null ? void 0 : descriptor.urls) == null ? void 0 : _a.authorize)) throw new Error("This connection declares no authorize url");
   if (descriptor.pkce && !challenge) throw new Error("This connection requires PKCE, so a code challenge is not optional");
-  return descriptor.authorize + "?" + new URLSearchParams({
+  return descriptor.urls.authorize + "?" + new URLSearchParams({
     // The descriptor's own params go FIRST, so a vendor quirk cannot quietly
     // overwrite one of the fields below that every consent carries.
     ...descriptor.params || {},
@@ -34,17 +35,33 @@ var consentUrl = ({ challenge, clientId, descriptor, redirect, state } = {}) =>
     state
   });
 };
-var exchange = async ({ clientId, clientSecret, code, descriptor, fetcher = fetch, redirect, verifier } = {}) => {
-  if (!(descriptor == null ? void 0 : descriptor.token)) throw new Error("This connection declares no token url");
-  if (descriptor.pkce && !verifier) throw new Error("This connection requires PKCE, so the code verifier is not optional");
-  const client = credentials({ clientId, clientSecret, descriptor });
-  const response = await fetcher(descriptor.token, {
+var authToken = async ({
+  basic,
+  clientId,
+  clientSecret,
+  code,
+  descriptor,
+  fetcher = fetch,
+  redirect,
+  refreshToken,
+  verifier
+} = {}) => {
+  var _a;
+  if (!clientId || !clientSecret) throw new Error("This deployment has no OAuth client configured, so no token can be minted");
+  if (!((_a = descriptor == null ? void 0 : descriptor.urls) == null ? void 0 : _a.token)) throw new Error("This connection declares no token url");
+  const renewing = !code;
+  if (renewing && !refreshToken) throw new Error("Nothing has been consented to yet, so there is no refresh token to spend");
+  if (!renewing && descriptor.pkce && !verifier) throw new Error("This connection requires PKCE, so the code verifier is not optional");
+  const client = credentials({ basic, clientId, clientSecret });
+  const response = await fetcher(descriptor.urls.token, {
     body: new URLSearchParams({
       ...client.body,
-      code: decodeURIComponent(String(code || "").trim()),
-      grant_type: "authorization_code",
-      redirect_uri: redirect,
-      ...descriptor.pkce && { code_verifier: verifier }
+      ...renewing ? { grant_type: "refresh_token", refresh_token: refreshToken } : {
+        code: decodeURIComponent(String(code || "").trim()),
+        grant_type: "authorization_code",
+        redirect_uri: redirect,
+        ...descriptor.pkce && { code_verifier: verifier }
+      }
     }),
     headers: { "content-type": "application/x-www-form-urlencoded", ...client.headers },
     method: "POST",
@@ -52,45 +69,28 @@ var exchange = async ({ clientId, clientSecret, code, descriptor, fetcher = fetc
   });
   const body = await response.json().catch(() => ({}));
   if (!response.ok) {
-    throw new Error("The vendor refused the exchange (" + response.status + ")" + ((body == null ? void 0 : body.error) ? ": " + body.error : ""));
+    throw new Error(
+      renewing ? "The vendor refused the refresh token (" + response.status + ") \u2014 reconnect the connection" : "The vendor refused the exchange (" + response.status + ")" + ((body == null ? void 0 : body.error) ? ": " + body.error : "")
+    );
   }
-  if (!body.access_token) throw new Error("The vendor returned no access token");
+  if (!renewing && !body.access_token) throw new Error("The vendor returned no access token");
   return {
     accessToken: body.access_token,
     expiresIn: body.expires_in || null,
+    // A REFRESH TOKEN IS NOT UNIVERSAL. Google returns one only with
+    // access_type=offline; Mailchimp's tokens do not expire and it returns none
+    // at all, so its absence cannot be an error here.
+    //
+    // On a RENEWAL the same null matters for the opposite reason: a vendor that
+    // rotates returns a new one, and dropping it silently invalidates the stored
+    // grant on the NEXT refresh — a failure a day late and nowhere near its
+    // cause. tokenSettings() keeps the existing one when this is null.
     refreshToken: body.refresh_token || null,
     scope: body.scope || null
   };
 };
-var refresh = async ({ clientId, clientSecret, descriptor, fetcher = fetch, refreshToken } = {}) => {
-  if (!clientId || !clientSecret) throw new Error("This deployment has no OAuth client configured, so no token can be minted");
-  if (!refreshToken) throw new Error("Nothing has been consented to yet, so there is no refresh token to spend");
-  if (!(descriptor == null ? void 0 : descriptor.token)) throw new Error("This connection declares no token url");
-  const client = credentials({ clientId, clientSecret, descriptor });
-  const response = await fetcher(descriptor.token, {
-    body: new URLSearchParams({
-      ...client.body,
-      grant_type: "refresh_token",
-      refresh_token: refreshToken
-    }),
-    headers: { "content-type": "application/x-www-form-urlencoded", ...client.headers },
-    method: "POST",
-    signal: AbortSignal.timeout(15e3)
-  });
-  if (!response.ok) throw new Error("The vendor refused the refresh token (" + response.status + ") \u2014 reconnect the connection");
-  const body = await response.json();
-  return {
-    accessToken: body.access_token,
-    expiresIn: body.expires_in || null,
-    // A vendor that rotates its refresh token returns a new one, and dropping
-    // it silently invalidates the stored grant on the NEXT refresh rather
-    // than this one — a failure a day late and nowhere near its cause.
-    refreshToken: body.refresh_token || null
-  };
-};
 export {
+  authToken,
   consentUrl,
-  exchange,
-  pkcePair,
-  refresh
+  pkcePair
 };

package/dist/safe-http.d.cts

@@ -1,7 +1,7 @@
 import dns from 'dns';
 import * as http from 'node:http';
 import * as https from 'node:https';
-import { isBlockedIP, axios } from './axios.cjs';
+import { axios, isBlockedIP } from './axios.cjs';
 import 'axios';
 import 'net';
 

package/dist/safe-http.d.ts

@@ -1,7 +1,7 @@
 import dns from 'dns';
 import * as http from 'node:http';
 import * as https from 'node:https';
-import { isBlockedIP, axios } from './axios.js';
+import { axios, isBlockedIP } from './axios.js';
 import 'axios';
 import 'net';
 

package/dist/sendgrid.cjs

@@ -0,0 +1,168 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/sendgrid.js
+var sendgrid_exports = {};
+__export(sendgrid_exports, {
+  sendWithRetry: () => sendWithRetry,
+  sendgrid: () => sendgrid,
+  sendgridRequest: () => sendgridRequest
+});
+module.exports = __toCommonJS(sendgrid_exports);
+
+// lib/http.js
+var DEFAULT_TIMEOUT_MS = 15e3;
+var request = async ({
+  body,
+  headers = {},
+  method = "GET",
+  query,
+  timeout = DEFAULT_TIMEOUT_MS,
+  type = "json",
+  url
+}) => {
+  const fullUrl = new URL(url);
+  if (query) {
+    Object.entries(query).forEach(([k, v]) => fullUrl.searchParams.set(k, v));
+  }
+  ;
+  const isForm = type === "form";
+  const response = await fetch(fullUrl.toString(), {
+    method,
+    headers: {
+      "Content-Type": isForm ? "application/x-www-form-urlencoded" : "application/json",
+      ...headers
+    },
+    signal: AbortSignal.timeout(timeout),
+    ...body !== void 0 && {
+      body: isForm ? new URLSearchParams(body).toString() : JSON.stringify(body)
+    }
+  });
+  if (!response.ok) {
+    const text2 = await response.text().catch(() => "");
+    const error = new Error(text2 || response.statusText);
+    error.status = response.status;
+    throw error;
+  }
+  ;
+  const text = await response.text();
+  try {
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return null;
+  }
+};
+
+// lib/sendgrid.js
+var import_drawbridge_telemetry = require("@drawbridge/drawbridge-telemetry");
+var logger = (0, import_drawbridge_telemetry.createLogger)();
+var SENDGRID_BASE = "https://api.sendgrid.com";
+var RETRYABLE_STATUSES = [429, 500, 502, 503];
+var RETRY_DELAYS_MS = [1e3, 4e3];
+var sendWithRetry = async (send, { delays = RETRY_DELAYS_MS } = {}) => {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await send();
+    } catch (error) {
+      const status = Number(error == null ? void 0 : error.status);
+      const retryable = RETRYABLE_STATUSES.includes(status);
+      if (!retryable || attempt >= delays.length) {
+        if (!status) {
+          logger.warn("email.send.ambiguous-failure", {
+            name: error == null ? void 0 : error.name,
+            message: error == null ? void 0 : error.message
+          });
+        }
+        throw error;
+      }
+      logger.info("email.send.retry", {
+        attempt: attempt + 1,
+        status,
+        delayMs: delays[attempt]
+      });
+      await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+    }
+  }
+};
+var sendgridRequest = ({ apiKey, body, method, path, query, request: request2 = request }) => {
+  const key = apiKey || process.env.SENDGRID_API_KEY;
+  return request2({
+    body,
+    headers: {
+      "Authorization": "Bearer " + key
+    },
+    method,
+    query,
+    url: SENDGRID_BASE + path
+  });
+};
+var sendgrid = {
+  // `headers` (optional) carries the List-Unsubscribe pair on lead-facing
+  // commercial sends; omitted, the request body is byte-identical to the
+  // pre-opt-out-floor shape so system mail is untouched.
+  send: async ({ apiKey, from, headers, html, request: request2, subject, text, to }) => {
+    var _a, _b;
+    try {
+      const sender = (from == null ? void 0 : from.email) ? from : {
+        email: process.env.SENDGRID_FROM_ADDRESS,
+        name: "Drawbridge"
+      };
+      await sendWithRetry(() => sendgridRequest({
+        apiKey,
+        ...request2 && { request: request2 },
+        method: "POST",
+        path: "/v3/mail/send",
+        body: {
+          content: [
+            {
+              type: "text/plain",
+              value: text
+            },
+            {
+              type: "text/html",
+              value: html
+            }
+          ],
+          from: sender,
+          ...headers && { headers },
+          personalizations: [
+            {
+              to: [
+                { email: to }
+              ]
+            }
+          ],
+          subject
+        }
+      }));
+    } catch (error) {
+      try {
+        const parsed = JSON.parse(error.message);
+        if ((_b = (_a = parsed == null ? void 0 : parsed.errors) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) error.message = parsed.errors[0].message;
+      } catch {
+      }
+      throw error;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sendWithRetry,
+  sendgrid,
+  sendgridRequest
+});

package/dist/sendgrid.d.cts

@@ -0,0 +1,185 @@
+import { request } from './http.cjs';
+import { createLogger } from '@drawbridge/drawbridge-telemetry';
+
+// SENDGRID TRANSPORT. Vendor HTTP and nothing else — no controller, no queue,
+// no database.
+//
+// HERE rather than in drawbridge-sync because every other vendor's transport is
+// here: Klaviyo's api(), Shopify's signature verification, Mailchimp's fetch.
+// SendGrid was the one exception, and Drawbridge is a connection now like any
+// other — the private `drawbridge` manifest declares email.send, email.notify
+// and email.digest, so its transport belongs beside its manifest.
+//
+// The API key still falls back to process.env, which is a carry-over rather than
+// a preference: a published package reading a deployment's environment is the
+// thing `client : { id : 'KLAVIYO_OAUTH_CLIENT_ID' }` exists to avoid. Callers
+// that pass a key explicitly never touch it.
+
+
+const logger = createLogger();
+
+const SENDGRID_BASE = 'https://api.sendgrid.com';
+
+// --- provider-send retry -----------------------------------------------------
+//
+// Notification jobs are non-retryable BY DESIGN (non-idempotent $incs on the
+// user-notification path), so a provider hiccup used to mean a silently
+// dropped email. This retry wraps ONLY the provider POST, and only fires on
+// DEFINITE pre-delivery failures — an HTTP status proving the provider
+// REJECTED the request (rate limit / server error), where a retry can never
+// double-send. Ambiguous outcomes (timeout, abort, connection reset — no
+// status, because the request died in transit) are NOT retried: the provider
+// may already have accepted the mail, and retrying risks a duplicate email in
+// a real person's inbox. Those are logged and rethrown (plan guard-rail 12).
+const RETRYABLE_STATUSES = [ 429, 500, 502, 503 ];
+
+// 1s then 4s — long enough for a rate-limit window to roll over, short enough
+// to keep the send inside the notification job's runtime budget.
+const RETRY_DELAYS_MS = [ 1000, 4000 ];
+
+const sendWithRetry = async ( send, { delays = RETRY_DELAYS_MS } = {} ) => {
+
+	for( let attempt = 0; ; attempt++ ){
+
+		try {
+
+			return await send();
+
+		} catch ( error ) {
+
+			const status = Number( error?.status );
+			const retryable = RETRYABLE_STATUSES.includes( status );
+
+			if( ! retryable || attempt >= delays.length ){
+
+				if( ! status ){
+
+					// No HTTP status = timeout / abort / reset — the ambiguous
+					// "maybe the provider accepted it" case. Surface it in logs
+					// so possible-but-unconfirmed sends are searchable.
+					logger.warn( 'email.send.ambiguous-failure', {
+						name : error?.name,
+						message : error?.message
+					});
+
+				}
+
+				throw error;
+
+			}
+
+			logger.info( 'email.send.retry', {
+				attempt : attempt + 1,
+				status,
+				delayMs : delays[ attempt ]
+			});
+
+			await new Promise( ( resolve ) => setTimeout( resolve, delays[ attempt ] ) );
+
+		}
+
+	}
+
+};
+
+// `request` is INJECTABLE, and that is not decoration. tsup emits this module's
+// exports as getter-only, non-configurable properties, so the stub-by-mutation
+// trick that worked when this lived in drawbridge-sync silently no-ops here —
+// the assignment appears to succeed and the real HTTP call goes out. Injection
+// is how every other vendor call in this package is tested (`fetcher` on each
+// manifest hook), and it is the only thing that works across the boundary.
+const sendgridRequest = ({ apiKey, body, method, path, query, request: request$1 = request }) => {
+
+	const key = apiKey || process.env.SENDGRID_API_KEY;
+
+	return request$1({
+		body,
+		headers : {
+			'Authorization' : 'Bearer ' + key
+		},
+		method,
+		query,
+		url : SENDGRID_BASE + path
+	});
+
+};
+
+const sendgrid = {
+
+	// `headers` (optional) carries the List-Unsubscribe pair on lead-facing
+	// commercial sends; omitted, the request body is byte-identical to the
+	// pre-opt-out-floor shape so system mail is untouched.
+	send : async ({ apiKey, from, headers, html, request, subject, text, to }) => {
+
+		try {
+
+			const sender = ( from?.email ?
+				from
+				:
+				{
+					email : process.env.SENDGRID_FROM_ADDRESS,
+					name : 'Drawbridge'
+				}
+			);
+
+			await sendWithRetry( () => sendgridRequest({
+				apiKey,
+				...( request && { request }),
+				method : 'POST',
+				path : '/v3/mail/send',
+				body : {
+					content : [
+						{
+							type : 'text/plain',
+							value : text
+						},
+						{
+							type : 'text/html',
+							value : html
+						}
+					],
+					from : sender,
+					...( headers && { headers } ),
+					personalizations : [
+						{
+							to : [
+								{ email : to }
+							]
+						}
+					],
+					subject
+				}
+			}) );
+
+		} catch ( error ) {
+
+			// SendGrid rejections carry a JSON body; surface its first message.
+			// Non-JSON failures (timeouts, resets) pass through untouched so the
+			// parse can't mask the real error, and error.status survives for the
+			// caller.
+			try {
+
+				const parsed = JSON.parse( error.message );
+
+				if( parsed?.errors?.[ 0 ]?.message ) error.message = parsed.errors[ 0 ].message;
+
+			} catch {}
+
+			throw error;
+
+		}
+
+	}
+
+};
+
+// The Mandrill sender that used to live here is gone. Drawbridge sends every
+// lead-facing email from its own SendGrid account now, so there was no caller
+// left — and the merchant `mailchimp` connection is becoming an audience sync,
+// which speaks to the Marketing API rather than Mandrill's transactional one.
+
+// sendgridRequest is exported so the sending-domain slice can call SendGrid's
+// domain-authentication endpoints (/v3/whitelabel/domains) through the same
+// authenticated client the mail send uses, rather than minting a second one.
+
+export { sendWithRetry, sendgrid, sendgridRequest };

package/dist/sendgrid.d.ts

@@ -0,0 +1,185 @@
+import { request } from './http.js';
+import { createLogger } from '@drawbridge/drawbridge-telemetry';
+
+// SENDGRID TRANSPORT. Vendor HTTP and nothing else — no controller, no queue,
+// no database.
+//
+// HERE rather than in drawbridge-sync because every other vendor's transport is
+// here: Klaviyo's api(), Shopify's signature verification, Mailchimp's fetch.
+// SendGrid was the one exception, and Drawbridge is a connection now like any
+// other — the private `drawbridge` manifest declares email.send, email.notify
+// and email.digest, so its transport belongs beside its manifest.
+//
+// The API key still falls back to process.env, which is a carry-over rather than
+// a preference: a published package reading a deployment's environment is the
+// thing `client : { id : 'KLAVIYO_OAUTH_CLIENT_ID' }` exists to avoid. Callers
+// that pass a key explicitly never touch it.
+
+
+const logger = createLogger();
+
+const SENDGRID_BASE = 'https://api.sendgrid.com';
+
+// --- provider-send retry -----------------------------------------------------
+//
+// Notification jobs are non-retryable BY DESIGN (non-idempotent $incs on the
+// user-notification path), so a provider hiccup used to mean a silently
+// dropped email. This retry wraps ONLY the provider POST, and only fires on
+// DEFINITE pre-delivery failures — an HTTP status proving the provider
+// REJECTED the request (rate limit / server error), where a retry can never
+// double-send. Ambiguous outcomes (timeout, abort, connection reset — no
+// status, because the request died in transit) are NOT retried: the provider
+// may already have accepted the mail, and retrying risks a duplicate email in
+// a real person's inbox. Those are logged and rethrown (plan guard-rail 12).
+const RETRYABLE_STATUSES = [ 429, 500, 502, 503 ];
+
+// 1s then 4s — long enough for a rate-limit window to roll over, short enough
+// to keep the send inside the notification job's runtime budget.
+const RETRY_DELAYS_MS = [ 1000, 4000 ];
+
+const sendWithRetry = async ( send, { delays = RETRY_DELAYS_MS } = {} ) => {
+
+	for( let attempt = 0; ; attempt++ ){
+
+		try {
+
+			return await send();
+
+		} catch ( error ) {
+
+			const status = Number( error?.status );
+			const retryable = RETRYABLE_STATUSES.includes( status );
+
+			if( ! retryable || attempt >= delays.length ){
+
+				if( ! status ){
+
+					// No HTTP status = timeout / abort / reset — the ambiguous
+					// "maybe the provider accepted it" case. Surface it in logs
+					// so possible-but-unconfirmed sends are searchable.
+					logger.warn( 'email.send.ambiguous-failure', {
+						name : error?.name,
+						message : error?.message
+					});
+
+				}
+
+				throw error;
+
+			}
+
+			logger.info( 'email.send.retry', {
+				attempt : attempt + 1,
+				status,
+				delayMs : delays[ attempt ]
+			});
+
+			await new Promise( ( resolve ) => setTimeout( resolve, delays[ attempt ] ) );
+
+		}
+
+	}
+
+};
+
+// `request` is INJECTABLE, and that is not decoration. tsup emits this module's
+// exports as getter-only, non-configurable properties, so the stub-by-mutation
+// trick that worked when this lived in drawbridge-sync silently no-ops here —
+// the assignment appears to succeed and the real HTTP call goes out. Injection
+// is how every other vendor call in this package is tested (`fetcher` on each
+// manifest hook), and it is the only thing that works across the boundary.
+const sendgridRequest = ({ apiKey, body, method, path, query, request: request$1 = request }) => {
+
+	const key = apiKey || process.env.SENDGRID_API_KEY;
+
+	return request$1({
+		body,
+		headers : {
+			'Authorization' : 'Bearer ' + key
+		},
+		method,
+		query,
+		url : SENDGRID_BASE + path
+	});
+
+};
+
+const sendgrid = {
+
+	// `headers` (optional) carries the List-Unsubscribe pair on lead-facing
+	// commercial sends; omitted, the request body is byte-identical to the
+	// pre-opt-out-floor shape so system mail is untouched.
+	send : async ({ apiKey, from, headers, html, request, subject, text, to }) => {
+
+		try {
+
+			const sender = ( from?.email ?
+				from
+				:
+				{
+					email : process.env.SENDGRID_FROM_ADDRESS,
+					name : 'Drawbridge'
+				}
+			);
+
+			await sendWithRetry( () => sendgridRequest({
+				apiKey,
+				...( request && { request }),
+				method : 'POST',
+				path : '/v3/mail/send',
+				body : {
+					content : [
+						{
+							type : 'text/plain',
+							value : text
+						},
+						{
+							type : 'text/html',
+							value : html
+						}
+					],
+					from : sender,
+					...( headers && { headers } ),
+					personalizations : [
+						{
+							to : [
+								{ email : to }
+							]
+						}
+					],
+					subject
+				}
+			}) );
+
+		} catch ( error ) {
+
+			// SendGrid rejections carry a JSON body; surface its first message.
+			// Non-JSON failures (timeouts, resets) pass through untouched so the
+			// parse can't mask the real error, and error.status survives for the
+			// caller.
+			try {
+
+				const parsed = JSON.parse( error.message );
+
+				if( parsed?.errors?.[ 0 ]?.message ) error.message = parsed.errors[ 0 ].message;
+
+			} catch {}
+
+			throw error;
+
+		}
+
+	}
+
+};
+
+// The Mandrill sender that used to live here is gone. Drawbridge sends every
+// lead-facing email from its own SendGrid account now, so there was no caller
+// left — and the merchant `mailchimp` connection is becoming an audience sync,
+// which speaks to the Marketing API rather than Mandrill's transactional one.
+
+// sendgridRequest is exported so the sending-domain slice can call SendGrid's
+// domain-authentication endpoints (/v3/whitelabel/domains) through the same
+// authenticated client the mail send uses, rather than minting a second one.
+
+export { sendWithRetry, sendgrid, sendgridRequest };