vintasend 0.1.12 → 0.1.14

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Vinta Serviços e Soluções Tecnológicas Ltda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,6 +2,30 @@
 
 A flexible package for implementing transactional notifications in TypeScript.
 
+## Features
+
+* **Storing notifications in a Database**: This package relies on a data store to record all the notifications that will be sent. It also keeps it's state column up to date.
+* **Scheduling notifications**: Storing notifications to be send in the future. The notification's context for rendering the template is only evaluated at the moment the notification is sent due to the lib's context generation registry.
+* **Notification context fetched at send time**: On scheduled notifications, we only get the notification context at the send time, so we always get the most up-to-date information.
+* **Flexible backend**: Your projects database is getting slow after you created the first milion notifications? You can migrate to a faster no-sql database with a blink of an eye without affecting how you send the notifications.
+* **Flexible adapters**: Your project probably will need to change how it sends notifications overtime. This package allows to change the adapter without having to change how notifications templates are rendered or how the notification themselves are stored.
+* **Flexible template renderers**: Wanna start managing your templates with a third party tool (so non-technical people can help maintaining them)? Or even choose a more powerful rendering engine? You can do it independently of how you send the notifications or store them in the database.
+* **Sending notifications in background jobs**: This packages supports enqueing notifications to send it from separate processes. This may be helpful to free up the HTTP server of processing heavy notifications during the request time.
+
+## How does it work?
+
+The VintaSend package provides a NotificationService class that allows the user to store and send notification, scheduled or not. It relies on Dependency Injection to define how to store/retrieve, render the notification templates, and send notifications. This architechture allows us to swap each part without changing the code we actually use to send the notifications.
+
+### Scheduled Notifications
+
+VintaSend schedules notifications by creating them on the database for sending when the send_after value has passed. The sending isn't done automatically but we have a service method called `sendPendingNotifications` to send all pending notifications found in the database.
+
+You need to call the `sendPendingNotifications` service method in a cron job or a tool for running periodic jobs.
+
+#### Keeping the content up-to-date in scheduled notifications
+
+The NotificationService stores every notification in a database. This helps us to audit and manage our notifications. At the same time, notifications usually have a context that's used to hydrate its template with data. If we stored the cotext directly on the notification records, we'd have to update it anytime the context changes. Instead of storing the context itself, we store a reference to a Context Generator class and the parameters it requires (like ids, flags, types, etc) so we generate the context only when the notification is sent. This ensures we're always getting the most up-to-date context when sending notifications. We also store the generated context after we send the notification, for auditing purposes.
+
 ## Installation
 
 ```bash
@@ -10,13 +34,112 @@ npm install vintasend
 yarn add vintasend
 ```
 
-## Features
-* **Storing notifications in a Database**: This package relies on a data store to record all the notifications that will be sent. It also keeps it's state column up to date.
-* **Scheduling notifications**: Storing notifications to be send in the future. The notification's context for rendering the template is only evaluated at the moment the notification is sent due to the lib's context generation registry.
-* **Notification context fetched at send time**: On scheduled notifications, we only get the notification context at the send time, so we always get the most up-to-date information.
-* **Flexible backend**: Your projects database is getting slow after you created the first milion notifications? You can migrate to a faster no-sql database with a blink of an eye without affecting how you send the notifications.
-* **Flexible adapters**: Your project probably will need to change how it sends notifications overtime. This package allows to change the adapter without having to change how notifications templates are rendered or how the notification themselves are stored.
-* **Flexible template renderers**: Wanna start managing your templates with a third party tool (so non-technical people can help maintaining them)? Or even choose a more powerful rendering engine? You can do it independently of how you send the notifications or store them in the database.
+## Getting Started
+
+To start using VintaSend you just need to initialize the notification service and start using it to manage your notifications.
+
+
+```typescript
+import { NotificationService } from 'vintasend';
+
+// context map for generating the context of each notification
+export const contextGeneratorsMap = {
+  welcome: {
+    generate: async ({ userId }: { userId: number }): { firstName: string } => {
+      const user = await getUserById(userId);  // example
+      return {
+        firstName: user.firstName,
+      };
+    }
+  },
+} as const;
+
+// type config definition, so all modules use the same types
+export type NotificationTypeConfig = {
+  ContextMap: typeof contextGeneratorsMap;
+  NotificationIdType: number;
+  UserIdType: number;
+};
+
+export function getNotificationService() {
+  /* 
+   Function to instanciate the notificationService 
+   The Backend, Template Renderer, Logger, and Adapter used here are not included
+     here and should be installed and imported separately or manually defined if 
+     the existing implementations don't support the specific use-case.
+  */
+  const backend = new MyNotificationBackend<NotificationTypeConfig>();
+  const templateRenderer = new MyTemplateRenderer<NotificationTypeConfig>();
+  const adapter = new MyNotificationAdapter<
+    typeof templateRenderer,
+    NotificationTypeConfig
+  >(templateRenderer, true)
+  return new NotificationService<NotificationTypeConfig>(
+    [adapter],
+    backend,
+    new MyLogger(loggerOptions),
+    contextGeneratorsMap,
+  );
+}
+
+export function sendWelcomeEmail(userId: number) {
+  /* sends the Welcome email to a user */
+  const vintasend = getNotificationService();
+  const now = new Date();
+
+  vintasend.createNotification({
+      userId: user.id,
+      notificationType: 'EMAIL',
+      title: 'Welcome Email',
+      contextName: 'welcome',
+      contextParameters: { userId },
+      sendAfter: now,
+      bodyTemplate: './src/email-templates/auth/welcome/welcome-body.html.template',
+      subjectTemplate: './src/email-templates/auth/welcome/welcome-subject.txt.template',
+      extraParams: {},
+  });
+} 
+```
+
+## Glossary
+
+* **Notification Backend**: It is a class that implements the methods necessary for VintaSend services to create, update, and retrieve Notifications from da database.
+* **Notification Adapter**: It is a class that implements the methods necessary for VintaSend services to send Notifications through email, SMS or even push/in-app notifications.
+* **Template Renderer**: It is a class that implements the methods necessary for VintaSend adapter to render the notification body.
+* **Notification Context**: It's the data passed to the templates to render the notification correctly. It's generated when the notification is sent, not on creation time
+* **Context generator**: It's a class defined by the user context generator map with a context name. That class has a `generate` method that, when called, generates the data necessary to render its respective notification.
+* **Context name**: The registered name of a context generator. It's stored in the notification so the context generator is called at the moment the notification will be sent.
+* **Context generators map**: It's an object defined by the user that maps context names to their respective context generators.
+* **Queue service**: Service for enqueueing notifications so they are send by an external service.
+* **Logger**: A class that allows the `NotificationService` to create logs following a format defined by its users.  
+
+
+## Implementations
+
+
+## Community
+
+VintaSend has many backend, adapter, and template renderer implementations. If you can't find something that fulfills your needs, the package has very clear interfaces you can implement and achieve the exact behavior you expect without loosing VintaSend's friendly API.
+
+### Officially supported packages 
+
+#### Backends
+
+* **[vintasend-prisma](https://github.com/vintasoftware/vintasend-prisma/)**: Uses Prisma Client to manage the notifications in the database.
+
+#### Adapters
+
+* **[vintasend-nodemailer](https://github.com/vintasoftware/vintasend-nodemailer/)**: Uses nodemailer to send transactional emails to users. 
+
+#### Template Renderers
+* **[vintasend-pug](https://github.com/vintasoftware/vintasend-pug/)**: Renders emails using Pug.
+
+#### Loggers
+* **[vintasend-winston](https://github.com/vintasoftware/vintasend-winston/)**: Uses Winston to allow `NotificationService` to create log entries.
+
+## Examples
+
+Examples of how to use VintaSend in different context are available on the [vintasend-ts-examples repository](https://github.com/vintasoftware/vintasend-ts-examples).
 
 ## Development
 
@@ -38,6 +161,10 @@ yarn test
 
 Feel free to open issues and submit pull requests.
 
+### Creating new implementations
+
+There's a template project for creating new implementations that already includes basic dependencies, configuration for tests, and Github Actions hooks. You can find it in [vintasend-ts/src/implementations/vintasend-implementation-template](https://github.com/vintasoftware/vintasend-ts/tree/main/src/implementations/vintasend-implementation-template)
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/index.d.ts

@@ -1,3 +1,8 @@
 export { Notification } from "./types/notification";
-export { NotificationService } from "./services/notification-service";
-export { NotificationContextRegistry } from "./services/notification-context-registry";
+export { VintaSendFactory } from "./services/notification-service";
+export type { VintaSend } from "./services/notification-service";
+export type { ContextGenerator } from "./types/notification-context-generators";
+export type { BaseNotificationTypeConfig } from "./types/notification-type-config";
+export type { BaseNotificationQueueService } from "./services/notification-queue-service/base-notification-queue-service";
+export type { BaseNotificationTemplateRenderer } from "./services/notification-template-renderers/base-notification-template-renderer";
+export type { BaseEmailTemplateRenderer } from "./services/notification-template-renderers/base-email-template-renderer";

package/dist/index.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationContextRegistry = exports.NotificationService = void 0;
+exports.VintaSendFactory = void 0;
 var notification_service_1 = require("./services/notification-service");
-Object.defineProperty(exports, "NotificationService", { enumerable: true, get: function () { return notification_service_1.NotificationService; } });
-var notification_context_registry_1 = require("./services/notification-context-registry");
-Object.defineProperty(exports, "NotificationContextRegistry", { enumerable: true, get: function () { return notification_context_registry_1.NotificationContextRegistry; } });
+Object.defineProperty(exports, "VintaSendFactory", { enumerable: true, get: function () { return notification_service_1.VintaSendFactory; } });

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

@@ -10,9 +10,9 @@ export interface BaseNotificationBackend<Config extends BaseNotificationTypeConf
     getFutureNotificationsFromUser(userId: Config["UserIdType"]): Promise<DatabaseNotification<Config>[]>;
     persistNotification(notification: Omit<Notification<Config>, 'id'>): Promise<DatabaseNotification<Config>>;
     persistNotificationUpdate(notificationId: Config["NotificationIdType"], notification: Partial<Omit<Notification<Config>, 'id'>>): Promise<DatabaseNotification<Config>>;
-    markPendingAsSent(notificationId: Config["NotificationIdType"]): Promise<DatabaseNotification<Config>>;
-    markPendingAsFailed(notificationId: Config["NotificationIdType"]): Promise<DatabaseNotification<Config>>;
-    markSentAsRead(notificationId: Config["NotificationIdType"]): Promise<DatabaseNotification<Config>>;
+    markAsSent(notificationId: Config["NotificationIdType"], checkIsPending: boolean): Promise<DatabaseNotification<Config>>;
+    markAsFailed(notificationId: Config["NotificationIdType"], checkIsPending: boolean): Promise<DatabaseNotification<Config>>;
+    markAsRead(notificationId: Config["NotificationIdType"], checkIsSent: boolean): Promise<DatabaseNotification<Config>>;
     cancelNotification(notificationId: Config["NotificationIdType"]): Promise<void>;
     getNotification(notificationId: Config["NotificationIdType"], forUpdate: boolean): Promise<DatabaseNotification<Config> | null>;
     filterAllInAppUnreadNotifications(userId: Config["UserIdType"]): Promise<DatabaseNotification<Config>[]>;

package/dist/services/notification-context-generators-map.d.ts

@@ -0,0 +1,8 @@
+import type { ContextGenerator } from "../types/notification-context-generators";
+export declare class NotificationContextGeneratorsMap<ContextMapType extends {
+    [key: string]: ContextGenerator;
+}> {
+    private contextGenerators;
+    constructor(contextGenerators: ContextMapType);
+    getContextGenerator<ContextName extends string & keyof ContextMapType>(contextName: ContextName): ContextMapType[ContextName];
+}

package/dist/services/notification-context-generators-map.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationContextGeneratorsMap = void 0;
+class NotificationContextGeneratorsMap {
+    constructor(contextGenerators) {
+        this.contextGenerators = contextGenerators;
+    }
+    getContextGenerator(contextName) {
+        return this.contextGenerators[contextName];
+    }
+}
+exports.NotificationContextGeneratorsMap = NotificationContextGeneratorsMap;

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

@@ -6,35 +6,36 @@ import type { BaseNotificationTemplateRenderer } from './notification-template-r
 import type { BaseNotificationBackend } from './notification-backends/base-notification-backend';
 import type { BaseLogger } from './loggers/base-logger';
 import type { BaseNotificationQueueService } from './notification-queue-service/base-notification-queue-service';
-type NotificationServiceOptions = {
+type VintaSendOptions = {
     raiseErrorOnFailedSend: boolean;
 };
-export declare class NotificationService<Config extends BaseNotificationTypeConfig> {
+export declare class VintaSendFactory<Config extends BaseNotificationTypeConfig> {
+    create<AdaptersList extends BaseNotificationAdapter<BaseNotificationTemplateRenderer<Config>, Config>[], Backend extends BaseNotificationBackend<Config>, Logger extends BaseLogger, QueueService extends BaseNotificationQueueService<Config>>(adapters: AdaptersList, backend: Backend, logger: Logger, contextGeneratorsMap: BaseNotificationTypeConfig['ContextMap'], queueService?: QueueService, options?: VintaSendOptions): VintaSend<Config, AdaptersList, Backend, Logger, QueueService>;
+}
+export declare class VintaSend<Config extends BaseNotificationTypeConfig, AdaptersList extends BaseNotificationAdapter<BaseNotificationTemplateRenderer<Config>, Config>[], Backend extends BaseNotificationBackend<Config>, Logger extends BaseLogger, QueueService extends BaseNotificationQueueService<Config>> {
     private adapters;
     private backend;
     private logger;
     private queueService?;
     private options;
-    constructor(adapters: BaseNotificationAdapter<BaseNotificationTemplateRenderer<Config>, Config>[], backend: BaseNotificationBackend<Config>, logger: BaseLogger, queueService?: BaseNotificationQueueService<Config> | undefined, options?: NotificationServiceOptions);
-    registerQueueService(queueService: BaseNotificationQueueService<Config>): void;
+    private contextGeneratorsMap;
+    constructor(adapters: AdaptersList, backend: Backend, logger: Logger, contextGeneratorsMap: Config['ContextMap'], queueService?: QueueService | undefined, options?: VintaSendOptions);
+    registerQueueService(queueService: QueueService): void;
     send(notification: DatabaseNotification<Config>): Promise<void>;
-    createNotification(notification: Omit<Notification<Config>, 'id'>): Promise<Notification<Config>>;
+    createNotification(notification: Omit<Notification<Config>, 'id'>): Promise<DatabaseNotification<Config>>;
     updateNotification(notificationId: Config['NotificationIdType'], notification: Partial<Omit<Notification<Config>, 'id'>>): Promise<DatabaseNotification<Config>>;
     getAllFutureNotifications(): Promise<DatabaseNotification<Config>[]>;
     getAllFutureNotificationsFromUser(userId: Config['NotificationIdType']): Promise<DatabaseNotification<Config>[]>;
     getFutureNotificationsFromUser(userId: Config['NotificationIdType']): Promise<DatabaseNotification<Config>[]>;
     getFutureNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getNotificationContext(contextName: keyof Config['ContextMap'], parameters: Parameters<Config['ContextMap'][keyof Config['ContextMap']]['generate']>[0]): Promise<JsonObject>;
+    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(): Promise<DatabaseNotification<Config>[]>;
     getNotification(notificationId: Config['NotificationIdType'], forUpdate?: boolean): Promise<DatabaseNotification<Config> | null>;
-    markRead(notificationId: Config['NotificationIdType']): Promise<DatabaseNotification<Config>>;
+    markRead(notificationId: Config['NotificationIdType'], checkIsSent?: boolean): Promise<DatabaseNotification<Config>>;
     getInAppUnread(userId: Config['NotificationIdType']): Promise<DatabaseNotification<Config>[]>;
     cancelNotification(notificationId: Config['NotificationIdType']): Promise<void>;
+    resendNotification(notificationId: Config['NotificationIdType'], useStoredContextIfAvailable?: boolean): Promise<DatabaseNotification<Config> | undefined>;
     delayedSend(notificationId: Config['NotificationIdType']): Promise<void>;
 }
-export declare class NotificationServiceSingleton {
-    private static instance;
-    static getInstance<Config extends BaseNotificationTypeConfig>(...args: ConstructorParameters<typeof NotificationService> | []): NotificationService<Config>;
-}
 export {};

package/dist/services/notification-service.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationServiceSingleton = exports.NotificationService = void 0;
-const notification_context_registry_1 = require("./notification-context-registry");
-class NotificationService {
-    constructor(adapters, backend, logger, queueService, options = {
+exports.VintaSend = exports.VintaSendFactory = void 0;
+const notification_context_generators_map_1 = require("./notification-context-generators-map");
+class VintaSendFactory {
+    create(adapters, backend, logger, contextGeneratorsMap, queueService, options = {
+        raiseErrorOnFailedSend: false,
+    }) {
+        return new VintaSend(adapters, backend, logger, contextGeneratorsMap, queueService, options);
+    }
+}
+exports.VintaSendFactory = VintaSendFactory;
+class VintaSend {
+    constructor(adapters, backend, logger, contextGeneratorsMap, queueService, options = {
         raiseErrorOnFailedSend: false,
     }) {
         this.adapters = adapters;
@@ -11,6 +19,7 @@ class NotificationService {
         this.logger = logger;
         this.queueService = queueService;
         this.options = options;
+        this.contextGeneratorsMap = new notification_context_generators_map_1.NotificationContextGeneratorsMap(contextGeneratorsMap);
         for (const adapter of adapters) {
             adapter.injectBackend(backend);
         }
@@ -48,16 +57,21 @@ class NotificationService {
                 }
             }
             let context = null;
-            try {
-                context = await this.getNotificationContext(notification.contextName, notification.contextParameters);
-                this.logger.info(`Generated context for notification ${notification.id}`);
+            if (notification.contextUsed) {
+                context = notification.contextUsed;
             }
-            catch (contextError) {
-                this.logger.error(`Error getting context for notification ${notification.id}: ${contextError}`);
-                if (this.options.raiseErrorOnFailedSend) {
-                    throw contextError;
+            else {
+                try {
+                    context = await this.getNotificationContext(notification.contextName, notification.contextParameters);
+                    this.logger.info(`Generated context for notification ${notification.id}`);
+                }
+                catch (contextError) {
+                    this.logger.error(`Error getting context for notification ${notification.id}: ${contextError}`);
+                    if (this.options.raiseErrorOnFailedSend) {
+                        throw contextError;
+                    }
+                    return;
                 }
-                return;
             }
             try {
                 this.logger.info(`Sending notification ${notification.id} with adapter ${adapter.key}`);
@@ -67,7 +81,7 @@ class NotificationService {
             catch (sendError) {
                 this.logger.error(`Error sending notification ${notification.id} with adapter ${adapter.key}: ${sendError}`);
                 try {
-                    await this.backend.markPendingAsFailed(notification.id);
+                    await this.backend.markAsFailed(notification.id, true);
                 }
                 catch (markFailedError) {
                     this.logger.error(`Error marking notification ${notification.id} as failed: ${markFailedError}`);
@@ -75,7 +89,7 @@ class NotificationService {
                 continue;
             }
             try {
-                await this.backend.markPendingAsSent(notification.id);
+                await this.backend.markAsSent(notification.id, true);
             }
             catch (markSentError) {
                 this.logger.error(`Error marking notification ${notification.id} as sent: ${markSentError}`);
@@ -118,8 +132,11 @@ class NotificationService {
         return this.backend.getFutureNotifications();
     }
     async getNotificationContext(contextName, parameters) {
-        const contextRegistry = notification_context_registry_1.NotificationContextRegistry.getInstance();
-        return contextRegistry.getContext(contextName, parameters);
+        const context = this.contextGeneratorsMap.getContextGenerator(contextName).generate(parameters);
+        if (context instanceof Promise) {
+            return await context;
+        }
+        return Promise.resolve(context);
     }
     async sendPendingNotifications() {
         const pendingNotifications = await this.backend.getAllPendingNotifications();
@@ -131,8 +148,8 @@ class NotificationService {
     async getNotification(notificationId, forUpdate = false) {
         return this.backend.getNotification(notificationId, forUpdate);
     }
-    async markRead(notificationId) {
-        const notification = this.backend.markSentAsRead(notificationId);
+    async markRead(notificationId, checkIsSent = true) {
+        const notification = await this.backend.markAsRead(notificationId, checkIsSent);
         this.logger.info(`Notification ${notificationId} marked as read`);
         return notification;
     }
@@ -143,6 +160,59 @@ class NotificationService {
         await this.backend.cancelNotification(notificationId);
         this.logger.info(`Notification ${notificationId} cancelled`);
     }
+    async resendNotification(notificationId, useStoredContextIfAvailable = false) {
+        const notification = await this.getNotification(notificationId, false);
+        if (!notification) {
+            this.logger.error(`Notification ${notificationId} not found`);
+            if (this.options.raiseErrorOnFailedSend) {
+                throw new Error(`Notification ${notificationId} not found`);
+            }
+            return;
+        }
+        if (notification.sendAfter && notification.sendAfter > new Date()) {
+            this.logger.error(`Notification ${notificationId} is scheduled for the future`);
+            if (this.options.raiseErrorOnFailedSend) {
+                throw new Error(`Notification ${notificationId} is scheduled for the future`);
+            }
+            return;
+        }
+        if (useStoredContextIfAvailable && !notification.contextUsed) {
+            this.logger.error(`Context not found for notification ${notificationId}`);
+            if (this.options.raiseErrorOnFailedSend) {
+                throw new Error(`Context not found for notification ${notificationId}`);
+            }
+            return;
+        }
+        const notificationResendInputWithoutContext = {
+            userId: notification.userId,
+            notificationType: notification.notificationType,
+            title: notification.title,
+            bodyTemplate: notification.bodyTemplate,
+            contextName: notification.contextName,
+            contextParameters: notification.contextParameters,
+            sendAfter: null,
+            subjectTemplate: notification.subjectTemplate,
+            extraParams: notification.extraParams,
+        };
+        let createdNotification;
+        if (useStoredContextIfAvailable && notification.contextUsed) {
+            const notificationResendInput = {
+                ...notificationResendInputWithoutContext,
+                contextUsed: notification.contextUsed,
+            };
+            createdNotification = await this.backend.persistNotification(notificationResendInput);
+        }
+        else {
+            const notificationResendInput = {
+                ...notificationResendInputWithoutContext,
+                contextUsed: await this.getNotificationContext(notification.contextName, notification.contextParameters),
+            };
+            createdNotification = await this.backend.persistNotification(notificationResendInput);
+        }
+        this.logger.info(`Notification ${createdNotification.id} created for resending notification ${notificationId}`);
+        this.send(createdNotification);
+        return createdNotification;
+    }
     async delayedSend(notificationId) {
         const notification = await this.getNotification(notificationId, false);
         if (!notification) {
@@ -168,14 +238,14 @@ class NotificationService {
             catch (sendError) {
                 this.logger.error(`Error sending notification ${notification.id} with adapter ${adapter.key}: ${sendError}`);
                 try {
-                    await this.backend.markPendingAsFailed(notification.id);
+                    await this.backend.markAsFailed(notification.id, true);
                 }
                 catch (markFailedError) {
                     this.logger.error(`Error marking notification ${notification.id} as failed: ${markFailedError}`);
                 }
             }
             try {
-                await this.backend.markPendingAsSent(notification.id);
+                await this.backend.markAsSent(notification.id, true);
             }
             catch (markSentError) {
                 this.logger.error(`Error marking notification ${notification.id} as sent: ${markSentError}`);
@@ -189,17 +259,4 @@ class NotificationService {
         }
     }
 }
-exports.NotificationService = NotificationService;
-// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>
-class NotificationServiceSingleton {
-    static getInstance(...args) {
-        if (!NotificationServiceSingleton.instance) {
-            if (!args || args.length === 0) {
-                throw new Error('NotificationServiceSingleton is not initialized. Please call getInstance with the required arguments');
-            }
-            NotificationServiceSingleton.instance = new NotificationService(...args);
-        }
-        return NotificationServiceSingleton.instance;
-    }
-}
-exports.NotificationServiceSingleton = NotificationServiceSingleton;
+exports.VintaSend = VintaSend;

package/dist/types/notification-context-generators.d.ts

@@ -0,0 +1,4 @@
+import type { JsonObject, JsonPrimitive } from './json-values';
+export interface ContextGenerator<Params extends Record<string, JsonPrimitive> = Record<string, JsonPrimitive>> {
+    generate(params: Params): JsonObject | Promise<JsonObject>;
+}

package/dist/types/notification-context-generators.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/notification-type-config.d.ts

@@ -1,4 +1,4 @@
-import type { ContextGenerator } from "../services/notification-context-registry";
+import type { ContextGenerator } from "./notification-context-generators";
 import type { Identifier } from "./identifier";
 export type BaseNotificationTypeConfig = {
     ContextMap: Record<string, ContextGenerator>;

package/dist/types/notification.d.ts

@@ -3,29 +3,40 @@ import type { NotificationStatus } from './notification-status';
 import type { NotificationType } from './notification-type';
 import type { BaseNotificationTypeConfig } from './notification-type-config';
 export type NotificationInput<Config extends BaseNotificationTypeConfig> = {
-    id: undefined;
     userId: Config['UserIdType'];
     notificationType: NotificationType;
     title: string | null;
     bodyTemplate: string;
-    contextName: keyof Config['ContextMap'];
+    contextName: string & keyof Config['ContextMap'];
     contextParameters: Parameters<Config['ContextMap'][NotificationInput<Config>['contextName']]['generate']>[0];
     sendAfter: Date | null;
     subjectTemplate: string | null;
     extraParams: InputJsonValue | null;
 };
+export type NotificationResendWithContextInput<Config extends BaseNotificationTypeConfig> = {
+    userId: Config['UserIdType'];
+    notificationType: NotificationType;
+    title: string | null;
+    bodyTemplate: string;
+    contextName: string & keyof Config['ContextMap'];
+    contextParameters: Parameters<Config['ContextMap'][NotificationResendWithContextInput<Config>['contextName']]['generate']>[0];
+    contextUsed: ReturnType<Config['ContextMap'][NotificationResendWithContextInput<Config>['contextName']]['generate']> extends Promise<infer T> ? T : ReturnType<Config['ContextMap'][NotificationResendWithContextInput<Config>['contextName']]['generate']>;
+    sendAfter: Date | null;
+    subjectTemplate: string | null;
+    extraParams: InputJsonValue | null;
+};
 export type DatabaseNotification<Config extends BaseNotificationTypeConfig> = {
     id: Config['NotificationIdType'];
     userId: Config['UserIdType'];
     notificationType: NotificationType;
     title: string | null;
     bodyTemplate: string;
-    contextName: keyof Config['ContextMap'];
-    contextParameters: Parameters<Config['ContextMap'][NotificationInput<Config>['contextName']]['generate']>[0];
+    contextName: string & keyof Config['ContextMap'];
+    contextParameters: Parameters<Config['ContextMap'][DatabaseNotification<Config>['contextName']]['generate']>[0];
     sendAfter: Date | null;
     subjectTemplate: string | null;
     status: NotificationStatus;
-    contextUsed: ReturnType<Config['ContextMap'][NotificationInput<Config>['contextName']]['generate']> | null;
+    contextUsed: ReturnType<Config['ContextMap'][DatabaseNotification<Config>['contextName']]['generate']> extends Promise<infer T> ? T : ReturnType<Config['ContextMap'][DatabaseNotification<Config>['contextName']]['generate']>;
     extraParams: JsonValue;
     adapterUsed: string | null;
     sentAt: Date | null;
@@ -33,4 +44,4 @@ export type DatabaseNotification<Config extends BaseNotificationTypeConfig> = {
     createdAt?: Date;
     updatedAt?: Date;
 };
-export type Notification<Config extends BaseNotificationTypeConfig> = NotificationInput<Config> | DatabaseNotification<Config>;
+export type Notification<Config extends BaseNotificationTypeConfig> = NotificationInput<Config> | NotificationResendWithContextInput<Config> | DatabaseNotification<Config>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vintasend",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "main": "dist/index.js",
   "files": [
     "dist"