@drawbridge/drawbridge-utils 0.0.112 → 0.0.115

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 };

package/dist/sendgrid.js

@@ -0,0 +1,140 @@
+// 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
+import { createLogger } from "@drawbridge/drawbridge-telemetry";
+var logger = 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;
+    }
+  }
+};
+export {
+  sendWithRetry,
+  sendgrid,
+  sendgridRequest
+};