@develit-services/notification 0.5.1 → 0.6.1

package/dist/export/worker.d.cts

@@ -1,16 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { S as SlackConnector, I as IEmailConnector, a as ISmsConnector, t as tables, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput } from '../shared/notification.B4ZLWDCP.cjs';
+import { s as schema } from '../database/schema.cjs';
+import { S as SlackConnector, W as WebhookConnector, I as IEmailConnector, a as ISmsConnector, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput, h as SendWebhookInput, i as SendWebhookOutput, G as GetReceivedEmailsInput, j as GetReceivedEmailsOutput, k as WaitForEmailInput, l as WaitForEmailOutput, C as ClearReceivedEmailsInput, m as ClearReceivedEmailsOutput } from '../shared/notification.BiG4Q650.cjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import '../shared/notification.BWLPh6Gb.cjs';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
 import 'zod/v4';
 
+declare const tables: typeof schema;
+
 declare const NotificationServiceBase_base: (abstract new (ctx: ExecutionContext, env: NotificationEnv) => WorkerEntrypoint<NotificationEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class NotificationServiceBase extends NotificationServiceBase_base {
     readonly slackConnector: SlackConnector;
+    protected webhookConnector: WebhookConnector;
     protected emailConnector: IEmailConnector;
     protected smsConnector: ISmsConnector;
     readonly db: DrizzleD1Database<typeof tables>;
@@ -23,6 +25,23 @@ declare class NotificationServiceBase extends NotificationServiceBase_base {
     sendSms(input: SendSmsInput): Promise<IRPCResponse<SendSmsOutput>>;
     protected _sendPushNotification(): Promise<IRPCResponse<{}>>;
     sendSlackNotification(input: SendSlackInput): Promise<IRPCResponse<SendSlackOutput>>;
+    sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    protected _sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    /**
+     * Get received emails from KV storage
+     * Used primarily for E2E testing
+     */
+    getReceivedEmails(input: GetReceivedEmailsInput): Promise<IRPCResponse<GetReceivedEmailsOutput>>;
+    /**
+     * Wait for an email to arrive (polling helper for E2E tests)
+     * NOTE: Limited to 5 second timeout to prevent blocking
+     */
+    waitForEmail(input: WaitForEmailInput): Promise<IRPCResponse<WaitForEmailOutput>>;
+    /**
+     * Clear received emails for a recipient (cleanup helper)
+     * Used primarily for E2E testing
+     */
+    clearReceivedEmails(input: ClearReceivedEmailsInput): Promise<IRPCResponse<ClearReceivedEmailsOutput>>;
 }
 declare function defineNotificationService(): new (ctx: ExecutionContext, env: NotificationEnv) => NotificationServiceBase;
 

package/dist/export/worker.d.mts

@@ -1,16 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { S as SlackConnector, I as IEmailConnector, a as ISmsConnector, t as tables, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput } from '../shared/notification.CpFoKjoN.mjs';
+import { s as schema } from '../database/schema.mjs';
+import { S as SlackConnector, W as WebhookConnector, I as IEmailConnector, a as ISmsConnector, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput, h as SendWebhookInput, i as SendWebhookOutput, G as GetReceivedEmailsInput, j as GetReceivedEmailsOutput, k as WaitForEmailInput, l as WaitForEmailOutput, C as ClearReceivedEmailsInput, m as ClearReceivedEmailsOutput } from '../shared/notification.BiG4Q650.mjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import '../shared/notification.BWLPh6Gb.mjs';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
 import 'zod/v4';
 
+declare const tables: typeof schema;
+
 declare const NotificationServiceBase_base: (abstract new (ctx: ExecutionContext, env: NotificationEnv) => WorkerEntrypoint<NotificationEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class NotificationServiceBase extends NotificationServiceBase_base {
     readonly slackConnector: SlackConnector;
+    protected webhookConnector: WebhookConnector;
     protected emailConnector: IEmailConnector;
     protected smsConnector: ISmsConnector;
     readonly db: DrizzleD1Database<typeof tables>;
@@ -23,6 +25,23 @@ declare class NotificationServiceBase extends NotificationServiceBase_base {
     sendSms(input: SendSmsInput): Promise<IRPCResponse<SendSmsOutput>>;
     protected _sendPushNotification(): Promise<IRPCResponse<{}>>;
     sendSlackNotification(input: SendSlackInput): Promise<IRPCResponse<SendSlackOutput>>;
+    sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    protected _sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    /**
+     * Get received emails from KV storage
+     * Used primarily for E2E testing
+     */
+    getReceivedEmails(input: GetReceivedEmailsInput): Promise<IRPCResponse<GetReceivedEmailsOutput>>;
+    /**
+     * Wait for an email to arrive (polling helper for E2E tests)
+     * NOTE: Limited to 5 second timeout to prevent blocking
+     */
+    waitForEmail(input: WaitForEmailInput): Promise<IRPCResponse<WaitForEmailOutput>>;
+    /**
+     * Clear received emails for a recipient (cleanup helper)
+     * Used primarily for E2E testing
+     */
+    clearReceivedEmails(input: ClearReceivedEmailsInput): Promise<IRPCResponse<ClearReceivedEmailsOutput>>;
 }
 declare function defineNotificationService(): new (ctx: ExecutionContext, env: NotificationEnv) => NotificationServiceBase;
 

package/dist/export/worker.d.ts

@@ -1,16 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { S as SlackConnector, I as IEmailConnector, a as ISmsConnector, t as tables, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput } from '../shared/notification.DWuoMDHY.js';
+import { s as schema } from '../database/schema.js';
+import { S as SlackConnector, W as WebhookConnector, I as IEmailConnector, a as ISmsConnector, N as NotificationQueueMessage, b as SendEmailInput, c as SendEmailOutput, d as SendSmsInput, e as SendSmsOutput, f as SendSlackInput, g as SendSlackOutput, h as SendWebhookInput, i as SendWebhookOutput, G as GetReceivedEmailsInput, j as GetReceivedEmailsOutput, k as WaitForEmailInput, l as WaitForEmailOutput, C as ClearReceivedEmailsInput, m as ClearReceivedEmailsOutput } from '../shared/notification.BiG4Q650.js';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import '../shared/notification.BWLPh6Gb.js';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
 import 'zod/v4';
 
+declare const tables: typeof schema;
+
 declare const NotificationServiceBase_base: (abstract new (ctx: ExecutionContext, env: NotificationEnv) => WorkerEntrypoint<NotificationEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class NotificationServiceBase extends NotificationServiceBase_base {
     readonly slackConnector: SlackConnector;
+    protected webhookConnector: WebhookConnector;
     protected emailConnector: IEmailConnector;
     protected smsConnector: ISmsConnector;
     readonly db: DrizzleD1Database<typeof tables>;
@@ -23,6 +25,23 @@ declare class NotificationServiceBase extends NotificationServiceBase_base {
     sendSms(input: SendSmsInput): Promise<IRPCResponse<SendSmsOutput>>;
     protected _sendPushNotification(): Promise<IRPCResponse<{}>>;
     sendSlackNotification(input: SendSlackInput): Promise<IRPCResponse<SendSlackOutput>>;
+    sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    protected _sendWebhook(input: SendWebhookInput): Promise<IRPCResponse<SendWebhookOutput>>;
+    /**
+     * Get received emails from KV storage
+     * Used primarily for E2E testing
+     */
+    getReceivedEmails(input: GetReceivedEmailsInput): Promise<IRPCResponse<GetReceivedEmailsOutput>>;
+    /**
+     * Wait for an email to arrive (polling helper for E2E tests)
+     * NOTE: Limited to 5 second timeout to prevent blocking
+     */
+    waitForEmail(input: WaitForEmailInput): Promise<IRPCResponse<WaitForEmailOutput>>;
+    /**
+     * Clear received emails for a recipient (cleanup helper)
+     * Used primarily for E2E testing
+     */
+    clearReceivedEmails(input: ClearReceivedEmailsInput): Promise<IRPCResponse<ClearReceivedEmailsOutput>>;
 }
 declare function defineNotificationService(): new (ctx: ExecutionContext, env: NotificationEnv) => NotificationServiceBase;
 

package/dist/export/worker.mjs

@@ -1,8 +1,9 @@
-import { createInternalError, uuidv4, develitWorker, cloudflareQueue, action, service } from '@develit-io/backend-sdk';
-import { s as schema } from '../shared/notification.C0X8Orrh.mjs';
+import { createInternalError, develitWorker, uuidv4, cloudflareQueue, action, service } from '@develit-io/backend-sdk';
+import { s as schema } from '../database/schema.mjs';
 import 'drizzle-orm';
 import 'drizzle-orm/sqlite-core';
-import { E as EcomailConnector, T as TwilioConnector, S as SlackConnector, s as sendEmailInputSchema, a as sendSmsInputSchema, b as sendSlackInputSchema } from '../shared/notification.CmITLO7E.mjs';
+import { E as EcomailConnector, T as TwilioConnector, S as SlackConnector, s as sendEmailInputSchema, f as sendSmsInputSchema, e as sendSlackInputSchema, h as sendWebhookInputSchema, W as WebhookConnector, g as getReceivedEmailsInputSchema, w as waitForEmailInputSchema, c as clearReceivedEmailsInputSchema } from '../shared/notification.CP_hFlNt.mjs';
+import '@develit-io/backend-sdk/signature';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
 import 'zod';
@@ -29,31 +30,9 @@ const initiateEmailConnector = async (provider, apiKey, smtpHost, senderEmail, s
   });
 };
 
-const createAuditLogCommand = async ({
-  db,
-  auditLog: {
-    event,
-    description,
-    initiatorService,
-    initiatorUserId,
-    ip,
-    userAgent
-  }
-}) => {
-  const command = db.insert(tables.auditLog).values({
-    id: uuidv4(),
-    createdAt: /* @__PURE__ */ new Date(),
-    event,
-    description,
-    ip,
-    userAgent,
-    initiatorService,
-    initiatorUserId
-  });
-  return {
-    command
-  };
-};
+function generateEmailKVPattern(recipient) {
+  return `email:${recipient}:`;
+}
 
 const initiateSmsConnector = async (provider, accountId, authToken, serviceId) => {
   const connector = [TwilioConnector].find(
@@ -117,6 +96,12 @@ let NotificationServiceBase = class extends develitWorker(
             metadata
           });
           break;
+        case "webhook":
+          notificationAction = async () => this._sendWebhook({
+            webhook: payload.webhook,
+            metadata
+          });
+          break;
         default:
           this.logError({ error: `Unknown notification type: ${type}` });
           message.retry();
@@ -141,7 +126,7 @@ let NotificationServiceBase = class extends develitWorker(
           metadata: {
             ip,
             userAgent,
-            initiator: { service: service2, userId }
+            initiator: { userId }
           }
         } = params;
         if (!this.emailConnector) {
@@ -156,19 +141,28 @@ let NotificationServiceBase = class extends develitWorker(
           );
         }
         await this.emailConnector.sendEmail(email);
-        const { command } = await createAuditLogCommand({
-          db: this.db,
-          auditLog: {
-            id: uuidv4(),
-            event: "EMAIL",
-            ip,
-            initiatorService: service2,
-            initiatorUserId: userId,
+        try {
+          await this.pushToQueue(this.env.AUDIT_LOGS_QUEUE, {
+            logType: "event",
+            service: "notification",
+            correlationId: uuidv4(),
+            eventType: "notification.email_sent",
+            actorUserId: userId,
+            actorEmail: userId || "SYSTEM",
+            targetType: "email",
+            targetId: email.to,
+            sourceIp: ip,
             userAgent,
-            description: JSON.stringify(input)
-          }
-        });
-        await this.db.batch([command]);
+            outcome: "success",
+            description: `Email sent to ${email.to}`,
+            details: JSON.stringify({
+              subject: email.subject,
+              templateId: email.templateId
+            })
+          });
+        } catch (e) {
+          console.error("Failed to push email audit log", e);
+        }
         return {};
       }
     );
@@ -183,7 +177,7 @@ let NotificationServiceBase = class extends develitWorker(
           metadata: {
             ip,
             userAgent,
-            initiator: { service: service2, userId }
+            initiator: { userId }
           }
         } = params;
         if (!this.smsConnector) {
@@ -201,19 +195,25 @@ let NotificationServiceBase = class extends develitWorker(
           );
         }
         await this.smsConnector.sendSms({ message, to });
-        const { command } = await createAuditLogCommand({
-          db: this.db,
-          auditLog: {
-            id: uuidv4(),
-            event: "SMS",
-            ip,
+        try {
+          await this.pushToQueue(this.env.AUDIT_LOGS_QUEUE, {
+            logType: "event",
+            service: "notification",
+            correlationId: uuidv4(),
+            eventType: "notification.sms_sent",
+            actorUserId: userId,
+            actorEmail: userId || "SYSTEM",
+            targetType: "sms",
+            targetId: to,
+            sourceIp: ip,
             userAgent,
-            initiatorService: service2,
-            initiatorUserId: userId,
-            description: JSON.stringify(input)
-          }
-        });
-        await this.db.batch([command]);
+            outcome: "success",
+            description: `SMS sent to ${to}`,
+            details: JSON.stringify({ message })
+          });
+        } catch (e) {
+          console.error("Failed to push sms audit log", e);
+        }
         return {};
       }
     );
@@ -294,12 +294,221 @@ let NotificationServiceBase = class extends develitWorker(
       },
       { successMessage: "Slack sent." },
       async (params) => {
-        const { slack } = params;
+        const { slack, metadata } = params;
         await this.slackConnector.sendNotificationToAllSlack(slack.message);
+        await this.pushToQueue(this.env.AUDIT_LOGS_QUEUE, {
+          logType: "event",
+          service: "notification",
+          correlationId: uuidv4(),
+          eventType: "notification.slack_sent",
+          actorUserId: metadata?.initiator?.userId,
+          actorEmail: metadata?.initiator?.userId || "SYSTEM",
+          targetType: "slack",
+          targetId: "all-channels",
+          sourceIp: metadata?.ip,
+          userAgent: metadata?.userAgent,
+          outcome: "success",
+          description: "Slack notification sent",
+          details: JSON.stringify({
+            message: slack.message
+          })
+        });
+        return {};
+      }
+    );
+  }
+  async sendWebhook(input) {
+    return this.handleAction(
+      { data: input, schema: sendWebhookInputSchema },
+      { successMessage: "Webhook queued." },
+      async (params) => {
+        const { webhook, metadata } = params;
+        await this.pushToQueue(
+          this.env.NOTIFICATIONS_QUEUE,
+          {
+            type: "webhook",
+            payload: {
+              webhook
+            },
+            metadata
+          }
+        );
+        return {};
+      }
+    );
+  }
+  async _sendWebhook(input) {
+    return this.handleAction(
+      { data: input, schema: sendWebhookInputSchema },
+      { successMessage: "Webhook sent." },
+      async (params) => {
+        const {
+          webhook,
+          metadata: {
+            ip,
+            userAgent,
+            initiator: { userId }
+          }
+        } = params;
+        if (!this.webhookConnector) {
+          const privateKey = (await this.env.SECRETS_STORE.get({
+            secretName: "NOTIFICATION_SERVICE_WEBHOOK_SIGNING_KEY"
+          })).data?.secretValue;
+          if (!privateKey) {
+            throw createInternalError(null, {
+              message: "NOTIFICATION_SERVICE_WEBHOOK_SIGNING_KEY is not configured",
+              code: "SYS-N-02",
+              status: 500
+            });
+          }
+          this.webhookConnector = new WebhookConnector(privateKey);
+        }
+        await this.webhookConnector.sendWebhook(webhook);
+        try {
+          await this.pushToQueue(this.env.AUDIT_LOGS_QUEUE, {
+            logType: "event",
+            service: "notification",
+            correlationId: uuidv4(),
+            eventType: "notification.webhook_sent",
+            actorUserId: userId,
+            actorEmail: userId || "SYSTEM",
+            targetType: "webhook",
+            targetId: webhook.url,
+            sourceIp: ip,
+            userAgent,
+            outcome: "success",
+            description: `Webhook sent to ${webhook.url}`,
+            details: JSON.stringify({
+              url: webhook.url
+            })
+          });
+        } catch (e) {
+          console.error("Failed to push webhook audit log", e);
+        }
         return {};
       }
     );
   }
+  async getReceivedEmails(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: getReceivedEmailsInputSchema
+      },
+      { successMessage: "Emails retrieved." },
+      async (params) => {
+        const { recipient, limit, includeContent } = params;
+        if (!this.env.RECEIVED_EMAILS_KV) {
+          throw new Error("RECEIVED_EMAILS_KV binding is not configured");
+        }
+        const pattern = generateEmailKVPattern(recipient);
+        const list = await this.env.RECEIVED_EMAILS_KV.list({
+          prefix: pattern,
+          limit
+        });
+        const emails = [];
+        for (const key of list.keys) {
+          const emailData = await this.env.RECEIVED_EMAILS_KV.get(
+            key.name,
+            "json"
+          );
+          if (emailData) {
+            const email = emailData;
+            if (!includeContent) {
+              delete email.text;
+              delete email.html;
+              delete email.raw;
+            }
+            emails.push(email);
+          }
+        }
+        emails.sort(
+          (a, b) => new Date(b.receivedAt).getTime() - new Date(a.receivedAt).getTime()
+        );
+        return {
+          emails,
+          count: emails.length
+        };
+      }
+    );
+  }
+  async waitForEmail(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: waitForEmailInputSchema
+      },
+      { successMessage: "Email check completed." },
+      async (params) => {
+        const { recipient, subject, timeout, pollInterval } = params;
+        if (!this.env.RECEIVED_EMAILS_KV) {
+          throw new Error("RECEIVED_EMAILS_KV binding is not configured");
+        }
+        const maxTimeout = Math.min(timeout || 5e3, 5e3);
+        const safeInterval = Math.max(pollInterval || 500, 100);
+        const startTime = Date.now();
+        const maxIterations = Math.ceil(maxTimeout / safeInterval);
+        let iterations = 0;
+        while (Date.now() - startTime < maxTimeout && iterations < maxIterations) {
+          const pattern = generateEmailKVPattern(recipient);
+          const list = await this.env.RECEIVED_EMAILS_KV.list({
+            prefix: pattern,
+            limit: 50
+          });
+          for (const key of list.keys) {
+            const emailData = await this.env.RECEIVED_EMAILS_KV.get(
+              key.name,
+              "json"
+            );
+            if (emailData) {
+              const email = emailData;
+              if (!subject || email.subject.includes(subject)) {
+                return {
+                  email,
+                  found: true
+                };
+              }
+            }
+          }
+          iterations++;
+          if (iterations < maxIterations && Date.now() - startTime < maxTimeout - safeInterval) {
+            await new Promise((resolve) => setTimeout(resolve, safeInterval));
+          }
+        }
+        return {
+          email: null,
+          found: false
+        };
+      }
+    );
+  }
+  async clearReceivedEmails(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: clearReceivedEmailsInputSchema
+      },
+      { successMessage: "Emails cleared." },
+      async (params) => {
+        const { recipient } = params;
+        if (!this.env.RECEIVED_EMAILS_KV) {
+          throw new Error("RECEIVED_EMAILS_KV binding is not configured");
+        }
+        const pattern = generateEmailKVPattern(recipient);
+        const list = await this.env.RECEIVED_EMAILS_KV.list({
+          prefix: pattern
+        });
+        let deleted = 0;
+        for (const key of list.keys) {
+          await this.env.RECEIVED_EMAILS_KV.delete(key.name);
+          deleted++;
+        }
+        return {
+          deleted
+        };
+      }
+    );
+  }
 };
 __decorateClass([
   cloudflareQueue({ baseDelay: 60 })
@@ -311,13 +520,13 @@ __decorateClass([
   action("private-send-sms")
 ], NotificationServiceBase.prototype, "_sendSms", 1);
 __decorateClass([
-  action("public-send-email")
+  action("send-email")
 ], NotificationServiceBase.prototype, "sendEmail", 1);
 __decorateClass([
-  action("public-send-email-sync")
+  action("send-email-sync")
 ], NotificationServiceBase.prototype, "sendEmailSync", 1);
 __decorateClass([
-  action("public-send-sms")
+  action("send-sms")
 ], NotificationServiceBase.prototype, "sendSms", 1);
 __decorateClass([
   action("send-push-notification")
@@ -325,6 +534,21 @@ __decorateClass([
 __decorateClass([
   action("send-slack-notification")
 ], NotificationServiceBase.prototype, "sendSlackNotification", 1);
+__decorateClass([
+  action("send-webhook")
+], NotificationServiceBase.prototype, "sendWebhook", 1);
+__decorateClass([
+  action("private-send-webhook")
+], NotificationServiceBase.prototype, "_sendWebhook", 1);
+__decorateClass([
+  action("get-received-emails")
+], NotificationServiceBase.prototype, "getReceivedEmails", 1);
+__decorateClass([
+  action("wait-for-email")
+], NotificationServiceBase.prototype, "waitForEmail", 1);
+__decorateClass([
+  action("clear-received-emails")
+], NotificationServiceBase.prototype, "clearReceivedEmails", 1);
 NotificationServiceBase = __decorateClass([
   service("notification")
 ], NotificationServiceBase);

package/dist/export/wrangler.cjs

@@ -27,11 +27,21 @@ function defineNotificationServiceWrangler(config) {
         migrations_dir: "./src/database/migrations"
       }
     ],
+    kv_namespaces: envs.local.kv ? [
+      {
+        binding: "RECEIVED_EMAILS_KV",
+        id: envs.local.kv.id
+      }
+    ] : [],
     queues: {
       producers: [
         {
           binding: "NOTIFICATIONS_QUEUE",
           queue: `${project}-notifications`
+        },
+        {
+          binding: "AUDIT_LOGS_QUEUE",
+          queue: `${project}-audit-logs`
         }
       ],
       consumers: [
@@ -60,7 +70,15 @@ function defineNotificationServiceWrangler(config) {
           database_id: envCfg.d1.id,
           migrations_dir: "./src/database/migrations"
         }
-      ]
+      ],
+      ...envCfg.kv && {
+        kv_namespaces: [
+          {
+            binding: "RECEIVED_EMAILS_KV",
+            id: envCfg.kv.id
+          }
+        ]
+      }
     };
   }
   return base;

package/dist/export/wrangler.d.cts

@@ -1,4 +1,4 @@
-import { N as NotificationServiceWranglerConfig } from '../shared/notification.BB9Jl8DI.cjs';
+import { N as NotificationServiceWranglerConfig } from '../shared/notification.CdlaOUd0.cjs';
 
 declare function defineNotificationServiceWrangler(config: NotificationServiceWranglerConfig): {
     vars: {
@@ -20,6 +20,10 @@ declare function defineNotificationServiceWrangler(config: NotificationServiceWr
         database_id: string;
         migrations_dir: string;
     }[];
+    kv_namespaces: {
+        binding: string;
+        id: string;
+    }[];
     queues: {
         producers: {
             binding: string;

package/dist/export/wrangler.d.mts

@@ -1,4 +1,4 @@
-import { N as NotificationServiceWranglerConfig } from '../shared/notification.BB9Jl8DI.mjs';
+import { N as NotificationServiceWranglerConfig } from '../shared/notification.CdlaOUd0.mjs';
 
 declare function defineNotificationServiceWrangler(config: NotificationServiceWranglerConfig): {
     vars: {
@@ -20,6 +20,10 @@ declare function defineNotificationServiceWrangler(config: NotificationServiceWr
         database_id: string;
         migrations_dir: string;
     }[];
+    kv_namespaces: {
+        binding: string;
+        id: string;
+    }[];
     queues: {
         producers: {
             binding: string;

package/dist/export/wrangler.d.ts

@@ -1,4 +1,4 @@
-import { N as NotificationServiceWranglerConfig } from '../shared/notification.BB9Jl8DI.js';
+import { N as NotificationServiceWranglerConfig } from '../shared/notification.CdlaOUd0.js';
 
 declare function defineNotificationServiceWrangler(config: NotificationServiceWranglerConfig): {
     vars: {
@@ -20,6 +20,10 @@ declare function defineNotificationServiceWrangler(config: NotificationServiceWr
         database_id: string;
         migrations_dir: string;
     }[];
+    kv_namespaces: {
+        binding: string;
+        id: string;
+    }[];
     queues: {
         producers: {
             binding: string;