vintasend-prisma 0.2.3 → 0.4.0

package/dist/implementations/vintasend-prisma/src/prisma-notification-backend.js

@@ -0,0 +1,406 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.PrismaNotificationBackendFactory =
+  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;
+  }
+  /**
+   * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
+   * based on whether it has a userId or not
+   */
+  serializeNotification(notification) {
+    const baseData = {
+      id: notification.id,
+      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,
+    };
+    // Check if this is a one-off notification (has emailOrPhone but no userId)
+    if (notification.emailOrPhone && !notification.userId) {
+      return {
+        ...baseData,
+        emailOrPhone: notification.emailOrPhone,
+        firstName: notification.firstName || '',
+        lastName: notification.lastName || '',
+      };
+    }
+    // Regular notification with userId
+    return {
+      ...baseData,
+      userId: notification.userId,
+    };
+  }
+  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((n) => this.serializeNotification(n));
+  }
+  async getPendingNotifications(page = 0, pageSize = 100) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        status: exports.NotificationStatusEnum.PENDING_SEND,
+        sendAfter: null,
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getAllFutureNotifications() {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        status: { not: exports.NotificationStatusEnum.PENDING_SEND },
+        sendAfter: { lte: new Date() },
+      },
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getFutureNotifications(page = 0, pageSize = 100) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        status: { not: exports.NotificationStatusEnum.PENDING_SEND },
+        sendAfter: { lte: new Date() },
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getAllFutureNotificationsFromUser(userId) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId,
+        status: {
+          not: exports.NotificationStatusEnum.PENDING_SEND,
+        },
+        sendAfter: {
+          lte: new Date(),
+        },
+      },
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getFutureNotificationsFromUser(userId, page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId,
+        status: {
+          not: exports.NotificationStatusEnum.PENDING_SEND,
+        },
+        sendAfter: {
+          lte: new Date(),
+        },
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getAllNotifications() {
+    const notifications = await this.prismaClient.notification.findMany({});
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getNotifications(page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async persistNotification(notification) {
+    const created = await this.prismaClient.notification.create({
+      data: this.deserializeNotification(notification),
+    });
+    // persistNotification takes NotificationInput which always has userId, so this is always a regular notification
+    return this.serializeNotification(created);
+  }
+  async persistNotificationUpdate(notificationId, notification) {
+    const updated = await this.prismaClient.notification.update({
+      where: {
+        id: notificationId,
+      },
+      data: this.deserializeNotificationForUpdate(notification),
+    });
+    // persistNotificationUpdate takes Partial<DatabaseNotification> which has userId, so this is always a regular notification
+    return this.serializeNotification(updated);
+  }
+  /* One-off notification persistence and query methods */
+  async persistOneOffNotification(notification) {
+    const created = await this.prismaClient.notification.create({
+      data: {
+        userId: null, // One-off notifications don't have a userId
+        emailOrPhone: notification.emailOrPhone,
+        firstName: notification.firstName,
+        lastName: notification.lastName,
+        notificationType: notification.notificationType,
+        title: notification.title,
+        bodyTemplate: notification.bodyTemplate,
+        contextName: notification.contextName,
+        contextParameters: notification.contextParameters,
+        sendAfter: notification.sendAfter,
+        subjectTemplate: notification.subjectTemplate,
+        extraParams: notification.extraParams,
+        status: exports.NotificationStatusEnum.PENDING_SEND,
+      },
+    });
+    return this.serializeNotification(created);
+  }
+  async persistOneOffNotificationUpdate(notificationId, notification) {
+    const data = {
+      ...(notification.emailOrPhone !== undefined
+        ? { emailOrPhone: notification.emailOrPhone }
+        : {}),
+      ...(notification.firstName !== undefined ? { firstName: notification.firstName } : {}),
+      ...(notification.lastName !== undefined ? { lastName: notification.lastName } : {}),
+      ...(notification.notificationType ? { notificationType: notification.notificationType } : {}),
+      ...(notification.title ? { title: notification.title } : {}),
+      ...(notification.bodyTemplate ? { bodyTemplate: notification.bodyTemplate } : {}),
+      ...(notification.contextName ? { contextName: notification.contextName } : {}),
+      ...(notification.contextParameters
+        ? { contextParameters: notification.contextParameters }
+        : {}),
+      ...(notification.sendAfter ? { sendAfter: notification.sendAfter } : {}),
+      ...(notification.subjectTemplate ? { subjectTemplate: notification.subjectTemplate } : {}),
+    };
+    const updated = await this.prismaClient.notification.update({
+      where: { id: notificationId },
+      data,
+    });
+    return this.serializeNotification(updated);
+  }
+  async getOneOffNotification(notificationId, _forUpdate) {
+    const notification = await this.prismaClient.notification.findUnique({
+      where: {
+        id: notificationId,
+      },
+    });
+    if (!notification || !notification.emailOrPhone || notification.userId !== null) {
+      return null;
+    }
+    return this.serializeNotification(notification);
+  }
+  async getAllOneOffNotifications() {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId: null,
+        emailOrPhone: { not: null },
+      },
+    });
+    return notifications
+      .filter((n) => n.emailOrPhone !== null)
+      .map((n) => this.serializeNotification(n));
+  }
+  async getOneOffNotifications(page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId: null,
+        emailOrPhone: { not: null },
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications
+      .filter((n) => n.emailOrPhone !== null)
+      .map((n) => this.serializeNotification(n));
+  }
+  async markAsSent(notificationId, checkIsPending = true) {
+    const whereClause = {
+      id: notificationId,
+    };
+    if (checkIsPending) {
+      whereClause.status = exports.NotificationStatusEnum.PENDING_SEND;
+    }
+    const updated = await this.prismaClient.notification.update({
+      where: whereClause,
+      data: {
+        status: exports.NotificationStatusEnum.SENT,
+        sentAt: new Date(),
+      },
+    });
+    return this.serializeNotification(updated);
+  }
+  async markAsFailed(notificationId, checkIsPending = true) {
+    const whereClause = {
+      id: notificationId,
+    };
+    if (checkIsPending) {
+      whereClause.status = exports.NotificationStatusEnum.PENDING_SEND;
+    }
+    const updated = await this.prismaClient.notification.update({
+      where: whereClause,
+      data: {
+        status: exports.NotificationStatusEnum.FAILED,
+        sentAt: new Date(),
+      },
+    });
+    return this.serializeNotification(updated);
+  }
+  async markAsRead(notificationId, checkIsSent = true) {
+    const whereClause = {
+      id: notificationId,
+    };
+    if (checkIsSent) {
+      whereClause.status = exports.NotificationStatusEnum.SENT;
+    }
+    const updated = await this.prismaClient.notification.update({
+      where: whereClause,
+      data: {
+        status: 'READ',
+        readAt: new Date(),
+      },
+    });
+    // markAsRead is only for in-app notifications (which are always regular notifications with userId)
+    return this.serializeNotification(updated);
+  }
+  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,
+      },
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async filterInAppUnreadNotifications(userId, page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId,
+        status: 'SENT',
+        readAt: null,
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  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 },
+    });
+  }
+  async bulkPersistNotifications(notifications) {
+    return this.prismaClient.notification.createMany({
+      data: notifications.map((notification) => this.deserializeNotification(notification)),
+    });
+  }
+}
+exports.PrismaNotificationBackend = PrismaNotificationBackend;
+class PrismaNotificationBackendFactory {
+  create(prismaClient) {
+    return new PrismaNotificationBackend(prismaClient);
+  }
+}
+exports.PrismaNotificationBackendFactory = PrismaNotificationBackendFactory;