@better-auth/infra 0.1.7 → 0.1.9-beta.1

package/dist/client.d.mts

@@ -1,4 +1,4 @@
-import * as better_auth_client0 from "better-auth/client";
+import * as _better_fetch_fetch0 from "@better-fetch/fetch";
 
 //#region src/client.d.ts
 interface DashAuditLog {
@@ -49,7 +49,7 @@ interface DashClientOptions {
 }
 declare const dashClient: (options?: DashClientOptions) => {
   id: "dash";
-  getActions: ($fetch: better_auth_client0.BetterFetch) => {
+  getActions: ($fetch: _better_fetch_fetch0.BetterFetch) => {
     dash: {
       getAuditLogs: (input?: DashGetAuditLogsInput) => Promise<{
         data: DashAuditLogsResponse;
@@ -97,15 +97,15 @@ declare const sentinelClient: (options?: SentinelClientOptions) => {
     id: string;
     name: string;
     hooks: {
-      onRequest<T extends Record<string, any>>(context: better_auth_client0.RequestContext<T>): Promise<better_auth_client0.RequestContext<T>>;
+      onRequest<T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>): Promise<_better_fetch_fetch0.RequestContext<T>>;
       onResponse?: undefined;
     };
   } | {
     id: string;
     name: string;
     hooks: {
-      onResponse(context: better_auth_client0.ResponseContext): Promise<better_auth_client0.ResponseContext>;
-      onRequest<T extends Record<string, any>>(context: better_auth_client0.RequestContext<T>): Promise<better_auth_client0.RequestContext<T>>;
+      onResponse(context: _better_fetch_fetch0.ResponseContext): Promise<_better_fetch_fetch0.ResponseContext>;
+      onRequest<T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>): Promise<_better_fetch_fetch0.RequestContext<T>>;
     };
   })[];
 };

package/dist/client.mjs

@@ -1,3 +1,4 @@
+import { r as KV_TIMEOUT_MS } from "./constants-DWl1utFw.mjs";
 import { env } from "@better-auth/core/env";
 
 //#region src/client.ts
@@ -415,9 +416,12 @@ async function sendIdentify(identifyUrl) {
 		await fetch(`${identifyUrl}/identify`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(payload)
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(KV_TIMEOUT_MS)
 		});
-	} catch {} finally {
+	} catch (error) {
+		console.warn("[Dash] Identify request failed:", error);
+	} finally {
 		identifyCompleteResolve?.();
 	}
 }

package/dist/constants-DWl1utFw.mjs

@@ -0,0 +1,18 @@
+import { env } from "@better-auth/core/env";
+
+//#region src/constants.ts
+/**
+* Infrastructure API URL
+* Can be overridden via plugin config or BETTER_AUTH_API_URL env var for local development
+*/
+const INFRA_API_URL = env.BETTER_AUTH_API_URL || "https://beta.better-auth.com";
+/**
+* KV Storage URL
+* Can be overridden via plugin config or BETTER_AUTH_KV_URL env var for local development
+*/
+const INFRA_KV_URL = env.BETTER_AUTH_KV_URL || "https://kv.better-auth.com";
+/** Timeout for KV HTTP operations (ms) */
+const KV_TIMEOUT_MS = 5e3;
+
+//#endregion
+export { INFRA_KV_URL as n, KV_TIMEOUT_MS as r, INFRA_API_URL as t };

package/dist/email.d.mts

@@ -168,11 +168,46 @@ type SendEmailOptions<T extends EmailTemplateId = EmailTemplateId> = {
    */
   subject?: string;
 };
+/**
+ * Options for sending bulk emails
+ */
+type SendBulkEmailsOptions<T extends EmailTemplateId = EmailTemplateId> = {
+  /**
+   * The template ID to use for all emails
+   */
+  template: T;
+  /**
+   * Array of recipients with their template variables
+   */
+  emails: Array<{
+    to: string;
+    variables?: EmailTemplateVariables<T>;
+  }>;
+  /**
+   * Optional subject override (shared across all emails)
+   */
+  subject?: string;
+  /**
+   * Optional shared variables applied to all emails (per-recipient variables override these)
+   */
+  variables?: Record<string, string>;
+};
+/**
+ * Result of a bulk email send operation
+ */
+interface SendBulkEmailsResult {
+  success: boolean;
+  failures?: Record<string, {
+    error?: string;
+    messageId?: string;
+  }[]>;
+}
 /**
  * Create an email sender instance
  */
 declare function createEmailSender(config?: EmailConfig): {
   send: <T extends EmailTemplateId>(options: SendEmailOptions<T>) => Promise<SendEmailResult>;
+  sendBulk: <T extends EmailTemplateId>(options: SendBulkEmailsOptions<T>) => Promise<SendBulkEmailsResult>;
   getTemplates: () => Promise<{
     id: string;
     name: string;
@@ -198,5 +233,22 @@ declare function createEmailSender(config?: EmailConfig): {
  * ```
  */
 declare function sendEmail<T extends EmailTemplateId>(options: SendEmailOptions<T>, config?: EmailConfig): Promise<SendEmailResult>;
+/**
+ * Send bulk emails using the Better Auth dashboard's email templates.
+ *
+ * @example
+ * ```ts
+ * import { sendBulkEmails } from "@better-auth/infra";
+ *
+ * const result = await sendBulkEmails({
+ *   template: "reset-password",
+ *   emails: [
+ *     { to: "user1@example.com", variables: { resetLink: "...", userEmail: "user1@example.com" } },
+ *     { to: "user2@example.com", variables: { resetLink: "...", userEmail: "user2@example.com" } },
+ *   ],
+ * });
+ * ```
+ */
+declare function sendBulkEmails<T extends EmailTemplateId>(options: SendBulkEmailsOptions<T>, config?: EmailConfig): Promise<SendBulkEmailsResult>;
 //#endregion
-export { EMAIL_TEMPLATES, EmailConfig, EmailTemplateId, EmailTemplateVariables, SendEmailOptions, SendEmailResult, createEmailSender, sendEmail };
+export { EMAIL_TEMPLATES, EmailConfig, EmailTemplateId, EmailTemplateVariables, SendBulkEmailsOptions, SendBulkEmailsResult, SendEmailOptions, SendEmailResult, createEmailSender, sendBulkEmails, sendEmail };

package/dist/email.mjs

@@ -1,3 +1,183 @@
-import { n as createEmailSender, r as sendEmail, t as EMAIL_TEMPLATES } from "./email-BGxJ96Ky.mjs";
+import { t as INFRA_API_URL } from "./constants-DWl1utFw.mjs";
+import { logger } from "better-auth";
+import { env } from "@better-auth/core/env";
 
-export { EMAIL_TEMPLATES, createEmailSender, sendEmail };
+//#region src/email.ts
+/**
+* Email sending module for @better-auth/infra
+*
+* This module provides email sending functionality that integrates with
+* Better Auth Infra's template system.
+*/
+/**
+* Email template definitions with their required variables
+*/
+const EMAIL_TEMPLATES = {
+	"verify-email": { variables: {} },
+	"reset-password": { variables: {} },
+	"change-email": { variables: {} },
+	"sign-in-otp": { variables: {} },
+	"verify-email-otp": { variables: {} },
+	"reset-password-otp": { variables: {} },
+	"magic-link": { variables: {} },
+	"two-factor": { variables: {} },
+	invitation: { variables: {} },
+	"application-invite": { variables: {} },
+	"delete-account": { variables: {} },
+	"stale-account-user": { variables: {} },
+	"stale-account-admin": { variables: {} }
+};
+/**
+* Create an email sender instance
+*/
+function createEmailSender(config) {
+	const baseUrl = config?.apiUrl || INFRA_API_URL;
+	const apiUrl = baseUrl.endsWith("/api") ? baseUrl : `${baseUrl}/api`;
+	const apiKey = config?.apiKey || env.BETTER_AUTH_API_KEY || "";
+	if (!apiKey) logger.warn("[Dash] No API key provided for email sending. Set BETTER_AUTH_API_KEY environment variable or pass apiKey in config.");
+	/**
+	* Send an email using a template from Better Auth Infra
+	*/
+	async function send(options) {
+		if (!apiKey) return {
+			success: false,
+			error: "API key not configured"
+		};
+		try {
+			const response = await fetch(`${apiUrl}/v1/email/send`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${apiKey}`
+				},
+				body: JSON.stringify({
+					template: options.template,
+					to: options.to,
+					variables: options.variables || {},
+					subject: options.subject
+				})
+			});
+			if (!response.ok) return {
+				success: false,
+				error: (await response.json().catch(() => ({ message: "Unknown error" }))).message || `HTTP ${response.status}`
+			};
+			return {
+				success: true,
+				messageId: (await response.json()).messageId
+			};
+		} catch (error) {
+			logger.warn("[Dash] Email send failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Failed to send email"
+			};
+		}
+	}
+	/**
+	* Send bulk emails using a template from Better Auth Infra
+	*/
+	async function sendBulk(options) {
+		if (!apiKey) return {
+			success: false,
+			failures: Object.fromEntries(options.emails.map((e) => [e.to, [{ error: "API key not configured" }]]))
+		};
+		try {
+			const response = await fetch(`${apiUrl}/v1/email/send-bulk`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${apiKey}`
+				},
+				body: JSON.stringify({
+					template: options.template,
+					emails: options.emails.map((e) => ({
+						to: e.to,
+						variables: e.variables || {}
+					})),
+					subject: options.subject,
+					variables: options.variables || {}
+				})
+			});
+			if (!response.ok) {
+				const error = await response.json().catch(() => ({ message: "Unknown error" }));
+				return {
+					success: false,
+					failures: Object.fromEntries(options.emails.map((e) => [e.to, [{ error: error.message || `HTTP ${response.status}` }]]))
+				};
+			}
+			const result = await response.json();
+			return {
+				success: result.success,
+				failures: result.failures
+			};
+		} catch (error) {
+			logger.warn("[Dash] Bulk email send failed:", error);
+			return {
+				success: false,
+				failures: Object.fromEntries(options.emails.map((e) => [e.to, [{ error: error instanceof Error ? error.message : "Failed to send bulk emails" }]]))
+			};
+		}
+	}
+	/**
+	* Get available email templates
+	*/
+	async function getTemplates() {
+		if (!apiKey) return [];
+		try {
+			const response = await fetch(`${apiUrl}/v1/email/templates`, { headers: { Authorization: `Bearer ${apiKey}` } });
+			if (!response.ok) return [];
+			return response.json();
+		} catch (error) {
+			logger.warn("[Dash] Failed to fetch email templates:", error);
+			return [];
+		}
+	}
+	return {
+		send,
+		sendBulk,
+		getTemplates
+	};
+}
+/**
+* Send an email using the Better Auth dashboard's email templates.
+*
+* @example
+* ```ts
+* import { sendEmail } from "@better-auth/infra";
+*
+* // Type-safe - variables are inferred from template
+* await sendEmail({
+*   template: "reset-password",
+*   to: "user@example.com",
+*   variables: {
+*     resetLink: "https://...",
+*     userEmail: "user@example.com",
+*   },
+* });
+* ```
+*/
+async function sendEmail(options, config) {
+	return createEmailSender(config).send(options);
+}
+/**
+* Send bulk emails using the Better Auth dashboard's email templates.
+*
+* @example
+* ```ts
+* import { sendBulkEmails } from "@better-auth/infra";
+*
+* const result = await sendBulkEmails({
+*   template: "reset-password",
+*   emails: [
+*     { to: "user1@example.com", variables: { resetLink: "...", userEmail: "user1@example.com" } },
+*     { to: "user2@example.com", variables: { resetLink: "...", userEmail: "user2@example.com" } },
+*   ],
+* });
+* ```
+*/
+async function sendBulkEmails(options, config) {
+	return createEmailSender(config).sendBulk(options);
+}
+
+//#endregion
+export { EMAIL_TEMPLATES, createEmailSender, sendBulkEmails, sendEmail };