vintasend-prisma 0.2.3 → 0.4.0

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

@@ -1,9 +1,12 @@
 import type { BaseNotificationBackend } from 'vintasend/dist/services/notification-backends/base-notification-backend';
 import type { InputJsonValue, JsonValue } from 'vintasend/dist/types/json-values';
-import type { DatabaseNotification, Notification, NotificationInput } from 'vintasend/dist/types/notification';
+import type { AnyNotificationInput, DatabaseNotification, Notification, NotificationInput } from 'vintasend/dist/types/notification';
+import type { AnyDatabaseNotification, AnyNotification, DatabaseOneOffNotification, OneOffNotificationInput } 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 { AttachmentFileRecord, StoredAttachment } from 'vintasend/dist/types/attachment';
+import type { BaseAttachmentManager } from 'vintasend/dist/services/attachment-manager/base-attachment-manager';
 export declare const NotificationStatusEnum: {
     readonly PENDING_SEND: "PENDING_SEND";
     readonly SENT: "SENT";
@@ -19,7 +22,10 @@ export declare const NotificationTypeEnum: {
 };
 export interface PrismaNotificationModel<IdType, UserId> {
     id: IdType;
-    userId: UserId;
+    userId: UserId | null;
+    emailOrPhone: string | null;
+    firstName: string | null;
+    lastName: string | null;
     notificationType: NotificationType;
     title: string | null;
     bodyTemplate: string;
@@ -38,10 +44,31 @@ export interface PrismaNotificationModel<IdType, UserId> {
     user?: {
         email: string;
     };
+    attachments?: PrismaNotificationAttachmentModel[];
+}
+export interface PrismaAttachmentFileModel {
+    id: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    checksum: string;
+    storageMetadata: JsonValue;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PrismaNotificationAttachmentModel {
+    id: string;
+    notificationId: number;
+    fileId: string;
+    description: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    attachmentFile?: PrismaAttachmentFileModel;
 }
 export interface NotificationPrismaClientInterface<NotificationIdType, UserIdType> {
+    $transaction<R>(fn: (prisma: NotificationPrismaClientInterface<NotificationIdType, UserIdType>) => Promise<R>): Promise<R>;
     notification: {
-        findMany(args: {
+        findMany(args?: {
             where?: {
                 status?: NotificationStatus | {
                     not: NotificationStatus;
@@ -49,31 +76,49 @@ export interface NotificationPrismaClientInterface<NotificationIdType, UserIdTyp
                 sendAfter?: {
                     lte: Date;
                 } | null;
-                userId?: UserIdType;
+                userId?: UserIdType | null;
                 readAt?: null;
+                emailOrPhone?: string | {
+                    not: null;
+                };
             };
             skip?: number;
             take?: number;
             include?: {
                 user?: boolean;
+                attachments?: boolean | {
+                    include: {
+                        attachmentFile: boolean;
+                    };
+                };
             };
         }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>[]>;
         create(args: {
-            data: BaseNotificationCreateInput<UserIdType>;
+            data: PrismaNotificationCreateData<UserIdType>;
             include?: {
                 user?: boolean;
+                attachments?: boolean | {
+                    include: {
+                        attachmentFile: boolean;
+                    };
+                };
             };
         }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
-        createMany(args: {
-            data: BaseNotificationCreateInput<UserIdType>[];
-        }): Promise<NotificationIdType[]>;
+        createManyAndReturn(args: {
+            data: PrismaNotificationCreateData<UserIdType>[];
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>[]>;
         update(args: {
             where: {
                 id: NotificationIdType;
             };
-            data: Partial<BaseNotificationUpdateInput<UserIdType>>;
+            data: BaseNotificationUpdateInput<UserIdType>;
             include?: {
                 user?: boolean;
+                attachments?: boolean | {
+                    include: {
+                        attachmentFile: boolean;
+                    };
+                };
             };
         }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
         findUnique(args: {
@@ -82,9 +127,79 @@ export interface NotificationPrismaClientInterface<NotificationIdType, UserIdTyp
             };
             include?: {
                 user?: boolean;
+                attachments?: boolean | {
+                    include: {
+                        attachmentFile: boolean;
+                    };
+                };
             };
         }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType> | null>;
     };
+    attachmentFile: {
+        findUnique(args: {
+            where: {
+                id: string;
+            } | {
+                checksum: string;
+            };
+        }): Promise<PrismaAttachmentFileModel | null>;
+        create(args: {
+            data: {
+                id?: string;
+                filename: string;
+                contentType: string;
+                size: number;
+                checksum: string;
+                storageMetadata: InputJsonValue;
+            };
+        }): Promise<PrismaAttachmentFileModel>;
+        delete(args: {
+            where: {
+                id: string;
+            };
+        }): Promise<PrismaAttachmentFileModel>;
+        findMany(args?: {
+            where?: {
+                notificationAttachments?: {
+                    none: object;
+                };
+                createdAt?: {
+                    lt: Date;
+                };
+            };
+        }): Promise<PrismaAttachmentFileModel[]>;
+    };
+    notificationAttachment: {
+        findMany(args: {
+            where: {
+                notificationId: NotificationIdType;
+            };
+            include?: {
+                attachmentFile: boolean;
+            };
+        }): Promise<PrismaNotificationAttachmentModel[]>;
+        delete(args: {
+            where: {
+                id: string;
+            };
+        }): Promise<PrismaNotificationAttachmentModel>;
+        deleteMany(args: {
+            where: {
+                id: string;
+                notificationId: NotificationIdType;
+            };
+        }): Promise<{
+            count: number;
+        }>;
+        create(args: {
+            data: {
+                id?: string;
+                notificationId: NotificationIdType;
+                fileId: string;
+                description?: string | null;
+            };
+        }): Promise<PrismaNotificationAttachmentModel>;
+    };
 }
 type NoExpand<T> = T extends unknown ? T : never;
 type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
@@ -93,12 +208,6 @@ type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ?
     [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;
@@ -112,14 +221,28 @@ export interface BaseNotificationCreateInput<UserIdType> {
     adapterUsed?: string | null;
     sentAt?: Date | null;
     readAt?: Date | null;
+    emailOrPhone?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
 }
+export type PrismaNotificationCreateData<UserIdType> = BaseNotificationCreateInput<UserIdType> & {
+    userId?: UserIdType | null;
+    user?: {
+        connect: {
+            id: UserIdType;
+        };
+    };
+};
 export interface BaseNotificationUpdateInput<UserIdType> {
-    user: {
+    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;
@@ -136,32 +259,155 @@ export interface BaseNotificationUpdateInput<UserIdType> {
 }
 export declare class PrismaNotificationBackend<Client extends NotificationPrismaClientInterface<Config['NotificationIdType'], Config['UserIdType']>, Config extends BaseNotificationTypeConfig> implements BaseNotificationBackend<Config> {
     private prismaClient;
-    constructor(prismaClient: Client);
-    serializeNotification(notification: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>): DatabaseNotification<Config>;
-    deserializeNotification(notification: NotificationInput<Config>): BaseNotificationCreateInput<Config['UserIdType']>;
+    private attachmentManager?;
+    constructor(prismaClient: Client, attachmentManager?: BaseAttachmentManager | undefined);
+    /**
+     * Inject attachment manager (called by VintaSend when both service and backend exist)
+     */
+    injectAttachmentManager(manager: BaseAttachmentManager): void;
+    /**
+     * Build a where clause for status-based updates
+     */
+    private buildStatusWhere;
+    /**
+     * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
+     * based on whether it has a userId or not (internal implementation)
+     */
+    private serializeAnyNotification;
+    /**
+     * Serialize a Prisma notification model to DatabaseNotification
+     */
+    private serializeRegularNotification;
+    /**
+     * Serialize a Prisma notification model to DatabaseOneOffNotification
+     */
+    private serializeOneOffNotification;
+    /**
+     * Public accessor for serialization - primarily for testing
+     * @internal
+     */
+    serializeNotification(notification: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>): AnyDatabaseNotification<Config>;
+    /**
+     * Core internal builder for creating notification data
+     * Validates that notification has either userId or emailOrPhone (but not neither)
+     */
+    private buildCreateData;
+    /**
+     * Deserialize a regular notification input for creation
+     */
+    private deserializeRegularNotification;
+    /**
+     * Build one-off notification data for creation
+     */
+    private buildOneOffNotificationData;
+    /**
+     * Core internal builder for update data (supports both regular and one-off)
+     */
+    private buildUpdateData;
+    /**
+     * Get or create file record for attachment upload with deduplication (transaction-aware)
+     * @private
+     */
+    private getOrCreateFileRecordForUploadInTransaction;
+    /**
+     * Get or create file record for attachment upload with deduplication (non-transactional)
+     * @private
+     */
+    private getOrCreateFileRecordForUpload;
+    /**
+     * Create notification attachment link (transaction-aware)
+     * @private
+     */
+    private createNotificationAttachmentLinkInTransaction;
+    /**
+     * Create notification attachment link (non-transactional)
+     * @private
+     */
+    private createNotificationAttachmentLink;
+    /**
+     * Get attachment file by ID (transaction-aware)
+     * @private
+     */
+    private getAttachmentFileInTransaction;
+    /**
+     * Find attachment file by checksum (transaction-aware)
+     * @private
+     */
+    private findAttachmentFileByChecksumInTransaction;
+    /**
+     * Core helper for creating notifications with attachments (both regular and one-off)
+     * Uses transactions to ensure atomicity - if attachment processing fails, the notification won't be created
+     * @private
+     */
+    private createNotificationWithAttachments;
+    /**
+     * Get attachment manager with null check
+     * @private
+     */
+    private getAttachmentManager;
+    deserializeNotification(notification: AnyNotificationInput<Config> | Omit<AnyNotificationInput<Config>, 'id'>): PrismaNotificationCreateData<Config['UserIdType']>;
     deserializeNotificationForUpdate(notification: Partial<Notification<Config>>): Partial<Parameters<typeof this.prismaClient.notification.update>[0]['data']>;
-    getAllPendingNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getPendingNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getAllFutureNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getFutureNotifications(): Promise<DatabaseNotification<Config>[]>;
+    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<DatabaseNotification<Config>[]>;
-    getNotifications(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>>;
-    markAsSent(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], checkIsPending?: boolean): Promise<DatabaseNotification<Config>>;
-    markAsFailed(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], checkIsPending?: boolean): 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<DatabaseNotification<Config> | null>;
+    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'][]>;
+    bulkPersistNotifications(notifications: Omit<AnyNotification<Config>, 'id'>[]): Promise<Config['NotificationIdType'][]>;
+    getAttachmentFile(fileId: string): Promise<AttachmentFileRecord | null>;
+    /**
+     * Find an attachment file by checksum for deduplication.
+     * This allows the backend to check if a file already exists before uploading.
+     */
+    findAttachmentFileByChecksum(checksum: string): Promise<AttachmentFileRecord | null>;
+    deleteAttachmentFile(fileId: string): Promise<void>;
+    getOrphanedAttachmentFiles(): Promise<AttachmentFileRecord[]>;
+    getAttachments(notificationId: Config['NotificationIdType']): Promise<StoredAttachment[]>;
+    deleteNotificationAttachment(notificationId: Config['NotificationIdType'], attachmentId: string): Promise<void>;
+    /**
+     * Process and store attachments for a notification within a transaction.
+     * Handles both new file uploads and references to existing files.
+     * Uses attachmentManager for checksum calculation and storage operations.
+     * @private
+     */
+    private processAndStoreAttachmentsInTransaction;
+    /**
+     * Process and store attachments for a notification (non-transactional version).
+     * Handles both new file uploads and references to existing files.
+     * Uses attachmentManager for checksum calculation and storage operations.
+     * @private
+     */
+    private processAndStoreAttachments;
+    /**
+     * Serialize a Prisma attachment file model to AttachmentFileRecord
+     * @private
+     */
+    private serializeAttachmentFileRecord;
+    /**
+     * Serialize a Prisma notification attachment model to StoredAttachment
+     * @private
+     */
+    private serializeStoredAttachment;
 }
 export declare class PrismaNotificationBackendFactory<Config extends BaseNotificationTypeConfig> {
-    create<Client extends NotificationPrismaClientInterface<Config['NotificationIdType'], Config['UserIdType']>>(prismaClient: Client): PrismaNotificationBackend<Client, Config>;
+    create<Client extends NotificationPrismaClientInterface<Config['NotificationIdType'], Config['UserIdType']>>(prismaClient: Client, attachmentManager?: BaseAttachmentManager): PrismaNotificationBackend<Client, Config>;
 }
 export {};