vintasend-prisma 0.2.3 → 0.4.0

package/dist/implementations/vintasend-prisma/src/index.d.ts

@@ -0,0 +1,2 @@
+export { PrismaNotificationBackendFactory } from './prisma-notification-backend';
+export type { PrismaNotificationBackend } from './prisma-notification-backend';

package/dist/implementations/vintasend-prisma/src/index.js

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.PrismaNotificationBackendFactory = void 0;
+var prisma_notification_backend_1 = require('./prisma-notification-backend');
+Object.defineProperty(exports, 'PrismaNotificationBackendFactory', {
+  enumerable: true,
+  get: () => prisma_notification_backend_1.PrismaNotificationBackendFactory,
+});

package/dist/implementations/vintasend-prisma/src/prisma-notification-backend.d.ts

@@ -0,0 +1,318 @@
+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 { BaseNotificationTypeConfig } from 'vintasend/dist/types/notification-type-config';
+import type { BaseNotificationBackend } from '../../../services/notification-backends/base-notification-backend';
+import type {
+  AnyDatabaseNotification,
+  DatabaseOneOffNotification,
+  OneOffNotificationInput,
+} from '../../../types/notification';
+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 | null;
+  emailOrPhone: string | null;
+  firstName: string | null;
+  lastName: string | null;
+  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 | null;
+        readAt?: null;
+        emailOrPhone?:
+          | string
+          | {
+              not: null;
+            };
+      };
+      skip?: number;
+      take?: number;
+      include?: {
+        user?: boolean;
+      };
+    }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>[]>;
+    create(args: {
+      data: BaseNotificationCreateInput<UserIdType>;
+      include?: {
+        user?: boolean;
+      };
+    }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
+    createMany(args: {
+      data: BaseNotificationCreateInput<UserIdType>[];
+    }): Promise<NotificationIdType[]>;
+    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'
+    >;
+  };
+  userId?: UserIdType | null;
+  emailOrPhone?: string | null;
+  firstName?: string | null;
+  lastName?: string | null;
+  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'
+    >;
+  };
+  emailOrPhone?: string | null;
+  firstName?: string | null;
+  lastName?: string | null;
+  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<
+    Config['NotificationIdType'],
+    Config['UserIdType']
+  >,
+  Config extends BaseNotificationTypeConfig,
+> implements BaseNotificationBackend<Config>
+{
+  private prismaClient;
+  constructor(prismaClient: Client);
+  /**
+   * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
+   * based on whether it has a userId or not
+   */
+  serializeNotification(
+    notification: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >,
+  ): AnyDatabaseNotification<Config>;
+  deserializeNotification(
+    notification: NotificationInput<Config>,
+  ): BaseNotificationCreateInput<Config['UserIdType']>;
+  deserializeNotificationForUpdate(
+    notification: Partial<Notification<Config>>,
+  ): Partial<Parameters<typeof this.prismaClient.notification.update>[0]['data']>;
+  getAllPendingNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+  getPendingNotifications(
+    page?: number,
+    pageSize?: number,
+  ): Promise<AnyDatabaseNotification<Config>[]>;
+  getAllFutureNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+  getFutureNotifications(
+    page?: number,
+    pageSize?: number,
+  ): Promise<AnyDatabaseNotification<Config>[]>;
+  getAllFutureNotificationsFromUser(
+    userId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['userId'],
+  ): Promise<DatabaseNotification<Config>[]>;
+  getFutureNotificationsFromUser(
+    userId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['userId'],
+    page: number,
+    pageSize: number,
+  ): Promise<DatabaseNotification<Config>[]>;
+  getAllNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+  getNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
+  persistNotification(
+    notification: NotificationInput<Config>,
+  ): Promise<DatabaseNotification<Config>>;
+  persistNotificationUpdate(
+    notificationId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['id'],
+    notification: Partial<Omit<DatabaseNotification<Config>, 'id'>>,
+  ): Promise<DatabaseNotification<Config>>;
+  persistOneOffNotification(
+    notification: OneOffNotificationInput<Config>,
+  ): Promise<DatabaseOneOffNotification<Config>>;
+  persistOneOffNotificationUpdate(
+    notificationId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['id'],
+    notification: Partial<Omit<DatabaseOneOffNotification<Config>, 'id'>>,
+  ): Promise<DatabaseOneOffNotification<Config>>;
+  getOneOffNotification(
+    notificationId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['id'],
+    _forUpdate: boolean,
+  ): Promise<DatabaseOneOffNotification<Config> | null>;
+  getAllOneOffNotifications(): Promise<DatabaseOneOffNotification<Config>[]>;
+  getOneOffNotifications(
+    page: number,
+    pageSize: number,
+  ): Promise<DatabaseOneOffNotification<Config>[]>;
+  markAsSent(
+    notificationId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['id'],
+    checkIsPending?: boolean,
+  ): Promise<AnyDatabaseNotification<Config>>;
+  markAsFailed(
+    notificationId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['id'],
+    checkIsPending?: boolean,
+  ): Promise<AnyDatabaseNotification<Config>>;
+  markAsRead(
+    notificationId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['id'],
+    checkIsSent?: boolean,
+  ): Promise<DatabaseNotification<Config>>;
+  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<AnyDatabaseNotification<Config> | null>;
+  filterAllInAppUnreadNotifications(
+    userId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['userId'],
+  ): Promise<DatabaseNotification<Config>[]>;
+  filterInAppUnreadNotifications(
+    userId: NonNullable<
+      Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>
+    >['userId'],
+    page: number,
+    pageSize: number,
+  ): Promise<DatabaseNotification<Config>[]>;
+  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>;
+  bulkPersistNotifications(
+    notifications: Omit<Notification<Config>, 'id'>[],
+  ): Promise<Config['NotificationIdType'][]>;
+}
+export declare class PrismaNotificationBackendFactory<Config extends BaseNotificationTypeConfig> {
+  create<
+    Client extends NotificationPrismaClientInterface<
+      Config['NotificationIdType'],
+      Config['UserIdType']
+    >,
+  >(prismaClient: Client): PrismaNotificationBackend<Client, Config>;
+}