@keystrokehq/sendgrid 0.0.1

package/dist/api-keys.d.mts

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+
+//#region src/api-keys.d.ts
+declare const createApiKey: _keystrokehq_core0.Operation<z.ZodObject<{
+  name: z.ZodString;
+  scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+  api_key_id: z.ZodString;
+  name: z.ZodString;
+  scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  api_key: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"sendgrid", z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const listApiKeys: _keystrokehq_core0.Operation<z.ZodOptional<z.ZodObject<{}, z.core.$strip>>, z.ZodObject<{
+  result: z.ZodArray<z.ZodObject<{
+    api_key_id: z.ZodString;
+    name: z.ZodString;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"sendgrid", z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getApiKey: _keystrokehq_core0.Operation<z.ZodObject<{
+  apiKeyId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  api_key_id: z.ZodString;
+  name: z.ZodString;
+  scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"sendgrid", z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const updateApiKeyName: _keystrokehq_core0.Operation<z.ZodObject<{
+  apiKeyId: z.ZodString;
+  name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  api_key_id: z.ZodString;
+  name: z.ZodString;
+  scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"sendgrid", z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const updateApiKeyNameAndScopes: _keystrokehq_core0.Operation<z.ZodObject<{
+  apiKeyId: z.ZodString;
+  name: z.ZodString;
+  scopes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  api_key_id: z.ZodString;
+  name: z.ZodString;
+  scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"sendgrid", z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const deleteApiKey: _keystrokehq_core0.Operation<z.ZodObject<{
+  apiKeyId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  success: z.ZodBoolean;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"sendgrid", z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SENDGRID_API_KEY: z.ZodString;
+  SENDGRID_SUBUSER: z.ZodOptional<z.ZodString>;
+  SENDGRID_ACCOUNT_REGION: z.ZodDefault<z.ZodEnum<{
+    global: "global";
+    eu: "eu";
+  }>>;
+  SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY: z.ZodOptional<z.ZodString>;
+  SENDGRID_INBOUND_PARSE_TOKEN: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { createApiKey, deleteApiKey, getApiKey, listApiKeys, updateApiKeyName, updateApiKeyNameAndScopes };

package/dist/api-keys.mjs

@@ -0,0 +1,113 @@
+import { n as __exportAll, t as sendgridOperation } from "./factory-BSL0D2L0.mjs";
+import { n as omitUndefined } from "./shared-CQ8JFNXi.mjs";
+import { createSendGridClient } from "./client.mjs";
+import { Qt as sendgridApiKeyWithKeySchema, Xt as sendgridApiKeySchema, Yt as sendgridApiKeyListSchema, on as sendgridIdSchema } from "./webhooks-CKdsIikb.mjs";
+import { z } from "zod";
+
+//#region src/api-keys.ts
+var api_keys_exports = /* @__PURE__ */ __exportAll({
+	createApiKey: () => createApiKey,
+	deleteApiKey: () => deleteApiKey,
+	getApiKey: () => getApiKey,
+	listApiKeys: () => listApiKeys,
+	updateApiKeyName: () => updateApiKeyName,
+	updateApiKeyNameAndScopes: () => updateApiKeyNameAndScopes
+});
+const createApiKey = sendgridOperation({
+	id: "create_api_key",
+	name: "Create API Key",
+	description: "Create a new SendGrid API key. Returns the full key value only at creation time — store it safely.",
+	input: z.object({
+		name: z.string().min(1),
+		scopes: z.array(z.string()).optional()
+	}),
+	output: sendgridApiKeyWithKeySchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const response = await createSendGridClient(credentials).request("/api_keys", {
+			method: "POST",
+			body: omitUndefined({
+				name: input.name,
+				scopes: input.scopes
+			})
+		});
+		return sendgridApiKeyWithKeySchema.parse(response);
+	}
+});
+const listApiKeys = sendgridOperation({
+	id: "list_api_keys",
+	name: "List API Keys",
+	description: "List all API keys on the account (values are not returned).",
+	input: z.object({}).optional(),
+	output: sendgridApiKeyListSchema,
+	run: async (_input, credentials) => {
+		const response = await createSendGridClient(credentials).request("/api_keys");
+		return sendgridApiKeyListSchema.parse(response ?? { result: [] });
+	}
+});
+const getApiKey = sendgridOperation({
+	id: "get_api_key",
+	name: "Get API Key",
+	description: "Retrieve an API key record by ID (the secret value is never returned).",
+	input: z.object({ apiKeyId: sendgridIdSchema }),
+	output: sendgridApiKeySchema,
+	run: async (input, credentials) => {
+		const response = await createSendGridClient(credentials).request(`/api_keys/${encodeURIComponent(input.apiKeyId)}`);
+		return sendgridApiKeySchema.parse(response);
+	}
+});
+const updateApiKeyName = sendgridOperation({
+	id: "update_api_key_name",
+	name: "Update API Key Name",
+	description: "Rename an API key without changing its scopes.",
+	input: z.object({
+		apiKeyId: sendgridIdSchema,
+		name: z.string().min(1)
+	}),
+	output: sendgridApiKeySchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const response = await createSendGridClient(credentials).request(`/api_keys/${encodeURIComponent(input.apiKeyId)}`, {
+			method: "PATCH",
+			body: { name: input.name }
+		});
+		return sendgridApiKeySchema.parse(response);
+	}
+});
+const updateApiKeyNameAndScopes = sendgridOperation({
+	id: "update_api_key_name_and_scopes",
+	name: "Update API Key Name and Scopes",
+	description: "Update an API key by replacing the full set of scopes.",
+	input: z.object({
+		apiKeyId: sendgridIdSchema,
+		name: z.string().min(1),
+		scopes: z.array(z.string()).min(1)
+	}),
+	output: sendgridApiKeySchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const response = await createSendGridClient(credentials).request(`/api_keys/${encodeURIComponent(input.apiKeyId)}`, {
+			method: "PUT",
+			body: {
+				name: input.name,
+				scopes: input.scopes
+			}
+		});
+		return sendgridApiKeySchema.parse(response);
+	}
+});
+const deleteApiKey = sendgridOperation({
+	id: "delete_api_key",
+	name: "Delete API Key",
+	description: "Delete (revoke) an API key.",
+	input: z.object({ apiKeyId: sendgridIdSchema }),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		await createSendGridClient(credentials).request(`/api_keys/${encodeURIComponent(input.apiKeyId)}`, { method: "DELETE" });
+		return { success: true };
+	}
+});
+
+//#endregion
+export { createApiKey, deleteApiKey, getApiKey, listApiKeys, api_keys_exports as t, updateApiKeyName, updateApiKeyNameAndScopes };

package/dist/client.d.mts

@@ -0,0 +1,73 @@
+import { t as SendGridCredentials } from "./integration-CmJ2TILG.mjs";
+
+//#region src/client.d.ts
+type Primitive = string | number | boolean;
+type QueryValue = Primitive | readonly Primitive[] | undefined | null;
+type SendGridHttpMethod = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+interface SendGridRequestOptions {
+  readonly body?: unknown;
+  readonly method?: SendGridHttpMethod;
+  readonly query?: Record<string, QueryValue>;
+  /** Override `on-behalf-of` for a single request (rare; defaults to credential subuser). */
+  readonly onBehalfOf?: string;
+  /** Send as `application/x-www-form-urlencoded` instead of JSON. */
+  readonly form?: Record<string, Primitive>;
+  /** Raw text body (e.g. CSV upload via PUT presigned URL responses). */
+  readonly rawBody?: string;
+  /** Disable retry for this call (e.g. idempotent-write guards). */
+  readonly noRetry?: boolean;
+}
+type SendGridErrorKind = 'auth' | 'forbidden' | 'not_found' | 'rate_limit' | 'server' | 'validation' | 'network';
+interface SendGridProviderError {
+  readonly message: string;
+  readonly field?: string;
+  readonly errorId?: string;
+  readonly help?: string;
+}
+declare class SendGridError extends Error {
+  readonly kind: SendGridErrorKind;
+  readonly status: number;
+  readonly body: unknown;
+  readonly providerErrors: readonly SendGridProviderError[];
+  readonly requestId: string | undefined;
+  readonly retryable: boolean;
+  constructor(init: {
+    kind: SendGridErrorKind;
+    status: number;
+    body: unknown;
+    providerErrors: readonly SendGridProviderError[];
+    requestId?: string;
+    retryable: boolean;
+    message: string;
+  });
+}
+declare function isSendGridError(value: unknown): value is SendGridError;
+interface SendGridClientConfig {
+  readonly maxRetries?: number;
+  readonly fetchImpl?: typeof fetch;
+}
+declare function createSendGridClient(credentials: SendGridCredentials, config?: SendGridClientConfig): {
+  request: <T>(path: string, options?: SendGridRequestOptions) => Promise<T>;
+  credentials: {
+    SENDGRID_API_KEY: string;
+    SENDGRID_ACCOUNT_REGION: "global" | "eu";
+    SENDGRID_SUBUSER?: string | undefined;
+    SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY?: string | undefined;
+    SENDGRID_INBOUND_PARSE_TOKEN?: string | undefined;
+  };
+  baseUrl: string;
+};
+type SendGridClient = ReturnType<typeof createSendGridClient>;
+/**
+ * Iterate a paginated SendGrid endpoint, yielding individual items.
+ *
+ * Implemented as a standalone function rather than a client method because
+ * the client is wrapped in an error-normalizing `Proxy` which does not play
+ * well with async iterators returned from method calls.
+ */
+declare function paginateSendGrid<TItem>(client: SendGridClient, path: string, options?: {
+  readonly query?: Record<string, QueryValue>;
+  readonly itemsKey?: string;
+}): AsyncIterableIterator<TItem>;
+//#endregion
+export { SendGridClient, SendGridClientConfig, SendGridError, SendGridErrorKind, SendGridHttpMethod, SendGridProviderError, SendGridRequestOptions, createSendGridClient, isSendGridError, paginateSendGrid };

package/dist/client.mjs

@@ -0,0 +1,261 @@
+import { t as sendgrid } from "./integration-37BovSeK.mjs";
+import { r as stringIfPresent, t as asRecord } from "./shared-CQ8JFNXi.mjs";
+import { CredentialRevokedError } from "@keystrokehq/core/errors";
+import { createErrorNormalizingProxy } from "@keystrokehq/integration-authoring";
+
+//#region src/client.ts
+const SENDGRID_GLOBAL_BASE = "https://api.sendgrid.com/v3";
+const SENDGRID_EU_BASE = "https://api.eu.sendgrid.com/v3";
+const CONNECT_HINT = "If you haven't connected SendGrid yet, create an API key in the SendGrid console and save it as `SENDGRID_API_KEY`.";
+var SendGridError = class extends Error {
+	kind;
+	status;
+	body;
+	providerErrors;
+	requestId;
+	retryable;
+	constructor(init) {
+		super(init.message);
+		this.name = "SendGridError";
+		this.kind = init.kind;
+		this.status = init.status;
+		this.body = init.body;
+		this.providerErrors = init.providerErrors;
+		this.requestId = init.requestId;
+		this.retryable = init.retryable;
+	}
+};
+function isSendGridError(value) {
+	return value instanceof SendGridError;
+}
+function parseProviderErrors(body) {
+	const errors = asRecord(body).errors;
+	if (!Array.isArray(errors)) return [];
+	return errors.map((entry) => {
+		const rec = asRecord(entry);
+		const message = stringIfPresent(rec.message);
+		if (!message) return null;
+		const field = stringIfPresent(rec.field);
+		const errorId = stringIfPresent(rec.error_id);
+		const help = stringIfPresent(rec.help);
+		return {
+			message,
+			...field !== void 0 ? { field } : {},
+			...errorId !== void 0 ? { errorId } : {},
+			...help !== void 0 ? { help } : {}
+		};
+	}).filter((entry) => entry !== null);
+}
+function classifyStatus(status) {
+	if (status === 401) return {
+		kind: "auth",
+		retryable: false
+	};
+	if (status === 403) return {
+		kind: "forbidden",
+		retryable: false
+	};
+	if (status === 404) return {
+		kind: "not_found",
+		retryable: false
+	};
+	if (status === 429) return {
+		kind: "rate_limit",
+		retryable: true
+	};
+	if (status >= 500) return {
+		kind: "server",
+		retryable: true
+	};
+	if (status >= 400) return {
+		kind: "validation",
+		retryable: false
+	};
+	return {
+		kind: "server",
+		retryable: true
+	};
+}
+function joinErrorMessages(status, providerErrors) {
+	if (providerErrors.length === 0) return `HTTP ${status}`;
+	return providerErrors.map((entry) => entry.message).join("; ");
+}
+function isAuthFlavoredError(error) {
+	if (!isSendGridError(error)) return false;
+	if (error.kind === "auth") return true;
+	if (error.kind === "forbidden") return error.providerErrors.map((entry) => entry.message.toLowerCase()).some((msg) => msg.includes("invalid api key") || msg.includes("authorization") || msg.includes("authentication"));
+	return false;
+}
+function normalizeSendGridError(error, context) {
+	if (isAuthFlavoredError(error)) return new CredentialRevokedError(sendgrid.id, `SendGrid authentication failed while calling \`${context.methodPath}\`. The stored credentials for ${sendgrid.id} may be revoked or missing required scopes. ${CONNECT_HINT}`);
+	if (isSendGridError(error)) return new Error(`SendGrid API call failed while calling \`${context.methodPath}\` (${error.status} ${error.kind}): ${error.message}`, { cause: error });
+	if (error instanceof Error) return new Error(`SendGrid API call failed while calling \`${context.methodPath}\`: ${error.message}`, { cause: error });
+	return /* @__PURE__ */ new Error(`SendGrid API call failed while calling \`${context.methodPath}\`.`);
+}
+function resolveBaseUrl(region) {
+	return region === "eu" ? SENDGRID_EU_BASE : SENDGRID_GLOBAL_BASE;
+}
+function appendQuery(searchParams, query) {
+	if (!query) return;
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			if (value.length === 0) continue;
+			searchParams.set(key, value.map(String).join(","));
+			continue;
+		}
+		searchParams.set(key, String(value));
+	}
+}
+function parseRetryAfterMs(header) {
+	if (!header) return void 0;
+	const seconds = Number(header);
+	if (Number.isFinite(seconds) && seconds >= 0) return Math.ceil(seconds * 1e3);
+	const whenMs = Date.parse(header);
+	if (Number.isFinite(whenMs)) return Math.max(0, whenMs - Date.now());
+}
+async function sleep(ms) {
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+function computeBackoffMs(attempt, retryAfterMs) {
+	if (retryAfterMs !== void 0) return retryAfterMs;
+	return 500 * 2 ** Math.min(attempt, 5) + Math.random() * 250;
+}
+async function parseResponseBody(response) {
+	if (response.status === 204 || response.status === 205) return {
+		body: void 0,
+		text: ""
+	};
+	const contentType = response.headers.get("content-type") ?? "";
+	const text = await response.text();
+	if (text.length === 0) return {
+		body: void 0,
+		text
+	};
+	if (contentType.includes("application/json")) try {
+		return {
+			body: JSON.parse(text),
+			text
+		};
+	} catch {
+		return {
+			body: text,
+			text
+		};
+	}
+	return {
+		body: text,
+		text
+	};
+}
+function createSendGridApiClient(credentials, config) {
+	const apiKey = credentials.SENDGRID_API_KEY.trim();
+	if (apiKey.length === 0) throw new Error(`SendGrid authentication failed at client initialization. ${CONNECT_HINT}`);
+	const baseUrl = resolveBaseUrl(credentials.SENDGRID_ACCOUNT_REGION ?? "global");
+	const defaultSubuser = credentials.SENDGRID_SUBUSER;
+	const maxRetries = config?.maxRetries ?? 3;
+	const fetchImpl = config?.fetchImpl ?? fetch;
+	async function request(path, options = {}) {
+		const url = new URL(`${baseUrl}${path}`);
+		appendQuery(url.searchParams, options.query);
+		const headers = {
+			Authorization: `Bearer ${apiKey}`,
+			Accept: "application/json"
+		};
+		const subuser = options.onBehalfOf ?? defaultSubuser;
+		if (subuser !== void 0 && subuser.length > 0) headers["on-behalf-of"] = subuser;
+		let body;
+		if (options.rawBody !== void 0) body = options.rawBody;
+		else if (options.form !== void 0) {
+			const params = new URLSearchParams();
+			for (const [key, value] of Object.entries(options.form)) params.set(key, String(value));
+			body = params.toString();
+			headers["Content-Type"] = "application/x-www-form-urlencoded";
+		} else if (options.body !== void 0) {
+			body = JSON.stringify(options.body);
+			headers["Content-Type"] = "application/json";
+		}
+		const method = options.method ?? "GET";
+		const maxAttempts = options.noRetry ? 1 : Math.max(1, maxRetries + 1);
+		let lastError;
+		for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+			let response;
+			try {
+				response = await fetchImpl(url, {
+					method,
+					headers,
+					...body !== void 0 ? { body } : {}
+				});
+			} catch (cause) {
+				const networkError = new SendGridError({
+					kind: "network",
+					status: 0,
+					body: void 0,
+					providerErrors: [],
+					retryable: true,
+					message: cause instanceof Error ? cause.message : "Network error calling SendGrid"
+				});
+				lastError = networkError;
+				if (attempt + 1 >= maxAttempts) throw networkError;
+				await sleep(computeBackoffMs(attempt));
+				continue;
+			}
+			if (response.ok) return (await parseResponseBody(response)).body;
+			const parsed = await parseResponseBody(response);
+			const providerErrors = parseProviderErrors(parsed.body);
+			const { kind, retryable } = classifyStatus(response.status);
+			const requestId = response.headers.get("x-message-id") ?? response.headers.get("x-request-id") ?? void 0;
+			const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
+			const err = new SendGridError({
+				kind,
+				status: response.status,
+				body: parsed.body,
+				providerErrors,
+				...requestId !== void 0 ? { requestId } : {},
+				retryable,
+				message: joinErrorMessages(response.status, providerErrors)
+			});
+			if (!retryable || attempt + 1 >= maxAttempts) throw err;
+			lastError = err;
+			await sleep(computeBackoffMs(attempt, retryAfterMs));
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("SendGrid request exhausted retries without a response.");
+	}
+	return {
+		request,
+		credentials,
+		baseUrl
+	};
+}
+function createSendGridClient(credentials, config) {
+	return createErrorNormalizingProxy(createSendGridApiClient(credentials, config), normalizeSendGridError);
+}
+/**
+* Iterate a paginated SendGrid endpoint, yielding individual items.
+*
+* Implemented as a standalone function rather than a client method because
+* the client is wrapped in an error-normalizing `Proxy` which does not play
+* well with async iterators returned from method calls.
+*/
+async function* paginateSendGrid(client, path, options = {}) {
+	const itemsKey = options.itemsKey ?? "result";
+	let nextPath = path;
+	let nextQuery = options.query;
+	while (nextPath !== void 0) {
+		const record = asRecord(await client.request(nextPath, { query: nextQuery }));
+		const items = record[itemsKey];
+		if (Array.isArray(items)) for (const item of items) yield item;
+		const nextUrl = stringIfPresent(asRecord(record._metadata).next);
+		if (!nextUrl) nextPath = void 0;
+		else {
+			const parsed = new URL(nextUrl);
+			nextPath = `${parsed.pathname.replace(/^\/v3/u, "")}${parsed.search}`;
+			nextQuery = void 0;
+		}
+	}
+}
+
+//#endregion
+export { SendGridError, createSendGridClient, isSendGridError, paginateSendGrid };

package/dist/connection.d.mts

@@ -0,0 +1,2 @@
+import { i as sendgridOfficialIntegration, n as sendgrid, t as SendGridCredentials } from "./integration-CmJ2TILG.mjs";
+export { type SendGridCredentials, sendgrid, sendgridOfficialIntegration };

package/dist/connection.mjs

@@ -0,0 +1,3 @@
+import { r as sendgridOfficialIntegration, t as sendgrid } from "./integration-37BovSeK.mjs";
+
+export { sendgrid, sendgridOfficialIntegration };