feat: migrate templates and documents to envelope model

packages/lib/server-only/admin/admin-find-documents.ts

@@ -1,17 +1,21 @@
-import type { Prisma } from '@prisma/client';
+import { EnvelopeType, type Prisma } from '@prisma/client';
 
 import { prisma } from '@documenso/prisma';
 
 import type { FindResultResponse } from '../../types/search-params';
 
-export interface FindDocumentsOptions {
+export interface AdminFindDocumentsOptions {
   query?: string;
   page?: number;
   perPage?: number;
 }
 
-export const findDocuments = async ({ query, page = 1, perPage = 10 }: FindDocumentsOptions) => {
-  const termFilters: Prisma.DocumentWhereInput | undefined = !query
+export const adminFindDocuments = async ({
+  query,
+  page = 1,
+  perPage = 10,
+}: AdminFindDocumentsOptions) => {
+  const termFilters: Prisma.EnvelopeWhereInput | undefined = !query
     ? undefined
     : {
         title: {
@@ -21,8 +25,9 @@ export const findDocuments = async ({ query, page = 1, perPage = 10 }: FindDocum
       };
 
   const [data, count] = await Promise.all([
-    prisma.document.findMany({
+    prisma.envelope.findMany({
       where: {
+        type: EnvelopeType.DOCUMENT,
         ...termFilters,
       },
       skip: Math.max(page - 1, 0) * perPage,
@@ -39,10 +44,17 @@ export const findDocuments = async ({ query, page = 1, perPage = 10 }: FindDocum
           },
         },
         recipients: true,
+        team: {
+          select: {
+            id: true,
+            url: true,
+          },
+        },
       },
     }),
-    prisma.document.count({
+    prisma.envelope.count({
       where: {
+        type: EnvelopeType.DOCUMENT,
         ...termFilters,
       },
     }),

packages/lib/server-only/admin/admin-super-delete-document.ts

@@ -0,0 +1,131 @@
+import { createElement } from 'react';
+
+import { msg } from '@lingui/core/macro';
+import { DocumentStatus, SendStatus } from '@prisma/client';
+
+import { mailer } from '@documenso/email/mailer';
+import DocumentCancelTemplate from '@documenso/email/templates/document-cancel';
+import { prisma } from '@documenso/prisma';
+
+import { getI18nInstance } from '../../client-only/providers/i18n-server';
+import { NEXT_PUBLIC_WEBAPP_URL } from '../../constants/app';
+import { AppError, AppErrorCode } from '../../errors/app-error';
+import { DOCUMENT_AUDIT_LOG_TYPE } from '../../types/document-audit-logs';
+import { extractDerivedDocumentEmailSettings } from '../../types/document-email';
+import type { RequestMetadata } from '../../universal/extract-request-metadata';
+import { createDocumentAuditLogData } from '../../utils/document-audit-logs';
+import { renderEmailWithI18N } from '../../utils/render-email-with-i18n';
+import { getEmailContext } from '../email/get-email-context';
+
+export type AdminSuperDeleteDocumentOptions = {
+  envelopeId: string;
+  requestMetadata?: RequestMetadata;
+};
+
+export const adminSuperDeleteDocument = async ({
+  envelopeId,
+  requestMetadata,
+}: AdminSuperDeleteDocumentOptions) => {
+  const envelope = await prisma.envelope.findUnique({
+    where: {
+      id: envelopeId,
+    },
+    include: {
+      recipients: true,
+      documentMeta: true,
+      user: {
+        select: {
+          id: true,
+          email: true,
+          name: true,
+        },
+      },
+    },
+  });
+
+  if (!envelope) {
+    throw new AppError(AppErrorCode.NOT_FOUND, {
+      message: 'Document not found',
+    });
+  }
+
+  const { branding, settings, senderEmail, replyToEmail } = await getEmailContext({
+    emailType: 'RECIPIENT',
+    source: {
+      type: 'team',
+      teamId: envelope.teamId,
+    },
+    meta: envelope.documentMeta,
+  });
+
+  const { status, user } = envelope;
+
+  const isDocumentDeletedEmailEnabled = extractDerivedDocumentEmailSettings(
+    envelope.documentMeta,
+  ).documentDeleted;
+
+  // if the document is pending, send cancellation emails to all recipients
+  if (
+    status === DocumentStatus.PENDING &&
+    envelope.recipients.length > 0 &&
+    isDocumentDeletedEmailEnabled
+  ) {
+    await Promise.all(
+      envelope.recipients.map(async (recipient) => {
+        if (recipient.sendStatus !== SendStatus.SENT) {
+          return;
+        }
+
+        const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
+        const template = createElement(DocumentCancelTemplate, {
+          documentName: envelope.title,
+          inviterName: user.name || undefined,
+          inviterEmail: user.email,
+          assetBaseUrl,
+        });
+
+        const lang = envelope.documentMeta?.language ?? settings.documentLanguage;
+
+        const [html, text] = await Promise.all([
+          renderEmailWithI18N(template, { lang, branding }),
+          renderEmailWithI18N(template, {
+            lang,
+            branding,
+            plainText: true,
+          }),
+        ]);
+
+        const i18n = await getI18nInstance(lang);
+
+        await mailer.sendMail({
+          to: {
+            address: recipient.email,
+            name: recipient.name,
+          },
+          from: senderEmail,
+          replyTo: replyToEmail,
+          subject: i18n._(msg`Document Cancelled`),
+          html,
+          text,
+        });
+      }),
+    );
+  }
+
+  // always hard delete if deleted from admin
+  return await prisma.$transaction(async (tx) => {
+    await tx.documentAuditLog.create({
+      data: createDocumentAuditLogData({
+        envelopeId,
+        type: DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_DELETED,
+        user,
+        requestMetadata,
+        data: {
+          type: 'HARD',
+        },
+      }),
+    });
+
+    return await tx.envelope.delete({ where: { id: envelopeId } });
+  });
+};

packages/lib/server-only/admin/get-documents-stats.ts

@@ -1,8 +1,13 @@
+import { EnvelopeType } from '@prisma/client';
+
 import { prisma } from '@documenso/prisma';
 import { ExtendedDocumentStatus } from '@documenso/prisma/types/extended-document-status';
 
 export const getDocumentStats = async () => {
-  const counts = await prisma.document.groupBy({
+  const counts = await prisma.envelope.groupBy({
+    where: {
+      type: EnvelopeType.DOCUMENT,
+    },
     by: ['status'],
     _count: {
       _all: true,

packages/lib/server-only/admin/get-entire-document.ts

@@ -1,14 +1,22 @@
+import type { EnvelopeType } from '@prisma/client';
+
 import { prisma } from '@documenso/prisma';
 
-export type GetEntireDocumentOptions = {
-  id: number;
+import { AppError, AppErrorCode } from '../../errors/app-error';
+import type { EnvelopeIdOptions } from '../../utils/envelope';
+import { unsafeBuildEnvelopeIdQuery } from '../../utils/envelope';
+
+export type unsafeGetEntireEnvelopeOptions = {
+  id: EnvelopeIdOptions;
+  type: EnvelopeType;
 };
 
-export const getEntireDocument = async ({ id }: GetEntireDocumentOptions) => {
-  const document = await prisma.document.findFirstOrThrow({
-    where: {
-      id,
-    },
+/**
+ * An unauthenticated function that returns the whole envelope
+ */
+export const unsafeGetEntireEnvelope = async ({ id, type }: unsafeGetEntireEnvelopeOptions) => {
+  const envelope = await prisma.envelope.findFirst({
+    where: unsafeBuildEnvelopeIdQuery(id, type),
     include: {
       documentMeta: true,
       user: {
@@ -30,5 +38,11 @@ export const getEntireDocument = async ({ id }: GetEntireDocumentOptions) => {
     },
   });
 
-  return document;
+  if (!envelope) {
+    throw new AppError(AppErrorCode.NOT_FOUND, {
+      message: 'Envelope not found',
+    });
+  }
+
+  return envelope;
 };

packages/lib/server-only/admin/get-signing-volume.ts

@@ -1,4 +1,4 @@
-import { DocumentStatus, SubscriptionStatus } from '@prisma/client';
+import { DocumentStatus, EnvelopeType, SubscriptionStatus } from '@prisma/client';
 
 import { kyselyPrisma, sql } from '@documenso/prisma';
 
@@ -31,22 +31,23 @@ export async function getSigningVolume({
     .selectFrom('Subscription as s')
     .innerJoin('Organisation as o', 's.organisationId', 'o.id')
     .leftJoin('Team as t', 'o.id', 't.organisationId')
-    .leftJoin('Document as d', (join) =>
+    .leftJoin('Envelope as e', (join) =>
       join
-        .onRef('t.id', '=', 'd.teamId')
-        .on('d.status', '=', sql.lit(DocumentStatus.COMPLETED))
-        .on('d.deletedAt', 'is', null),
+        .onRef('t.id', '=', 'e.teamId')
+        .on('e.status', '=', sql.lit(DocumentStatus.COMPLETED))
+        .on('e.deletedAt', 'is', null),
     )
     .where(sql`s.status = ${SubscriptionStatus.ACTIVE}::"SubscriptionStatus"`)
     .where((eb) =>
       eb.or([eb('o.name', 'ilike', `%${search}%`), eb('t.name', 'ilike', `%${search}%`)]),
     )
+    .where('e.type', '=', EnvelopeType.DOCUMENT)
     .select([
       's.id as id',
       's.createdAt as createdAt',
       's.planId as planId',
       sql<string>`COALESCE(o.name, 'Unknown')`.as('name'),
-      sql<number>`COUNT(DISTINCT d.id)`.as('signingVolume'),
+      sql<number>`COUNT(DISTINCT e.id)`.as('signingVolume'),
     ])
     .groupBy(['s.id', 'o.name']);