@frigear-nu/notify 0.0.8 → 0.0.10

package/README.md

@@ -1,7 +1,7 @@
 # @frigear-nu/notify
 
 Generic notification driver/dispatch Nuxt module. Lets feature modules (e.g. `@frigear-nu/users`)
-dispatch email/SMS/simple notifications, and push UI toasts, without ever deciding how they're
+dispatch email/SMS/simple notifications without ever deciding how they're
 delivered - that choice (and configuration) belongs to the app/consuming layer.
 
 ## Quick Setup
@@ -13,8 +13,7 @@ want to configure it.
 ## Configuration
 
 Configure the module via the `notify` key in `nuxt.config.ts`. Every notification type (`email`,
-`sms`, `simple`) defaults to the built-in `log` driver (logs instead of sending) - only the
-`ui` driver has no default, since there's no sensible UI to push to unless you configure one:
+`sms`, `simple`) defaults to the built-in `log` driver (logs instead of sending):
 
 ```ts
 export default defineNuxtConfig({
@@ -33,19 +32,13 @@ export default defineNuxtConfig({
       // Same idea, matching the `SimpleDriver` signature, for generic push notifications.
       driver: 'log',
     },
-    ui: {
-      // Built-in `'@nuxt/ui'` driver (forwards to `@nuxt/ui`'s `useToast`), or a path to a
-      // function (default export) matching the `UIDriver` signature - a composable factory
-      // invoked once, synchronously, during `useNotify()`'s own setup-time call.
-      driver: '@nuxt/ui',
-    },
   },
 })
 ```
 
-Only the configured driver for each notification type is ever resolved/loaded - unconfigured
-drivers (e.g. the `ui` driver when `notify.ui` isn't set) are never bundled, to keep the client
-bundle small.
+Only the configured driver for each notification type is ever resolved/loaded.
+
+In-app toasts are not part of this module: call `useToast()` from Nuxt UI directly.
 
 #### Example Custom Driver
 
@@ -86,21 +79,31 @@ await dispatchSimpleNotification({
 })
 ```
 
-### UI notifications
+## Built-in email drivers: `resend`, `ses`, `cloudflare`
 
-When `notify.ui.driver` is configured, `useNotify` is auto-imported client-side to push
-`UINotification`s through the configured driver (e.g. `@nuxt/ui`'s `useToast`):
+Zero dependencies and zero config beyond environment variables - each driver talks to its provider with plain `fetch`
+(SES requests are signed with AWS SigV4 via Web Crypto). The driver and its credentials are read at **runtime**, so
+you can switch providers per environment without rebuilding:
 
-```vue
-<script setup lang="ts">
-const notify = useNotify()
+```bash
+NUXT_NOTIFY_EMAIL_DRIVER=resend   # log (default) | resend | ses | cloudflare
+NUXT_NOTIFY_EMAIL_FROM="Frigear <no-reply@frigear.nu>"
 
-function onSuccess() {
-  notify.addNotification(defineUINotification({
-    title: 'Saved',
-    text: 'Your changes have been saved.',
-    type: 'success',
-  }))
-}
-</script>
+# resend
+NUXT_NOTIFY_EMAIL_RESEND_API_TOKEN=...
+
+# ses (v2 API)
+NUXT_NOTIFY_EMAIL_SES_REGION=eu-west-1
+NUXT_NOTIFY_EMAIL_SES_ACCESS_KEY_ID=...
+NUXT_NOTIFY_EMAIL_SES_SECRET_ACCESS_KEY=...
+NUXT_NOTIFY_EMAIL_SES_SESSION_TOKEN=...   # optional, for temporary credentials
+
+# cloudflare (Email Service)
+NUXT_NOTIFY_EMAIL_CLOUDFLARE_ACCOUNT_ID=...
+NUXT_NOTIFY_EMAIL_CLOUDFLARE_API_TOKEN=...
 ```
+
+Setting `notify.email.driver` in `nuxt.config.ts` to one of these names only changes the default; the env var still
+wins. A missing credential fails the send with an error naming the variable to set. Any other `driver` value is still
+treated as a path to a custom `EmailDriver`.
+

package/dist/module.d.mts

@@ -15,15 +15,6 @@ interface SimpleNotification<M = Record<string, unknown>> {
     url?: string;
     meta?: M;
 }
-/**
- * A notification that is intended to be displayed in the UI, e.g. via a toast or snackbar.
- * The `type` field can be used to determine the styling of the notification.
- */
-interface UINotification<A = unknown, M = NotificationMeta> extends SimpleNotification<M> {
-    type?: 'success' | 'error' | 'info' | 'warning';
-    actions?: A[];
-    meta?: M;
-}
 /**
  * Generic, transport-agnostic SMS notification. Concrete notifications (e.g. a password reset)
  * build one of these and hand it to `dispatchSMSNotification`, similar in spirit to how Laravel
@@ -46,6 +37,8 @@ interface EmailNotification<M = NotificationMeta> {
     body: string;
     /** Optional plain-text body. */
     text?: string;
+    /** Address replies should go to (the `Reply-To` header). */
+    replyTo?: string;
     meta?: M;
 }
 /**
@@ -56,18 +49,9 @@ interface EmailNotification<M = NotificationMeta> {
 type SimpleDriver = (notification: SimpleNotification) => Promise<void> | void;
 type SMSDriver = (notification: SMSNotification) => Promise<void> | void;
 type EmailDriver = (notification: EmailNotification) => Promise<void> | void;
-/**
- * Unlike the server-side drivers above, a UI driver is a *composable factory*: `useNotify()` calls
- * it once, synchronously, during its own (setup-time) invocation, and uses the function it returns
- * to actually dispatch notifications later. This is required because driver implementations that
- * need Vue's `inject()` (e.g. the built-in `@nuxt/ui` driver's `useToast()`) only work when called
- * during a component's `setup()` - resolving them lazily, when a notification is dispatched (e.g.
- * from a `setInterval` callback), runs outside any component and breaks `inject()`.
- */
-type UIDriver = () => (notification: UINotification) => Promise<void> | void;
 type ModuleOptions = {
     email?: {
-        driver?: string | 'log';
+        driver?: 'log' | 'resend' | 'ses' | 'cloudflare' | (string & {});
     };
     sms?: {
         driver?: string | 'log';
@@ -78,8 +62,30 @@ type ModuleOptions = {
     push?: {
         driver?: string;
     };
-    ui?: {
-        driver?: string | '@nuxt/ui';
+};
+/** Private runtime config (`runtimeConfig.notify`), overridable through `NUXT_NOTIFY_*` env vars. */
+type NotifyRuntimeConfig = {
+    email: {
+        /** `NUXT_NOTIFY_EMAIL_DRIVER`: `log` (default), `resend`, `ses` or `cloudflare`. */
+        driver: string;
+        /** `NUXT_NOTIFY_EMAIL_FROM`: sender address, e.g. `Frigear <no-reply@frigear.nu>`. */
+        from: string;
+        /** `NUXT_NOTIFY_EMAIL_RESEND_API_TOKEN` */
+        resend: {
+            apiToken: string;
+        };
+        /** `NUXT_NOTIFY_EMAIL_SES_REGION`, `_ACCESS_KEY_ID`, `_SECRET_ACCESS_KEY`, `_SESSION_TOKEN` (optional) */
+        ses: {
+            region: string;
+            accessKeyId: string;
+            secretAccessKey: string;
+            sessionToken: string;
+        };
+        /** `NUXT_NOTIFY_EMAIL_CLOUDFLARE_ACCOUNT_ID`, `_API_TOKEN` */
+        cloudflare: {
+            accountId: string;
+            apiToken: string;
+        };
     };
 };
 
@@ -87,8 +93,11 @@ declare module '@nuxt/schema' {
     interface NuxtConfig {
         notify?: ModuleOptions;
     }
+    interface RuntimeConfig {
+        notify: NotifyRuntimeConfig;
+    }
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { _default as default };
-export type { EmailDriver, EmailNotification, ModuleOptions, SMSDriver, SMSNotification, SimpleDriver, SimpleNotification, UIDriver, UINotification };
+export type { EmailDriver, EmailNotification, ModuleOptions, SMSDriver, SMSNotification, SimpleDriver, SimpleNotification };

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@frigear-nu/notify",
   "configKey": "notify",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,13 +1,12 @@
-import { defineNuxtModule, createResolver, hasNuxtModule, addImports, addTemplate, addTypeTemplate, addServerImportsDir, addServerTemplate } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addServerImportsDir, addServerTemplate, addTypeTemplate } from '@nuxt/kit';
+import { defu } from 'defu';
 import { joinURL } from 'ufo';
 
-const BUILTIN_UI_DRIVERS = {
-  "log": { path: "./runtime/drivers/log", exportName: "logUIDriver" },
-  "@nuxt/ui": { path: "./runtime/drivers/ui/nuxt.ui", exportName: "default" }
-};
 const BUILTIN_SERVER_DRIVERS = {
   log: { path: "./runtime/drivers/log", exportName: "logDriver" }
 };
+const BUILTIN_EMAIL_DRIVERS = ["log", "resend", "ses", "cloudflare"];
+const AUTO_EMAIL_DRIVER = { path: "./runtime/drivers/email/index", exportName: "default" };
 const module$1 = defineNuxtModule({
   meta: { name: "@frigear-nu/notify", configKey: "notify" },
   defaults: {
@@ -15,83 +14,49 @@ const module$1 = defineNuxtModule({
     sms: { driver: "log" },
     simple: { driver: "log" }
   },
-  moduleDependencies: {
-    "@nuxt/ui": {
-      optional: true,
-      version: ">=4.10"
-    }
-  },
   async setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
-    if (options.ui?.driver) {
-      if (options.ui.driver === "@nuxt/ui" && !hasNuxtModule("@nuxt/ui")) {
-        throw new Error(`@nuxt/ui driver is configured but @nuxt/ui module is not installed. Please install @nuxt/ui or configure a different UI driver.`);
-      }
-      addImports({
-        name: "useNotify",
-        as: "useNotify",
-        from: resolver.resolve("./runtime/app/composables/useNotify")
-      });
-      addImports({
-        name: "defineUINotification",
-        as: "defineUINotification",
-        from: resolver.resolve("./runtime/server/utils/definers")
-      });
-      const uiDriverTemplate = addTemplate({
-        filename: "#notify/ui-driver.ts",
-        write: true,
+    const registerServerDriver = (name, driverType, driver, builtins = BUILTIN_SERVER_DRIVERS) => {
+      const filename = `#notify/${name}`;
+      const template = addServerTemplate({
+        filename,
         getContents: async () => {
-          const builtin = BUILTIN_UI_DRIVERS[options.ui?.driver];
+          const builtin = builtins[driver];
           if (builtin) {
             return `export { ${builtin.exportName} as default } from ${JSON.stringify(await resolver.resolvePath(builtin.path))}`;
           }
-          if (!options.ui?.driver) {
-            throw new Error(`Invalid UI driver: ${options.ui?.driver || "undefined"}`);
-          }
-          const driverPath = await resolver.resolvePath(options.ui.driver, { cwd: nuxt.options.rootDir });
+          const driverPath = await resolver.resolvePath(driver, { cwd: nuxt.options.rootDir });
           return `export { default } from ${JSON.stringify(driverPath)}`;
         }
       });
-      nuxt.options.alias["#notify/ui-driver"] = uiDriverTemplate.dst;
+      nuxt.options.nitro.alias ||= {};
+      nuxt.options.nitro.alias[`#notify/${name}`] = joinURL(template.filename, ".ts");
       addTypeTemplate({
-        filename: "types/notify-ui-driver.d.ts",
-        getContents: () => `declare module '#notify/ui-driver' {
-  import type { UIDriver } from ${JSON.stringify(resolver.resolve("./types"))}
-  const driver: UIDriver
-  export default driver
-}
-`
-      });
-      const registerServerDriver = (name, driverType, driver) => {
-        const filename = `#notify/${name}`;
-        const template = addServerTemplate({
-          filename,
-          getContents: async () => {
-            const builtin = BUILTIN_SERVER_DRIVERS[driver];
-            if (builtin) {
-              return `export { ${builtin.exportName} as default } from ${JSON.stringify(await resolver.resolvePath(builtin.path))}`;
-            }
-            const driverPath = await resolver.resolvePath(driver, { cwd: nuxt.options.rootDir });
-            return `export { default } from ${JSON.stringify(driverPath)}`;
-          }
-        });
-        nuxt.options.nitro.alias ||= {};
-        nuxt.options.nitro.alias[`#notify/${name}`] = joinURL(template.filename, ".ts");
-        addTypeTemplate({
-          filename: `types/notify-${name}.d.ts`,
-          getContents: () => `declare module '#notify/${name}' {
+        filename: `types/notify-${name}.d.ts`,
+        getContents: () => `declare module '#notify/${name}' {
   import type { ${driverType} } from ${JSON.stringify(resolver.resolve("./types"))}
   const driver: ${driverType}
   export default driver
 }
 `
-        }, { nitro: true, nuxt: true });
-      };
-      registerServerDriver("email-driver", "EmailDriver", options.email?.driver ?? "log");
-      registerServerDriver("sms-driver", "SMSDriver", options.sms?.driver ?? "log");
-      registerServerDriver("simple-driver", "SimpleDriver", options.simple?.driver ?? "log");
-      addServerImportsDir(resolver.resolve("./runtime/server/utils"));
-    }
+      }, { nitro: true, nuxt: true });
+    };
+    const emailDriver = options.email?.driver || "log";
+    const emailBuiltin = BUILTIN_EMAIL_DRIVERS.includes(emailDriver);
+    const runtimeConfig = nuxt.options.runtimeConfig;
+    runtimeConfig.notify = defu(runtimeConfig.notify, {
+      email: {
+        driver: emailBuiltin ? emailDriver : "",
+        from: "",
+        resend: { apiToken: "" },
+        ses: { region: "", accessKeyId: "", secretAccessKey: "", sessionToken: "" },
+        cloudflare: { accountId: "", apiToken: "" }
+      }
+    });
+    registerServerDriver("email-driver", "EmailDriver", emailBuiltin ? "auto" : emailDriver, { auto: AUTO_EMAIL_DRIVER });
+    registerServerDriver("sms-driver", "SMSDriver", options.sms?.driver ?? "log");
+    registerServerDriver("simple-driver", "SimpleDriver", options.simple?.driver ?? "log");
+    addServerImportsDir(resolver.resolve("./runtime/server/utils"));
   }
 });
 

package/dist/runtime/drivers/email/cloudflare.d.ts

@@ -0,0 +1,7 @@
+import type { EmailDriver } from '../../../types.js';
+import { type EmailConfig } from './shared.js';
+export interface CloudflareConfig extends EmailConfig {
+    accountId?: string;
+    apiToken?: string;
+}
+export declare const createCloudflareDriver: (config: CloudflareConfig) => EmailDriver;

package/dist/runtime/drivers/email/cloudflare.js

@@ -0,0 +1,20 @@
+import { assertOk, requireConfig, resolveFrom, toArray } from "./shared.js";
+export const createCloudflareDriver = (config) => async (n) => {
+  const accountId = requireConfig(config.accountId, "NUXT_NOTIFY_EMAIL_CLOUDFLARE_ACCOUNT_ID");
+  const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/email/sending/send`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${requireConfig(config.apiToken, "NUXT_NOTIFY_EMAIL_CLOUDFLARE_API_TOKEN")}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      from: resolveFrom(config),
+      to: toArray(n.to),
+      subject: n.subject,
+      html: n.body,
+      text: n.text,
+      reply_to: n.replyTo
+    })
+  });
+  await assertOk("Cloudflare", response);
+};

package/dist/runtime/drivers/email/index.d.ts

@@ -0,0 +1,9 @@
+import type { EmailDriver } from '../../../types.js';
+export declare const EMAIL_DRIVER_NAMES: readonly ["log", "resend", "ses", "cloudflare"];
+/**
+ * Default `#notify/email-driver`. Environment variables only exist at runtime, so the concrete
+ * driver is chosen per send from `runtimeConfig.notify.email` (`NUXT_NOTIFY_EMAIL_DRIVER`), and
+ * only that driver's code is loaded.
+ */
+declare const autoDriver: EmailDriver;
+export default autoDriver;

package/dist/runtime/drivers/email/index.js

@@ -0,0 +1,21 @@
+import { useRuntimeConfig } from "#imports";
+import { logDriver } from "../log.js";
+export const EMAIL_DRIVER_NAMES = ["log", "resend", "ses", "cloudflare"];
+const autoDriver = async (notification) => {
+  const config = useRuntimeConfig().notify?.email ?? {};
+  const name = config.driver || "log";
+  const base = { from: config.from };
+  switch (name) {
+    case "log":
+      return logDriver(notification);
+    case "resend":
+      return (await import("./resend.js")).createResendDriver({ ...base, ...config.resend })(notification);
+    case "ses":
+      return (await import("./ses.js")).createSesDriver({ ...base, ...config.ses })(notification);
+    case "cloudflare":
+      return (await import("./cloudflare.js")).createCloudflareDriver({ ...base, ...config.cloudflare })(notification);
+    default:
+      throw new Error(`[notify] Unknown email driver "${name}" (NUXT_NOTIFY_EMAIL_DRIVER). Expected one of: ${EMAIL_DRIVER_NAMES.join(", ")}`);
+  }
+};
+export default autoDriver;

package/dist/runtime/drivers/email/resend.d.ts

@@ -0,0 +1,6 @@
+import type { EmailDriver } from '../../../types.js';
+import { type EmailConfig } from './shared.js';
+export interface ResendConfig extends EmailConfig {
+    apiToken?: string;
+}
+export declare const createResendDriver: (config: ResendConfig) => EmailDriver;

package/dist/runtime/drivers/email/resend.js

@@ -0,0 +1,19 @@
+import { assertOk, requireConfig, resolveFrom, toArray } from "./shared.js";
+export const createResendDriver = (config) => async (n) => {
+  const response = await fetch("https://api.resend.com/emails", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${requireConfig(config.apiToken, "NUXT_NOTIFY_EMAIL_RESEND_API_TOKEN")}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      from: resolveFrom(config),
+      to: toArray(n.to),
+      subject: n.subject,
+      html: n.body,
+      text: n.text,
+      reply_to: n.replyTo
+    })
+  });
+  await assertOk("Resend", response);
+};

package/dist/runtime/drivers/email/ses.d.ts

@@ -0,0 +1,9 @@
+import type { EmailDriver } from '../../../types.js';
+import { type EmailConfig } from './shared.js';
+export interface SesConfig extends EmailConfig {
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+}
+export declare const createSesDriver: (config: SesConfig) => EmailDriver;

package/dist/runtime/drivers/email/ses.js

@@ -0,0 +1,33 @@
+import { assertOk, requireConfig, resolveFrom, toArray } from "./shared.js";
+import { signRequest } from "./sigv4.js";
+export const createSesDriver = (config) => async (n) => {
+  const region = requireConfig(config.region, "NUXT_NOTIFY_EMAIL_SES_REGION");
+  const accessKeyId = requireConfig(config.accessKeyId, "NUXT_NOTIFY_EMAIL_SES_ACCESS_KEY_ID");
+  const secretAccessKey = requireConfig(config.secretAccessKey, "NUXT_NOTIFY_EMAIL_SES_SECRET_ACCESS_KEY");
+  const url = `https://email.${region}.amazonaws.com/v2/email/outbound-emails`;
+  const body = JSON.stringify({
+    FromEmailAddress: resolveFrom(config),
+    Destination: { ToAddresses: toArray(n.to) },
+    ReplyToAddresses: n.replyTo ? [n.replyTo] : void 0,
+    Content: {
+      Simple: {
+        Subject: { Data: n.subject, Charset: "UTF-8" },
+        Body: {
+          Html: { Data: n.body, Charset: "UTF-8" },
+          ...n.text ? { Text: { Data: n.text, Charset: "UTF-8" } } : {}
+        }
+      }
+    }
+  });
+  const headers = await signRequest({
+    method: "POST",
+    url,
+    body,
+    region,
+    service: "ses",
+    accessKeyId,
+    secretAccessKey,
+    sessionToken: config.sessionToken || void 0
+  });
+  await assertOk("SES", await fetch(url, { method: "POST", headers, body }));
+};

package/dist/runtime/drivers/email/shared.d.ts

@@ -0,0 +1,11 @@
+import type { EmailNotification } from '../../../types.js';
+export interface EmailConfig {
+    from?: string;
+}
+export declare const toArray: (value: string | string[]) => string[];
+/** Throws a config error naming the env var an operator needs to set. */
+export declare function requireConfig(value: string | undefined, envVar: string): string;
+export declare const resolveFrom: (config: EmailConfig) => string;
+/** Throws with the provider's response body for any non-2xx response. */
+export declare function assertOk(provider: string, response: Response): Promise<void>;
+export type { EmailNotification };

package/dist/runtime/drivers/email/shared.js

@@ -0,0 +1,14 @@
+export const toArray = (value) => Array.isArray(value) ? value : [value];
+export function requireConfig(value, envVar) {
+  if (!value) {
+    throw new Error(`[notify] Missing email configuration: set ${envVar}`);
+  }
+  return value;
+}
+export const resolveFrom = (config) => requireConfig(config.from, "NUXT_NOTIFY_EMAIL_FROM");
+export async function assertOk(provider, response) {
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(`[notify] ${provider} responded ${response.status}${detail ? `: ${detail}` : ""}`);
+  }
+}

package/dist/runtime/drivers/email/sigv4.d.ts

@@ -0,0 +1,14 @@
+export interface SignOptions {
+    method: string;
+    url: string;
+    body: string;
+    region: string;
+    service: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    /** Injectable for tests. */
+    now?: Date;
+}
+/** Returns the headers (including `Authorization`) to send with the request. */
+export declare function signRequest(o: SignOptions): Promise<Record<string, string>>;

package/dist/runtime/drivers/email/sigv4.js

@@ -0,0 +1,38 @@
+const encoder = new TextEncoder();
+const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+const sha256Hex = async (data) => hex(await crypto.subtle.digest("SHA-256", encoder.encode(data)));
+async function hmac(key, data) {
+  const raw = typeof key === "string" ? encoder.encode(key) : key;
+  const cryptoKey = await crypto.subtle.importKey("raw", raw, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return crypto.subtle.sign("HMAC", cryptoKey, encoder.encode(data));
+}
+export async function signRequest(o) {
+  const url = new URL(o.url);
+  const amzDate = (o.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:-]|\.\d{3}/g, "");
+  const dateStamp = amzDate.slice(0, 8);
+  const payloadHash = await sha256Hex(o.body);
+  const headers = {
+    "content-type": "application/json",
+    "host": url.host,
+    "x-amz-content-sha256": payloadHash,
+    "x-amz-date": amzDate
+  };
+  if (o.sessionToken) headers["x-amz-security-token"] = o.sessionToken;
+  const names = Object.keys(headers).sort();
+  const canonicalHeaders = names.map((n) => `${n}:${headers[n].trim()}
+`).join("");
+  const signedHeaders = names.join(";");
+  const canonicalRequest = [o.method, url.pathname, url.searchParams.toString(), canonicalHeaders, signedHeaders, payloadHash].join("\n");
+  const scope = `${dateStamp}/${o.region}/${o.service}/aws4_request`;
+  const stringToSign = ["AWS4-HMAC-SHA256", amzDate, scope, await sha256Hex(canonicalRequest)].join("\n");
+  const kDate = await hmac(`AWS4${o.secretAccessKey}`, dateStamp);
+  const kRegion = await hmac(kDate, o.region);
+  const kService = await hmac(kRegion, o.service);
+  const kSigning = await hmac(kService, "aws4_request");
+  const signature = hex(await hmac(kSigning, stringToSign));
+  const { host: _host, ...sendable } = headers;
+  return {
+    ...sendable,
+    Authorization: `AWS4-HMAC-SHA256 Credential=${o.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`
+  };
+}

package/dist/runtime/drivers/log.d.ts

@@ -1,14 +1,7 @@
-import type { SimpleNotification, UINotification, SMSNotification, EmailNotification, UIDriver } from '../../types.js';
+import type { SimpleNotification, SMSNotification, EmailNotification } from '../../types.js';
 /**
  * Logs the notification instead of sending it. Safe default for development/unconfigured setups,
  * and a reference implementation for the `EmailDriver` signature.
  */
-export declare const logDriver: (notification: SimpleNotification | UINotification | SMSNotification | EmailNotification) => void;
-/**
- * `UIDriver`-shaped version of `logDriver` - unlike the server-side drivers, UI drivers are
- * composable factories (see `UIDriver`'s doc comment), so this just wraps `logDriver` in one to
- * use as the built-in `'log'` UI driver. Doesn't call any Vue composables itself, so there's
- * nothing `inject()`-sensitive here - it works the same called eagerly or lazily.
- */
-export declare const logUIDriver: UIDriver;
+export declare const logDriver: (notification: SimpleNotification | SMSNotification | EmailNotification) => void;
 export default logDriver;

package/dist/runtime/drivers/log.js

@@ -1,5 +1,4 @@
 export const logDriver = (notification) => {
   console.log("[notify] Dispatching notification:", notification);
 };
-export const logUIDriver = () => (notification) => logDriver(notification);
 export default logDriver;

package/dist/runtime/server/utils/definers.d.ts

@@ -1,9 +1,7 @@
-import type { SimpleDriver, UIDriver, SMSDriver, EmailDriver, SimpleNotification, UINotification, SMSNotification, EmailNotification } from '../../../types.js';
+import type { SimpleDriver, SMSDriver, EmailDriver, SimpleNotification, SMSNotification, EmailNotification } from '../../../types.js';
 export declare const defineSimpleNotification: <T extends SimpleNotification>(notification: T) => T;
-export declare const defineUINotification: <T extends UINotification>(notification: T) => T;
 export declare const defineEmailNotification: <T extends EmailNotification>(notification: T) => T;
 export declare const defineSMSNotification: <T extends SMSNotification>(notification: T) => T;
 export declare const defineSimpleDriver: (driver: SimpleDriver) => SimpleDriver;
-export declare const defineUIDriver: (driver: UIDriver) => UIDriver;
 export declare const defineSMSDriver: (driver: SMSDriver) => SMSDriver;
 export declare const defineEmailDriver: (driver: EmailDriver) => EmailDriver;

package/dist/runtime/server/utils/definers.js

@@ -1,8 +1,6 @@
 export const defineSimpleNotification = (notification) => notification;
-export const defineUINotification = (notification) => notification;
 export const defineEmailNotification = (notification) => notification;
 export const defineSMSNotification = (notification) => notification;
 export const defineSimpleDriver = (driver) => driver;
-export const defineUIDriver = (driver) => driver;
 export const defineSMSDriver = (driver) => driver;
 export const defineEmailDriver = (driver) => driver;

package/dist/types.d.mts

@@ -1,3 +1,3 @@
 export { default } from './module.mjs'
 
-export { type EmailDriver, type EmailNotification, type ModuleOptions, type SMSDriver, type SMSNotification, type SimpleDriver, type SimpleNotification, type UIDriver, type UINotification } from './module.mjs'
+export { type EmailDriver, type EmailNotification, type ModuleOptions, type SMSDriver, type SMSNotification, type SimpleDriver, type SimpleNotification } from './module.mjs'

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@frigear-nu/notify",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
-  "description": "Framework-agnostic email notification driver/dispatch Nuxt module, shared across Frigear modules.",
+  "description": "Email, SMS and generic notification dispatch (pluggable drivers) Nuxt module, shared across Frigear modules.",
   "license": "MIT",
   "homepage": "https://docs.frigear.dev/modules/notify",
   "repository": {
@@ -22,6 +22,7 @@
   ],
   "dependencies": {
     "@nuxt/kit": "^4.6.0",
+    "defu": "^6.1.7",
     "ufo": "^1.6.4"
   },
   "devDependencies": {
@@ -36,15 +37,13 @@
     "vitest": "^5.0.1",
     "vue-tsc": "^3.3.11"
   },
-  "optionalDependencies": {
-    "@nuxt/ui": ">=4.10.0"
-  },
   "scripts": {
     "postinstall": "nuxt-module-build build --stub && nuxt prepare",
     "build": "nuxt-module-build build",
     "dev": "npm run dev:prepare && nuxt dev playground",
     "dev:build": "nuxt build playground",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "test": "vitest run",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },

package/dist/runtime/app/composables/useNotify.d.ts

@@ -1,11 +0,0 @@
-import type { UINotification } from '../../../types.js';
-/**
- * App-side composable for pushing `UINotification`s through the configured UI driver (e.g. the
- * `@nuxt/ui` driver, which forwards them to `useToast`). Only registered when `notify.ui.driver`
- * is configured - see `setup()` in the module.
- */
-export declare const useNotify: () => {
-    notifications: import("vue").Ref<UINotification<unknown, import("../../../types.js").NotificationMeta<Record<string, unknown>>>[], UINotification<unknown, import("../../../types.js").NotificationMeta<Record<string, unknown>>>[]>;
-    addNotification: (notification: UINotification) => any;
-    add: (notification: UINotification) => any;
-};

package/dist/runtime/app/composables/useNotify.js

@@ -1,16 +0,0 @@
-import { useState } from "#imports";
-import uiDriver from "#notify/ui-driver";
-export const useNotify = () => {
-  const notifications = useState("notify-notifications", () => []);
-  const dispatch = uiDriver();
-  const add = (notification) => {
-    notifications.value.push(notification);
-    return dispatch(notification);
-  };
-  return {
-    notifications,
-    // `addNotification` is an alias for `add` to make the API more explicit and self-documenting
-    addNotification: add,
-    add
-  };
-};

package/dist/runtime/drivers/ui/nuxt.ui.d.ts

@@ -1,2 +0,0 @@
-declare const nuxtUiDriver: import("../../../types.js").UIDriver;
-export default nuxtUiDriver;

package/dist/runtime/drivers/ui/nuxt.ui.js

@@ -1,20 +0,0 @@
-import { useToast } from "#imports";
-import { defineUIDriver } from "../../server/utils/definers.js";
-const COLOR_BY_TYPE = {
-  success: "success",
-  error: "error",
-  warning: "warning",
-  info: "info"
-};
-const nuxtUiDriver = defineUIDriver(() => {
-  const toast = useToast();
-  return (notification) => {
-    toast.add({
-      title: notification.title,
-      description: notification.text,
-      color: COLOR_BY_TYPE[notification?.type ?? "info"],
-      actions: notification?.actions
-    });
-  };
-});
-export default nuxtUiDriver;