vintasend-prisma 0.1.5 → 0.1.8

package/{index.ts → dist/index.d.ts}

@@ -1 +1 @@
-export { PrismaNotificationBackend } from './prisma-notification-backend';
+export { PrismaNotificationBackend } from './prisma-notification-backend';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaNotificationBackend = void 0;
+var prisma_notification_backend_1 = require("./prisma-notification-backend");
+Object.defineProperty(exports, "PrismaNotificationBackend", { enumerable: true, get: function () { return prisma_notification_backend_1.PrismaNotificationBackend; } });

package/dist/prisma-notification-backend.d.ts

@@ -0,0 +1,159 @@
+import type { BaseNotificationBackend } from 'vintasend/dist/services/notification-backends/base-notification-backend';
+import type { ContextGenerator } from 'vintasend/dist/services/notification-context-registry';
+import type { InputJsonValue, JsonValue } from 'vintasend/dist/types/json-values';
+import type { DatabaseNotification, Notification, NotificationInput } from 'vintasend/dist/types/notification';
+import type { NotificationStatus } from 'vintasend/dist/types/notification-status';
+import type { NotificationType } from 'vintasend/dist/types/notification-type';
+import type { Identifier } from 'vintasend/dist/types/identifier';
+export declare const NotificationStatusEnum: {
+    readonly PENDING_SEND: "PENDING_SEND";
+    readonly SENT: "SENT";
+    readonly FAILED: "FAILED";
+    readonly READ: "READ";
+    readonly CANCELLED: "CANCELLED";
+};
+export declare const NotificationTypeEnum: {
+    readonly EMAIL: "EMAIL";
+    readonly PUSH: "PUSH";
+    readonly SMS: "SMS";
+    readonly IN_APP: "IN_APP";
+};
+export interface PrismaNotificationModel<IdType, UserId> {
+    id: IdType;
+    userId: UserId;
+    notificationType: NotificationType;
+    title: string | null;
+    bodyTemplate: string;
+    contextName: string;
+    contextParameters: JsonValue;
+    sendAfter: Date | null;
+    subjectTemplate: string | null;
+    status: NotificationStatus;
+    contextUsed: JsonValue | null;
+    extraParams: JsonValue | null;
+    adapterUsed: string | null;
+    sentAt: Date | null;
+    readAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+    user?: {
+        email: string;
+    };
+}
+export interface NotificationPrismaClientInterface<NotificationIdType, UserIdType> {
+    notification: {
+        findMany(args: {
+            where?: {
+                status?: NotificationStatus | {
+                    not: NotificationStatus;
+                };
+                sendAfter?: {
+                    lte: Date;
+                } | null;
+                userId?: UserIdType;
+                readAt?: null;
+            };
+            skip?: number;
+            take?: number;
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>[]>;
+        create(args: {
+            data: BaseNotificationCreateInput<UserIdType>;
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
+        update(args: {
+            where: {
+                id: NotificationIdType;
+            };
+            data: Partial<BaseNotificationUpdateInput<UserIdType>>;
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
+        findUnique(args: {
+            where: {
+                id: NotificationIdType;
+            };
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType> | null>;
+    };
+}
+type NoExpand<T> = T extends unknown ? T : never;
+type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
+    [P in K]: O[P];
+} & O : O) | ({
+    [P in keyof O as P extends K ? K : never]-?: O[P];
+} & O) : never>;
+export interface BaseNotificationCreateInput<UserIdType> {
+    user: {
+        connect?: AtLeast<{
+            id?: UserIdType;
+            email?: string;
+        }, 'id' | 'email'>;
+    };
+    notificationType: NotificationType;
+    title?: string | null;
+    bodyTemplate: string;
+    contextName: string;
+    contextParameters: InputJsonValue;
+    sendAfter?: Date | null;
+    subjectTemplate?: string | null;
+    status?: NotificationStatus;
+    contextUsed?: InputJsonValue;
+    extraParams?: InputJsonValue;
+    adapterUsed?: string | null;
+    sentAt?: Date | null;
+    readAt?: Date | null;
+}
+export interface BaseNotificationUpdateInput<UserIdType> {
+    user: {
+        connect?: AtLeast<{
+            id?: UserIdType;
+            email?: string;
+        }, 'id' | 'email'>;
+    };
+    notificationType?: NotificationType;
+    title?: string | null;
+    bodyTemplate?: string;
+    contextName?: string;
+    contextParameters?: InputJsonValue;
+    sendAfter?: Date | null;
+    subjectTemplate?: string | null;
+    status?: NotificationStatus;
+    contextUsed?: InputJsonValue;
+    extraParams?: InputJsonValue;
+    adapterUsed?: string | null;
+    sentAt?: Date | null;
+    readAt?: Date | null;
+}
+export declare class PrismaNotificationBackend<Client extends NotificationPrismaClientInterface<NotificationIdType, UserIdType>, AvailableContexts extends Record<string, ContextGenerator>, NotificationIdType extends Identifier = Identifier, UserIdType extends Identifier = Identifier> implements BaseNotificationBackend<AvailableContexts, NotificationIdType, UserIdType> {
+    private prismaClient;
+    constructor(prismaClient: Client);
+    serializeNotification(notification: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>): DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>;
+    deserializeNotification(notification: NotificationInput<AvailableContexts, UserIdType>): BaseNotificationCreateInput<UserIdType>;
+    deserializeNotificationForUpdate(notification: Partial<Notification<AvailableContexts, NotificationIdType, UserIdType>>): Partial<Parameters<typeof this.prismaClient.notification.update>[0]['data']>;
+    getAllPendingNotifications(): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    getPendingNotifications(): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    getAllFutureNotifications(): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    getFutureNotifications(): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    getAllFutureNotificationsFromUser(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId']): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    getFutureNotificationsFromUser(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId']): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    persistNotification(notification: NotificationInput<AvailableContexts, UserIdType>): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>>;
+    persistNotificationUpdate(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], notification: Partial<Omit<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>, 'id'>>): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>>;
+    markPendingAsSent(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id']): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>>;
+    markPendingAsFailed(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id']): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>>;
+    markSentAsRead(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id']): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>>;
+    cancelNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id']): Promise<void>;
+    getNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], _forUpdate: boolean): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType> | null>;
+    filterAllInAppUnreadNotifications(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId']): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    filterInAppUnreadNotifications(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId'], page: number, pageSize: number): Promise<DatabaseNotification<AvailableContexts, NotificationIdType, UserIdType>[]>;
+    getUserEmailFromNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id']): Promise<string | undefined>;
+    storeContextUsed(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], context: InputJsonValue): Promise<void>;
+}
+export {};

package/dist/prisma-notification-backend.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaNotificationBackend = exports.NotificationTypeEnum = exports.NotificationStatusEnum = void 0;
+exports.NotificationStatusEnum = {
+    PENDING_SEND: 'PENDING_SEND',
+    SENT: 'SENT',
+    FAILED: 'FAILED',
+    READ: 'READ',
+    CANCELLED: 'CANCELLED',
+};
+exports.NotificationTypeEnum = {
+    EMAIL: 'EMAIL',
+    PUSH: 'PUSH',
+    SMS: 'SMS',
+    IN_APP: 'IN_APP',
+};
+function convertJsonValueToRecord(jsonValue) {
+    if (typeof jsonValue === 'object' && !Array.isArray(jsonValue)) {
+        return jsonValue;
+    }
+    throw new Error('Invalid JSON value. It should be an object.');
+}
+class PrismaNotificationBackend {
+    constructor(prismaClient) {
+        this.prismaClient = prismaClient;
+    }
+    serializeNotification(notification) {
+        return {
+            id: notification.id,
+            userId: notification.userId,
+            notificationType: notification.notificationType,
+            title: notification.title,
+            bodyTemplate: notification.bodyTemplate,
+            contextName: notification.contextName,
+            contextParameters: notification.contextParameters
+                ? notification.contextParameters
+                : {},
+            sendAfter: notification.sendAfter,
+            subjectTemplate: notification.subjectTemplate,
+            status: notification.status,
+            contextUsed: notification.contextUsed,
+            extraParams: notification.extraParams
+                ? convertJsonValueToRecord(notification.extraParams)
+                : null,
+            adapterUsed: notification.adapterUsed,
+            sentAt: notification.sentAt,
+            readAt: notification.readAt,
+            createdAt: notification.createdAt,
+            updatedAt: notification.updatedAt,
+        };
+    }
+    deserializeNotification(notification) {
+        return {
+            user: {
+                connect: {
+                    id: notification.userId,
+                },
+            },
+            notificationType: notification.notificationType,
+            title: notification.title,
+            bodyTemplate: notification.bodyTemplate,
+            contextName: notification.contextName,
+            contextParameters: notification.contextParameters,
+            sendAfter: notification.sendAfter,
+            subjectTemplate: notification.subjectTemplate,
+            extraParams: notification.extraParams,
+        };
+    }
+    deserializeNotificationForUpdate(notification) {
+        return {
+            ...(notification.userId ? { user: { connect: { id: notification.userId } } } : {}),
+            ...(notification.notificationType
+                ? {
+                    notificationType: exports.NotificationTypeEnum[notification.notificationType],
+                }
+                : {}),
+            ...(notification.title ? { title: notification.title } : {}),
+            ...(notification.bodyTemplate ? { bodyTemplate: notification.bodyTemplate } : {}),
+            ...(notification.contextName ? { contextName: notification.contextName } : {}),
+            ...(notification.contextParameters
+                ? {
+                    contextParameters: notification.contextParameters ? notification.contextParameters : {},
+                }
+                : {}),
+            ...(notification.sendAfter ? { sendAfter: notification.sendAfter } : {}),
+            ...(notification.subjectTemplate ? { subjectTemplate: notification.subjectTemplate } : {}),
+        };
+    }
+    async getAllPendingNotifications() {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                status: exports.NotificationStatusEnum.PENDING_SEND,
+            },
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async getPendingNotifications() {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                status: exports.NotificationStatusEnum.PENDING_SEND,
+                sendAfter: null,
+            },
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async getAllFutureNotifications() {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                status: {
+                    not: exports.NotificationStatusEnum.PENDING_SEND,
+                },
+                sendAfter: {
+                    lte: new Date(),
+                },
+            },
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async getFutureNotifications() {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                status: {
+                    not: exports.NotificationStatusEnum.PENDING_SEND,
+                },
+                sendAfter: {
+                    lte: new Date(),
+                },
+            },
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async getAllFutureNotificationsFromUser(userId) {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                userId,
+                status: {
+                    not: exports.NotificationStatusEnum.PENDING_SEND,
+                },
+                sendAfter: {
+                    lte: new Date(),
+                },
+            },
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async getFutureNotificationsFromUser(userId) {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                userId,
+                status: {
+                    not: exports.NotificationStatusEnum.PENDING_SEND,
+                },
+                sendAfter: {
+                    lte: new Date(),
+                },
+            },
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async persistNotification(notification) {
+        return this.serializeNotification(await this.prismaClient.notification.create({
+            data: this.deserializeNotification(notification),
+        }));
+    }
+    async persistNotificationUpdate(notificationId, notification) {
+        return this.serializeNotification(await this.prismaClient.notification.update({
+            where: {
+                id: notificationId,
+            },
+            data: this.deserializeNotificationForUpdate(notification),
+        }));
+    }
+    async markPendingAsSent(notificationId) {
+        return this.serializeNotification(await this.prismaClient.notification.update({
+            where: {
+                id: notificationId,
+            },
+            data: {
+                status: exports.NotificationStatusEnum.SENT,
+                sentAt: new Date(),
+            },
+        }));
+    }
+    async markPendingAsFailed(notificationId) {
+        return this.serializeNotification(await this.prismaClient.notification.update({
+            where: {
+                id: notificationId,
+            },
+            data: {
+                status: exports.NotificationStatusEnum.FAILED,
+                sentAt: new Date(),
+            },
+        }));
+    }
+    async markSentAsRead(notificationId) {
+        return this.serializeNotification(await this.prismaClient.notification.update({
+            where: {
+                id: notificationId,
+            },
+            data: {
+                status: 'READ',
+                readAt: new Date(),
+            },
+        }));
+    }
+    async cancelNotification(notificationId) {
+        await this.prismaClient.notification.update({
+            where: {
+                id: notificationId,
+            },
+            data: {
+                status: exports.NotificationStatusEnum.CANCELLED,
+            },
+        });
+    }
+    async getNotification(notificationId, _forUpdate) {
+        const notification = await this.prismaClient.notification.findUnique({
+            where: {
+                id: notificationId,
+            },
+        });
+        if (!notification) {
+            return null;
+        }
+        return this.serializeNotification(notification);
+    }
+    async filterAllInAppUnreadNotifications(userId) {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                userId,
+                status: 'SENT',
+                readAt: null,
+            },
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async filterInAppUnreadNotifications(userId, page, pageSize) {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                userId,
+                status: 'SENT',
+                readAt: null,
+            },
+            skip: page * pageSize,
+            take: pageSize,
+        });
+        return notifications.map(this.serializeNotification);
+    }
+    async getUserEmailFromNotification(notificationId) {
+        var _a;
+        const notification = await this.prismaClient.notification.findUnique({
+            where: {
+                id: notificationId,
+            },
+            include: {
+                user: true,
+            },
+        });
+        return (_a = notification === null || notification === void 0 ? void 0 : notification.user) === null || _a === void 0 ? void 0 : _a.email;
+    }
+    async storeContextUsed(notificationId, context) {
+        await this.prismaClient.notification.update({
+            where: {
+                id: notificationId,
+            },
+            data: {
+                contextUsed: context,
+            },
+        });
+    }
+}
+exports.PrismaNotificationBackend = PrismaNotificationBackend;

package/package.json

@@ -1,17 +1,29 @@
 {
   "name": "vintasend-prisma",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "description": "VintaSend Backend implementation for Prisma",
-  "main": "index.js",
+  "main": "dist/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "generate-prisma-client": "prisma generate"
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
-  "author": "",
-  "license": "ISC",
+  "files": [
+    "dist"
+  ],
+  "author": "Hugo Bessa",
+  "license": "MIT",
   "dependencies": {
     "@prisma/client": "^6.3.1",
     "prisma": "^6.3.1",
-    "vintasend": "^0.1.4"
+    "vintasend": "^0.1.8"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.6",
+    "typescript": "^5.8.2"
   }
 }

package/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[{src,scripts}/**.{ts,json,js}]
-end_of_line = crlf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-indent_style = space
-indent_size = 2

package/biome.json

@@ -1,34 +0,0 @@
-{
-	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-	"vcs": {
-		"enabled": false,
-		"clientKind": "git",
-		"useIgnoreFile": false
-	},
-	"files": {
-		"ignoreUnknown": false,
-		"ignore": []
-	},
-	"formatter": {
-		"enabled": true,
-		"indentStyle": "space",
-		"indentWidth": 2,
-		"lineWidth": 100
-	},
-	"organizeImports": {
-		"enabled": true
-	},
-	"linter": {
-		"enabled": true,
-		"rules": {
-			"recommended": true
-		}
-	},
-	"javascript": {
-		"formatter": {
-			"quoteStyle": "single",
-			"semicolons": "always",
-			"trailingCommas": "all"
-		}
-	}
-}

package/prisma-notification-backend.ts

@@ -1,516 +0,0 @@
-import type { BaseNotificationBackend } from 'vintasend/src/services/notification-backends/base-notification-backend';
-import type { ContextGenerator } from 'vintasend/src/services/notification-context-registry';
-import type { InputJsonValue, JsonValue } from 'vintasend/src/types/json-values';
-import type { Notification, NotificationInput } from 'vintasend/src/types/notification';
-import type { NotificationStatus } from 'vintasend/src/types/notification-status';
-import type { NotificationType } from 'vintasend/src/types/notification-type';
-import type { Identifier } from 'vintasend/src/types/identifier';
-
-export const NotificationStatusEnum = {
-  PENDING_SEND: 'PENDING_SEND',
-  SENT: 'SENT',
-  FAILED: 'FAILED',
-  READ: 'READ',
-  CANCELLED: 'CANCELLED',
-} as const;
-
-export const NotificationTypeEnum = {
-  EMAIL: 'EMAIL',
-  PUSH: 'PUSH',
-  SMS: 'SMS',
-  IN_APP: 'IN_APP',
-} as const;
-
-export interface PrismaNotificationModel<IdType, UserId> {
-  id: IdType;
-  userId: UserId;
-  notificationType: NotificationType;
-  title: string | null;
-  bodyTemplate: string;
-  contextName: string;
-  contextParameters: JsonValue;
-  sendAfter: Date | null;
-  subjectTemplate: string | null;
-  status: NotificationStatus;
-  contextUsed: JsonValue | null;
-  extraParams: JsonValue | null;
-  adapterUsed: string | null;
-  sentAt: Date | null;
-  readAt: Date | null;
-  createdAt: Date;
-  updatedAt: Date;
-  user?: {
-    email: string;
-  };
-}
-
-export interface NotificationPrismaClientInterface<NotificationIdType, UserIdType> {
-  notification: {
-    findMany(args: {
-      where?: {
-        status?: NotificationStatus | { not: NotificationStatus };
-        sendAfter?: { lte: Date } | null;
-        userId?: UserIdType;
-        readAt?: null;
-      };
-      skip?: number;
-      take?: number;
-      include?: { user?: boolean };
-    }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>[]>;
-    create(args: {
-      data: BaseNotificationCreateInput<UserIdType>;
-      include?: { user?: boolean };
-    }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
-    update(args: {
-      where: { id: NotificationIdType };
-      data: Partial<BaseNotificationUpdateInput<UserIdType>>;
-      include?: { user?: boolean };
-    }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
-    findUnique(args: {
-      where: { id: NotificationIdType };
-      include?: { user?: boolean };
-    }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType> | null>;
-  };
-}
-
-// cause typescript not to expand types and preserve names
-type NoExpand<T> = T extends unknown ? T : never;
-
-// this type assumes the passed object is entirely optional
-type AtLeast<O extends object, K extends string> = NoExpand<
-  O extends unknown
-    ?
-        | (K extends keyof O ? { [P in K]: O[P] } & O : O)
-        | ({ [P in keyof O as P extends K ? K : never]-?: O[P] } & O)
-    : never
->;
-
-export interface BaseNotificationCreateInput<UserIdType> {
-  user: {
-    connect?: AtLeast<
-      {
-        id?: UserIdType;
-        email?: string;
-      },
-      'id' | 'email'
-    >;
-  };
-  notificationType: NotificationType;
-  title?: string | null;
-  bodyTemplate: string;
-  contextName: string;
-  contextParameters: InputJsonValue;
-  sendAfter?: Date | null;
-  subjectTemplate?: string | null;
-  status?: NotificationStatus;
-  contextUsed?: InputJsonValue;
-  extraParams?: InputJsonValue;
-  adapterUsed?: string | null;
-  sentAt?: Date | null;
-  readAt?: Date | null;
-}
-
-export interface BaseNotificationUpdateInput<UserIdType> {
-  user: {
-    connect?: AtLeast<
-      {
-        id?: UserIdType;
-        email?: string;
-      },
-      'id' | 'email'
-    >;
-  };
-  notificationType?: NotificationType;
-  title?: string | null;
-  bodyTemplate?: string;
-  contextName?: string;
-  contextParameters?: InputJsonValue;
-  sendAfter?: Date | null;
-  subjectTemplate?: string | null;
-  status?: NotificationStatus;
-  contextUsed?: InputJsonValue;
-  extraParams?: InputJsonValue;
-  adapterUsed?: string | null;
-  sentAt?: Date | null;
-  readAt?: Date | null;
-}
-
-function convertJsonValueToRecord(jsonValue: JsonValue): Record<string, string | number | boolean> {
-  if (typeof jsonValue === 'object' && !Array.isArray(jsonValue) && jsonValue !== null) {
-    return jsonValue as Record<string, string | number | boolean>;
-  }
-
-  throw new Error('Invalid JSON value. It should be an object.');
-}
-
-export class PrismaNotificationBackend<
-  Client extends NotificationPrismaClientInterface<NotificationIdType, UserIdType>,
-  AvailableContexts extends Record<string, ContextGenerator>,
-  NotificationIdType extends Identifier = Identifier,
-  UserIdType extends Identifier = Identifier,
-> implements BaseNotificationBackend<AvailableContexts, NotificationIdType, UserIdType>
-{
-  constructor(private prismaClient: Client) {}
-
-  serializeNotification(
-    notification: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >,
-  ): Notification<AvailableContexts, NotificationIdType, UserIdType> {
-    return {
-      id: notification.id,
-      userId: notification.userId,
-      notificationType: notification.notificationType,
-      title: notification.title,
-      bodyTemplate: notification.bodyTemplate,
-      contextName: notification.contextName as keyof AvailableContexts,
-      contextParameters: notification.contextParameters
-        ? (notification.contextParameters as Parameters<
-            AvailableContexts[keyof AvailableContexts]['generate']
-          >[0])
-        : {},
-      sendAfter: notification.sendAfter,
-      subjectTemplate: notification.subjectTemplate,
-      status: notification.status,
-      contextUsed: notification.contextUsed as ReturnType<
-        AvailableContexts[keyof AvailableContexts]['generate']
-      > | null,
-      extraParams: notification.extraParams
-        ? convertJsonValueToRecord(notification.extraParams)
-        : null,
-      adapterUsed: notification.adapterUsed,
-      sentAt: notification.sentAt,
-      readAt: notification.readAt,
-      createdAt: notification.createdAt,
-      updatedAt: notification.updatedAt,
-    };
-  }
-
-  deserializeNotification(
-    notification: NotificationInput<AvailableContexts, UserIdType>,
-  ): BaseNotificationCreateInput<UserIdType> {
-    return {
-      user: {
-        connect: {
-          id: notification.userId,
-        },
-      },
-      notificationType: notification.notificationType,
-      title: notification.title,
-      bodyTemplate: notification.bodyTemplate,
-      contextName: notification.contextName as string,
-      contextParameters: notification.contextParameters as InputJsonValue,
-      sendAfter: notification.sendAfter,
-      subjectTemplate: notification.subjectTemplate,
-      extraParams: notification.extraParams as InputJsonValue,
-    };
-  }
-
-  deserializeNotificationForUpdate(
-    notification: Partial<Notification<AvailableContexts, NotificationIdType, UserIdType>>,
-  ): Partial<Parameters<typeof this.prismaClient.notification.update>[0]['data']> {
-    return {
-      ...(notification.userId ? { user: { connect: { id: notification.userId } } } : {}),
-      ...(notification.notificationType
-        ? {
-            notificationType: NotificationTypeEnum[
-              notification.notificationType as keyof typeof NotificationTypeEnum
-            ] as NotificationType,
-          }
-        : {}),
-      ...(notification.title ? { title: notification.title } : {}),
-      ...(notification.bodyTemplate ? { bodyTemplate: notification.bodyTemplate } : {}),
-      ...(notification.contextName ? { contextName: notification.contextName } : {}),
-      ...(notification.contextParameters
-        ? {
-            contextParameters: notification.contextParameters ? notification.contextParameters : {},
-          }
-        : {}),
-      ...(notification.sendAfter ? { sendAfter: notification.sendAfter } : {}),
-      ...(notification.subjectTemplate ? { subjectTemplate: notification.subjectTemplate } : {}),
-    } as Partial<Parameters<typeof this.prismaClient.notification.update>[0]['data']>;
-  }
-
-  async getAllPendingNotifications(): Promise<
-    Notification<AvailableContexts, NotificationIdType, UserIdType>[]
-  > {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        status: NotificationStatusEnum.PENDING_SEND,
-      },
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async getPendingNotifications(): Promise<
-    Notification<AvailableContexts, NotificationIdType, UserIdType>[]
-  > {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        status: NotificationStatusEnum.PENDING_SEND,
-        sendAfter: null,
-      },
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async getAllFutureNotifications(): Promise<
-    Notification<AvailableContexts, NotificationIdType, UserIdType>[]
-  > {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        status: {
-          not: NotificationStatusEnum.PENDING_SEND,
-        },
-        sendAfter: {
-          lte: new Date(),
-        },
-      },
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async getFutureNotifications(): Promise<
-    Notification<AvailableContexts, NotificationIdType, UserIdType>[]
-  > {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        status: {
-          not: NotificationStatusEnum.PENDING_SEND,
-        },
-        sendAfter: {
-          lte: new Date(),
-        },
-      },
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async getAllFutureNotificationsFromUser(
-    userId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['userId'],
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>[]> {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        userId,
-        status: {
-          not: NotificationStatusEnum.PENDING_SEND,
-        },
-        sendAfter: {
-          lte: new Date(),
-        },
-      },
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async getFutureNotificationsFromUser(
-    userId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['userId'],
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>[]> {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        userId,
-        status: {
-          not: NotificationStatusEnum.PENDING_SEND,
-        },
-        sendAfter: {
-          lte: new Date(),
-        },
-      },
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async persistNotification(
-    notification: NotificationInput<AvailableContexts, UserIdType>,
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>> {
-    return this.serializeNotification(
-      await this.prismaClient.notification.create({
-        data: this.deserializeNotification(notification),
-      }),
-    );
-  }
-
-  async persistNotificationUpdate(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-    notification: Partial<
-      Omit<Notification<AvailableContexts, NotificationIdType, UserIdType>, 'id'>
-    >,
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>> {
-    return this.serializeNotification(
-      await this.prismaClient.notification.update({
-        where: {
-          id: notificationId,
-        },
-        data: this.deserializeNotificationForUpdate(notification),
-      }),
-    );
-  }
-
-  async markPendingAsSent(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>> {
-    return this.serializeNotification(
-      await this.prismaClient.notification.update({
-        where: {
-          id: notificationId,
-        },
-        data: {
-          status: NotificationStatusEnum.SENT,
-          sentAt: new Date(),
-        },
-      }),
-    );
-  }
-
-  async markPendingAsFailed(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>> {
-    return this.serializeNotification(
-      await this.prismaClient.notification.update({
-        where: {
-          id: notificationId,
-        },
-        data: {
-          status: NotificationStatusEnum.FAILED,
-          sentAt: new Date(),
-        },
-      }),
-    );
-  }
-
-  async markSentAsRead(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>> {
-    return this.serializeNotification(
-      await this.prismaClient.notification.update({
-        where: {
-          id: notificationId,
-        },
-        data: {
-          status: 'READ',
-          readAt: new Date(),
-        },
-      }),
-    );
-  }
-
-  async cancelNotification(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-  ): Promise<void> {
-    await this.prismaClient.notification.update({
-      where: {
-        id: notificationId,
-      },
-      data: {
-        status: NotificationStatusEnum.CANCELLED,
-      },
-    });
-  }
-
-  async getNotification(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-    _forUpdate: boolean,
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType> | null> {
-    const notification = await this.prismaClient.notification.findUnique({
-      where: {
-        id: notificationId,
-      },
-    });
-    if (!notification) {
-      return null;
-    }
-
-    return this.serializeNotification(notification);
-  }
-
-  async filterAllInAppUnreadNotifications(
-    userId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['userId'],
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>[]> {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        userId,
-        status: 'SENT',
-        readAt: null,
-      },
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async filterInAppUnreadNotifications(
-    userId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['userId'],
-    page: number,
-    pageSize: number,
-  ): Promise<Notification<AvailableContexts, NotificationIdType, UserIdType>[]> {
-    const notifications = await this.prismaClient.notification.findMany({
-      where: {
-        userId,
-        status: 'SENT',
-        readAt: null,
-      },
-      skip: page * pageSize,
-      take: pageSize,
-    });
-
-    return notifications.map(this.serializeNotification);
-  }
-
-  async getUserEmailFromNotification(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-  ): Promise<string | undefined> {
-    const notification = await this.prismaClient.notification.findUnique({
-      where: {
-        id: notificationId,
-      },
-      include: {
-        user: true,
-      },
-    });
-
-    return notification?.user?.email;
-  }
-
-  async storeContextUsed(
-    notificationId: NonNullable<
-      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
-    >['id'],
-    context: InputJsonValue,
-  ): Promise<void> {
-    await this.prismaClient.notification.update({
-      where: {
-        id: notificationId,
-      },
-      data: {
-        contextUsed: context,
-      },
-    });
-  }
-}

package/schema.prisma.example

@@ -1,49 +0,0 @@
-datasource db {
-  provider = "postgresql"
-  url      = env("DATABASE_URL")
-}
-
-generator client {
-  provider = "prisma-client-js"
-}
-
-model User {
-  id                          Int                       @id @default(autoincrement())
-  email                       String                    @unique
-  notifications               Notification[]
-}
-
-model Notification {
-  id                          Int                       @id @default(autoincrement())
-  user                        User                      @relation(fields: [userId], references: [id])
-  userId                      Int
-  notificationType            NotificationType
-  title                       String?
-  bodyTemplate                String
-  contextName                 String
-  contextParameters           Json                      @default("{}")
-  sendAfter                   DateTime?
-  subjectTemplate             String?
-  status                      NotificationStatus        @default(PENDING_SEND)
-  contextUsed                 Json?
-  adapterUsed                 String?
-  sentAt                      DateTime?
-  readAt                      DateTime?
-  createdAt                   DateTime                  @default(now())
-  updatedAt                   DateTime                  @updatedAt
-}
-
-enum NotificationType {
-  EMAIL
-  PUSH
-  SMS
-  IN_APP
-}
-
-enum NotificationStatus {
-  PENDING_SEND
-  SENT
-  FAILED
-  READ
-  CANCELLED
-}