@openora/core 0.4.1-canary.112 → 0.4.1-canary.113

package/dist/engagement/notifications/drizzle/migrations/meta/0001_snapshot.json

@@ -0,0 +1,98 @@
+{
+  "id": "fa9988e3-5040-4f86-b921-4320fa27eeaa",
+  "prevId": "c5045022-6772-41f6-b8cc-54dc6f58645d",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.notification": {
+      "name": "notification",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "data": {
+          "name": "data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "read_at": {
+          "name": "read_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "notification_user_id_idx": {
+          "name": "notification_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/dist/engagement/notifications/drizzle/migrations/meta/0002_snapshot.json

@@ -0,0 +1,119 @@
+{
+  "id": "a7e44828-dab8-4c21-ad56-ea8e67992ea5",
+  "prevId": "fa9988e3-5040-4f86-b921-4320fa27eeaa",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.notification": {
+      "name": "notification",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "data": {
+          "name": "data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "read_at": {
+          "name": "read_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "event_id": {
+          "name": "event_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "notification_user_id_idx": {
+          "name": "notification_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notification_event_id_idx": {
+          "name": "notification_event_id_idx",
+          "columns": [
+            {
+              "expression": "event_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/dist/engagement/notifications/drizzle/migrations/meta/_journal.json

@@ -8,6 +8,20 @@
       "when": 1783555224659,
       "tag": "0000_sparkling_kulan_gath",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1787595667142,
+      "tag": "0001_classy_pixie",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1787911988004,
+      "tag": "0002_open_madame_web",
+      "breakpoints": true
     }
   ]
 }

package/dist/engagement/notifications/plugin.d.ts

@@ -1,4 +1,15 @@
-import { type AdminUserDirectory, type JobQueueAdapter, type NotificationDeliveryAdapter } from '@openora/core/contracts';
+import { type AdminUserDirectory, type DomainEventName, type JobQueueAdapter, type NotificationDeliveryAdapter, type RealtimeTransport } from '@openora/core/contracts';
+import { type CreateNotificationInput } from './contract/index.js';
+type NotificationMapEntry = {
+    event: DomainEventName;
+    sendEmail: boolean;
+    handle: (payload: unknown) => CreateNotificationInput | null;
+};
+export declare const notificationEventMap: NotificationMapEntry[];
+export declare function buildKycResubmissionNotification(payload: {
+    userId: string;
+    reason: string | null;
+}): CreateNotificationInput;
 declare const _default: {
     readonly id: "notifications";
     readonly dependsOn: readonly ["identity"];
@@ -16,7 +27,7 @@ declare const _default: {
         CHAT_BLOCK_WRITER: import("@openora/core/contracts").Token<import("@openora/core/contracts").ChatBlockWriter>;
         CHAT_MODERATION: import("@openora/core/contracts").Token<import("@openora/core/contracts").ChatModeration, string>;
         CHAT_REALTIME_CLIENT_AUTHORIZER: import("@openora/core/contracts").Token<import("@openora/core/contracts").RealtimeClientAuthorizer>;
-        CHAT_REALTIME_TRANSPORT: import("@openora/core/contracts").Token<import("@openora/core/contracts").RealtimeTransport>;
+        CHAT_REALTIME_TRANSPORT: import("@openora/core/contracts").Token<RealtimeTransport>;
         CHAT_ROOM_ACCESS: import("@openora/core/contracts").Token<import("@openora/core/contracts").ChatRoomAccess>;
         CHAT_SYSTEM_WRITER: import("@openora/core/contracts").Token<import("@openora/core/contracts").ChatSystemWriter, string>;
         DRIZZLE: import("@openora/core/contracts").Token<import("@openora/core/server").DrizzleService>;
@@ -118,6 +129,12 @@ declare const _default: {
                 termsVersion: string;
                 requireEmailVerification: boolean;
             } | undefined;
+            notifications?: {
+                retention?: {
+                    days: number;
+                    cron: string;
+                } | undefined;
+            } | undefined;
             supportedLanguages?: string[] | undefined;
         }, string>;
         PLAYER_ACTIVITY_TRACKER: import("@openora/core/contracts").Token<import("@openora/core/contracts").PlayerActivityTracker>;
@@ -126,7 +143,7 @@ declare const _default: {
         PLAY_ELIGIBILITY: import("@openora/core/contracts").Token<import("@openora/core/contracts").PlayEligibilityPort>;
         RATE_LIMITER: import("@openora/core/contracts").Token<import("@openora/core/contracts").RateLimiterAdapter<`register:${string}` | `login:${string}` | `enable2fa:${string}` | `verify2fa:${string}` | `disable2fa:${string}` | `pwreset-req:${string}` | `pwreset-verify:${string}` | `pwreset:${string}` | `change-password:${string}` | `email-verify:${string}` | `verify-email:${string}` | `wallet-mutation:${string}` | `wallet-webhook:${string}` | `chat-room-join:${string}` | `chat-send:${string}` | `report-access-denied:${string}`>>;
         REALTIME_CLIENT_AUTHORIZER: import("@openora/core/contracts").Token<import("@openora/core/contracts").RealtimeClientAuthorizer>;
-        REALTIME_TRANSPORT: import("@openora/core/contracts").Token<import("@openora/core/contracts").RealtimeTransport>;
+        REALTIME_TRANSPORT: import("@openora/core/contracts").Token<RealtimeTransport>;
         RNG_ADAPTER: import("@openora/core/contracts").Token<import("@openora/core/contracts").RngAdapter>;
         SEND_EMAIL: import("@openora/core/contracts").Token<import("@openora/core/contracts").SendEmailPort>;
         SESSION_COMMANDS: import("@openora/core/contracts").Token<import("@openora/core/contracts").SessionCommands>;

package/dist/engagement/notifications/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/engagement/notifications/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,2BAA2B,EACjC,MAAM,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcjC,wBA2J8C"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/engagement/notifications/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EASL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAEpB,KAAK,eAAe,EACpB,KAAK,2BAA2B,EAChC,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAUjC,OAAO,EAAiC,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAgClG,KAAK,oBAAoB,GAAG;IAC1B,KAAK,EAAE,eAAe,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,uBAAuB,GAAG,IAAI,CAAC;CAC9D,CAAC;AAqCF,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,EAuItD,CAAC;AAEF,wBAAgB,gCAAgC,CAAC,OAAO,EAAE;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,GAAG,uBAAuB,CAQ1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,wBAmL8C"}

package/dist/engagement/notifications/plugin.js

@@ -1,18 +1,155 @@
 import * as z from 'zod';
-import { ADMIN_USER_DIRECTORY, JOB_QUEUE, NOTIFICATION_DELIVERY_ADAPTER, UuidSchema, domainEventSchemas, queue, } from '@openora/core/contracts';
+import { ADMIN_USER_DIRECTORY, JOB_QUEUE, NOTIFICATION_DELIVERY_ADAPTER, PLATFORM_CONFIG, REALTIME_TRANSPORT, UuidSchema, domainEventSchemas, queue, } from '@openora/core/contracts';
 import { createLogger, EVENT_BUS, DRIZZLE } from '@openora/core/server';
 import { MockNotificationDeliveryAdapter } from './adapters/mock/mock-notification-adapter.js';
-import { createNotificationsRouter } from './router/index.js';
+import { createNotificationsRouter, notificationsChannel, toNotificationDto, } from './router/index.js';
 import { NotificationsService } from './service/notifications.service.js';
+import { CreateNotificationInputSchema } from './contract/index.js';
 const KYC_RESUBMISSION_NOTIFY_QUEUE = queue('kyc-resubmission-notify');
+const NOTIFICATIONS_RETENTION_PURGE_QUEUE = queue('notifications-retention-purge');
+const NOTIFICATIONS_DISPATCH_QUEUE = queue('notifications-dispatch');
+const DEFAULT_NOTIFICATIONS_RETENTION_DAYS = 30;
+const DEFAULT_NOTIFICATIONS_RETENTION_CRON = '0 3 * * *';
 const KycResubmissionNotifyJobSchema = z.object({
     userId: UuidSchema,
     reason: z.string().nullable(),
 });
+const NotificationDispatchJobSchema = z.object({
+    event: z.string(),
+    input: CreateNotificationInputSchema,
+    sendEmail: z.boolean(),
+});
+function formatMoneyAmount(amount) {
+    const match = /^(-)?(\d+)(?:\.(\d+))?$/.exec(amount);
+    if (!match) {
+        return amount;
+    }
+    const [, sign, integerPart, fractionPart] = match;
+    const groupedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+    const trimmedFraction = fractionPart ? fractionPart.replace(/0+$/, '') : '';
+    const magnitude = trimmedFraction ? `${groupedInteger}.${trimmedFraction}` : groupedInteger;
+    return sign ? `${sign}${magnitude}` : magnitude;
+}
+// Drops null/undefined entity refs (eg a nullable roomId) so `data` only ever carries
+// fields the source event actually had a value for; an all-null payload becomes `null`.
+function compactData(fields) {
+    const entries = Object.entries(fields).filter((entry) => entry[1] !== null && entry[1] !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+}
+// A plain array literal would widen every entry's `event` to DomainEventName and lose the
+// payload type tied to it; this generic keeps K bound per entry so buildNotification stays
+// checked against that one event's actual payload shape.
+function mapEvent(event, buildNotification, options) {
+    return {
+        event,
+        sendEmail: options.sendEmail,
+        handle: (payload) => {
+            const parsed = domainEventSchemas[event].safeParse(payload);
+            if (!parsed.success) {
+                return null;
+            }
+            // Library boundary: TS cannot narrow a domainEventSchemas lookup keyed by this
+            // function's own generic K to that one event's payload type; the pairing holds
+            // by domainEventSchemas' own definition (DomainEventPayload<K> is inferred from it).
+            return buildNotification(parsed.data);
+        },
+    };
+}
+export const notificationEventMap = [
+    mapEvent('wallet.withdrawal.approved', (p) => ({
+        userId: p.userId,
+        type: 'withdrawal.approved',
+        title: 'Withdrawal approved',
+        body: `Your withdrawal of ${formatMoneyAmount(p.amount)} ${p.currency} has been approved and is being processed.`,
+        data: { transactionId: p.transactionId },
+    }), { sendEmail: true }),
+    mapEvent('wallet.withdrawal.rejected', (p) => ({
+        userId: p.userId,
+        type: 'withdrawal.rejected',
+        title: 'Withdrawal rejected',
+        body: `Your withdrawal of ${formatMoneyAmount(p.amount)} ${p.currency} was rejected and the funds were returned to your balance.${p.reason ? ` Reason: ${p.reason}.` : ''}`,
+        data: { transactionId: p.transactionId },
+    }), { sendEmail: true }),
+    mapEvent('wallet.withdrawal.requested', (p) => ({
+        userId: p.userId,
+        type: 'withdrawal.requested',
+        title: 'Withdrawal requested',
+        body: `Your withdrawal request of ${formatMoneyAmount(p.amount)} ${p.currency} has been received and is pending review.`,
+        data: { transactionId: p.transactionId },
+    }), { sendEmail: false }),
+    mapEvent('wallet.withdrawal.completed', (p) => ({
+        userId: p.userId,
+        type: 'withdrawal.completed',
+        title: 'Withdrawal completed',
+        body: `Your withdrawal of ${formatMoneyAmount(p.amount)} ${p.currency} has been completed.`,
+        data: { transactionId: p.transactionId },
+    }), { sendEmail: false }),
+    mapEvent('wallet.withdrawal.failed', (p) => ({
+        userId: p.userId,
+        type: 'withdrawal.failed',
+        title: 'Withdrawal failed',
+        body: `Your withdrawal of ${formatMoneyAmount(p.amount)} ${p.currency} failed and the funds were returned to your balance.`,
+        data: { transactionId: p.transactionId },
+    }), { sendEmail: false }),
+    mapEvent('wallet.deposit.completed', (p) => ({
+        userId: p.userId,
+        type: 'deposit.completed',
+        title: 'Deposit completed',
+        body: `Your deposit of ${formatMoneyAmount(p.amount)} ${p.currency} has been completed.`,
+        data: { transactionId: p.transactionId },
+    }), { sendEmail: false }),
+    mapEvent('wallet.manual_adjustment.created', (p) => ({
+        userId: p.userId,
+        type: 'balance.adjusted',
+        title: 'Balance adjusted',
+        body: `Your balance was ${p.direction === 'credit' ? 'credited' : 'debited'} ${formatMoneyAmount(p.amount)} ${p.currency}. Reason: ${p.reason}.`,
+        data: { transactionId: p.transactionId },
+    }), { sendEmail: false }),
+    mapEvent('wallet.bonus_rollover.completed', (p) => ({
+        userId: p.userId,
+        type: 'wallet.bonus_rollover.completed',
+        title: 'Bonus unlocked',
+        body: `Your ${formatMoneyAmount(p.creditedAmount)} ${p.currency} bonus credit has cleared its rollover requirement and is now fully withdrawable.`,
+        data: null,
+    }), { sendEmail: false }),
+    mapEvent('chat.user.mentioned', (p) => ({
+        userId: p.mentionedUserId,
+        type: 'chat.mention',
+        title: 'You were mentioned',
+        body: 'You were mentioned in a chat message.',
+        data: compactData({ roomId: p.roomId, messageId: p.messageId }),
+    }), { sendEmail: false }),
+    // Pre-existing types: in-app only, unchanged from before the declarative-map refactor.
+    mapEvent('social.friend_request.sent', (p) => ({
+        userId: p.addresseeId,
+        type: 'social.friend_request.received',
+        title: 'New friend request',
+        body: `${p.requesterUsername} sent you a friend request.`,
+        data: { requesterId: p.requesterId },
+    }), { sendEmail: false }),
+    mapEvent('social.friend_request.accepted', (p) => ({
+        userId: p.requesterId,
+        type: 'social.friend_request.accepted',
+        title: 'Friend request accepted',
+        body: `${p.accepterUsername} accepted your friend request.`,
+        // accepterId, not requesterId: the recipient of THIS notification is the
+        // requester, so the linkable "other party" is whoever just accepted.
+        data: { accepterId: p.accepterId },
+    }), { sendEmail: false }),
+];
+export function buildKycResubmissionNotification(payload) {
+    return {
+        userId: payload.userId,
+        type: 'kyc.resubmission_requested',
+        title: 'Document resubmission required',
+        body: `An admin has requested you resubmit your verification documents.${payload.reason ? ` Reason: ${payload.reason}.` : ''}`,
+        data: null,
+    };
+}
 export default {
     id: 'notifications',
     // ADMIN_USER_DIRECTORY (owned by identity) resolves the player's email for the
-    // withdrawal delivery emails; pin load order so a split still finds the port. See ADR-0017.
+    // delivery emails; pin load order so a split still finds the port. See ADR-0017.
     dependsOn: ['identity'],
     register(ctx) {
         ctx.provide(NOTIFICATION_DELIVERY_ADAPTER, () => new MockNotificationDeliveryAdapter());
@@ -23,6 +160,8 @@ export default {
         let deliveryRef = null;
         let directoryRef = null;
         let jobQueueRef = null;
+        let realtimeRef = null;
+        let retentionDaysRef = DEFAULT_NOTIFICATIONS_RETENTION_DAYS;
         // Best-effort email alongside the in-app notification; a missing user or delivery
         // failure is logged, never thrown - the in-app notification already landed.
         const sendEmail = (userId, title, body) => {
@@ -41,69 +180,34 @@ export default {
             })
                 .catch((err) => logger.error({ err }, 'notification email delivery failed'));
         };
-        ctx.events.on('wallet.withdrawal.approved', (payload) => {
-            const parsed = domainEventSchemas['wallet.withdrawal.approved'].safeParse(payload);
-            if (!parsed.success || !svcRef) {
-                return;
-            }
-            const p = parsed.data;
-            const title = 'Withdrawal approved';
-            const body = `Your withdrawal of ${p.amount} ${p.currency} has been approved and is being processed.`;
-            svcRef
-                .create({ userId: p.userId, type: 'withdrawal.approved', title, body })
-                .catch((err) => logger.error({ err }, 'withdrawal.approved notification failed'));
-            sendEmail(p.userId, title, body);
-        });
-        ctx.events.on('wallet.withdrawal.rejected', (payload) => {
-            const parsed = domainEventSchemas['wallet.withdrawal.rejected'].safeParse(payload);
-            if (!parsed.success || !svcRef) {
-                return;
-            }
-            const p = parsed.data;
-            const reason = p.reason ? ` Reason: ${p.reason}.` : '';
-            const title = 'Withdrawal rejected';
-            const body = `Your withdrawal of ${p.amount} ${p.currency} was rejected and the funds were returned to your balance.${reason}`;
-            svcRef
-                .create({ userId: p.userId, type: 'withdrawal.rejected', title, body })
-                .catch((err) => logger.error({ err }, 'withdrawal.rejected notification failed'));
-            sendEmail(p.userId, title, body);
-        });
-        ctx.events.on('wallet.bonus_rollover.completed', (payload) => {
-            const parsed = domainEventSchemas['wallet.bonus_rollover.completed'].safeParse(payload);
-            if (!parsed.success || !svcRef) {
-                return;
-            }
-            const p = parsed.data;
-            const title = 'Bonus unlocked';
-            const body = `Your ${p.creditedAmount} ${p.currency} bonus credit has cleared its rollover requirement and is now fully withdrawable.`;
-            svcRef
-                .create({ userId: p.userId, type: 'wallet.bonus_rollover.completed', title, body })
-                .catch((err) => logger.error({ err }, 'wallet.bonus_rollover.completed notification failed'));
-        });
-        ctx.events.on('social.friend_request.sent', (payload) => {
-            const parsed = domainEventSchemas['social.friend_request.sent'].safeParse(payload);
-            if (!parsed.success || !svcRef) {
+        const publishNotification = (record) => {
+            if (!realtimeRef) {
                 return;
             }
-            const p = parsed.data;
-            const title = 'New friend request';
-            const body = `${p.requesterUsername} sent you a friend request.`;
-            svcRef
-                .create({ userId: p.addresseeId, type: 'social.friend_request.received', title, body })
-                .catch((err) => logger.error({ err }, 'social.friend_request.sent notification failed'));
-        });
-        ctx.events.on('social.friend_request.accepted', (payload) => {
-            const parsed = domainEventSchemas['social.friend_request.accepted'].safeParse(payload);
-            if (!parsed.success || !svcRef) {
-                return;
+            const dto = toNotificationDto(record);
+            if (dto) {
+                void Promise.resolve(realtimeRef.publish(notificationsChannel(record.userId), dto)).catch((err) => logger.error({ err }, 'notification realtime publish failed'));
             }
-            const p = parsed.data;
-            const title = 'Friend request accepted';
-            const body = `${p.accepterUsername} accepted your friend request.`;
-            svcRef
-                .create({ userId: p.requesterId, type: 'social.friend_request.accepted', title, body })
-                .catch((err) => logger.error({ err }, 'social.friend_request.accepted notification failed'));
-        });
+        };
+        for (const entry of notificationEventMap) {
+            ctx.events.on(entry.event, (payload, envelope) => {
+                const input = entry.handle(payload);
+                if (!input || !jobQueueRef || !envelope) {
+                    return;
+                }
+                jobQueueRef
+                    .enqueue(NOTIFICATIONS_DISPATCH_QUEUE, {
+                    event: entry.event,
+                    input: { ...input, eventId: envelope.eventId },
+                    sendEmail: entry.sendEmail,
+                }, {
+                    idempotencyKey: `notifications-dispatch:${envelope.eventId}`,
+                    attempts: 5,
+                    backoff: { type: 'exponential', delayMs: 1000 },
+                })
+                    .catch((err) => logger.error({ err, event: entry.event }, 'notification dispatch enqueue failed'));
+            });
+        }
         ctx.events.on('compliance.kyc.updated', (payload, envelope) => {
             const parsed = domainEventSchemas['compliance.kyc.updated'].safeParse(payload);
             if (!parsed.success || !jobQueueRef) {
@@ -113,8 +217,12 @@ export default {
             if (p.status !== 'resubmission_requested' || p.source !== 'manual') {
                 return;
             }
+            if (!envelope?.eventId) {
+                logger.warn({ userId: p.userId }, 'kyc-resubmission-notify enqueue skipped: missing eventId');
+                return;
+            }
             jobQueueRef
-                .enqueue(KYC_RESUBMISSION_NOTIFY_QUEUE, { userId: p.userId, reason: p.reason }, { idempotencyKey: `kyc-resubmission-notify:${envelope?.eventId ?? p.userId}` })
+                .enqueue(KYC_RESUBMISSION_NOTIFY_QUEUE, { userId: p.userId, reason: p.reason }, { idempotencyKey: `kyc-resubmission-notify:${envelope.eventId}` })
                 .catch((err) => logger.error({ err }, 'kyc-resubmission-notify enqueue failed'));
         });
         ctx.jobs.worker({
@@ -124,16 +232,44 @@ export default {
                 if (!svcRef) {
                     return;
                 }
-                const reasonText = payload.reason ? ` Reason: ${payload.reason}.` : '';
-                const title = 'Document resubmission required';
-                const body = `An admin has requested you resubmit your verification documents.${reasonText}`;
-                await svcRef.create({
-                    userId: payload.userId,
-                    type: 'kyc.resubmission_requested',
-                    title,
-                    body,
-                });
-                sendEmail(payload.userId, title, body);
+                const input = buildKycResubmissionNotification(payload);
+                const record = await svcRef.create(input);
+                if (!record) {
+                    return;
+                }
+                publishNotification(record);
+                sendEmail(input.userId, input.title, input.body);
+            },
+        });
+        ctx.jobs.worker({
+            queue: NOTIFICATIONS_DISPATCH_QUEUE,
+            schema: NotificationDispatchJobSchema,
+            handler: async ({ payload }) => {
+                if (!svcRef) {
+                    return;
+                }
+                const record = await svcRef.create(payload.input);
+                if (!record) {
+                    return;
+                }
+                publishNotification(record);
+                if (payload.sendEmail) {
+                    sendEmail(record.userId, record.title, record.body);
+                }
+            },
+            onDeadLetter: (jobCtx, error) => {
+                logger.error({ err: error, event: jobCtx.payload.event, jobId: jobCtx.id }, 'notification dispatch exhausted retries');
+            },
+        });
+        ctx.jobs.worker({
+            queue: NOTIFICATIONS_RETENTION_PURGE_QUEUE,
+            schema: z.object({}),
+            handler: async () => {
+                if (!svcRef) {
+                    return;
+                }
+                const { count } = await svcRef.purgeExpired(retentionDaysRef);
+                logger.info({ count }, 'notification retention purge complete');
             },
         });
         ctx.routers.add('notifications', (c) => {
@@ -142,7 +278,15 @@ export default {
             deliveryRef = c.get(NOTIFICATION_DELIVERY_ADAPTER);
             directoryRef = c.get(ADMIN_USER_DIRECTORY);
             jobQueueRef = c.get(JOB_QUEUE);
-            return createNotificationsRouter(svc);
+            realtimeRef = c.get(REALTIME_TRANSPORT);
+            const platformConfig = c.has(PLATFORM_CONFIG) ? c.get(PLATFORM_CONFIG) : undefined;
+            retentionDaysRef =
+                platformConfig?.notifications?.retention?.days ?? DEFAULT_NOTIFICATIONS_RETENTION_DAYS;
+            const purgeCron = platformConfig?.notifications?.retention?.cron ?? DEFAULT_NOTIFICATIONS_RETENTION_CRON;
+            // Off-peak, one hour after tag's daily-evaluation (0 2 * * *), so the in-process
+            // driver doesn't run both sweeps at once in dev/test.
+            void jobQueueRef.schedule(NOTIFICATIONS_RETENTION_PURGE_QUEUE, 'notifications.retention-purge.daily', {}, { cron: purgeCron });
+            return createNotificationsRouter({ notifications: svc, realtime: realtimeRef });
         });
     },
 };