vintasend 0.5.1 → 0.6.0

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export type { LocalFileAttachmentManagerConfig } from './services/attachment-man
 export { LocalFileAttachmentManager } from './services/attachment-manager/local-file-attachment-manager';
 export { BaseNotificationAdapter, isOneOffNotification, } from './services/notification-adapters/base-notification-adapter';
 export type { BaseNotificationBackend } from './services/notification-backends/base-notification-backend';
-export { supportsAttachments } from './services/notification-backends/base-notification-backend';
+export { supportsAttachments, isFieldFilter } from './services/notification-backends/base-notification-backend';
+export type { NotificationFilter, NotificationFilterFields, DateRange, NotificationFilterCapabilities } from './services/notification-backends/base-notification-backend';
 export type { BaseNotificationQueueService } from './services/notification-queue-service/base-notification-queue-service';
 export type { VintaSend } from './services/notification-service';
 export { VintaSendFactory } from './services/notification-service';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAttachmentReference = exports.VintaSendFactory = exports.supportsAttachments = exports.isOneOffNotification = exports.BaseNotificationAdapter = exports.LocalFileAttachmentManager = exports.BaseAttachmentManager = void 0;
+exports.isAttachmentReference = exports.VintaSendFactory = exports.isFieldFilter = exports.supportsAttachments = exports.isOneOffNotification = exports.BaseNotificationAdapter = exports.LocalFileAttachmentManager = exports.BaseAttachmentManager = void 0;
 // Attachment Manager
 var base_attachment_manager_1 = require("./services/attachment-manager/base-attachment-manager");
 Object.defineProperty(exports, "BaseAttachmentManager", { enumerable: true, get: function () { return base_attachment_manager_1.BaseAttachmentManager; } });
@@ -11,6 +11,7 @@ Object.defineProperty(exports, "BaseNotificationAdapter", { enumerable: true, ge
 Object.defineProperty(exports, "isOneOffNotification", { enumerable: true, get: function () { return base_notification_adapter_1.isOneOffNotification; } });
 var base_notification_backend_1 = require("./services/notification-backends/base-notification-backend");
 Object.defineProperty(exports, "supportsAttachments", { enumerable: true, get: function () { return base_notification_backend_1.supportsAttachments; } });
+Object.defineProperty(exports, "isFieldFilter", { enumerable: true, get: function () { return base_notification_backend_1.isFieldFilter; } });
 var notification_service_1 = require("./services/notification-service");
 Object.defineProperty(exports, "VintaSendFactory", { enumerable: true, get: function () { return notification_service_1.VintaSendFactory; } });
 var attachment_1 = require("./types/attachment");

package/dist/services/notification-backends/base-notification-backend.d.ts

@@ -1,8 +1,62 @@
 import type { AttachmentFileRecord, StoredAttachment } from '../../types/attachment';
 import type { InputJsonValue } from '../../types/json-values';
+import type { NotificationStatus } from '../../types/notification-status';
+import type { NotificationType } from '../../types/notification-type';
 import type { AnyDatabaseNotification, AnyNotification, DatabaseNotification, DatabaseOneOffNotification, Notification, OneOffNotificationInput } from '../../types/notification';
 import type { BaseNotificationTypeConfig } from '../../types/notification-type-config';
 import type { BaseLogger } from '../loggers/base-logger';
+/**
+ * Date range filter with optional lower and upper bounds.
+ */
+export type DateRange = {
+    from?: Date;
+    to?: Date;
+};
+/**
+ * Flat dotted key capability map describing which filter features a backend supports.
+ * Use flat dotted keys for logical operators, fields, and negations:
+ * - `logical.*`: Operator support (and, or, not, notNested)
+ * - `fields.*`: Field filtering support
+ * - `negation.*`: Negation support for specific fields
+ *
+ * When a backend implements getFilterCapabilities(), missing keys default to true (supported),
+ * ensuring forward compatibility when new capabilities are added.
+ * Backends that don't implement getFilterCapabilities() are treated as supporting all features.
+ */
+export type NotificationFilterCapabilities = {
+    [key: string]: boolean;
+};
+/**
+ * Leaf-level filter conditions for notification fields.
+ * All specified fields are combined with implicit AND.
+ */
+export type NotificationFilterFields<Config extends BaseNotificationTypeConfig> = {
+    status?: NotificationStatus | NotificationStatus[];
+    notificationType?: NotificationType | NotificationType[];
+    adapterUsed?: string | string[];
+    userId?: Config['UserIdType'];
+    bodyTemplate?: string;
+    subjectTemplate?: string;
+    contextName?: string;
+    sendAfterRange?: DateRange;
+    createdAtRange?: DateRange;
+    sentAtRange?: DateRange;
+};
+/**
+ * Composable notification filter supporting logical operators.
+ *
+ * - A plain field filter applies all conditions with implicit AND.
+ * - `{ and: [...] }` requires all sub-filters to match.
+ * - `{ or: [...] }` requires at least one sub-filter to match.
+ * - `{ not: filter }` inverts the sub-filter.
+ */
+export type NotificationFilter<Config extends BaseNotificationTypeConfig> = NotificationFilterFields<Config> | {
+    and: NotificationFilter<Config>[];
+} | {
+    or: NotificationFilter<Config>[];
+} | {
+    not: NotificationFilter<Config>;
+};
 export interface BaseNotificationBackend<Config extends BaseNotificationTypeConfig> {
     getAllPendingNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
     getPendingNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
@@ -23,12 +77,40 @@ export interface BaseNotificationBackend<Config extends BaseNotificationTypeConf
     filterAllInAppUnreadNotifications(userId: Config['UserIdType']): Promise<DatabaseNotification<Config>[]>;
     filterInAppUnreadNotifications(userId: Config['UserIdType'], page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
     getUserEmailFromNotification(notificationId: Config['NotificationIdType']): Promise<string | undefined>;
-    storeContextUsed(notificationId: Config['NotificationIdType'], context: InputJsonValue): Promise<void>;
+    storeAdapterAndContextUsed(notificationId: Config['NotificationIdType'], adapterKey: string, context: InputJsonValue): Promise<void>;
     persistOneOffNotification(notification: Omit<OneOffNotificationInput<Config>, 'id'>): Promise<DatabaseOneOffNotification<Config>>;
     persistOneOffNotificationUpdate(notificationId: Config['NotificationIdType'], notification: Partial<Omit<OneOffNotificationInput<Config>, 'id'>>): Promise<DatabaseOneOffNotification<Config>>;
     getOneOffNotification(notificationId: Config['NotificationIdType'], forUpdate: boolean): Promise<DatabaseOneOffNotification<Config> | null>;
     getAllOneOffNotifications(): Promise<DatabaseOneOffNotification<Config>[]>;
     getOneOffNotifications(page: number, pageSize: number): Promise<DatabaseOneOffNotification<Config>[]>;
+    /**
+     * Filter notifications using composable query filters.
+     * Supports filtering by status, notification type, adapter, recipient,
+      * body/subject templates, context, and date ranges (sendAfter, created, sent).
+     * Filters can be combined with logical operators (and, or, not).
+     *
+     * @param filter - Composable filter expression
+     * @param page - Page number (1-indexed) for pagination
+     * @param pageSize - Number of results per page
+     * @returns Matching notifications
+     */
+    filterNotifications(filter: NotificationFilter<Config>, page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
+    /**
+     * Get the filter capabilities supported by this backend.
+     * Returns an object with flat dotted keys indicating which filtering features are supported.
+     *
+     * Example capability names:
+     * - `logical.and`, `logical.or`, `logical.not`, `logical.notNested`
+     * - `fields.status`, `fields.notificationType`, `fields.adapterUsed`, `fields.userId`,
+     *   `fields.bodyTemplate`, `fields.subjectTemplate`, `fields.contextName`,
+    *   `fields.sendAfterRange`, `fields.createdAtRange`, `fields.sentAtRange`
+    * - `negation.sendAfterRange`, `negation.createdAtRange`, `negation.sentAtRange`
+     *
+     * If this method is not implemented, all features are assumed to be supported.
+     * If this method is implemented, missing keys default to true (supported) for forward compatibility.
+     * Only explicitly set keys to false to indicate unsupported features.
+     */
+    getFilterCapabilities?(): NotificationFilterCapabilities;
     /**
      * Inject logger into backend for debugging and monitoring
      */
@@ -73,6 +155,10 @@ export interface BaseNotificationBackend<Config extends BaseNotificationTypeConf
      */
     deleteNotificationAttachment?(notificationId: Config['NotificationIdType'], attachmentId: string): Promise<void>;
 }
+/**
+ * Type guard to check if a filter is a field filter (leaf node).
+ */
+export declare function isFieldFilter<Config extends BaseNotificationTypeConfig>(filter: NotificationFilter<Config>): filter is NotificationFilterFields<Config>;
 /**
  * Type guard to check if backend supports attachment operations
  */

package/dist/services/notification-backends/base-notification-backend.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFieldFilter = isFieldFilter;
 exports.supportsAttachments = supportsAttachments;
+/**
+ * Type guard to check if a filter is a field filter (leaf node).
+ */
+function isFieldFilter(filter) {
+    return !('and' in filter) && !('or' in filter) && !('not' in filter);
+}
 /**
  * Type guard to check if backend supports attachment operations
  */

package/dist/services/notification-service.d.ts

@@ -83,6 +83,8 @@ export declare class VintaSend<Config extends BaseNotificationTypeConfig, Adapte
     getNotificationContext<ContextName extends string & keyof Config['ContextMap']>(contextName: ContextName, parameters: Parameters<ReturnType<typeof this.contextGeneratorsMap.getContextGenerator<ContextName>>['generate']>[0]): Promise<JsonObject>;
     sendPendingNotifications(): Promise<void>;
     getPendingNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
+    getNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
+    getOneOffNotifications(page: number, pageSize: number): Promise<DatabaseOneOffNotification<Config>[]>;
     getNotification(notificationId: Config['NotificationIdType'], forUpdate?: boolean): Promise<AnyDatabaseNotification<Config> | null>;
     /**
      * Gets a one-off notification by ID.

package/dist/services/notification-service.js

@@ -77,6 +77,7 @@ class VintaSend {
         this.queueService = queueService;
     }
     async send(notification) {
+        var _a;
         const adaptersOfType = this.adapters.filter((adapter) => adapter.notificationType === notification.notificationType);
         if (adaptersOfType.length === 0) {
             this.logger.error(`No adapter found for notification type ${notification.notificationType}`);
@@ -144,10 +145,10 @@ class VintaSend {
                 this.logger.error(`Error marking notification ${notification.id} as sent: ${markSentError}`);
             }
             try {
-                await this.backend.storeContextUsed(notification.id, context !== null && context !== void 0 ? context : {});
+                await this.backend.storeAdapterAndContextUsed(notification.id, (_a = adapter.key) !== null && _a !== void 0 ? _a : 'unknown', context !== null && context !== void 0 ? context : {});
             }
             catch (storeContextError) {
-                this.logger.error(`Error storing context for notification ${notification.id}: ${storeContextError}`);
+                this.logger.error(`Error storing adapter and context for notification ${notification.id}: ${storeContextError}`);
             }
         }
     }
@@ -254,6 +255,12 @@ class VintaSend {
     async getPendingNotifications(page, pageSize) {
         return this.backend.getPendingNotifications(page, pageSize);
     }
+    async getNotifications(page, pageSize) {
+        return this.backend.getNotifications(page, pageSize);
+    }
+    async getOneOffNotifications(page, pageSize) {
+        return this.backend.getOneOffNotifications(page, pageSize);
+    }
     async getNotification(notificationId, forUpdate = false) {
         return this.backend.getNotification(notificationId, forUpdate);
     }
@@ -341,6 +348,7 @@ class VintaSend {
         return createdNotification;
     }
     async delayedSend(notificationId) {
+        var _a;
         const notification = await this.getNotification(notificationId, false);
         if (!notification) {
             this.logger.error(`Notification ${notificationId} not found`);
@@ -358,7 +366,9 @@ class VintaSend {
             return;
         }
         const context = await this.getNotificationContext(notification.contextName, notification.contextParameters);
+        let lastAdapterKey = 'unknown';
         for (const adapter of enqueueNotificationsAdapters) {
+            lastAdapterKey = (_a = adapter.key) !== null && _a !== void 0 ? _a : 'unknown';
             try {
                 await adapter.send(notification, context);
             }
@@ -379,10 +389,10 @@ class VintaSend {
             }
         }
         try {
-            await this.backend.storeContextUsed(notification.id, context);
+            await this.backend.storeAdapterAndContextUsed(notification.id, lastAdapterKey, context);
         }
         catch (storeContextError) {
-            this.logger.error(`Error storing context for notification ${notification.id}: ${storeContextError}`);
+            this.logger.error(`Error storing adapter and context for notification ${notification.id}: ${storeContextError}`);
         }
     }
     async bulkPersistNotifications(notifications) {

package/dist/tools/vintasend-dashboard/app/components/auth-status.d.ts

@@ -0,0 +1 @@
+export declare function AuthStatus(): import("react").JSX.Element;

package/dist/tools/vintasend-dashboard/app/components/auth-status.js

@@ -0,0 +1,29 @@
+"use strict";
+"use client";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthStatus = AuthStatus;
+const image_1 = __importDefault(require("next/image"));
+const auth_context_1 = require("@/lib/auth/auth-context");
+function AuthStatus() {
+    const { user, isAuthenticated, signOutUrl } = (0, auth_context_1.useAuth)();
+    if (!isAuthenticated || !user) {
+        return (<a href={`/sign-in`} className="text-sm text-blue-600 hover:text-blue-800 underline">
+        Sign In
+      </a>);
+    }
+    return (<div className="flex items-center gap-3">
+      {user.imageUrl && (<image_1.default src={user.imageUrl} alt={user.name || "User avatar"} className="w-8 h-8 rounded-full" width={32} height={32}/>)}
+      <div className="flex flex-col">
+        {user.name && (<span className="text-sm font-medium text-gray-900">
+            {user.name}
+          </span>)}
+        {user.email && (<span className="text-xs text-gray-500">{user.email}</span>)}
+      </div>
+      <a href={signOutUrl} className="text-sm text-red-600 hover:text-red-800 underline ml-2">
+        Sign Out
+      </a>
+    </div>);
+}

package/dist/tools/vintasend-dashboard/app/error.d.ts

@@ -0,0 +1,6 @@
+export default function ErrorPage({ error, reset, }: {
+    error: Error & {
+        digest?: string;
+    };
+    reset: () => void;
+}): import("react").JSX.Element;

package/dist/tools/vintasend-dashboard/app/error.js

@@ -0,0 +1,40 @@
+"use strict";
+"use client";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ErrorPage;
+const react_1 = require("react");
+const link_1 = __importDefault(require("next/link"));
+const isConfigurationError = (message) => {
+    return (message.includes("AUTH_PROVIDER env var is required") ||
+        message.includes("Unsupported auth provider") ||
+        message.includes("Missing required auth configuration"));
+};
+function ErrorPage({ error, reset, }) {
+    (0, react_1.useEffect)(() => {
+        console.error(error);
+    }, [error]);
+    const isDev = process.env.NODE_ENV === "development";
+    const showConfigDetails = isDev && isConfigurationError(error.message);
+    return (<main className="mx-auto flex min-h-screen max-w-2xl flex-col gap-4 px-6 py-16">
+      <h1 className="text-3xl font-semibold">Dashboard configuration error</h1>
+      <p className="text-base text-slate-700">
+        The dashboard could not start because authentication settings are
+        missing or invalid.
+      </p>
+      {showConfigDetails && (<div className="rounded-md border border-amber-200 bg-amber-50 p-4 text-sm text-amber-900">
+          <p className="font-medium">Details</p>
+          <p className="mt-2 break-words">{error.message}</p>
+        </div>)}
+      <div className="flex gap-3">
+        <button type="button" onClick={() => reset()} className="rounded-md border border-slate-300 px-3 py-2 text-sm">
+          Retry
+        </button>
+        <link_1.default className="rounded-md bg-slate-900 px-3 py-2 text-sm text-white" href="/">
+          Go to home
+        </link_1.default>
+      </div>
+    </main>);
+}

package/dist/tools/vintasend-dashboard/app/layout.d.ts

@@ -0,0 +1,6 @@
+import type { Metadata } from "next";
+import "./globals.css";
+export declare const metadata: Metadata;
+export default function RootLayout({ children, }: Readonly<{
+    children: React.ReactNode;
+}>): Promise<import("react").JSX.Element>;

package/dist/tools/vintasend-dashboard/app/layout.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadata = void 0;
+exports.default = RootLayout;
+const google_1 = require("next/font/google");
+require("./globals.css");
+const auth_1 = require("@/lib/auth");
+const auth_context_1 = require("@/lib/auth/auth-context");
+const validate_config_1 = require("@/lib/auth/validate-config");
+const geistSans = (0, google_1.Geist)({
+    variable: "--font-geist-sans",
+    subsets: ["latin"],
+});
+const geistMono = (0, google_1.Geist_Mono)({
+    variable: "--font-geist-mono",
+    subsets: ["latin"],
+});
+exports.metadata = {
+    title: "Vintasend Dashboard",
+    description: "Authentication-enabled dashboard for Vintasend",
+};
+async function RootLayout({ children, }) {
+    const strategy = (0, auth_1.resolveAuthStrategy)();
+    (0, validate_config_1.assertValidAuthConfig)(strategy);
+    const ProviderComponent = strategy.getProviderComponent();
+    const currentUser = await strategy.getCurrentUser();
+    const signInUrl = strategy.getSignInUrl();
+    const signOutUrl = strategy.getSignOutUrl();
+    return (<html lang="en">
+      <body className={`${geistSans.variable} ${geistMono.variable} antialiased`}>
+        <ProviderComponent>
+          <auth_context_1.AuthProvider initialUser={currentUser} signInUrl={signInUrl} signOutUrl={signOutUrl}>
+            {children}
+          </auth_context_1.AuthProvider>
+        </ProviderComponent>
+      </body>
+    </html>);
+}

package/dist/tools/vintasend-dashboard/app/notifications/actions.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Server actions for the notifications page.
+ * Handles data fetching and real-time updates without page reloads.
+ */
+import type { AnyDashboardNotification, AnyDashboardNotificationDetail, NotificationFilters, PaginatedResult } from '@/lib/notifications/types';
+/**
+ * Fetches notifications with optional filtering and pagination.
+ * Returns mock data in Phase 2; will call real backend in Phase 5.
+ *
+ * @param filters - Filter criteria (status, notificationType, search)
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of dashboard notifications
+ */
+export declare function fetchNotifications(filters: NotificationFilters, page: number, pageSize: number): Promise<PaginatedResult<AnyDashboardNotification>>;
+/**
+ * Fetches a single notification with full details (contextUsed, extraParams, etc.).
+ * Used by the detail panel/modal.
+ *
+ * @param id - Notification ID
+ * @returns Full notification detail
+ */
+export declare function fetchNotificationDetail(id: string): Promise<AnyDashboardNotificationDetail>;
+/**
+ * Fetches pending notifications (status = PENDING_SEND).
+ * Convenience method that calls fetchNotifications with a pre-set filter.
+ *
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of pending notifications
+ */
+export declare function fetchPendingNotifications(page: number, pageSize: number): Promise<PaginatedResult<AnyDashboardNotification>>;
+/**
+ * Fetches future notifications (sendAfter > now).
+ * Convenience method that calls fetchNotifications.
+ * In Phase 5, will delegate to backend's getFutureNotifications method.
+ *
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of scheduled notifications
+ */
+export declare function fetchFutureNotifications(page: number, pageSize: number): Promise<PaginatedResult<AnyDashboardNotification>>;
+/**
+ * Fetches one-off notifications only.
+ * In Phase 5, will call backend's getOneOffNotifications method.
+ *
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of one-off notifications
+ */
+export declare function fetchOneOffNotifications(page: number, pageSize: number): Promise<PaginatedResult<AnyDashboardNotification>>;

package/dist/tools/vintasend-dashboard/app/notifications/actions.js

@@ -0,0 +1,224 @@
+"use strict";
+'use server';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchNotifications = fetchNotifications;
+exports.fetchNotificationDetail = fetchNotificationDetail;
+exports.fetchPendingNotifications = fetchPendingNotifications;
+exports.fetchFutureNotifications = fetchFutureNotifications;
+exports.fetchOneOffNotifications = fetchOneOffNotifications;
+/**
+ * Mock data generators for Phase 2 development.
+ * Will be replaced with real backend calls in Phase 5.
+ */
+function generateMockNotification(id) {
+    const types = ['EMAIL', 'SMS', 'PUSH', 'IN_APP'];
+    const statuses = ['PENDING_SEND', 'SENT', 'FAILED', 'READ', 'CANCELLED'];
+    const notificationType = types[Math.floor(Math.random() * types.length)];
+    const status = statuses[Math.floor(Math.random() * statuses.length)];
+    const sendAfter = Math.random() > 0.7 ? new Date(Date.now() + Math.random() * 86400000).toISOString() : null;
+    const sentAt = status !== 'PENDING_SEND' && status !== 'CANCELLED'
+        ? new Date(Date.now() - Math.random() * 604800000).toISOString()
+        : null;
+    const readAt = status === 'READ' ? new Date(Date.now() - 3600000).toISOString() : null;
+    const createdAt = new Date(Date.now() - Math.random() * 2592000000).toISOString();
+    const bodyTemplate = `This is a mock notification body for notification ${id}`;
+    const subjectTemplate = `Notification ${id}`;
+    if (Math.random() > 0.5) {
+        // One-off notification
+        const oneOffNotification = {
+            id: `oneoff-${id}`,
+            emailOrPhone: `user${id}@example.com`,
+            firstName: 'User',
+            lastName: `${id}`,
+            notificationType,
+            title: Math.random() > 0.3 ? `One-off notification ${id}` : null,
+            contextName: 'defaultContext',
+            status,
+            sendAfter,
+            sentAt,
+            readAt,
+            createdAt,
+            adapterUsed: notificationType === 'EMAIL' ? 'nodemailer' : null,
+            bodyTemplate,
+            subjectTemplate,
+        };
+        return oneOffNotification;
+    }
+    // Regular notification
+    const regularNotification = {
+        id: `notif-${id}`,
+        userId: `user-${Math.floor(Math.random() * 100)}`,
+        notificationType,
+        title: Math.random() > 0.3 ? `Notification ${id}` : null,
+        contextName: 'defaultContext',
+        status,
+        sendAfter,
+        sentAt,
+        readAt,
+        createdAt,
+        adapterUsed: notificationType === 'EMAIL' ? 'nodemailer' : null,
+        bodyTemplate,
+        subjectTemplate,
+    };
+    return regularNotification;
+}
+/**
+ * Fetches notifications with optional filtering and pagination.
+ * Returns mock data in Phase 2; will call real backend in Phase 5.
+ *
+ * @param filters - Filter criteria (status, notificationType, search)
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of dashboard notifications
+ */
+async function fetchNotifications(filters, page, pageSize) {
+    // Phase 2: Generate mock data
+    // In Phase 5, replace with:
+    // const service = await getVintaSendService();
+    // const result = await service.getNotifications(page, pageSize);
+    const mockTotal = 127;
+    const allMockData = Array.from({ length: mockTotal }, (_, i) => generateMockNotification(i + 1));
+    // Apply filters
+    let filtered = allMockData;
+    if (filters.status) {
+        filtered = filtered.filter((item) => item.status === filters.status);
+    }
+    if (filters.notificationType) {
+        filtered = filtered.filter((item) => item.notificationType === filters.notificationType);
+    }
+    if (filters.search) {
+        const searchLower = filters.search.toLowerCase();
+        filtered = filtered.filter((item) => {
+            var _a, _b;
+            return ((_b = (_a = item.title) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(searchLower)) !== null && _b !== void 0 ? _b : false) ||
+                item.id.toLowerCase().includes(searchLower) ||
+                ('emailOrPhone' in item && item.emailOrPhone.toLowerCase().includes(searchLower));
+        });
+    }
+    // Paginate
+    const startIdx = (page - 1) * pageSize;
+    const endIdx = startIdx + pageSize;
+    const paginatedData = filtered.slice(startIdx, endIdx);
+    return {
+        data: paginatedData,
+        page,
+        pageSize,
+        total: filtered.length,
+    };
+}
+/**
+ * Fetches a single notification with full details (contextUsed, extraParams, etc.).
+ * Used by the detail panel/modal.
+ *
+ * @param id - Notification ID
+ * @returns Full notification detail
+ */
+async function fetchNotificationDetail(id) {
+    // Phase 2: Generate mock detail
+    // In Phase 5, replace with:
+    // const service = await getVintaSendService();
+    // const notification = await service.getNotification(id);
+    const mockNotification = Math.random() > 0.5
+        ? {
+            id: `oneoff-${id}`,
+            emailOrPhone: `user@example.com`,
+            firstName: 'John',
+            lastName: 'Doe',
+            notificationType: 'EMAIL',
+            title: `Notification ${id}`,
+            contextName: 'defaultContext',
+            status: 'SENT',
+            sendAfter: null,
+            sentAt: new Date().toISOString(),
+            readAt: null,
+            createdAt: new Date().toISOString(),
+            adapterUsed: 'nodemailer',
+            bodyTemplate: 'This is the full body template with dynamic content.',
+            subjectTemplate: `Subject for ${id}`,
+            contextUsed: {
+                userName: 'John Doe',
+                accountBalance: 1500.0,
+            },
+            contextParameters: {
+                userId: 'user-123',
+                userRole: 'customer',
+            },
+            extraParams: {
+                campaignId: 'campaign-123',
+                trackingCode: 'track-abc',
+            },
+        }
+        : {
+            id: `notif-${id}`,
+            userId: 'user-42',
+            notificationType: 'EMAIL',
+            title: `Notification ${id}`,
+            contextName: 'defaultContext',
+            status: 'SENT',
+            sendAfter: null,
+            sentAt: new Date().toISOString(),
+            readAt: null,
+            createdAt: new Date().toISOString(),
+            adapterUsed: 'nodemailer',
+            bodyTemplate: 'This is the full body template with dynamic content.',
+            subjectTemplate: `Subject for ${id}`,
+            contextUsed: {
+                userName: 'Test User',
+                accountBalance: 2000.0,
+            },
+            contextParameters: {
+                userId: 'user-42',
+                userRole: 'admin',
+            },
+            extraParams: {
+                campaignId: 'campaign-456',
+                trackingCode: 'track-def',
+            },
+        };
+    return mockNotification;
+}
+/**
+ * Fetches pending notifications (status = PENDING_SEND).
+ * Convenience method that calls fetchNotifications with a pre-set filter.
+ *
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of pending notifications
+ */
+async function fetchPendingNotifications(page, pageSize) {
+    return fetchNotifications({ status: 'PENDING_SEND' }, page, pageSize);
+}
+/**
+ * Fetches future notifications (sendAfter > now).
+ * Convenience method that calls fetchNotifications.
+ * In Phase 5, will delegate to backend's getFutureNotifications method.
+ *
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of scheduled notifications
+ */
+async function fetchFutureNotifications(page, pageSize) {
+    const result = await fetchNotifications({}, page, pageSize);
+    // Filter to only future notifications (in real implementation, backend would do this)
+    const now = new Date();
+    return {
+        ...result,
+        data: result.data.filter((n) => n.sendAfter && new Date(n.sendAfter) > now),
+    };
+}
+/**
+ * Fetches one-off notifications only.
+ * In Phase 5, will call backend's getOneOffNotifications method.
+ *
+ * @param page - Page number (1-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Paginated result of one-off notifications
+ */
+async function fetchOneOffNotifications(page, pageSize) {
+    const result = await fetchNotifications({}, page, pageSize);
+    // Filter to only one-off notifications
+    return {
+        ...result,
+        data: result.data.filter((n) => n.id.startsWith('oneoff-')),
+    };
+}

package/dist/tools/vintasend-dashboard/app/notifications/components/columns.d.ts

@@ -0,0 +1,6 @@
+import { ColumnDef } from '@tanstack/react-table';
+import type { AnyDashboardNotification } from '@/lib/notifications/types';
+/**
+ * TanStack column definitions for the notifications table.
+ */
+export declare const columns: ColumnDef<AnyDashboardNotification>[];