Merge branch 'main' into feat/add-envelopes-api

Co-authored-by: Ephraim Atta-Duncan <ephraimduncan68@gmail.com>

CODE_STYLE.md

@@ -0,0 +1,692 @@
+# Documenso Code Style Guide
+
+This document captures the code style, patterns, and conventions used in the Documenso codebase. It covers both enforceable rules and subjective "taste" elements that make our code consistent and maintainable.
+
+## Table of Contents
+
+1. [General Principles](#general-principles)
+2. [TypeScript Conventions](#typescript-conventions)
+3. [Imports & Dependencies](#imports--dependencies)
+4. [Functions & Methods](#functions--methods)
+5. [React & Components](#react--components)
+6. [Error Handling](#error-handling)
+7. [Async/Await Patterns](#asyncawait-patterns)
+8. [Whitespace & Formatting](#whitespace--formatting)
+9. [Naming Conventions](#naming-conventions)
+10. [Pattern Matching](#pattern-matching)
+11. [Database & Prisma](#database--prisma)
+12. [TRPC Patterns](#trpc-patterns)
+
+---
+
+## General Principles
+
+- **Functional over Object-Oriented**: Prefer functional programming patterns over classes
+- **Explicit over Implicit**: Be explicit about types, return values, and error cases
+- **Early Returns**: Use guard clauses and early returns to reduce nesting
+- **Immutability**: Favor `const` over `let`; avoid mutation where possible
+
+---
+
+## TypeScript Conventions
+
+### Type Definitions
+
+```typescript
+// ✅ Prefer `type` over `interface`
+type CreateDocumentOptions = {
+  templateId: number;
+  userId: number;
+  recipients: Recipient[];
+};
+
+// ❌ Avoid interfaces unless absolutely necessary
+interface CreateDocumentOptions {
+  templateId: number;
+}
+```
+
+### Type Imports
+
+```typescript
+// ✅ Use `type` keyword for type-only imports
+import type { Document, Recipient } from '@prisma/client';
+import { DocumentStatus } from '@prisma/client';
+
+// Types in function signatures
+export const findDocuments = async ({ userId, teamId }: FindDocumentsOptions) => {
+  // ...
+};
+```
+
+### Inline Types for Function Parameters
+
+```typescript
+// ✅ Extract inline types to named types
+type FinalRecipient = Pick<Recipient, 'name' | 'email' | 'role' | 'authOptions'> & {
+  templateRecipientId: number;
+  fields: Field[];
+};
+
+const finalRecipients: FinalRecipient[] = [];
+```
+
+---
+
+## Imports & Dependencies
+
+### Import Organization
+
+Imports should be organized in the following order with blank lines between groups:
+
+```typescript
+// 1. React imports
+import { useCallback, useEffect, useMemo } from 'react';
+
+// 2. Third-party library imports (alphabetically)
+import { zodResolver } from '@hookform/resolvers/zod';
+import { Trans } from '@lingui/react/macro';
+import type { Document, Recipient } from '@prisma/client';
+import { DocumentStatus, RecipientRole } from '@prisma/client';
+import { match } from 'ts-pattern';
+
+// 3. Internal package imports (from @documenso/*)
+import { AppError } from '@documenso/lib/errors/app-error';
+import { prisma } from '@documenso/prisma';
+import { Button } from '@documenso/ui/primitives/button';
+
+// 4. Relative imports
+import { getTeamById } from '../team/get-team';
+import type { FindResultResponse } from './types';
+```
+
+### Destructuring Imports
+
+```typescript
+// ✅ Destructure specific exports
+// ✅ Use type imports for types
+import type { Document } from '@prisma/client';
+
+import { Button } from '@documenso/ui/primitives/button';
+import { Input } from '@documenso/ui/primitives/input';
+```
+
+---
+
+## Functions & Methods
+
+### Arrow Functions
+
+```typescript
+// ✅ Always use arrow functions for functions
+export const createDocument = async ({
+  userId,
+  title,
+}: CreateDocumentOptions) => {
+  // ...
+};
+
+// ✅ Callbacks and handlers
+const onSubmit = useCallback(async () => {
+  // ...
+}, [dependencies]);
+
+// ❌ Avoid regular function declarations
+function createDocument() {
+  // ...
+}
+```
+
+### Function Parameters
+
+```typescript
+// ✅ Use destructured object parameters for multiple params
+export const findDocuments = async ({
+  userId,
+  teamId,
+  status = ExtendedDocumentStatus.ALL,
+  page = 1,
+  perPage = 10,
+}: FindDocumentsOptions) => {
+  // ...
+};
+
+// ✅ Destructure on separate line when needed
+const onFormSubmit = form.handleSubmit(onSubmit);
+
+// ✅ Deconstruct nested properties explicitly
+const { user } = ctx;
+const { templateId } = input;
+```
+
+---
+
+## React & Components
+
+### Component Definition
+
+```typescript
+// ✅ Use const with arrow function
+export const AddSignersFormPartial = ({
+  documentFlow,
+  recipients,
+  fields,
+  onSubmit,
+}: AddSignersFormProps) => {
+  // ...
+};
+
+// ❌ Never use classes
+class MyComponent extends React.Component {
+  // ...
+}
+```
+
+### Hooks
+
+```typescript
+// ✅ Group related hooks together with blank line separation
+const { _ } = useLingui();
+const { toast } = useToast();
+
+const { currentStep, totalSteps, previousStep } = useStep();
+
+const form = useForm<TFormSchema>({
+  resolver: zodResolver(ZFormSchema),
+  defaultValues: {
+    // ...
+  },
+});
+```
+
+### Event Handlers
+
+```typescript
+// ✅ Use arrow functions with descriptive names
+const onFormSubmit = async () => {
+  await form.trigger();
+  // ...
+};
+
+const onFieldCopy = useCallback(
+  (event?: KeyboardEvent | null) => {
+    event?.preventDefault();
+    // ...
+  },
+  [dependencies],
+);
+
+// ✅ Inline handlers for simple operations
+<Button onClick={() => setOpen(false)}>Close</Button>
+```
+
+### State Management
+
+```typescript
+// ✅ Descriptive state names with auxiliary verbs
+const [isLoading, setIsLoading] = useState(false);
+const [hasError, setHasError] = useState(false);
+const [showAdvancedSettings, setShowAdvancedSettings] = useState(false);
+
+// ✅ Complex state in single useState when related
+const [coords, setCoords] = useState({
+  x: 0,
+  y: 0,
+});
+```
+
+---
+
+## Error Handling
+
+### Try-Catch Blocks
+
+```typescript
+// ✅ Use try-catch for operations that might fail
+try {
+  const document = await getDocumentById({
+    documentId: Number(documentId),
+    userId: user.id,
+  });
+
+  return {
+    status: 200,
+    body: document,
+  };
+} catch (err) {
+  return {
+    status: 404,
+    body: {
+      message: 'Document not found',
+    },
+  };
+}
+```
+
+### Throwing Errors
+
+```typescript
+// ✅ Use AppError for application errors
+throw new AppError(AppErrorCode.NOT_FOUND, {
+  message: 'Template not found',
+});
+
+// ✅ Use descriptive error messages
+if (!template) {
+  throw new AppError(AppErrorCode.NOT_FOUND, {
+    message: `Template with ID ${templateId} not found`,
+  });
+}
+```
+
+### Error Parsing on Frontend
+
+```typescript
+// ✅ Parse errors on the frontend
+try {
+  await updateOrganisation({ organisationId, data });
+} catch (err) {
+  const error = AppError.parseError(err);
+  console.error(error);
+
+  toast({
+    title: t`An error occurred`,
+    description: error.message,
+    variant: 'destructive',
+  });
+}
+```
+
+---
+
+## Async/Await Patterns
+
+### Async Function Definitions
+
+```typescript
+// ✅ Mark async functions clearly
+export const createDocument = async ({
+  userId,
+  title,
+}: Options): Promise<Document> => {
+  // ...
+};
+
+// ✅ Use await for promises
+const document = await prisma.document.create({ data });
+
+// ✅ Use Promise.all for parallel operations
+const [document, recipients] = await Promise.all([
+  getDocumentById({ documentId }),
+  getRecipientsForDocument({ documentId }),
+]);
+```
+
+### Void for Fire-and-Forget
+
+```typescript
+// ✅ Use void for intentionally unwaited promises
+void handleAutoSave();
+
+// ✅ Or in event handlers
+onClick={() => void onFormSubmit()}
+```
+
+---
+
+## Whitespace & Formatting
+
+### Blank Lines Between Concepts
+
+```typescript
+// ✅ Blank line after imports
+import { prisma } from '@documenso/prisma';
+
+export const findDocuments = async () => {
+  // ...
+};
+
+// ✅ Blank line between logical sections
+const user = await prisma.user.findFirst({ where: { id: userId } });
+
+let team = null;
+
+if (teamId !== undefined) {
+  team = await getTeamById({ userId, teamId });
+}
+
+// ✅ Blank line before return statements
+const result = await someOperation();
+
+return result;
+```
+
+### Function/Method Spacing
+
+```typescript
+// ✅ No blank lines between chained methods in same operation
+const documents = await prisma.document
+  .findMany({ where: { userId } })
+  .then((docs) => docs.map(maskTokens));
+
+// ✅ Blank line between different operations
+const document = await createDocument({ userId });
+
+await sendDocument({ documentId: document.id });
+
+return document;
+```
+
+### Object and Array Formatting
+
+```typescript
+// ✅ Multi-line when complex
+const options = {
+  userId,
+  teamId,
+  status: ExtendedDocumentStatus.ALL,
+  page: 1,
+};
+
+// ✅ Single line when simple
+const coords = { x: 0, y: 0 };
+
+// ✅ Array items on separate lines when objects
+const recipients = [
+  {
+    name: 'John',
+    email: 'john@example.com',
+  },
+  {
+    name: 'Jane',
+    email: 'jane@example.com',
+  },
+];
+```
+
+---
+
+## Naming Conventions
+
+### Variables
+
+```typescript
+// ✅ camelCase for variables and functions
+const documentId = 123;
+const onSubmit = () => {};
+
+// ✅ Descriptive names with auxiliary verbs for booleans
+const isLoading = false;
+const hasError = false;
+const canEdit = true;
+const shouldRender = true;
+
+// ✅ Prefix with $ for DOM elements
+const $page = document.querySelector('.page');
+const $inputRef = useRef<HTMLInputElement>(null);
+```
+
+### Types and Schemas
+
+```typescript
+// ✅ PascalCase for types
+type CreateDocumentOptions = {
+  userId: number;
+};
+
+// ✅ Prefix Zod schemas with Z
+const ZCreateDocumentSchema = z.object({
+  title: z.string(),
+});
+
+// ✅ Prefix type from Zod schema with T
+type TCreateDocumentSchema = z.infer<typeof ZCreateDocumentSchema>;
+```
+
+### Constants
+
+```typescript
+// ✅ UPPER_SNAKE_CASE for true constants
+const DEFAULT_DOCUMENT_DATE_FORMAT = 'dd/MM/yyyy';
+const MAX_FILE_SIZE = 1024 * 1024 * 5;
+
+// ✅ camelCase for const variables that aren't "constants"
+const userId = await getUserId();
+```
+
+### Functions
+
+```typescript
+// ✅ Verb-based names for functions
+const createDocument = async () => {};
+const findDocuments = async () => {};
+const updateDocument = async () => {};
+const deleteDocument = async () => {};
+
+// ✅ On prefix for event handlers
+const onSubmit = () => {};
+const onClick = () => {};
+const onFieldCopy = () => {}; // 'on' is also acceptable
+```
+
+### Clarity Over Brevity
+
+```typescript
+// ✅ Prefer descriptive names over abbreviations
+const superLongMethodThatIsCorrect = () => {};
+const recipientAuthenticationOptions = {};
+const documentMetadata = {};
+
+// ❌ Avoid abbreviations that sacrifice clarity
+const supLongMethThatIsCorrect = () => {};
+const recipAuthOpts = {};
+const docMeta = {};
+
+// ✅ Common abbreviations that are widely understood are acceptable
+const userId = 123;
+const htmlElement = document.querySelector('div');
+const apiResponse = await fetch('/api');
+```
+
+---
+
+## Pattern Matching
+
+### Using ts-pattern
+
+```typescript
+import { match } from 'ts-pattern';
+
+// ✅ Use match for complex conditionals
+const result = match(status)
+  .with(ExtendedDocumentStatus.DRAFT, () => ({
+    status: 'draft',
+  }))
+  .with(ExtendedDocumentStatus.PENDING, () => ({
+    status: 'pending',
+  }))
+  .with(ExtendedDocumentStatus.COMPLETED, () => ({
+    status: 'completed',
+  }))
+  .exhaustive();
+
+// ✅ Use .otherwise() for default case when not exhaustive
+const value = match(type)
+  .with('text', () => 'Text field')
+  .with('number', () => 'Number field')
+  .otherwise(() => 'Unknown field');
+```
+
+---
+
+## Database & Prisma
+
+### Query Structure
+
+```typescript
+// ✅ Destructure commonly used fields
+const { id, email, name } = user;
+
+// ✅ Use select to limit returned fields
+const user = await prisma.user.findFirst({
+  where: { id: userId },
+  select: {
+    id: true,
+    email: true,
+    name: true,
+  },
+});
+
+// ✅ Use include for relations
+const document = await prisma.document.findFirst({
+  where: { id: documentId },
+  include: {
+    recipients: true,
+    fields: true,
+  },
+});
+```
+
+### Transactions
+
+```typescript
+// ✅ Use transactions for related operations
+return await prisma.$transaction(async (tx) => {
+  const document = await tx.document.create({ data });
+
+  await tx.field.createMany({ data: fieldsData });
+
+  await tx.documentAuditLog.create({ data: auditData });
+
+  return document;
+});
+```
+
+### Where Clauses
+
+```typescript
+// ✅ Build complex where clauses separately
+const whereClause: Prisma.DocumentWhereInput = {
+  AND: [
+    { userId: user.id },
+    { deletedAt: null },
+    { status: { in: [DocumentStatus.DRAFT, DocumentStatus.PENDING] } },
+  ],
+};
+
+const documents = await prisma.document.findMany({
+  where: whereClause,
+});
+```
+
+---
+
+## TRPC Patterns
+
+### Router Structure
+
+```typescript
+// ✅ Destructure context and input at start
+.query(async ({ input, ctx }) => {
+  const { teamId } = ctx;
+  const { templateId } = input;
+
+  ctx.logger.info({
+    input: { templateId },
+  });
+
+  return await getTemplateById({
+    id: templateId,
+    userId: ctx.user.id,
+    teamId,
+  });
+});
+```
+
+### Request/Response Schemas
+
+```typescript
+// ✅ Name schemas clearly
+const ZCreateDocumentRequestSchema = z.object({
+  title: z.string(),
+  recipients: z.array(ZRecipientSchema),
+});
+
+const ZCreateDocumentResponseSchema = z.object({
+  documentId: z.number(),
+  status: z.string(),
+});
+```
+
+### Error Handling in TRPC
+
+```typescript
+// ✅ Catch and transform errors appropriately
+try {
+  const result = await createDocument({ userId, data });
+
+  return result;
+} catch (err) {
+  return AppError.toRestAPIError(err);
+}
+
+// ✅ Or throw AppError directly
+if (!template) {
+  throw new AppError(AppErrorCode.NOT_FOUND, {
+    message: 'Template not found',
+  });
+}
+```
+
+---
+
+## Additional Patterns
+
+### Optional Chaining
+
+```typescript
+// ✅ Use optional chaining for potentially undefined values
+const email = user?.email;
+const recipientToken = recipient?.token ?? '';
+
+// ✅ Use nullish coalescing for defaults
+const pageSize = perPage ?? 10;
+const status = documentStatus ?? DocumentStatus.DRAFT;
+```
+
+### Array Operations
+
+```typescript
+// ✅ Use functional array methods
+const activeRecipients = recipients.filter((r) => r.signingStatus === 'SIGNED');
+const recipientEmails = recipients.map((r) => r.email);
+const hasSignedRecipients = recipients.some((r) => r.signingStatus === 'SIGNED');
+
+// ✅ Use find instead of filter + [0]
+const recipient = recipients.find((r) => r.id === recipientId);
+```
+
+### Conditional Rendering
+
+```typescript
+// ✅ Use && for conditional rendering
+{isLoading && <Loader />}
+
+// ✅ Use ternary for either/or
+{isLoading ? <Loader /> : <Content />}
+
+// ✅ Extract complex conditions to variables
+const shouldShowAdvanced = isAdmin && hasPermission && !isDisabled;
+{shouldShowAdvanced && <AdvancedSettings />}
+```
+
+---
+
+## When in Doubt
+
+- **Consistency**: Follow the patterns you see in similar files
+- **Readability**: Favor code that's easy to read over clever one-liners
+- **Explicitness**: Be explicit rather than implicit
+- **Whitespace**: Use blank lines to separate logical sections
+- **Early Returns**: Use guard clauses to reduce nesting
+- **Functional**: Prefer functional patterns over imperative ones

apps/remix/app/components/dialogs/admin-organisation-member-update-dialog.tsx

@@ -0,0 +1,218 @@
+import { useEffect, useState } from 'react';
+
+import { zodResolver } from '@hookform/resolvers/zod';
+import { useLingui } from '@lingui/react/macro';
+import { Trans } from '@lingui/react/macro';
+import { OrganisationMemberRole } from '@prisma/client';
+import type * as DialogPrimitive from '@radix-ui/react-dialog';
+import { useForm } from 'react-hook-form';
+import { useNavigate } from 'react-router';
+import { match } from 'ts-pattern';
+import { z } from 'zod';
+
+import { getHighestOrganisationRoleInGroup } from '@documenso/lib/utils/organisations';
+import { trpc } from '@documenso/trpc/react';
+import type { TGetAdminOrganisationResponse } from '@documenso/trpc/server/admin-router/get-admin-organisation.types';
+import { Button } from '@documenso/ui/primitives/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from '@documenso/ui/primitives/dialog';
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '@documenso/ui/primitives/form/form';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@documenso/ui/primitives/select';
+import { useToast } from '@documenso/ui/primitives/use-toast';
+
+export type AdminOrganisationMemberUpdateDialogProps = {
+  trigger?: React.ReactNode;
+  organisationId: string;
+  organisationMember: TGetAdminOrganisationResponse['members'][number];
+  isOwner: boolean;
+} & Omit<DialogPrimitive.DialogProps, 'children'>;
+
+const ZUpdateOrganisationMemberFormSchema = z.object({
+  role: z.enum(['OWNER', 'ADMIN', 'MANAGER', 'MEMBER']),
+});
+
+type ZUpdateOrganisationMemberSchema = z.infer<typeof ZUpdateOrganisationMemberFormSchema>;
+
+export const AdminOrganisationMemberUpdateDialog = ({
+  trigger,
+  organisationId,
+  organisationMember,
+  isOwner,
+  ...props
+}: AdminOrganisationMemberUpdateDialogProps) => {
+  const [open, setOpen] = useState(false);
+
+  const { t } = useLingui();
+  const { toast } = useToast();
+  const navigate = useNavigate();
+
+  // Determine the current role value for the form
+  const currentRoleValue = isOwner
+    ? 'OWNER'
+    : getHighestOrganisationRoleInGroup(
+        organisationMember.organisationGroupMembers.map((ogm) => ogm.group),
+      );
+  const organisationMemberName = organisationMember.user.name ?? organisationMember.user.email;
+
+  const form = useForm<ZUpdateOrganisationMemberSchema>({
+    resolver: zodResolver(ZUpdateOrganisationMemberFormSchema),
+    defaultValues: {
+      role: currentRoleValue,
+    },
+  });
+
+  const { mutateAsync: updateOrganisationMemberRole } =
+    trpc.admin.organisationMember.updateRole.useMutation();
+
+  const onFormSubmit = async ({ role }: ZUpdateOrganisationMemberSchema) => {
+    try {
+      await updateOrganisationMemberRole({
+        organisationId,
+        userId: organisationMember.userId,
+        role,
+      });
+
+      const roleLabel = match(role)
+        .with('OWNER', () => t`Owner`)
+        .with(OrganisationMemberRole.ADMIN, () => t`Admin`)
+        .with(OrganisationMemberRole.MANAGER, () => t`Manager`)
+        .with(OrganisationMemberRole.MEMBER, () => t`Member`)
+        .exhaustive();
+
+      toast({
+        title: t`Success`,
+        description:
+          role === 'OWNER'
+            ? t`Ownership transferred to ${organisationMemberName}.`
+            : t`Updated ${organisationMemberName} to ${roleLabel}.`,
+        duration: 5000,
+      });
+
+      setOpen(false);
+
+      // Refresh the page to show updated data
+      await navigate(0);
+    } catch (err) {
+      console.error(err);
+
+      toast({
+        title: t`An unknown error occurred`,
+        description: t`We encountered an unknown error while attempting to update this organisation member. Please try again later.`,
+        variant: 'destructive',
+      });
+    }
+  };
+
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+
+    form.reset({
+      role: currentRoleValue,
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open, currentRoleValue, form]);
+
+  return (
+    <Dialog
+      {...props}
+      open={open}
+      onOpenChange={(value) => !form.formState.isSubmitting && setOpen(value)}
+    >
+      <DialogTrigger onClick={(e) => e.stopPropagation()} asChild>
+        {trigger ?? (
+          <Button variant="secondary">
+            <Trans>Update role</Trans>
+          </Button>
+        )}
+      </DialogTrigger>
+
+      <DialogContent position="center">
+        <DialogHeader>
+          <DialogTitle>
+            <Trans>Update organisation member</Trans>
+          </DialogTitle>
+
+          <DialogDescription className="mt-4">
+            <Trans>
+              You are currently updating{' '}
+              <span className="font-bold">{organisationMemberName}.</span>
+            </Trans>
+          </DialogDescription>
+        </DialogHeader>
+
+        <Form {...form}>
+          <form onSubmit={form.handleSubmit(onFormSubmit)}>
+            <fieldset className="flex h-full flex-col" disabled={form.formState.isSubmitting}>
+              <FormField
+                control={form.control}
+                name="role"
+                render={({ field }) => (
+                  <FormItem className="w-full">
+                    <FormLabel required>
+                      <Trans>Role</Trans>
+                    </FormLabel>
+                    <FormControl>
+                      <Select {...field} onValueChange={field.onChange}>
+                        <SelectTrigger className="text-muted-foreground">
+                          <SelectValue />
+                        </SelectTrigger>
+
+                        <SelectContent className="w-full" position="popper">
+                          <SelectItem value="OWNER">
+                            <Trans>Owner</Trans>
+                          </SelectItem>
+                          <SelectItem value={OrganisationMemberRole.ADMIN}>
+                            <Trans>Admin</Trans>
+                          </SelectItem>
+                          <SelectItem value={OrganisationMemberRole.MANAGER}>
+                            <Trans>Manager</Trans>
+                          </SelectItem>
+                          <SelectItem value={OrganisationMemberRole.MEMBER}>
+                            <Trans>Member</Trans>
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <DialogFooter className="mt-4">
+                <Button type="button" variant="secondary" onClick={() => setOpen(false)}>
+                  <Trans>Cancel</Trans>
+                </Button>
+
+                <Button type="submit" loading={form.formState.isSubmitting}>
+                  <Trans>Update</Trans>
+                </Button>
+              </DialogFooter>
+            </fieldset>
+          </form>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  );
+};

apps/remix/app/components/general/direct-template/direct-template-page.tsx

@@ -89,7 +89,10 @@ export const DirectTemplatePageView = ({
     setStep('sign');
   };
 
-  const onSignDirectTemplateSubmit = async (fields: DirectTemplateLocalField[]) => {
+  const onSignDirectTemplateSubmit = async (
+    fields: DirectTemplateLocalField[],
+    nextSigner?: { name: string; email: string },
+  ) => {
     try {
       let directTemplateExternalId = searchParams?.get('externalId') || undefined;
 
@@ -98,6 +101,7 @@ export const DirectTemplatePageView = ({
       }
 
       const { token } = await createDocumentFromDirectTemplate({
+        nextSigner,
         directTemplateToken,
         directTemplateExternalId,
         directRecipientName: fullName,

apps/remix/app/components/general/direct-template/direct-template-signing-form.tsx

@@ -55,10 +55,13 @@ import { DocumentSigningRecipientProvider } from '../document-signing/document-s
 
 export type DirectTemplateSigningFormProps = {
   flowStep: DocumentFlowStep;
-  directRecipient: Pick<Recipient, 'authOptions' | 'email' | 'role' | 'name' | 'token'>;
+  directRecipient: Pick<Recipient, 'authOptions' | 'email' | 'role' | 'name' | 'token' | 'id'>;
   directRecipientFields: Field[];
   template: Omit<TTemplate, 'user'>;
-  onSubmit: (_data: DirectTemplateLocalField[]) => Promise<void>;
+  onSubmit: (
+    _data: DirectTemplateLocalField[],
+    _nextSigner?: { name: string; email: string },
+  ) => Promise<void>;
 };
 
 export type DirectTemplateLocalField = Field & {
@@ -149,7 +152,7 @@ export const DirectTemplateSigningForm = ({
     validateFieldsInserted(fieldsRequiringValidation);
   };
 
-  const handleSubmit = async () => {
+  const handleSubmit = async (nextSigner?: { name: string; email: string }) => {
     setValidateUninsertedFields(true);
 
     const isFieldsValid = validateFieldsInserted(fieldsRequiringValidation);
@@ -161,7 +164,7 @@ export const DirectTemplateSigningForm = ({
     setIsSubmitting(true);
 
     try {
-      await onSubmit(localFields);
+      await onSubmit(localFields, nextSigner);
     } catch {
       setIsSubmitting(false);
     }
@@ -218,6 +221,30 @@ export const DirectTemplateSigningForm = ({
     setLocalFields(updatedFields);
   }, []);
 
+  const nextRecipient = useMemo(() => {
+    if (
+      !template.templateMeta?.signingOrder ||
+      template.templateMeta.signingOrder !== 'SEQUENTIAL' ||
+      !template.templateMeta.allowDictateNextSigner
+    ) {
+      return undefined;
+    }
+
+    const sortedRecipients = template.recipients.sort((a, b) => {
+      // Sort by signingOrder first (nulls last), then by id
+      if (a.signingOrder === null && b.signingOrder === null) return a.id - b.id;
+      if (a.signingOrder === null) return 1;
+      if (b.signingOrder === null) return -1;
+      if (a.signingOrder === b.signingOrder) return a.id - b.id;
+      return a.signingOrder - b.signingOrder;
+    });
+
+    const currentIndex = sortedRecipients.findIndex((r) => r.id === directRecipient.id);
+    return currentIndex !== -1 && currentIndex < sortedRecipients.length - 1
+      ? sortedRecipients[currentIndex + 1]
+      : undefined;
+  }, [template.templateMeta?.signingOrder, template.recipients, directRecipient.id]);
+
   return (
     <DocumentSigningRecipientProvider recipient={directRecipient}>
       <DocumentFlowFormContainerHeader title={flowStep.title} description={flowStep.description} />
@@ -417,11 +444,15 @@ export const DirectTemplateSigningForm = ({
 
           <DocumentSigningCompleteDialog
             isSubmitting={isSubmitting}
-            onSignatureComplete={async () => handleSubmit()}
+            onSignatureComplete={async (nextSigner) => handleSubmit(nextSigner)}
             documentTitle={template.title}
             fields={localFields}
             fieldsValidated={fieldsValidated}
             recipient={directRecipient}
+            allowDictateNextSigner={nextRecipient && template.templateMeta?.allowDictateNextSigner}
+            defaultNextSigner={
+              nextRecipient ? { name: nextRecipient.name, email: nextRecipient.email } : undefined
+            }
           />
         </div>
       </DocumentFlowFormContainerFooter>

apps/remix/app/components/general/document-signing/document-signing-auth-page.tsx

@@ -9,7 +9,7 @@ import { Button } from '@documenso/ui/primitives/button';
 import { useToast } from '@documenso/ui/primitives/use-toast';
 
 export type DocumentSigningAuthPageViewProps = {
-  email: string;
+  email?: string;
   emailHasAccount?: boolean;
 };
 
@@ -22,12 +22,18 @@ export const DocumentSigningAuthPageView = ({
 
   const [isSigningOut, setIsSigningOut] = useState(false);
 
-  const handleChangeAccount = async (email: string) => {
+  const handleChangeAccount = async (email?: string) => {
     try {
       setIsSigningOut(true);
 
+      let redirectPath = '/signin';
+
+      if (email) {
+        redirectPath = emailHasAccount ? `/signin#email=${email}` : `/signup#email=${email}`;
+      }
+
       await authClient.signOut({
-        redirectPath: emailHasAccount ? `/signin#email=${email}` : `/signup#email=${email}`,
+        redirectPath,
       });
     } catch {
       toast({
@@ -49,9 +55,13 @@ export const DocumentSigningAuthPageView = ({
         </h1>
 
         <p className="text-muted-foreground mt-2 text-sm">
+          {email ? (
             <Trans>
               You need to be logged in as <strong>{email}</strong> to view this page.
             </Trans>
+          ) : (
+            <Trans>You need to be logged in to view this page.</Trans>
+          )}
         </p>
 
         <Button

apps/remix/app/components/general/document-signing/document-signing-auth-provider.tsx

@@ -24,7 +24,10 @@ type PasskeyData = {
   isError: boolean;
 };
 
-type SigningAuthRecipient = Pick<Recipient, 'authOptions' | 'email' | 'role' | 'name' | 'token'>;
+type SigningAuthRecipient = Pick<
+  Recipient,
+  'authOptions' | 'email' | 'role' | 'name' | 'token' | 'id'
+>;
 
 export type DocumentSigningAuthContextValue = {
   executeActionAuthProcedure: (_value: ExecuteActionAuthProcedureOptions) => Promise<void>;

apps/remix/app/components/general/document-signing/document-signing-complete-dialog.tsx

@@ -304,7 +304,6 @@ export const DocumentSigningCompleteDialog = ({
                 <form onSubmit={form.handleSubmit(onFormSubmit)}>
                   {allowDictateNextSigner && defaultNextSigner && (
                     <div className="mb-4 flex flex-col gap-4">
-                      {/* Todo: Envelopes - Should we say "The next recipient to sign this document will be"? */}
                       <div className="flex flex-col gap-4 md:flex-row">
                         <FormField
                           control={form.control}

apps/remix/app/components/general/document-signing/envelope-signing-provider.tsx

@@ -285,8 +285,6 @@ export const EnvelopeSigningProvider = ({
   }, [envelope.documentMeta?.signingOrder, envelope.recipients, recipient.id]);
 
   const signField = async (fieldId: number, fieldValue: TSignEnvelopeFieldValue) => {
-    console.log('insertField', fieldId, fieldValue);
-
     // Set the field locally for direct templates.
     if (isDirectTemplate) {
       handleDirectTemplateFieldInsertion(fieldId, fieldValue);

apps/remix/app/components/general/envelope-editor/envelope-editor-settings-dialog.tsx

@@ -242,7 +242,6 @@ export const EnvelopeEditorSettingsDialog = ({
     try {
       await updateEnvelope({
         envelopeId: envelope.id,
-        envelopeType: envelope.type,
         data: {
           externalId: data.externalId || null,
           visibility: data.visibility,

apps/remix/app/components/general/envelope-editor/envelope-editor-upload-page.tsx

@@ -142,7 +142,7 @@ export const EnvelopeEditorUploadPage = () => {
 
     const { createdEnvelopeItems } = await createEnvelopeItems({
       envelopeId: envelope.id,
-      items: envelopeItemsToCreate,
+      data: envelopeItemsToCreate,
     }).catch((error) => {
       console.error(error);
 

apps/remix/app/components/general/envelope-signing/envelope-signing-complete-dialog.tsx

@@ -127,6 +127,7 @@ export const EnvelopeSignerCompleteDialog = () => {
             isBase64,
           };
         }),
+        nextSigner,
       });
 
       const redirectUrl = envelope.documentMeta.redirectUrl;

apps/remix/app/routes/_authenticated+/admin+/organisations.$id.tsx

@@ -34,6 +34,7 @@ import { Input } from '@documenso/ui/primitives/input';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@documenso/ui/primitives/tooltip';
 import { useToast } from '@documenso/ui/primitives/use-toast';
 
+import { AdminOrganisationMemberUpdateDialog } from '~/components/dialogs/admin-organisation-member-update-dialog';
 import { GenericErrorLayout } from '~/components/general/generic-error-layout';
 import { SettingsHeader } from '~/components/general/settings-header';
 
@@ -71,23 +72,6 @@ export default function OrganisationGroupSettingsPage({ params }: Route.Componen
       },
     });
 
-  const { mutateAsync: promoteToOwner, isPending: isPromotingToOwner } =
-    trpc.admin.organisationMember.promoteToOwner.useMutation({
-      onSuccess: () => {
-        toast({
-          title: t`Success`,
-          description: t`Member promoted to owner successfully`,
-        });
-      },
-      onError: () => {
-        toast({
-          title: t`Error`,
-          description: t`We couldn't promote the member to owner. Please try again.`,
-          variant: 'destructive',
-        });
-      },
-    });
-
   const teamsColumns = useMemo(() => {
     return [
       {
@@ -120,23 +104,24 @@ export default function OrganisationGroupSettingsPage({ params }: Route.Componen
       },
       {
         header: t`Actions`,
-        cell: ({ row }) => (
+        cell: ({ row }) => {
+          const isOwner = row.original.userId === organisation?.ownerUserId;
+
+          return (
             <div className="flex justify-end space-x-2">
-            <Button
-              variant="outline"
-              disabled={row.original.userId === organisation?.ownerUserId}
-              loading={isPromotingToOwner}
-              onClick={async () =>
-                promoteToOwner({
-                  organisationId,
-                  userId: row.original.userId,
-                })
-              }
-            >
-              <Trans>Promote to owner</Trans>
+              <AdminOrganisationMemberUpdateDialog
+                trigger={
+                  <Button variant="outline">
+                    <Trans>Update role</Trans>
                   </Button>
+                }
+                organisationId={organisationId}
+                organisationMember={row.original}
+                isOwner={isOwner}
+              />
             </div>
-        ),
+          );
+        },
       },
     ] satisfies DataTableColumnDef<TGetAdminOrganisationResponse['members'][number]>[];
   }, [organisation]);

apps/remix/app/routes/_recipient+/d.$token+/_index.tsx

@@ -8,7 +8,6 @@ import { EnvelopeRenderProvider } from '@documenso/lib/client-only/providers/env
 import { useOptionalSession } from '@documenso/lib/client-only/providers/session';
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { getEnvelopeForDirectTemplateSigning } from '@documenso/lib/server-only/envelope/get-envelope-for-direct-template-signing';
-import { getEnvelopeRequiredAccessData } from '@documenso/lib/server-only/envelope/get-envelope-required-access-data';
 import { getTemplateByDirectLinkToken } from '@documenso/lib/server-only/template/get-template-by-direct-link-token';
 import { DocumentAccessAuth } from '@documenso/lib/types/document-auth';
 import { extractDocumentAuthMethods } from '@documenso/lib/utils/document-auth';
@@ -98,15 +97,12 @@ const handleV2Loader = async ({ params, request }: Route.LoaderArgs) => {
         envelopeForSigning,
       } as const;
     })
-    .catch(async (e) => {
+    .catch((e) => {
       const error = AppError.parseError(e);
 
       if (error.code === AppErrorCode.UNAUTHORIZED) {
-        const requiredAccessData = await getEnvelopeRequiredAccessData({ token });
-
         return {
           isDocumentAccessValid: false,
-          ...requiredAccessData,
         } as const;
       }
 
@@ -226,20 +222,21 @@ const DirectSigningPageV2 = ({ data }: { data: Awaited<ReturnType<typeof handleV
   const user = sessionData?.user;
 
   if (!data.isDocumentAccessValid) {
-    return (
-      <DocumentSigningAuthPageView
-        email={data.recipientEmail}
-        emailHasAccount={!!data.recipientHasAccount}
-      />
-    );
+    return <DocumentSigningAuthPageView email={''} emailHasAccount={true} />;
   }
 
   const { envelope, recipient } = data.envelopeForSigning;
 
+  const { derivedRecipientAccessAuth } = extractDocumentAuthMethods({
+    documentAuth: envelope.authOptions,
+  });
+
+  const isEmailForced = derivedRecipientAccessAuth.includes(DocumentAccessAuth.ACCOUNT);
+
   return (
     <EnvelopeSigningProvider
       envelopeData={data.envelopeForSigning}
-      email={''} // Doing this allows us to let users change the email if they want to.
+      email={isEmailForced ? user?.email || '' : ''} // Doing this allows us to let users change the email if they want to for non-auth templates.
       fullName={user?.name}
       signature={user?.signature}
     >

package-lock.json

@@ -12557,6 +12557,16 @@
         "@types/pg": "*"
       }
     },
+    "node_modules/@types/pngjs": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/@types/pngjs/-/pngjs-6.0.5.tgz",
+      "integrity": "sha512-0k5eKfrA83JOZPppLtS2C7OUtyNAl2wKNxfyYl9Q5g9lPkgBl/9hNyAu6HuEH2J4XmIv2znEpkDd0SaZVxW6iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/prop-types": {
       "version": "15.7.14",
       "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz",
@@ -27544,6 +27554,19 @@
         "node": ">= 6"
       }
     },
+    "node_modules/pixelmatch": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/pixelmatch/-/pixelmatch-7.1.0.tgz",
+      "integrity": "sha512-1wrVzJ2STrpmONHKBy228LM1b84msXDUoAzVEl0R8Mz4Ce6EPr+IVtxm8+yvrqLYMHswREkjYFaMxnyGnaY3Ng==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "pngjs": "^7.0.0"
+      },
+      "bin": {
+        "pixelmatch": "bin/pixelmatch"
+      }
+    },
     "node_modules/pkg-dir": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz",
@@ -27740,6 +27763,16 @@
         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
       }
     },
+    "node_modules/pngjs": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-7.0.0.tgz",
+      "integrity": "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.19.0"
+      }
+    },
     "node_modules/pofile": {
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/pofile/-/pofile-1.1.4.tgz",
@@ -36183,7 +36216,10 @@
         "@documenso/lib": "*",
         "@documenso/prisma": "*",
         "@playwright/test": "1.52.0",
-        "@types/node": "^20"
+        "@types/node": "^20",
+        "@types/pngjs": "^6.0.5",
+        "pixelmatch": "^7.1.0",
+        "pngjs": "^7.0.0"
       }
     },
     "packages/app-tests/node_modules/@playwright/test": {

packages/api/v1/implementation.ts

@@ -20,12 +20,12 @@ import {
   getEnvelopeWhereInput,
 } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
 import { deleteDocumentField } from '@documenso/lib/server-only/field/delete-document-field';
-import { updateDocumentFields } from '@documenso/lib/server-only/field/update-document-fields';
+import { updateEnvelopeFields } from '@documenso/lib/server-only/field/update-envelope-fields';
 import { insertFormValuesInPdf } from '@documenso/lib/server-only/pdf/insert-form-values-in-pdf';
-import { deleteDocumentRecipient } from '@documenso/lib/server-only/recipient/delete-document-recipient';
+import { deleteEnvelopeRecipient } from '@documenso/lib/server-only/recipient/delete-envelope-recipient';
 import { getRecipientsForDocument } from '@documenso/lib/server-only/recipient/get-recipients-for-document';
 import { setDocumentRecipients } from '@documenso/lib/server-only/recipient/set-document-recipients';
-import { updateDocumentRecipients } from '@documenso/lib/server-only/recipient/update-document-recipients';
+import { updateEnvelopeRecipients } from '@documenso/lib/server-only/recipient/update-envelope-recipients';
 import { createDocumentFromTemplate } from '@documenso/lib/server-only/template/create-document-from-template';
 import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
 import { findTemplates } from '@documenso/lib/server-only/template/find-templates';
@@ -1285,7 +1285,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    const updatedRecipient = await updateDocumentRecipients({
+    const updatedRecipient = await updateEnvelopeRecipients({
       userId: user.id,
       teamId: team.id,
       id: {
@@ -1336,7 +1336,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       },
     });
 
-    const deletedRecipient = await deleteDocumentRecipient({
+    const deletedRecipient = await deleteEnvelopeRecipient({
       userId: user.id,
       teamId: team.id,
       recipientId: Number(recipientId),
@@ -1634,10 +1634,13 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    const { fields } = await updateDocumentFields({
+    const { fields } = await updateEnvelopeFields({
       userId: user.id,
       teamId: team.id,
-      documentId: legacyDocumentId,
+      id: {
+        type: 'documentId',
+        id: legacyDocumentId,
+      },
       fields: [
         {
           id: Number(fieldId),

packages/app-tests/constants/field-alignment-pdf.ts

@@ -0,0 +1,498 @@
+import { FieldType } from '@prisma/client';
+
+import type { TFieldAndMeta } from '@documenso/lib/types/field-meta';
+import { toCheckboxCustomText } from '@documenso/lib/utils/fields';
+
+export type FieldTestData = TFieldAndMeta & {
+  page: number;
+  positionX: number;
+  positionY: number;
+  width: number;
+  height: number;
+  customText: string;
+  signature?: string;
+};
+
+const columnWidth = 19.125;
+const rowHeight = 6.7;
+
+const alignmentGridStartX = 31;
+const alignmentGridStartY = 19.02;
+
+export const ALIGNMENT_TEST_FIELDS: FieldTestData[] = [
+  /**
+   * Row 1 EMAIL
+   */
+  {
+    type: FieldType.EMAIL,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'email',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'admin@documenso.com',
+  },
+  {
+    type: FieldType.EMAIL,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'email',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'admin@documenso.com',
+  },
+  {
+    type: FieldType.EMAIL,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'email',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'admin@documenso.com',
+  },
+  /**
+   * Row 2 NAME
+   */
+  {
+    type: FieldType.NAME,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'name',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'John Doe',
+  },
+  {
+    type: FieldType.NAME,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'name',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'John Doe',
+  },
+  {
+    type: FieldType.NAME,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'name',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'John Doe',
+  },
+  /**
+   * Row 3 DATE
+   */
+  {
+    type: FieldType.DATE,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'date',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.DATE,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'date',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.DATE,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'date',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  /**
+   * Row 4 TEXT
+   */
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'text',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'text',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'text',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  /**
+   * Row 5 NUMBER
+   */
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'number',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'number',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'number',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  /**
+   * Row 6 Initials
+   */
+  {
+    type: FieldType.INITIALS,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'initials',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'JD',
+  },
+  {
+    type: FieldType.INITIALS,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'initials',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'JD',
+  },
+  {
+    type: FieldType.INITIALS,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'initials',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'JD',
+  },
+  /**
+   * Row 7 Radio
+   */
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      fontSize: 10,
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '0',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '2',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      fontSize: 20,
+      direction: 'horizontal',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+  },
+  /**
+   * Row 8 Checkbox
+   */
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      fontSize: 10,
+      direction: 'vertical',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: toCheckboxCustomText([0]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: toCheckboxCustomText([1]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      fontSize: 20,
+      direction: 'horizontal',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+  },
+  /**
+   * Row 8 Dropdown
+   */
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      fontSize: 10,
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      fontSize: 20,
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }, { value: 'Option 3' }],
+      type: 'dropdown',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'Option 1',
+  },
+  /**
+   * Row 9 Signature
+   */
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      fontSize: 10,
+      type: 'signature',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      fontSize: 20,
+      type: 'signature',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+    signature: 'My Signature',
+  },
+] as const;
+
+export const formatAlignmentTestFields = ALIGNMENT_TEST_FIELDS.map((field, index) => {
+  const row = Math.floor(index / 3);
+  const column = index % 3;
+
+  return {
+    ...field,
+    positionX: alignmentGridStartX + column * columnWidth,
+    positionY: alignmentGridStartY + row * rowHeight,
+  };
+});

packages/app-tests/constants/field-meta-pdf.ts

@@ -0,0 +1,482 @@
+import { FieldType } from '@prisma/client';
+
+import { toCheckboxCustomText } from '@documenso/lib/utils/fields';
+import {
+  CheckboxValidationRules,
+  numberFormatValues,
+} from '@documenso/ui/primitives/document-flow/field-items-advanced-settings/constants';
+
+import type { FieldTestData } from './field-alignment-pdf';
+
+const columnWidth = 20.1;
+const fullColumnWidth = 75.8;
+const rowHeight = 9.8;
+const rowPadding = 1.8;
+
+const alignmentGridStartX = 11.85;
+const alignmentGridStartY = 15.07;
+
+const calculatePosition = (row: number, column: number, width: 'full' | 'column' = 'column') => {
+  return {
+    height: rowHeight,
+    width: width === 'full' ? fullColumnWidth : columnWidth,
+    positionX: alignmentGridStartX + (column ?? 0) * columnWidth,
+    positionY: alignmentGridStartY + row * (rowHeight + rowPadding),
+  };
+};
+
+export const FIELD_META_TEST_FIELDS: FieldTestData[] = [
+  /**
+   * PAGE 2 Signature
+   */
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(0, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(1, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(2, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(3, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+
+  /**
+   * PAGE 3 TEXT
+   */
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+    },
+    page: 3,
+    ...calculatePosition(0, 0, 'full'),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+    },
+    page: 3,
+    ...calculatePosition(1, 0),
+    customText: '123456789123456789123456789123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      characterLimit: 5,
+    },
+    page: 3,
+    ...calculatePosition(2, 0),
+    customText: '12345',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      placeholder: 'Demo Placeholder',
+    },
+    page: 3,
+    ...calculatePosition(3, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      label: 'Demo Label',
+    },
+    page: 3,
+    ...calculatePosition(3, 1),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      text: 'Prefilled text',
+    },
+    page: 3,
+    ...calculatePosition(3, 2),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      required: true,
+    },
+    page: 3,
+    ...calculatePosition(4, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      readOnly: true,
+      text: 'Readonly Value',
+    },
+    page: 3,
+    ...calculatePosition(4, 1),
+    customText: 'Readonly Value',
+  },
+
+  /**
+   * PAGE 4 NUMBER
+   */
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+    },
+    page: 4,
+    ...calculatePosition(0, 0, 'full'),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+    },
+    page: 4,
+    ...calculatePosition(1, 0),
+    customText: '123456789123456789123456789123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      minValue: 0,
+      maxValue: 100,
+    },
+    page: 4,
+    ...calculatePosition(2, 0),
+    customText: '50',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      numberFormat: numberFormatValues[0].value, // Todo: Envelopes - Check this.
+      value: '123,456,789.00',
+    },
+    page: 4,
+    ...calculatePosition(2, 1),
+    customText: '123,456,789.00',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      placeholder: 'Demo Placeholder',
+    },
+    page: 4,
+    ...calculatePosition(3, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      label: 'Demo Label',
+    },
+    page: 4,
+    ...calculatePosition(3, 1),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      value: '123',
+    },
+    page: 4,
+    ...calculatePosition(3, 2),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      required: true,
+    },
+    page: 4,
+    ...calculatePosition(4, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      readOnly: true,
+    },
+    page: 4,
+    ...calculatePosition(4, 1),
+    customText: '123456789',
+  },
+
+  /**
+   * PAGE 5 RADIO
+   */
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'horizontal',
+      type: 'radio',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(0, 0, 'full'),
+    customText: '0',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(1, 0),
+    customText: '2',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(2, 0),
+    customText: '',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(2, 1),
+    customText: '',
+  },
+
+  /**
+   * PAGE 6 CHECKBOX
+   */
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'horizontal',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 2, checked: false, value: 'Option 3' },
+        { id: 2, checked: false, value: 'Option 4' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(0, 0, 'full'),
+    customText: toCheckboxCustomText([0]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+        { id: 2, checked: true, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(1, 0),
+    customText: toCheckboxCustomText([1]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      required: true,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(2, 0),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      readOnly: true,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(2, 1),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      validationRule: CheckboxValidationRules.SELECT_AT_LEAST,
+      validationLength: 2,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(3, 0),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      validationRule: CheckboxValidationRules.SELECT_EXACTLY,
+      validationLength: 2,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(3, 1),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      validationRule: CheckboxValidationRules.SELECT_AT_MOST,
+      validationLength: 2,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(3, 2),
+    customText: '',
+  },
+
+  /**
+   * PAGE 7 DROPDOWN
+   */
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+    },
+    page: 7,
+    ...calculatePosition(0, 0, 'full'),
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+      defaultValue: 'Option 1',
+    },
+    page: 7,
+    ...calculatePosition(1, 0),
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }, { value: 'Option 3' }],
+      type: 'dropdown',
+      required: true,
+    },
+    page: 7,
+    ...calculatePosition(2, 0),
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }, { value: 'Option 3' }],
+      type: 'dropdown',
+      readOnly: true,
+    },
+    page: 7,
+    ...calculatePosition(2, 1),
+    customText: 'Option 1',
+  },
+] as const;
+
+export const formatFieldMetaTestFields = FIELD_META_TEST_FIELDS.map((field, index) => {
+  return {
+    ...field,
+  };
+});

packages/app-tests/e2e/admin/organisations/update-organisation-member-role.spec.ts

@@ -68,15 +68,29 @@ test('[ADMIN]: promote member to owner', async ({ page }) => {
   // Test promoting a MEMBER to owner
   const memberRow = page.getByRole('row', { name: memberUser.email });
 
-  // Find and click the "Promote to owner" button for the member
-  const promoteButton = memberRow.getByRole('button', { name: 'Promote to owner' });
-  await expect(promoteButton).toBeVisible();
-  await expect(promoteButton).not.toBeDisabled();
+  // Find and click the "Update role" button for the member
+  const updateRoleButton = memberRow.getByRole('button', {
+    name: 'Update role',
+  });
+  await expect(updateRoleButton).toBeVisible();
+  await expect(updateRoleButton).not.toBeDisabled();
 
-  await promoteButton.click();
+  await updateRoleButton.click();
 
-  // Verify success toast appears
-  await expect(page.getByText('Member promoted to owner successfully').first()).toBeVisible();
+  // Wait for dialog to open and select Owner role
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Find and click the select trigger - it's a button with role="combobox"
+  await page.getByRole('dialog').locator('button[role="combobox"]').click();
+
+  // Select "Owner" from the dropdown options
+  await page.getByRole('option', { name: 'Owner' }).click();
+
+  // Click Update button
+  await page.getByRole('dialog').getByRole('button', { name: 'Update' }).click();
+
+  // Wait for dialog to close (indicates success)
+  await expect(page.getByRole('dialog')).not.toBeVisible({ timeout: 10_000 });
 
   // Reload the page to see the changes
   await page.reload();
@@ -89,12 +103,18 @@ test('[ADMIN]: promote member to owner', async ({ page }) => {
   const previousOwnerRow = page.getByRole('row', { name: ownerUser.email });
   await expect(previousOwnerRow.getByRole('status').filter({ hasText: 'Owner' })).not.toBeVisible();
 
-  // Verify that the promote button is now disabled for the new owner
-  const newOwnerPromoteButton = newOwnerRow.getByRole('button', { name: 'Promote to owner' });
-  await expect(newOwnerPromoteButton).toBeDisabled();
+  // Verify that the Update role button exists for the new owner and shows Owner as current role
+  const newOwnerUpdateButton = newOwnerRow.getByRole('button', {
+    name: 'Update role',
+  });
+  await expect(newOwnerUpdateButton).toBeVisible();
 
-  // Test that we can't promote the current owner (button should be disabled)
-  await expect(newOwnerPromoteButton).toHaveAttribute('disabled');
+  // Verify clicking it shows the dialog with Owner already selected
+  await newOwnerUpdateButton.click();
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Close the dialog without making changes
+  await page.getByRole('button', { name: 'Cancel' }).click();
 });
 
 test('[ADMIN]: promote manager to owner', async ({ page }) => {
@@ -130,10 +150,26 @@ test('[ADMIN]: promote manager to owner', async ({ page }) => {
 
   // Promote the manager to owner
   const managerRow = page.getByRole('row', { name: managerUser.email });
-  const promoteButton = managerRow.getByRole('button', { name: 'Promote to owner' });
+  const updateRoleButton = managerRow.getByRole('button', {
+    name: 'Update role',
+  });
 
-  await promoteButton.click();
-  await expect(page.getByText('Member promoted to owner successfully').first()).toBeVisible();
+  await updateRoleButton.click();
+
+  // Wait for dialog to open and select Owner role
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Find and click the select trigger - it's a button with role="combobox"
+  await page.getByRole('dialog').locator('button[role="combobox"]').click();
+
+  // Select "Owner" from the dropdown options
+  await page.getByRole('option', { name: 'Owner' }).click();
+
+  // Click Update button
+  await page.getByRole('dialog').getByRole('button', { name: 'Update' }).click();
+
+  // Wait for dialog to close (indicates success)
+  await expect(page.getByRole('dialog')).not.toBeVisible({ timeout: 10_000 });
 
   // Reload and verify the change
   await page.reload();
@@ -173,14 +209,27 @@ test('[ADMIN]: promote admin member to owner', async ({ page }) => {
 
   // Promote the admin member to owner
   const adminMemberRow = page.getByRole('row', { name: adminMemberUser.email });
-  const promoteButton = adminMemberRow.getByRole('button', { name: 'Promote to owner' });
-
-  await promoteButton.click();
-
-  await expect(page.getByText('Member promoted to owner successfully').first()).toBeVisible({
-    timeout: 10_000,
+  const updateRoleButton = adminMemberRow.getByRole('button', {
+    name: 'Update role',
   });
 
+  await updateRoleButton.click();
+
+  // Wait for dialog to open and select Owner role
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Find and click the select trigger - it's a button with role="combobox"
+  await page.getByRole('dialog').locator('button[role="combobox"]').click();
+
+  // Select "Owner" from the dropdown options
+  await page.getByRole('option', { name: 'Owner' }).click();
+
+  // Click Update button
+  await page.getByRole('dialog').getByRole('button', { name: 'Update' }).click();
+
+  // Wait for dialog to close (indicates success)
+  await expect(page.getByRole('dialog')).not.toBeVisible({ timeout: 10_000 });
+
   // Reload and verify the change
   await page.reload();
   await expect(adminMemberRow.getByRole('status').filter({ hasText: 'Owner' })).toBeVisible();
@@ -249,11 +298,25 @@ test('[ADMIN]: verify role hierarchy after promotion', async ({ page }) => {
   await expect(memberRow.getByRole('status').filter({ hasText: 'Owner' })).not.toBeVisible();
 
   // Promote member to owner
-  const promoteButton = memberRow.getByRole('button', { name: 'Promote to owner' });
-  await promoteButton.click();
-  await expect(page.getByText('Member promoted to owner successfully').first()).toBeVisible({
-    timeout: 10_000,
+  const updateRoleButton = memberRow.getByRole('button', {
+    name: 'Update role',
   });
+  await updateRoleButton.click();
+
+  // Wait for dialog to open and select Owner role
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Find and click the select trigger - it's a button with role="combobox"
+  await page.getByRole('dialog').locator('button[role="combobox"]').click();
+
+  // Select "Owner" from the dropdown options
+  await page.getByRole('option', { name: 'Owner' }).click();
+
+  // Click Update button
+  await page.getByRole('dialog').getByRole('button', { name: 'Update' }).click();
+
+  // Wait for dialog to close (indicates success)
+  await expect(page.getByRole('dialog')).not.toBeVisible({ timeout: 10_000 });
 
   // Reload page to see updated state
   await page.reload();
@@ -262,9 +325,11 @@ test('[ADMIN]: verify role hierarchy after promotion', async ({ page }) => {
   memberRow = page.getByRole('row', { name: memberUser.email });
   await expect(memberRow.getByRole('status').filter({ hasText: 'Owner' })).toBeVisible();
 
-  // Verify the promote button is now disabled for the new owner
-  const newOwnerPromoteButton = memberRow.getByRole('button', { name: 'Promote to owner' });
-  await expect(newOwnerPromoteButton).toBeDisabled();
+  // Verify the Update role button exists and shows Owner as current role
+  const newOwnerUpdateButton = memberRow.getByRole('button', {
+    name: 'Update role',
+  });
+  await expect(newOwnerUpdateButton).toBeVisible();
 
   // Sign in as the newly promoted user to verify they have owner permissions
   await apiSignin({
@@ -336,28 +401,56 @@ test('[ADMIN]: multiple promotions in sequence', async ({ page }) => {
 
   // First promotion: Member 1 becomes owner
   let member1Row = page.getByRole('row', { name: member1User.email });
-  let promoteButton1 = member1Row.getByRole('button', { name: 'Promote to owner' });
-  await promoteButton1.click();
-  await expect(page.getByText('Member promoted to owner successfully').first()).toBeVisible({
-    timeout: 10_000,
+  let updateRoleButton1 = member1Row.getByRole('button', {
+    name: 'Update role',
   });
+  await updateRoleButton1.click();
+
+  // Wait for dialog to open and select Owner role
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Find and click the select trigger - it's a button with role="combobox"
+  await page.getByRole('dialog').locator('button[role="combobox"]').click();
+
+  // Select "Owner" from the dropdown options
+  await page.getByRole('option', { name: 'Owner' }).click();
+
+  // Click Update button
+  await page.getByRole('dialog').getByRole('button', { name: 'Update' }).click();
+
+  // Wait for dialog to close (indicates success)
+  await expect(page.getByRole('dialog')).not.toBeVisible({ timeout: 10_000 });
 
   await page.reload();
 
-  // Verify Member 1 is now owner and button is disabled
+  // Verify Member 1 is now owner
   member1Row = page.getByRole('row', { name: member1User.email });
   await expect(member1Row.getByRole('status').filter({ hasText: 'Owner' })).toBeVisible();
-  promoteButton1 = member1Row.getByRole('button', { name: 'Promote to owner' });
-  await expect(promoteButton1).toBeDisabled();
+  updateRoleButton1 = member1Row.getByRole('button', { name: 'Update role' });
+  await expect(updateRoleButton1).toBeVisible();
 
   // Second promotion: Member 2 becomes the new owner
   const member2Row = page.getByRole('row', { name: member2User.email });
-  const promoteButton2 = member2Row.getByRole('button', { name: 'Promote to owner' });
-  await expect(promoteButton2).not.toBeDisabled();
-  await promoteButton2.click();
-  await expect(page.getByText('Member promoted to owner successfully').first()).toBeVisible({
-    timeout: 10_000,
+  const updateRoleButton2 = member2Row.getByRole('button', {
+    name: 'Update role',
   });
+  await expect(updateRoleButton2).toBeVisible();
+  await updateRoleButton2.click();
+
+  // Wait for dialog to open and select Owner role
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Find and click the select trigger - it's a button with role="combobox"
+  await page.getByRole('dialog').locator('button[role="combobox"]').click();
+
+  // Select "Owner" from the dropdown options
+  await page.getByRole('option', { name: 'Owner' }).click();
+
+  // Click Update button
+  await page.getByRole('dialog').getByRole('button', { name: 'Update' }).click();
+
+  // Wait for dialog to close (indicates success)
+  await expect(page.getByRole('dialog')).not.toBeVisible({ timeout: 10_000 });
 
   await page.reload();
 
@@ -365,9 +458,11 @@ test('[ADMIN]: multiple promotions in sequence', async ({ page }) => {
   await expect(member2Row.getByRole('status').filter({ hasText: 'Owner' })).toBeVisible();
   await expect(member1Row.getByRole('status').filter({ hasText: 'Owner' })).not.toBeVisible();
 
-  // Verify Member 1's promote button is now enabled again
-  const newPromoteButton1 = member1Row.getByRole('button', { name: 'Promote to owner' });
-  await expect(newPromoteButton1).not.toBeDisabled();
+  // Verify Member 1's Update role button is still visible
+  const newUpdateButton1 = member1Row.getByRole('button', {
+    name: 'Update role',
+  });
+  await expect(newUpdateButton1).toBeVisible();
 });
 
 test('[ADMIN]: verify organisation access after ownership change', async ({ page }) => {
@@ -402,11 +497,25 @@ test('[ADMIN]: verify organisation access after ownership change', async ({ page
   });
 
   const memberRow = page.getByRole('row', { name: memberUser.email });
-  const promoteButton = memberRow.getByRole('button', { name: 'Promote to owner' });
-  await promoteButton.click();
-  await expect(page.getByText('Member promoted to owner successfully').first()).toBeVisible({
-    timeout: 10_000,
+  const updateRoleButton = memberRow.getByRole('button', {
+    name: 'Update role',
   });
+  await updateRoleButton.click();
+
+  // Wait for dialog to open and select Owner role
+  await expect(page.getByRole('dialog')).toBeVisible();
+
+  // Find and click the select trigger - it's a button with role="combobox"
+  await page.getByRole('dialog').locator('button[role="combobox"]').click();
+
+  // Select "Owner" from the dropdown options
+  await page.getByRole('option', { name: 'Owner' }).click();
+
+  // Click Update button
+  await page.getByRole('dialog').getByRole('button', { name: 'Update' }).click();
+
+  // Wait for dialog to close (indicates success)
+  await expect(page.getByRole('dialog')).not.toBeVisible({ timeout: 10_000 });
 
   // Test that the new owner can access organisation settings
   await apiSignin({

packages/app-tests/e2e/api/v2/envelopes-api.spec.ts

@@ -0,0 +1,264 @@
+import { expect, test } from '@playwright/test';
+import type { Team, User } from '@prisma/client';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+import { incrementDocumentId } from '@documenso/lib/server-only/envelope/increment-id';
+import { createApiToken } from '@documenso/lib/server-only/public-api/create-api-token';
+import { prefixedId } from '@documenso/lib/universal/id';
+import { prisma } from '@documenso/prisma';
+import {
+  DocumentSource,
+  DocumentVisibility,
+  EnvelopeType,
+  RecipientRole,
+} from '@documenso/prisma/client';
+import { seedUser } from '@documenso/prisma/seed/users';
+import type { TCreateEnvelopeItemsRequest } from '@documenso/trpc/server/envelope-router/create-envelope-items.types';
+import type { TCreateEnvelopeRecipientsRequest } from '@documenso/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.types';
+import type { TGetEnvelopeResponse } from '@documenso/trpc/server/envelope-router/get-envelope.types';
+import type { TUpdateEnvelopeRequest } from '@documenso/trpc/server/envelope-router/update-envelope.types';
+
+import { formatAlignmentTestFields } from '../../../constants/field-alignment-pdf';
+import { FIELD_META_TEST_FIELDS } from '../../../constants/field-meta-pdf';
+
+const WEBAPP_BASE_URL = NEXT_PUBLIC_WEBAPP_URL();
+const baseUrl = `${WEBAPP_BASE_URL}/api/v2-beta`;
+
+test.describe.configure({
+  mode: 'parallel',
+});
+
+test.describe('API V2 Envelopes', () => {
+  let userA: User, teamA: Team, userB: User, teamB: Team, tokenA: string, tokenB: string;
+
+  test.beforeEach(async () => {
+    ({ user: userA, team: teamA } = await seedUser());
+    ({ token: tokenA } = await createApiToken({
+      userId: userA.id,
+      teamId: teamA.id,
+      tokenName: 'userA',
+      expiresIn: null,
+    }));
+
+    ({ user: userB, team: teamB } = await seedUser());
+    ({ token: tokenB } = await createApiToken({
+      userId: userB.id,
+      teamId: teamB.id,
+      tokenName: 'userB',
+      expiresIn: null,
+    }));
+  });
+
+  /**
+   * Creates envelopes with the two field test PDFs.
+   */
+  test('Envelope full test', async ({ request }) => {
+    // Step 1: Create initial envelope with Prisma (with first envelope item)
+    const alignmentPdf = fs
+      .readFileSync(path.join(__dirname, '../../../../../assets/field-font-alignment.pdf'))
+      .toString('base64');
+
+    const fieldMetaPdf = fs
+      .readFileSync(path.join(__dirname, '../../../../../assets/field-meta.pdf'))
+      .toString('base64');
+
+    const alignmentDocumentData = await prisma.documentData.create({
+      data: {
+        type: 'BYTES_64',
+        data: alignmentPdf,
+        initialData: alignmentPdf,
+      },
+    });
+
+    const documentId = await incrementDocumentId();
+    const documentMeta = await prisma.documentMeta.create({
+      data: {},
+    });
+
+    const createdEnvelope = await prisma.envelope.create({
+      data: {
+        id: prefixedId('envelope'),
+        secondaryId: documentId.formattedDocumentId,
+        internalVersion: 2,
+        type: EnvelopeType.DOCUMENT,
+        documentMetaId: documentMeta.id,
+        source: DocumentSource.DOCUMENT,
+        title: `Envelope Full Field Test`,
+        status: 'DRAFT',
+        userId: userA.id,
+        teamId: teamA.id,
+        envelopeItems: {
+          create: {
+            id: prefixedId('envelope_item'),
+            title: `Alignment Test`,
+            documentDataId: alignmentDocumentData.id,
+            order: 1,
+          },
+        },
+      },
+      include: {
+        envelopeItems: true,
+      },
+    });
+
+    // Step 2: Create second envelope item via API
+    const fieldMetaDocumentData = await prisma.documentData.create({
+      data: {
+        type: 'BYTES_64',
+        data: fieldMetaPdf,
+        initialData: fieldMetaPdf,
+      },
+    });
+
+    const createEnvelopeItemsRequest: TCreateEnvelopeItemsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: [
+        {
+          title: 'Field Meta Test',
+          documentDataId: fieldMetaDocumentData.id,
+        },
+      ],
+    };
+
+    const createItemsRes = await request.post(`${baseUrl}/envelope/item/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: createEnvelopeItemsRequest,
+    });
+
+    expect(createItemsRes.ok()).toBeTruthy();
+    expect(createItemsRes.status()).toBe(200);
+
+    // Step 3: Update envelope via API
+    const updateEnvelopeRequest: TUpdateEnvelopeRequest = {
+      envelopeId: createdEnvelope.id,
+      envelopeType: EnvelopeType.DOCUMENT,
+      data: {
+        title: 'Envelope Full Field Test',
+        visibility: DocumentVisibility.MANAGER_AND_ABOVE,
+      },
+    };
+
+    const updateRes = await request.post(`${baseUrl}/envelope/update`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: updateEnvelopeRequest,
+    });
+
+    expect(updateRes.ok()).toBeTruthy();
+    expect(updateRes.status()).toBe(200);
+
+    // Step 4: Create recipient via API
+    const createRecipientsRequest: TCreateEnvelopeRecipientsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: [
+        {
+          email: userA.email,
+          name: userA.name || '',
+          role: RecipientRole.SIGNER,
+          accessAuth: [],
+          actionAuth: [],
+        },
+      ],
+    };
+
+    const createRecipientsRes = await request.post(`${baseUrl}/envelope/recipient/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: createRecipientsRequest,
+    });
+
+    expect(createRecipientsRes.ok()).toBeTruthy();
+    expect(createRecipientsRes.status()).toBe(200);
+
+    // Step 5: Get envelope to retrieve recipients and envelope items
+    const getRes = await request.get(`${baseUrl}/envelope/${createdEnvelope.id}`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+    });
+
+    expect(getRes.ok()).toBeTruthy();
+    expect(getRes.status()).toBe(200);
+
+    const envelopeResponse = (await getRes.json()) as TGetEnvelopeResponse;
+
+    const recipientId = envelopeResponse.recipients[0].id;
+    const alignmentItem = envelopeResponse.envelopeItems.find(
+      (item: { order: number }) => item.order === 1,
+    );
+    const fieldMetaItem = envelopeResponse.envelopeItems.find(
+      (item: { order: number }) => item.order === 2,
+    );
+
+    expect(recipientId).toBeDefined();
+    expect(alignmentItem).toBeDefined();
+    expect(fieldMetaItem).toBeDefined();
+
+    if (!alignmentItem || !fieldMetaItem) {
+      throw new Error('Envelope items not found');
+    }
+
+    // Step 6: Create fields for first PDF (alignment fields)
+    const alignmentFieldsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: formatAlignmentTestFields.map((field) => ({
+        recipientId,
+        envelopeItemId: alignmentItem.id,
+        type: field.type,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
+        width: field.width,
+        height: field.height,
+        fieldMeta: field.fieldMeta,
+      })),
+    };
+
+    const createAlignmentFieldsRes = await request.post(`${baseUrl}/envelope/field/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: alignmentFieldsRequest,
+    });
+
+    expect(createAlignmentFieldsRes.ok()).toBeTruthy();
+    expect(createAlignmentFieldsRes.status()).toBe(200);
+
+    // Step 7: Create fields for second PDF (field-meta fields)
+    const fieldMetaFieldsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: FIELD_META_TEST_FIELDS.map((field) => ({
+        recipientId,
+        envelopeItemId: fieldMetaItem.id,
+        type: field.type,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
+        width: field.width,
+        height: field.height,
+        fieldMeta: field.fieldMeta,
+      })),
+    };
+
+    const createFieldMetaFieldsRes = await request.post(`${baseUrl}/envelope/field/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: fieldMetaFieldsRequest,
+    });
+
+    expect(createFieldMetaFieldsRes.ok()).toBeTruthy();
+    expect(createFieldMetaFieldsRes.status()).toBe(200);
+
+    // Step 8: Verify final envelope structure
+    const finalGetRes = await request.get(`${baseUrl}/envelope/${createdEnvelope.id}`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+    });
+
+    expect(finalGetRes.ok()).toBeTruthy();
+    const finalEnvelope = (await finalGetRes.json()) as TGetEnvelopeResponse;
+
+    // Verify structure
+    expect(finalEnvelope.envelopeItems.length).toBe(2);
+    expect(finalEnvelope.recipients.length).toBe(1);
+    expect(finalEnvelope.fields.length).toBe(
+      formatAlignmentTestFields.length + FIELD_META_TEST_FIELDS.length,
+    );
+    expect(finalEnvelope.title).toBe('Envelope Full Field Test');
+    expect(finalEnvelope.type).toBe(EnvelopeType.DOCUMENT);
+  });
+});

packages/app-tests/e2e/envelopes/envelope-alignment.spec.ts

@@ -0,0 +1,282 @@
+// sort-imports-ignore
+
+// ---- PATCH pdfjs-dist's canvas require BEFORE importing it ----
+import Module from 'module';
+import { Canvas, Image } from 'skia-canvas';
+
+// Intercept require('canvas') and return skia-canvas equivalents
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (path: string) {
+  if (path === 'canvas') {
+    return {
+      createCanvas: (width: number, height: number) => new Canvas(width, height),
+      Image, // needed by pdfjs-dist
+    };
+  }
+  // eslint-disable-next-line prefer-rest-params, @typescript-eslint/consistent-type-assertions
+  return originalRequire.apply(this, arguments as unknown as [string]);
+};
+
+import pixelMatch from 'pixelmatch';
+import { PNG } from 'pngjs';
+import type { TestInfo } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+import { DocumentStatus } from '@prisma/client';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as pdfjsLib from 'pdfjs-dist/legacy/build/pdf.js';
+
+import { getFile } from '@documenso/lib/universal/upload/get-file';
+import { prisma } from '@documenso/prisma';
+import { seedAlignmentTestDocument } from '@documenso/prisma/seed/initial-seed';
+import { seedUser } from '@documenso/prisma/seed/users';
+
+import { apiSignin } from '../fixtures/authentication';
+
+test.describe.configure({ mode: 'parallel', timeout: 60000 });
+
+test('field placement visual regression', async ({ page }, testInfo) => {
+  const { user, team } = await seedUser();
+
+  const envelope = await seedAlignmentTestDocument({
+    userId: user.id,
+    teamId: team.id,
+    recipientName: user.name || '',
+    recipientEmail: user.email,
+    insertFields: true,
+    status: DocumentStatus.PENDING,
+  });
+
+  const token = envelope.recipients[0].token;
+
+  const signUrl = `/sign/${token}`;
+
+  await apiSignin({
+    page,
+    email: user.email,
+    redirectPath: signUrl,
+  });
+
+  await expect(page.getByRole('heading', { name: 'Sign Document' })).toBeVisible();
+
+  await page.getByRole('button', { name: 'Complete' }).click();
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(`${signUrl}/complete`);
+
+  await expect(async () => {
+    const { status } = await prisma.envelope.findFirstOrThrow({
+      where: {
+        id: envelope.id,
+      },
+    });
+
+    expect(status).toBe(DocumentStatus.COMPLETED);
+  }).toPass({
+    timeout: 10000,
+  });
+
+  const completedDocument = await prisma.envelope.findFirstOrThrow({
+    where: {
+      id: envelope.id,
+    },
+    include: {
+      envelopeItems: {
+        orderBy: {
+          order: 'asc',
+        },
+        include: {
+          documentData: true,
+        },
+      },
+    },
+  });
+
+  const storedImages = fs.readdirSync(path.join(__dirname, '../../visual-regression'));
+
+  await Promise.all(
+    completedDocument.envelopeItems.map(async (item) => {
+      const pdfData = await getFile(item.documentData);
+
+      const loadedImages = storedImages
+        .filter((image) => image.includes(item.title))
+        .map((image) => fs.readFileSync(path.join(__dirname, '../../visual-regression', image)));
+
+      await compareSignedPdfWithImages({
+        id: item.title.replaceAll(' ', '-').toLowerCase(),
+        pdfData,
+        images: loadedImages,
+        testInfo,
+      });
+    }),
+  );
+});
+
+/**
+ * Used to download the envelope images when updating the visual regression test.
+ *
+ * DON'T COMMIT THIS WITHOUT THE "SKIP" COMMAND.
+ */
+test.skip('download envelope images', async ({ page }) => {
+  const { user, team } = await seedUser();
+
+  const envelope = await seedAlignmentTestDocument({
+    userId: user.id,
+    teamId: team.id,
+    recipientName: user.name || '',
+    recipientEmail: user.email,
+    insertFields: true,
+    status: DocumentStatus.PENDING,
+  });
+
+  const token = envelope.recipients[0].token;
+
+  const signUrl = `/sign/${token}`;
+
+  await apiSignin({
+    page,
+    email: user.email,
+    redirectPath: signUrl,
+  });
+
+  await expect(page.getByRole('heading', { name: 'Sign Document' })).toBeVisible();
+
+  await page.getByRole('button', { name: 'Complete' }).click();
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(`${signUrl}/complete`);
+
+  await expect(async () => {
+    const { status } = await prisma.envelope.findFirstOrThrow({
+      where: {
+        id: envelope.id,
+      },
+    });
+
+    expect(status).toBe(DocumentStatus.COMPLETED);
+  }).toPass({
+    timeout: 10000,
+  });
+
+  const completedDocument = await prisma.envelope.findFirstOrThrow({
+    where: {
+      id: envelope.id,
+    },
+    include: {
+      envelopeItems: {
+        orderBy: {
+          order: 'asc',
+        },
+        include: {
+          documentData: true,
+        },
+      },
+    },
+  });
+
+  await Promise.all(
+    completedDocument.envelopeItems.map(async (item) => {
+      const pdfData = await getFile(item.documentData);
+
+      const pdfImages = await renderPdfToImage(pdfData);
+
+      for (const [index, { image }] of pdfImages.entries()) {
+        fs.writeFileSync(
+          path.join(__dirname, '../../visual-regression', `${item.title}-${index}.png`),
+          new Uint8Array(image),
+        );
+      }
+    }),
+  );
+});
+
+async function renderPdfToImage(pdfBytes: Uint8Array) {
+  const loadingTask = pdfjsLib.getDocument({ data: pdfBytes });
+  const pdf = await loadingTask.promise;
+
+  // Increase for higher resolution
+  const scale = 4;
+
+  return await Promise.all(
+    Array.from({ length: pdf.numPages }, async (_, index) => {
+      const page = await pdf.getPage(index + 1);
+
+      const viewport = page.getViewport({ scale });
+
+      const virtualCanvas = new Canvas(viewport.width, viewport.height);
+      const context = virtualCanvas.getContext('2d');
+      context.imageSmoothingEnabled = false;
+
+      // @ts-expect-error skia-canvas context satisfies runtime requirements for pdfjs
+      await page.render({ canvasContext: context, viewport }).promise;
+
+      return {
+        image: await virtualCanvas.toBuffer('png'),
+
+        // Rounded down because the certificate page somehow gives dimensions with decimals
+        width: Math.floor(viewport.width),
+        height: Math.floor(viewport.height),
+      };
+    }),
+  );
+}
+
+type CompareSignedPdfWithImagesOptions = {
+  id: string;
+  pdfData: Uint8Array;
+  images: Buffer[];
+  testInfo: TestInfo;
+};
+
+const compareSignedPdfWithImages = async ({
+  id,
+  pdfData,
+  images,
+  testInfo,
+}: CompareSignedPdfWithImagesOptions) => {
+  const renderedImages = await renderPdfToImage(pdfData);
+
+  const blankCertificateFile = fs.readFileSync(
+    path.join(__dirname, '../../visual-regression/blank-certificate.png'),
+  );
+  const blankCertificateImage = PNG.sync.read(blankCertificateFile).data;
+
+  for (const [index, { image, width, height }] of renderedImages.entries()) {
+    const isCertificate = index === renderedImages.length - 1;
+
+    const diff = new PNG({ width, height });
+
+    const storedImage = PNG.sync.read(images[index]).data;
+
+    const newImage = PNG.sync.read(image).data;
+
+    const oldImage = isCertificate ? blankCertificateImage : storedImage;
+
+    const comparison = pixelMatch(
+      new Uint8Array(oldImage),
+      new Uint8Array(newImage),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      diff.data as unknown as Uint8Array,
+      width,
+      height,
+      {
+        threshold: 0.25,
+        // includeAA: true, // This allows stricter testing.
+      },
+    );
+    console.log(`${id}-${index}: ${comparison}`);
+
+    const diffFilePath = path.join(testInfo.outputPath(), `${id}-${index}-diff.png`);
+    const oldFilePath = path.join(testInfo.outputPath(), `${id}-${index}-old.png`);
+    const newFilePath = path.join(testInfo.outputPath(), `${id}-${index}-new.png`);
+
+    fs.writeFileSync(diffFilePath, new Uint8Array(PNG.sync.write(diff)));
+    fs.writeFileSync(oldFilePath, new Uint8Array(images[index]));
+    fs.writeFileSync(newFilePath, new Uint8Array(image));
+
+    if (isCertificate) {
+      // Expect the certificate to NOT be blank. Since the storedImage is blank.
+      expect.soft(comparison).toBeGreaterThan(20000);
+    } else {
+      expect.soft(comparison).toEqual(0);
+    }
+  }
+};

packages/app-tests/e2e/templates/direct-templates.spec.ts

@@ -1,9 +1,12 @@
 import { expect, test } from '@playwright/test';
+import { DocumentSigningOrder, RecipientRole } from '@prisma/client';
 import { customAlphabet } from 'nanoid';
 
 import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
 import { createDocumentAuthOptions } from '@documenso/lib/utils/document-auth';
+import { mapSecondaryIdToTemplateId } from '@documenso/lib/utils/envelope';
 import { formatDirectTemplatePath } from '@documenso/lib/utils/templates';
+import { prisma } from '@documenso/prisma';
 import { seedTeam } from '@documenso/prisma/seed/teams';
 import { seedDirectTemplate, seedTemplate } from '@documenso/prisma/seed/templates';
 import { seedTestEmail, seedUser } from '@documenso/prisma/seed/users';
@@ -121,7 +124,7 @@ test('[DIRECT_TEMPLATES]: delete direct template link', async ({ page }) => {
   await expect(page.getByText('404 not found')).toBeVisible();
 });
 
-test('[DIRECT_TEMPLATES]: direct template link auth access', async ({ page }) => {
+test('[DIRECT_TEMPLATES]: V1 direct template link auth access', async ({ page }) => {
   const { user, team } = await seedUser();
 
   const directTemplateWithAuth = await seedDirectTemplate({
@@ -153,6 +156,53 @@ test('[DIRECT_TEMPLATES]: direct template link auth access', async ({ page }) =>
 
   await expect(page.getByRole('heading', { name: 'General' })).toBeVisible();
   await expect(page.getByLabel('Email')).toBeDisabled();
+
+  await page.getByRole('button', { name: 'Continue' }).click();
+  await page.getByRole('button', { name: 'Complete' }).click();
+
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(/\/sign/);
+  await expect(page.getByRole('heading', { name: 'Document Signed' })).toBeVisible();
+});
+
+test('[DIRECT_TEMPLATES]: V2 direct template link auth access', async ({ page }) => {
+  const { user, team } = await seedUser();
+
+  const directTemplateWithAuth = await seedDirectTemplate({
+    title: 'Personal direct template link',
+    userId: user.id,
+    teamId: team.id,
+    internalVersion: 2,
+    createTemplateOptions: {
+      authOptions: createDocumentAuthOptions({
+        globalAccessAuth: ['ACCOUNT'],
+        globalActionAuth: [],
+      }),
+    },
+  });
+
+  const directTemplatePath = formatDirectTemplatePath(
+    directTemplateWithAuth.directLink?.token || '',
+  );
+
+  await page.goto(directTemplatePath);
+
+  await expect(page.getByText('Authentication required')).toBeVisible();
+
+  await apiSignin({
+    page,
+    email: user.email,
+  });
+
+  await page.goto(directTemplatePath);
+
+  await expect(page.getByRole('heading', { name: 'Personal direct template link' })).toBeVisible();
+  await page.getByRole('button', { name: 'Complete' }).click();
+  await expect(page.getByLabel('Your Email')).not.toBeVisible();
+
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(/\/sign/);
+  await expect(page.getByRole('heading', { name: 'Document Signed' })).toBeVisible();
 });
 
 test('[DIRECT_TEMPLATES]: use direct template link with 1 recipient', async ({ page }) => {
@@ -175,6 +225,9 @@ test('[DIRECT_TEMPLATES]: use direct template link with 1 recipient', async ({ p
   await page.getByPlaceholder('recipient@documenso.com').fill(seedTestEmail());
 
   await page.getByRole('button', { name: 'Continue' }).click();
+
+  await expect(page.getByText('Next Recipient Name')).not.toBeVisible();
+
   await page.getByRole('button', { name: 'Complete' }).click();
   await page.getByRole('button', { name: 'Sign' }).click();
   await page.waitForURL(/\/sign/);
@@ -183,3 +236,173 @@ test('[DIRECT_TEMPLATES]: use direct template link with 1 recipient', async ({ p
   // Add a longer waiting period to ensure document status is updated
   await page.waitForTimeout(3000);
 });
+
+test('[DIRECT_TEMPLATES]: V1 use direct template link with 2 recipients with next signer dictation', async ({
+  page,
+}) => {
+  const { team, owner, organisation } = await seedTeam({
+    createTeamMembers: 1,
+  });
+
+  // Should be visible to team members.
+  const template = await seedDirectTemplate({
+    title: 'Team direct template link 1',
+    userId: owner.id,
+    teamId: team.id,
+  });
+
+  await prisma.documentMeta.update({
+    where: {
+      id: template.documentMetaId,
+    },
+    data: {
+      allowDictateNextSigner: true,
+      signingOrder: DocumentSigningOrder.SEQUENTIAL,
+    },
+  });
+
+  const originalName = 'Signer 2';
+  const originalSecondSignerEmail = seedTestEmail();
+
+  // Add another signer
+  await prisma.recipient.create({
+    data: {
+      signingOrder: 2,
+      envelopeId: template.id,
+      email: originalSecondSignerEmail,
+      name: originalName,
+      token: Math.random().toString().slice(2, 7),
+      role: RecipientRole.SIGNER,
+    },
+  });
+
+  // Check that the direct template link is accessible.
+  await page.goto(formatDirectTemplatePath(template.directLink?.token || ''));
+  await expect(page.getByRole('heading', { name: 'General' })).toBeVisible();
+
+  await page.waitForTimeout(100);
+  await page.getByPlaceholder('recipient@documenso.com').fill(seedTestEmail());
+
+  await page.getByRole('button', { name: 'Continue' }).click();
+  await page.getByRole('button', { name: 'Complete' }).click();
+
+  await expect(page.getByText('Next Recipient Name')).toBeVisible();
+
+  const nextRecipientNameInputValue = await page.getByLabel('Next Recipient Name').inputValue();
+  expect(nextRecipientNameInputValue).toBe(originalName);
+
+  const nextRecipientEmailInputValue = await page.getByLabel('Next Recipient Email').inputValue();
+  expect(nextRecipientEmailInputValue).toBe(originalSecondSignerEmail);
+
+  const newName = 'Hello';
+  const newSecondSignerEmail = seedTestEmail();
+
+  await page.getByLabel('Next Recipient Email').fill(newSecondSignerEmail);
+  await page.getByLabel('Next Recipient Name').fill(newName);
+
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(/\/sign/);
+  await expect(page.getByRole('heading', { name: 'Document Signed' })).toBeVisible();
+
+  const createdEnvelopeRecipients = await prisma.recipient.findMany({
+    where: {
+      envelope: {
+        templateId: mapSecondaryIdToTemplateId(template.secondaryId),
+      },
+    },
+  });
+
+  const updatedSecondRecipient = createdEnvelopeRecipients.find(
+    (recipient) => recipient.signingOrder === 2,
+  );
+
+  expect(updatedSecondRecipient?.name).toBe(newName);
+  expect(updatedSecondRecipient?.email).toBe(newSecondSignerEmail);
+});
+
+test('[DIRECT_TEMPLATES]: V2 use direct template link with 2 recipients with next signer dictation', async ({
+  page,
+}) => {
+  const { team, owner, organisation } = await seedTeam({
+    createTeamMembers: 1,
+  });
+
+  // Should be visible to team members.
+  const template = await seedDirectTemplate({
+    title: 'Team direct template link 1',
+    userId: owner.id,
+    teamId: team.id,
+    internalVersion: 2,
+  });
+
+  await prisma.documentMeta.update({
+    where: {
+      id: template.documentMetaId,
+    },
+    data: {
+      allowDictateNextSigner: true,
+      signingOrder: DocumentSigningOrder.SEQUENTIAL,
+    },
+  });
+
+  const originalName = 'Signer 2';
+  const originalSecondSignerEmail = seedTestEmail();
+
+  // Add another signer
+  await prisma.recipient.create({
+    data: {
+      signingOrder: 2,
+      envelopeId: template.id,
+      email: originalSecondSignerEmail,
+      name: originalName,
+      token: Math.random().toString().slice(2, 7),
+      role: RecipientRole.SIGNER,
+    },
+  });
+
+  // Check that the direct template link is accessible.
+  await page.goto(formatDirectTemplatePath(template.directLink?.token || ''));
+  await expect(page.getByRole('heading', { name: 'Team direct template link 1' })).toBeVisible();
+  await page.waitForTimeout(100);
+
+  await page.getByRole('button', { name: 'Complete' }).click();
+
+  const currentName = 'John Doe';
+  const currentEmail = seedTestEmail();
+
+  await page.getByPlaceholder('Enter Your Name').fill(currentName);
+  await page.getByPlaceholder('Enter Your Email').fill(currentEmail);
+
+  await expect(page.getByText('Next Recipient Name')).toBeVisible();
+
+  const nextRecipientNameInputValue = await page.getByLabel('Next Recipient Name').inputValue();
+  expect(nextRecipientNameInputValue).toBe(originalName);
+
+  const nextRecipientEmailInputValue = await page.getByLabel('Next Recipient Email').inputValue();
+  expect(nextRecipientEmailInputValue).toBe(originalSecondSignerEmail);
+
+  const newName = 'Hello';
+  const newSecondSignerEmail = seedTestEmail();
+
+  await page.getByLabel('Next Recipient Email').fill(newSecondSignerEmail);
+  await page.getByLabel('Next Recipient Name').fill(newName);
+
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(/\/sign/);
+  await expect(page.getByRole('heading', { name: 'Document Signed' })).toBeVisible();
+
+  const createdEnvelopeRecipients = await prisma.recipient.findMany({
+    where: {
+      envelope: {
+        templateId: mapSecondaryIdToTemplateId(template.secondaryId),
+      },
+    },
+  });
+
+  const updatedSecondRecipient = createdEnvelopeRecipients.find(
+    (recipient) => recipient.signingOrder === 2,
+  );
+
+  expect(updatedSecondRecipient?.name).toBe(newName);
+  expect(updatedSecondRecipient?.email).toBe(newSecondSignerEmail);
+});

packages/app-tests/package.json

@@ -15,7 +15,10 @@
     "@documenso/lib": "*",
     "@documenso/prisma": "*",
     "@playwright/test": "1.52.0",
-    "@types/node": "^20"
+    "@types/node": "^20",
+    "@types/pngjs": "^6.0.5",
+    "pixelmatch": "^7.1.0",
+    "pngjs": "^7.0.0"
   },
   "dependencies": {
     "start-server-and-test": "^2.0.12"

packages/lib/client-only/providers/envelope-editor-provider.tsx

@@ -215,7 +215,6 @@ export const EnvelopeEditorProvider = ({
   } = useEnvelopeAutosave(async (envelopeUpdates: UpdateEnvelopePayload) => {
     await envelopeUpdateMutationQuery.mutateAsync({
       envelopeId: envelope.id,
-      envelopeType: envelope.type,
       data: envelopeUpdates.data,
       meta: envelopeUpdates.meta,
     });

packages/lib/server-only/document/get-stats.ts

@@ -1,7 +1,5 @@
-import { EnvelopeType, TeamMemberRole } from '@prisma/client';
 import type { Prisma, User } from '@prisma/client';
-import { SigningStatus } from '@prisma/client';
-import { DocumentVisibility } from '@prisma/client';
+import { DocumentVisibility, EnvelopeType, SigningStatus, TeamMemberRole } from '@prisma/client';
 import { DateTime } from 'luxon';
 import { match } from 'ts-pattern';
 
@@ -215,13 +213,14 @@ const getTeamCounts = async (options: GetTeamCountsOption) => {
     ],
   };
 
+  const rootPageFilter = folderId === undefined ? { folderId: null } : {};
+
   let ownerCountsWhereInput: Prisma.EnvelopeWhereInput = {
     type: EnvelopeType.DOCUMENT,
     userId: userIdWhereClause,
     createdAt,
     teamId,
     deletedAt: null,
-    folderId,
   };
 
   let notSignedCountsGroupByArgs = null;
@@ -265,8 +264,16 @@ const getTeamCounts = async (options: GetTeamCountsOption) => {
 
   ownerCountsWhereInput = {
     ...ownerCountsWhereInput,
-    ...visibilityFiltersWhereInput,
-    ...searchFilter,
+    AND: [
+      ...(Array.isArray(visibilityFiltersWhereInput.AND)
+        ? visibilityFiltersWhereInput.AND
+        : visibilityFiltersWhereInput.AND
+          ? [visibilityFiltersWhereInput.AND]
+          : []),
+      searchFilter,
+      rootPageFilter,
+      folderId ? { folderId } : {},
+    ],
   };
 
   if (teamEmail) {
@@ -285,6 +292,7 @@ const getTeamCounts = async (options: GetTeamCountsOption) => {
         },
       ],
       deletedAt: null,
+      AND: [searchFilter, rootPageFilter, folderId ? { folderId } : {}],
     };
 
     notSignedCountsGroupByArgs = {
@@ -296,7 +304,6 @@ const getTeamCounts = async (options: GetTeamCountsOption) => {
         type: EnvelopeType.DOCUMENT,
         userId: userIdWhereClause,
         createdAt,
-        folderId,
         status: ExtendedDocumentStatus.PENDING,
         recipients: {
           some: {
@@ -306,6 +313,7 @@ const getTeamCounts = async (options: GetTeamCountsOption) => {
           },
         },
         deletedAt: null,
+        AND: [searchFilter, rootPageFilter, folderId ? { folderId } : {}],
       },
     } satisfies Prisma.EnvelopeGroupByArgs;
 
@@ -318,7 +326,6 @@ const getTeamCounts = async (options: GetTeamCountsOption) => {
         type: EnvelopeType.DOCUMENT,
         userId: userIdWhereClause,
         createdAt,
-        folderId,
         OR: [
           {
             status: ExtendedDocumentStatus.PENDING,
@@ -342,6 +349,7 @@ const getTeamCounts = async (options: GetTeamCountsOption) => {
             },
           },
         ],
+        AND: [searchFilter, rootPageFilter, folderId ? { folderId } : {}],
       },
     } satisfies Prisma.EnvelopeGroupByArgs;
   }

packages/lib/server-only/document/handle-document-ownership-on-deletion.ts

@@ -1,84 +0,0 @@
-import { deletedAccountServiceAccount } from '@documenso/lib/server-only/user/service-accounts/deleted-account';
-import { prisma } from '@documenso/prisma';
-import { DocumentStatus } from '@documenso/prisma/client';
-
-type HandleDocumentOwnershipOnDeletionOptions = {
-  documentIds: number[];
-  organisationOwnerId: number;
-};
-
-export const handleDocumentOwnershipOnDeletion = async ({
-  documentIds,
-  organisationOwnerId,
-}: HandleDocumentOwnershipOnDeletionOptions) => {
-  if (documentIds.length === 0) {
-    return;
-  }
-
-  const serviceAccount = await deletedAccountServiceAccount();
-  const serviceAccountTeam = serviceAccount.ownedOrganisations[0].teams[0];
-
-  await prisma.document.deleteMany({
-    where: {
-      id: {
-        in: documentIds,
-      },
-      status: DocumentStatus.DRAFT,
-    },
-  });
-
-  const organisationOwner = await prisma.user.findUnique({
-    where: {
-      id: organisationOwnerId,
-    },
-    select: {
-      id: true,
-      ownedOrganisations: {
-        select: {
-          id: true,
-          teams: {
-            select: {
-              id: true,
-            },
-          },
-        },
-      },
-    },
-  });
-
-  if (organisationOwner && organisationOwner.ownedOrganisations.length > 0) {
-    const ownerPersonalTeam = organisationOwner.ownedOrganisations[0].teams[0];
-
-    await prisma.document.updateMany({
-      where: {
-        id: {
-          in: documentIds,
-        },
-        status: {
-          in: [DocumentStatus.PENDING, DocumentStatus.REJECTED, DocumentStatus.COMPLETED],
-        },
-      },
-      data: {
-        userId: organisationOwner.id,
-        teamId: ownerPersonalTeam.id,
-        deletedAt: new Date(),
-      },
-    });
-  } else {
-    await prisma.document.updateMany({
-      where: {
-        id: {
-          in: documentIds,
-        },
-        status: {
-          in: [DocumentStatus.PENDING, DocumentStatus.REJECTED, DocumentStatus.COMPLETED],
-        },
-      },
-      data: {
-        userId: serviceAccount.id,
-        teamId: serviceAccountTeam.id,
-        deletedAt: new Date(),
-      },
-    });
-  }
-};

packages/lib/server-only/document/send-document.ts

@@ -20,7 +20,12 @@ import { validateCheckboxLength } from '../../advanced-fields-validation/validat
 import { AppError, AppErrorCode } from '../../errors/app-error';
 import { jobs } from '../../jobs/client';
 import { extractDerivedDocumentEmailSettings } from '../../types/document-email';
-import { ZCheckboxFieldMeta, ZDropdownFieldMeta, ZRadioFieldMeta } from '../../types/field-meta';
+import {
+  ZCheckboxFieldMeta,
+  ZDropdownFieldMeta,
+  ZFieldAndMetaSchema,
+  ZRadioFieldMeta,
+} from '../../types/field-meta';
 import {
   ZWebhookDocumentSchema,
   mapEnvelopeToWebhookDocumentPayload,
@@ -174,9 +179,20 @@ export const sendDocument = async ({
 
   const fieldsToAutoInsert: { fieldId: number; customText: string }[] = [];
 
-  // Auto insert radio and checkboxes that have default values.
+  // Validate and autoinsert fields for V2 envelopes.
   if (envelope.internalVersion === 2) {
-    for (const field of envelope.fields) {
+    for (const unknownField of envelope.fields) {
+      const parsedField = ZFieldAndMetaSchema.safeParse(unknownField);
+
+      if (parsedField.error) {
+        throw new AppError(AppErrorCode.INVALID_REQUEST, {
+          message: 'One or more fields have invalid metadata. Error: ' + parsedField.error.message,
+        });
+      }
+
+      const field = parsedField.data;
+      const fieldId = unknownField.id;
+
       if (field.type === FieldType.RADIO) {
         const { values = [] } = ZRadioFieldMeta.parse(field.fieldMeta);
 
@@ -184,7 +200,7 @@ export const sendDocument = async ({
 
         if (checkedItemIndex !== -1) {
           fieldsToAutoInsert.push({
-            fieldId: field.id,
+            fieldId,
             customText: toRadioCustomText(checkedItemIndex),
           });
         }
@@ -195,7 +211,7 @@ export const sendDocument = async ({
 
         if (defaultValue && values.some((value) => value.value === defaultValue)) {
           fieldsToAutoInsert.push({
-            fieldId: field.id,
+            fieldId,
             customText: defaultValue,
           });
         }
@@ -236,7 +252,7 @@ export const sendDocument = async ({
 
         if (isValid) {
           fieldsToAutoInsert.push({
-            fieldId: field.id,
+            fieldId,
             customText: toCheckboxCustomText(checkedIndices),
           });
         }

packages/lib/server-only/envelope/get-envelope-for-direct-template-signing.ts

@@ -1,10 +1,11 @@
 import { DocumentStatus, EnvelopeType } from '@prisma/client';
+import { match } from 'ts-pattern';
 
 import { prisma } from '@documenso/prisma';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
-import type { TDocumentAuthMethods } from '../../types/document-auth';
-import { isRecipientAuthorized } from '../document/is-recipient-authorized';
+import { DocumentAccessAuth, type TDocumentAuthMethods } from '../../types/document-auth';
+import { extractDocumentAuthMethods } from '../../utils/document-auth';
 import { getTeamSettings } from '../team/get-team-settings';
 import type { EnvelopeForSigningResponse } from './get-envelope-for-recipient-signing';
 import { ZEnvelopeForSigningResponse } from './get-envelope-for-recipient-signing';
@@ -98,14 +99,28 @@ export const getEnvelopeForDirectTemplateSigning = async ({
     });
   }
 
-  const documentAccessValid = await isRecipientAuthorized({
-    type: 'ACCESS',
-    documentAuthOptions: envelope.authOptions,
-    recipient,
-    userId,
-    authOptions: accessAuth,
+  // Currently not using this since for direct templates "User" access means they just need to be
+  // logged in.
+  // const documentAccessValid = await isRecipientAuthorized({
+  //   type: 'ACCESS',
+  //   documentAuthOptions: envelope.authOptions,
+  //   recipient,
+  //   userId,
+  //   authOptions: accessAuth,
+  // });
+
+  const { derivedRecipientAccessAuth } = extractDocumentAuthMethods({
+    documentAuth: envelope.authOptions,
   });
 
+  // Ensure typesafety when we add more options.
+  const documentAccessValid = derivedRecipientAccessAuth.every((auth) =>
+    match(auth)
+      .with(DocumentAccessAuth.ACCOUNT, () => Boolean(userId))
+      .with(DocumentAccessAuth.TWO_FACTOR_AUTH, () => true)
+      .exhaustive(),
+  );
+
   if (!documentAccessValid) {
     throw new AppError(AppErrorCode.UNAUTHORIZED, {
       message: 'Invalid access values',

packages/lib/server-only/envelope/get-envelope-required-access-data.ts

@@ -54,54 +54,3 @@ export const getEnvelopeRequiredAccessData = async ({ token }: { token: string }
     recipientHasAccount: Boolean(recipientUserAccount),
   } as const;
 };
-
-export const getEnvelopeDirectTemplateRequiredAccessData = async ({ token }: { token: string }) => {
-  const envelope = await prisma.envelope.findFirst({
-    where: {
-      type: EnvelopeType.TEMPLATE,
-      directLink: {
-        enabled: true,
-        token,
-      },
-      status: DocumentStatus.DRAFT,
-    },
-    include: {
-      recipients: {
-        where: {
-          token,
-        },
-      },
-      directLink: true,
-    },
-  });
-
-  if (!envelope) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Envelope not found',
-    });
-  }
-
-  const recipient = envelope.recipients.find(
-    (r) => r.id === envelope.directLink?.directTemplateRecipientId,
-  );
-
-  if (!recipient) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Recipient not found',
-    });
-  }
-
-  const recipientUserAccount = await prisma.user.findFirst({
-    where: {
-      email: recipient.email.toLowerCase(),
-    },
-    select: {
-      id: true,
-    },
-  });
-
-  return {
-    recipientEmail: recipient.email,
-    recipientHasAccount: Boolean(recipientUserAccount),
-  } as const;
-};

packages/lib/server-only/field/create-envelope-fields.ts

@@ -26,9 +26,9 @@ export interface CreateEnvelopeFieldsOptions {
     envelopeItemId?: string;
 
     recipientId: number;
-    pageNumber: number;
-    pageX: number;
-    pageY: number;
+    page: number;
+    positionX: number;
+    positionY: number;
     width: number;
     height: number;
   })[];
@@ -122,9 +122,9 @@ export const createEnvelopeFields = async ({
     const newlyCreatedFields = await tx.field.createManyAndReturn({
       data: validatedFields.map((field) => ({
         type: field.type,
-        page: field.pageNumber,
-        positionX: field.pageX,
-        positionY: field.pageY,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
         width: field.width,
         height: field.height,
         customText: '',

packages/lib/server-only/field/get-field-by-id.ts

@@ -11,7 +11,7 @@ export type GetFieldByIdOptions = {
   userId: number;
   teamId: number;
   fieldId: number;
-  envelopeType: EnvelopeType;
+  envelopeType?: EnvelopeType;
 };
 
 export const getFieldById = async ({
@@ -41,7 +41,7 @@ export const getFieldById = async ({
       type: 'envelopeId',
       id: field.envelopeId,
     },
-    type: envelopeType,
+    type: envelopeType ?? null,
     userId,
     teamId,
   });

packages/lib/server-only/field/set-fields-for-document.ts

@@ -158,7 +158,7 @@ export const setFieldsForDocument = async ({
           const numberFieldParsedMeta = ZNumberFieldMeta.parse(field.fieldMeta);
 
           const errors = validateNumberField(
-            String(numberFieldParsedMeta.value),
+            String(numberFieldParsedMeta.value || ''),
             numberFieldParsedMeta,
             false,
           );

packages/lib/server-only/field/update-envelope-fields.ts

@@ -10,18 +10,21 @@ import {
 import { prisma } from '@documenso/prisma';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
+import { type EnvelopeIdOptions } from '../../utils/envelope';
 import { mapFieldToLegacyField } from '../../utils/fields';
 import { canRecipientFieldsBeModified } from '../../utils/recipients';
 import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface UpdateDocumentFieldsOptions {
+export interface UpdateEnvelopeFieldsOptions {
   userId: number;
   teamId: number;
-  documentId: number;
+  id: EnvelopeIdOptions;
+  type?: EnvelopeType | null; // Only used to enforce the type.
   fields: {
     id: number;
     type?: FieldType;
     pageNumber?: number;
+    envelopeItemId?: string;
     pageX?: number;
     pageY?: number;
     width?: number;
@@ -31,19 +34,17 @@ export interface UpdateDocumentFieldsOptions {
   requestMetadata: ApiRequestMetadata;
 }
 
-export const updateDocumentFields = async ({
+export const updateEnvelopeFields = async ({
   userId,
   teamId,
-  documentId,
+  id,
+  type = null,
   fields,
   requestMetadata,
-}: UpdateDocumentFieldsOptions) => {
+}: UpdateEnvelopeFieldsOptions) => {
   const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'documentId',
-      id: documentId,
-    },
-    type: EnvelopeType.DOCUMENT,
+    id,
+    type,
     userId,
     teamId,
   });
@@ -53,18 +54,19 @@ export const updateDocumentFields = async ({
     include: {
       recipients: true,
       fields: true,
+      envelopeItems: true,
     },
   });
 
   if (!envelope) {
     throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
+      message: 'Envelope not found',
     });
   }
 
   if (envelope.completedAt) {
     throw new AppError(AppErrorCode.INVALID_REQUEST, {
-      message: 'Document already complete',
+      message: 'Envelope already complete',
     });
   }
 
@@ -96,6 +98,29 @@ export const updateDocumentFields = async ({
       });
     }
 
+    const fieldType = field.type || originalField.type;
+    const fieldMetaType = field.fieldMeta?.type || originalField.fieldMeta?.type;
+
+    // Not going to mess with V1 envelopes.
+    if (
+      envelope.internalVersion === 2 &&
+      fieldMetaType &&
+      fieldMetaType.toLowerCase() !== fieldType.toLowerCase()
+    ) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Field meta type does not match the field type',
+      });
+    }
+
+    if (
+      field.envelopeItemId &&
+      !envelope.envelopeItems.some((item) => item.id === field.envelopeItemId)
+    ) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Envelope item not found',
+      });
+    }
+
     return {
       originalField,
       updateData: field,
@@ -118,12 +143,14 @@ export const updateDocumentFields = async ({
             width: updateData.width,
             height: updateData.height,
             fieldMeta: updateData.fieldMeta,
+            envelopeItemId: updateData.envelopeItemId,
           },
         });
 
+        // Handle field updated audit log.
+        if (envelope.type === EnvelopeType.DOCUMENT) {
           const changes = diffFieldChanges(originalField, updatedField);
 
-        // Handle field updated audit log.
           if (changes.length > 0) {
             await tx.documentAuditLog.create({
               data: createDocumentAuditLogData({
@@ -140,6 +167,7 @@ export const updateDocumentFields = async ({
               }),
             });
           }
+        }
 
         return updatedField;
       }),

packages/lib/server-only/field/update-template-fields.ts

@@ -1,116 +0,0 @@
-import { EnvelopeType, type FieldType } from '@prisma/client';
-
-import type { TFieldMetaSchema } from '@documenso/lib/types/field-meta';
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { mapFieldToLegacyField } from '../../utils/fields';
-import { canRecipientFieldsBeModified } from '../../utils/recipients';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface UpdateTemplateFieldsOptions {
-  userId: number;
-  teamId: number;
-  templateId: number;
-  fields: {
-    id: number;
-    type?: FieldType;
-    pageNumber?: number;
-    pageX?: number;
-    pageY?: number;
-    width?: number;
-    height?: number;
-    fieldMeta?: TFieldMetaSchema;
-  }[];
-}
-
-export const updateTemplateFields = async ({
-  userId,
-  teamId,
-  templateId,
-  fields,
-}: UpdateTemplateFieldsOptions) => {
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'templateId',
-      id: templateId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  const envelope = await prisma.envelope.findFirst({
-    where: envelopeWhereInput,
-    include: {
-      recipients: true,
-      fields: true,
-    },
-  });
-
-  if (!envelope) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
-    });
-  }
-
-  const fieldsToUpdate = fields.map((field) => {
-    const originalField = envelope.fields.find((existingField) => existingField.id === field.id);
-
-    if (!originalField) {
-      throw new AppError(AppErrorCode.NOT_FOUND, {
-        message: `Field with id ${field.id} not found`,
-      });
-    }
-
-    const recipient = envelope.recipients.find(
-      (recipient) => recipient.id === originalField.recipientId,
-    );
-
-    // Each field MUST have a recipient associated with it.
-    if (!recipient) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message: `Recipient attached to field ${field.id} not found`,
-      });
-    }
-
-    // Check whether the recipient associated with the field can be modified.
-    if (!canRecipientFieldsBeModified(recipient, envelope.fields)) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message:
-          'Cannot modify a field where the recipient has already interacted with the document',
-      });
-    }
-
-    return {
-      updateData: field,
-    };
-  });
-
-  const updatedFields = await prisma.$transaction(async (tx) => {
-    return await Promise.all(
-      fieldsToUpdate.map(async ({ updateData }) => {
-        const updatedField = await tx.field.update({
-          where: {
-            id: updateData.id,
-          },
-          data: {
-            type: updateData.type,
-            page: updateData.pageNumber,
-            positionX: updateData.pageX,
-            positionY: updateData.pageY,
-            width: updateData.width,
-            height: updateData.height,
-            fieldMeta: updateData.fieldMeta,
-          },
-        });
-
-        return updatedField;
-      }),
-    );
-  });
-
-  return {
-    fields: updatedFields.map((field) => mapFieldToLegacyField(field, envelope)),
-  };
-};

packages/lib/server-only/recipient/create-envelope-recipients.ts

@@ -15,7 +15,7 @@ import type { EnvelopeIdOptions } from '../../utils/envelope';
 import { mapRecipientToLegacyRecipient } from '../../utils/recipients';
 import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface CreateDocumentRecipientsOptions {
+export interface CreateEnvelopeRecipientsOptions {
   userId: number;
   teamId: number;
   id: EnvelopeIdOptions;
@@ -30,16 +30,16 @@ export interface CreateDocumentRecipientsOptions {
   requestMetadata: ApiRequestMetadata;
 }
 
-export const createDocumentRecipients = async ({
+export const createEnvelopeRecipients = async ({
   userId,
   teamId,
   id,
   recipients: recipientsToCreate,
   requestMetadata,
-}: CreateDocumentRecipientsOptions) => {
+}: CreateEnvelopeRecipientsOptions) => {
   const { envelopeWhereInput } = await getEnvelopeWhereInput({
     id,
-    type: EnvelopeType.DOCUMENT,
+    type: null,
     userId,
     teamId,
   });
@@ -62,13 +62,13 @@ export const createDocumentRecipients = async ({
 
   if (!envelope) {
     throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
+      message: 'Envelope not found',
     });
   }
 
   if (envelope.completedAt) {
     throw new AppError(AppErrorCode.INVALID_REQUEST, {
-      message: 'Document already complete',
+      message: 'Envelope already complete',
     });
   }
 
@@ -112,6 +112,7 @@ export const createDocumentRecipients = async ({
         });
 
         // Handle recipient created audit log.
+        if (envelope.type === EnvelopeType.DOCUMENT) {
           await tx.documentAuditLog.create({
             data: createDocumentAuditLogData({
               type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_CREATED,
@@ -127,6 +128,7 @@ export const createDocumentRecipients = async ({
               },
             }),
           });
+        }
 
         return createdRecipient;
       }),

packages/lib/server-only/recipient/create-template-recipients.ts

@@ -1,115 +0,0 @@
-import { EnvelopeType, RecipientRole } from '@prisma/client';
-import { SendStatus, SigningStatus } from '@prisma/client';
-
-import type { TRecipientAccessAuthTypes } from '@documenso/lib/types/document-auth';
-import { type TRecipientActionAuthTypes } from '@documenso/lib/types/document-auth';
-import { nanoid } from '@documenso/lib/universal/id';
-import { createRecipientAuthOptions } from '@documenso/lib/utils/document-auth';
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { mapRecipientToLegacyRecipient } from '../../utils/recipients';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface CreateTemplateRecipientsOptions {
-  userId: number;
-  teamId: number;
-  templateId: number;
-  recipients: {
-    email: string;
-    name: string;
-    role: RecipientRole;
-    signingOrder?: number | null;
-    accessAuth?: TRecipientAccessAuthTypes[];
-    actionAuth?: TRecipientActionAuthTypes[];
-  }[];
-}
-
-export const createTemplateRecipients = async ({
-  userId,
-  teamId,
-  templateId,
-  recipients: recipientsToCreate,
-}: CreateTemplateRecipientsOptions) => {
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'templateId',
-      id: templateId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  const template = await prisma.envelope.findFirst({
-    where: envelopeWhereInput,
-    include: {
-      recipients: true,
-      team: {
-        select: {
-          organisation: {
-            select: {
-              organisationClaim: true,
-            },
-          },
-        },
-      },
-    },
-  });
-
-  if (!template) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Template not found',
-    });
-  }
-
-  const recipientsHaveActionAuth = recipientsToCreate.some(
-    (recipient) => recipient.actionAuth && recipient.actionAuth.length > 0,
-  );
-
-  // Check if user has permission to set the global action auth.
-  if (recipientsHaveActionAuth && !template.team.organisation.organisationClaim.flags.cfr21) {
-    throw new AppError(AppErrorCode.UNAUTHORIZED, {
-      message: 'You do not have permission to set the action auth',
-    });
-  }
-
-  const normalizedRecipients = recipientsToCreate.map((recipient) => ({
-    ...recipient,
-    email: recipient.email.toLowerCase(),
-  }));
-
-  const createdRecipients = await prisma.$transaction(async (tx) => {
-    return await Promise.all(
-      normalizedRecipients.map(async (recipient) => {
-        const authOptions = createRecipientAuthOptions({
-          accessAuth: recipient.accessAuth ?? [],
-          actionAuth: recipient.actionAuth ?? [],
-        });
-
-        const createdRecipient = await tx.recipient.create({
-          data: {
-            envelopeId: template.id,
-            name: recipient.name,
-            email: recipient.email,
-            role: recipient.role,
-            signingOrder: recipient.signingOrder,
-            token: nanoid(),
-            sendStatus: recipient.role === RecipientRole.CC ? SendStatus.SENT : SendStatus.NOT_SENT,
-            signingStatus:
-              recipient.role === RecipientRole.CC ? SigningStatus.SIGNED : SigningStatus.NOT_SIGNED,
-            authOptions,
-          },
-        });
-
-        return createdRecipient;
-      }),
-    );
-  });
-
-  return {
-    recipients: createdRecipients.map((recipient) =>
-      mapRecipientToLegacyRecipient(recipient, template),
-    ),
-  };
-};

packages/lib/server-only/recipient/delete-envelope-recipient.ts

@@ -14,26 +14,27 @@ import { NEXT_PUBLIC_WEBAPP_URL } from '../../constants/app';
 import { AppError, AppErrorCode } from '../../errors/app-error';
 import { extractDerivedDocumentEmailSettings } from '../../types/document-email';
 import { createDocumentAuditLogData } from '../../utils/document-audit-logs';
+import { canRecipientBeModified } from '../../utils/recipients';
 import { renderEmailWithI18N } from '../../utils/render-email-with-i18n';
 import { buildTeamWhereQuery } from '../../utils/teams';
 import { getEmailContext } from '../email/get-email-context';
+import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface DeleteDocumentRecipientOptions {
+export interface DeleteEnvelopeRecipientOptions {
   userId: number;
   teamId: number;
   recipientId: number;
   requestMetadata: ApiRequestMetadata;
 }
 
-export const deleteDocumentRecipient = async ({
+export const deleteEnvelopeRecipient = async ({
   userId,
   teamId,
   recipientId,
   requestMetadata,
-}: DeleteDocumentRecipientOptions) => {
+}: DeleteEnvelopeRecipientOptions) => {
   const envelope = await prisma.envelope.findFirst({
     where: {
-      type: EnvelopeType.DOCUMENT,
       recipients: {
         some: {
           id: recipientId,
@@ -48,6 +49,9 @@ export const deleteDocumentRecipient = async ({
         where: {
           id: recipientId,
         },
+        include: {
+          fields: true,
+        },
       },
     },
   });
@@ -89,7 +93,24 @@ export const deleteDocumentRecipient = async ({
     });
   }
 
+  if (!canRecipientBeModified(recipientToDelete, recipientToDelete.fields)) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Recipient has already interacted with the document.',
+    });
+  }
+
+  const { envelopeWhereInput } = await getEnvelopeWhereInput({
+    id: {
+      type: 'envelopeId',
+      id: envelope.id,
+    },
+    type: null,
+    userId,
+    teamId,
+  });
+
   const deletedRecipient = await prisma.$transaction(async (tx) => {
+    if (envelope.type === EnvelopeType.DOCUMENT) {
       await tx.documentAuditLog.create({
         data: createDocumentAuditLogData({
           type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_DELETED,
@@ -103,10 +124,12 @@ export const deleteDocumentRecipient = async ({
           },
         }),
       });
+    }
 
     return await tx.recipient.delete({
       where: {
         id: recipientId,
+        envelope: envelopeWhereInput,
       },
     });
   });
@@ -116,7 +139,11 @@ export const deleteDocumentRecipient = async ({
   ).recipientRemoved;
 
   // Send email to deleted recipient.
-  if (recipientToDelete.sendStatus === SendStatus.SENT && isRecipientRemovedEmailEnabled) {
+  if (
+    recipientToDelete.sendStatus === SendStatus.SENT &&
+    isRecipientRemovedEmailEnabled &&
+    envelope.type === EnvelopeType.DOCUMENT
+  ) {
     const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
 
     const template = createElement(RecipientRemovedFromDocumentTemplate, {

packages/lib/server-only/recipient/delete-template-recipient.ts

@@ -1,58 +0,0 @@
-import { EnvelopeType } from '@prisma/client';
-
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { buildTeamWhereQuery } from '../../utils/teams';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface DeleteTemplateRecipientOptions {
-  userId: number;
-  teamId: number;
-  recipientId: number;
-}
-
-export const deleteTemplateRecipient = async ({
-  userId,
-  teamId,
-  recipientId,
-}: DeleteTemplateRecipientOptions): Promise<void> => {
-  const recipientToDelete = await prisma.recipient.findFirst({
-    where: {
-      id: recipientId,
-      envelope: {
-        type: EnvelopeType.TEMPLATE,
-        team: buildTeamWhereQuery({ teamId, userId }),
-      },
-    },
-  });
-
-  if (!recipientToDelete) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Recipient not found',
-    });
-  }
-
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'envelopeId',
-      id: recipientToDelete.envelopeId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  if (!recipientToDelete || recipientToDelete.id !== recipientId) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Recipient not found',
-    });
-  }
-
-  await prisma.recipient.delete({
-    where: {
-      id: recipientId,
-      envelope: envelopeWhereInput,
-    },
-  });
-};

packages/lib/server-only/recipient/update-envelope-recipients.ts

@@ -1,5 +1,4 @@
-import { EnvelopeType, RecipientRole } from '@prisma/client';
-import { SendStatus, SigningStatus } from '@prisma/client';
+import { EnvelopeType, RecipientRole, SendStatus, SigningStatus } from '@prisma/client';
 
 import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
 import type { TRecipientAccessAuthTypes } from '@documenso/lib/types/document-auth';
@@ -16,29 +15,38 @@ import { createRecipientAuthOptions } from '@documenso/lib/utils/document-auth';
 import { prisma } from '@documenso/prisma';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
-import { type EnvelopeIdOptions, mapSecondaryIdToDocumentId } from '../../utils/envelope';
+import { extractLegacyIds } from '../../universal/id';
+import { type EnvelopeIdOptions } from '../../utils/envelope';
 import { mapFieldToLegacyField } from '../../utils/fields';
 import { canRecipientBeModified } from '../../utils/recipients';
 import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface UpdateDocumentRecipientsOptions {
+export interface UpdateEnvelopeRecipientsOptions {
   userId: number;
   teamId: number;
   id: EnvelopeIdOptions;
-  recipients: RecipientData[];
+  recipients: {
+    id: number;
+    email?: string;
+    name?: string;
+    role?: RecipientRole;
+    signingOrder?: number | null;
+    accessAuth?: TRecipientAccessAuthTypes[];
+    actionAuth?: TRecipientActionAuthTypes[];
+  }[];
   requestMetadata: ApiRequestMetadata;
 }
 
-export const updateDocumentRecipients = async ({
+export const updateEnvelopeRecipients = async ({
   userId,
   teamId,
   id,
   recipients,
   requestMetadata,
-}: UpdateDocumentRecipientsOptions) => {
+}: UpdateEnvelopeRecipientsOptions) => {
   const { envelopeWhereInput } = await getEnvelopeWhereInput({
     id,
-    type: EnvelopeType.DOCUMENT,
+    type: null,
     userId,
     teamId,
   });
@@ -62,13 +70,13 @@ export const updateDocumentRecipients = async ({
 
   if (!envelope) {
     throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
+      message: 'Envelope not found',
     });
   }
 
   if (envelope.completedAt) {
     throw new AppError(AppErrorCode.INVALID_REQUEST, {
-      message: 'Document already complete',
+      message: 'Envelope already complete',
     });
   }
 
@@ -160,9 +168,10 @@ export const updateDocumentRecipients = async ({
           });
         }
 
+        // Handle recipient updated audit log.
+        if (envelope.type === EnvelopeType.DOCUMENT) {
           const changes = diffRecipientChanges(originalRecipient, updatedRecipient);
 
-        // Handle recipient updated audit log.
           if (changes.length > 0) {
             await tx.documentAuditLog.create({
               data: createDocumentAuditLogData({
@@ -179,6 +188,7 @@ export const updateDocumentRecipients = async ({
               }),
             });
           }
+        }
 
         return updatedRecipient;
       }),
@@ -188,19 +198,8 @@ export const updateDocumentRecipients = async ({
   return {
     recipients: updatedRecipients.map((recipient) => ({
       ...recipient,
-      documentId: mapSecondaryIdToDocumentId(envelope.secondaryId),
-      templateId: null,
+      ...extractLegacyIds(envelope),
       fields: recipient.fields.map((field) => mapFieldToLegacyField(field, envelope)),
     })),
   };
 };
-
-type RecipientData = {
-  id: number;
-  email?: string;
-  name?: string;
-  role?: RecipientRole;
-  signingOrder?: number | null;
-  accessAuth?: TRecipientAccessAuthTypes[];
-  actionAuth?: TRecipientActionAuthTypes[];
-};

packages/lib/server-only/recipient/update-template-recipients.ts

@@ -1,168 +0,0 @@
-import { EnvelopeType, RecipientRole } from '@prisma/client';
-import { SendStatus, SigningStatus } from '@prisma/client';
-
-import type { TRecipientAccessAuthTypes } from '@documenso/lib/types/document-auth';
-import {
-  type TRecipientActionAuthTypes,
-  ZRecipientAuthOptionsSchema,
-} from '@documenso/lib/types/document-auth';
-import { createRecipientAuthOptions } from '@documenso/lib/utils/document-auth';
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { mapSecondaryIdToTemplateId } from '../../utils/envelope';
-import { mapFieldToLegacyField } from '../../utils/fields';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface UpdateTemplateRecipientsOptions {
-  userId: number;
-  teamId: number;
-  templateId: number;
-  recipients: {
-    id: number;
-    email?: string;
-    name?: string;
-    role?: RecipientRole;
-    signingOrder?: number | null;
-    accessAuth?: TRecipientAccessAuthTypes[];
-    actionAuth?: TRecipientActionAuthTypes[];
-  }[];
-}
-
-export const updateTemplateRecipients = async ({
-  userId,
-  teamId,
-  templateId,
-  recipients,
-}: UpdateTemplateRecipientsOptions) => {
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'templateId',
-      id: templateId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  const envelope = await prisma.envelope.findFirst({
-    where: envelopeWhereInput,
-    include: {
-      recipients: true,
-      team: {
-        select: {
-          organisation: {
-            select: {
-              organisationClaim: true,
-            },
-          },
-        },
-      },
-    },
-  });
-
-  if (!envelope) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Template not found',
-    });
-  }
-
-  const recipientsHaveActionAuth = recipients.some(
-    (recipient) => recipient.actionAuth && recipient.actionAuth.length > 0,
-  );
-
-  // Check if user has permission to set the global action auth.
-  if (recipientsHaveActionAuth && !envelope.team.organisation.organisationClaim.flags.cfr21) {
-    throw new AppError(AppErrorCode.UNAUTHORIZED, {
-      message: 'You do not have permission to set the action auth',
-    });
-  }
-
-  const recipientsToUpdate = recipients.map((recipient) => {
-    const originalRecipient = envelope.recipients.find(
-      (existingRecipient) => existingRecipient.id === recipient.id,
-    );
-
-    if (!originalRecipient) {
-      throw new AppError(AppErrorCode.NOT_FOUND, {
-        message: `Recipient with id ${recipient.id} not found`,
-      });
-    }
-
-    return {
-      originalRecipient,
-      recipientUpdateData: recipient,
-    };
-  });
-
-  const updatedRecipients = await prisma.$transaction(async (tx) => {
-    return await Promise.all(
-      recipientsToUpdate.map(async ({ originalRecipient, recipientUpdateData }) => {
-        let authOptions = ZRecipientAuthOptionsSchema.parse(originalRecipient.authOptions);
-
-        if (
-          recipientUpdateData.actionAuth !== undefined ||
-          recipientUpdateData.accessAuth !== undefined
-        ) {
-          authOptions = createRecipientAuthOptions({
-            accessAuth: recipientUpdateData.accessAuth || authOptions.accessAuth,
-            actionAuth: recipientUpdateData.actionAuth || authOptions.actionAuth,
-          });
-        }
-
-        const mergedRecipient = {
-          ...originalRecipient,
-          ...recipientUpdateData,
-        };
-
-        const updatedRecipient = await tx.recipient.update({
-          where: {
-            id: originalRecipient.id,
-            envelopeId: envelope.id,
-          },
-          data: {
-            name: mergedRecipient.name,
-            email: mergedRecipient.email,
-            role: mergedRecipient.role,
-            signingOrder: mergedRecipient.signingOrder,
-            envelopeId: envelope.id,
-            sendStatus:
-              mergedRecipient.role === RecipientRole.CC ? SendStatus.SENT : SendStatus.NOT_SENT,
-            signingStatus:
-              mergedRecipient.role === RecipientRole.CC
-                ? SigningStatus.SIGNED
-                : SigningStatus.NOT_SIGNED,
-            authOptions,
-          },
-          include: {
-            fields: true,
-          },
-        });
-
-        // Clear all fields if the recipient role is changed to a type that cannot have fields.
-        if (
-          originalRecipient.role !== updatedRecipient.role &&
-          (updatedRecipient.role === RecipientRole.CC ||
-            updatedRecipient.role === RecipientRole.VIEWER)
-        ) {
-          await tx.field.deleteMany({
-            where: {
-              recipientId: updatedRecipient.id,
-            },
-          });
-        }
-
-        return updatedRecipient;
-      }),
-    );
-  });
-
-  return {
-    recipients: updatedRecipients.map((recipient) => ({
-      ...recipient,
-      documentId: null,
-      templateId: mapSecondaryIdToTemplateId(envelope.secondaryId),
-      fields: recipient.fields.map((field) => mapFieldToLegacyField(field, envelope)),
-    })),
-  };
-};

packages/lib/server-only/template/create-document-from-direct-template.ts

@@ -3,6 +3,7 @@ import { createElement } from 'react';
 import { msg } from '@lingui/core/macro';
 import type { Field, Signature } from '@prisma/client';
 import {
+  DocumentSigningOrder,
   DocumentSource,
   DocumentStatus,
   EnvelopeType,
@@ -26,7 +27,7 @@ import type { TSignFieldWithTokenMutationSchema } from '@documenso/trpc/server/f
 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 { DOCUMENT_AUDIT_LOG_TYPE, RECIPIENT_DIFF_TYPE } from '../../types/document-audit-logs';
 import type { TRecipientActionAuthTypes } from '../../types/document-auth';
 import { DocumentAccessAuth, ZRecipientAuthOptionsSchema } from '../../types/document-auth';
 import { ZFieldMetaSchema } from '../../types/field-meta';
@@ -68,6 +69,10 @@ export type CreateDocumentFromDirectTemplateOptions = {
     name?: string;
     email: string;
   };
+  nextSigner?: {
+    email: string;
+    name: string;
+  };
 };
 
 type CreatedDirectRecipientField = {
@@ -92,6 +97,7 @@ export const createDocumentFromDirectTemplate = async ({
   directTemplateExternalId,
   signedFieldValues,
   templateUpdatedAt,
+  nextSigner,
   requestMetadata,
   user,
 }: CreateDocumentFromDirectTemplateOptions): Promise<TCreateDocumentFromDirectTemplateResponse> => {
@@ -128,6 +134,17 @@ export const createDocumentFromDirectTemplate = async ({
     throw new AppError(AppErrorCode.INVALID_REQUEST, { message: 'Invalid or missing template' });
   }
 
+  if (
+    nextSigner &&
+    (!directTemplateEnvelope.documentMeta?.allowDictateNextSigner ||
+      directTemplateEnvelope.documentMeta?.signingOrder !== DocumentSigningOrder.SEQUENTIAL)
+  ) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message:
+        'You need to enable allowDictateNextSigner and sequential signing to dictate the next signer',
+    });
+  }
+
   const directTemplateEnvelopeLegacyId = mapSecondaryIdToTemplateId(
     directTemplateEnvelope.secondaryId,
   );
@@ -630,6 +647,77 @@ export const createDocumentFromDirectTemplate = async ({
       }),
     ];
 
+    if (nextSigner) {
+      const pendingRecipients = await tx.recipient.findMany({
+        select: {
+          id: true,
+          signingOrder: true,
+          name: true,
+          email: true,
+          role: true,
+        },
+        where: {
+          envelopeId: createdEnvelope.id,
+          signingStatus: {
+            not: SigningStatus.SIGNED,
+          },
+          role: {
+            not: RecipientRole.CC,
+          },
+        },
+        // Composite sort so our next recipient is always the one with the lowest signing order or id
+        // if there is a tie.
+        orderBy: [{ signingOrder: { sort: 'asc', nulls: 'last' } }, { id: 'asc' }],
+      });
+
+      const nextRecipient = pendingRecipients[0];
+
+      if (nextRecipient) {
+        auditLogsToCreate.push(
+          createDocumentAuditLogData({
+            type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_UPDATED,
+            envelopeId: createdEnvelope.id,
+            user: {
+              name: user?.name || directRecipientName || '',
+              email: user?.email || directRecipientEmail,
+            },
+            metadata: requestMetadata,
+            data: {
+              recipientEmail: nextRecipient.email,
+              recipientName: nextRecipient.name,
+              recipientId: nextRecipient.id,
+              recipientRole: nextRecipient.role,
+              changes: [
+                {
+                  type: RECIPIENT_DIFF_TYPE.NAME,
+                  from: nextRecipient.name,
+                  to: nextSigner.name,
+                },
+                {
+                  type: RECIPIENT_DIFF_TYPE.EMAIL,
+                  from: nextRecipient.email,
+                  to: nextSigner.email,
+                },
+              ],
+            },
+          }),
+        );
+
+        await tx.recipient.update({
+          where: { id: nextRecipient.id },
+          data: {
+            sendStatus: SendStatus.SENT,
+            ...(nextSigner && documentMeta?.allowDictateNextSigner
+              ? {
+                  name: nextSigner.name,
+                  email: nextSigner.email,
+                }
+              : {}),
+          },
+        });
+      }
+    }
+
     await tx.documentAuditLog.createMany({
       data: auditLogsToCreate,
     });

packages/lib/server-only/user/service-accounts/deleted-account.ts

@@ -5,20 +5,6 @@ export const deletedAccountServiceAccount = async () => {
     where: {
       email: 'deleted-account@documenso.com',
     },
-    select: {
-      id: true,
-      email: true,
-      ownedOrganisations: {
-        select: {
-          id: true,
-          teams: {
-            select: {
-              id: true,
-            },
-          },
-        },
-      },
-    },
   });
 
   if (!serviceAccount) {

packages/lib/types/envelope.ts

@@ -37,11 +37,8 @@ export const ZEnvelopeSchema = EnvelopeSchema.pick({
   userId: true,
   teamId: true,
   folderId: true,
+  templateId: true,
 }).extend({
-  templateId: z
-    .number()
-    .nullish()
-    .describe('The ID of the template that the document was created from, if any.'),
   documentMeta: DocumentMetaSchema.pick({
     signingOrder: true,
     distributionMethod: true,

packages/lib/types/field-meta.ts

@@ -188,7 +188,7 @@ export type TFieldMetaSchema = z.infer<typeof ZFieldMetaSchema>;
 export const ZFieldAndMetaSchema = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(FieldType.SIGNATURE),
-    fieldMeta: z.undefined(),
+    fieldMeta: ZSignatureFieldMeta.optional(),
   }),
   z.object({
     type: z.literal(FieldType.FREE_SIGNATURE),

packages/lib/types/field.ts

@@ -50,6 +50,11 @@ export const ZFieldSchema = FieldSchema.pick({
   templateId: z.number().nullish(),
 });
 
+export const ZEnvelopeFieldSchema = ZFieldSchema.omit({
+  documentId: true,
+  templateId: true,
+});
+
 export const ZFieldPageNumberSchema = z
   .number()
   .min(1)
@@ -69,6 +74,30 @@ export const ZFieldWidthSchema = z.number().min(1).describe('The width of the fi
 
 export const ZFieldHeightSchema = z.number().min(1).describe('The height of the field.');
 
+export const ZClampedFieldPositionXSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based X coordinate where the field will be placed.');
+
+export const ZClampedFieldPositionYSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based Y coordinate where the field will be placed.');
+
+export const ZClampedFieldWidthSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based width of the field on the page.');
+
+export const ZClampedFieldHeightSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based height of the field on the page.');
+
 // ---------------------------------------------
 
 const PrismaDecimalSchema = z.preprocess(

packages/lib/types/recipient.ts

@@ -95,3 +95,18 @@ export const ZRecipientManySchema = RecipientSchema.pick({
   documentId: z.number().nullish(),
   templateId: z.number().nullish(),
 });
+
+export const ZEnvelopeRecipientSchema = ZRecipientSchema.omit({
+  documentId: true,
+  templateId: true,
+});
+
+export const ZEnvelopeRecipientLiteSchema = ZRecipientLiteSchema.omit({
+  documentId: true,
+  templateId: true,
+});
+
+export const ZEnvelopeRecipientManySchema = ZRecipientManySchema.omit({
+  documentId: true,
+  templateId: true,
+});

packages/lib/universal/field-renderer/render-checkbox-field.ts

@@ -3,6 +3,7 @@ import { match } from 'ts-pattern';
 
 import { DEFAULT_STANDARD_FONT_SIZE } from '../../constants/pdf';
 import type { TCheckboxFieldMeta } from '../../types/field-meta';
+import { parseCheckboxCustomText } from '../../utils/fields';
 import {
   createFieldHoverInteraction,
   konvaTextFill,
@@ -130,7 +131,7 @@ export const renderCheckboxFieldElement = (
     pageLayer.batchDraw();
   });
 
-  const checkedValues: number[] = field.customText ? JSON.parse(field.customText) : [];
+  const checkedValues: number[] = field.customText ? parseCheckboxCustomText(field.customText) : [];
 
   checkboxValues.forEach(({ value, checked }, index) => {
     const isCheckboxChecked = match(mode)
@@ -170,7 +171,7 @@ export const renderCheckboxFieldElement = (
       width: itemSize,
       height: itemSize,
       stroke: '#374151',
-      strokeWidth: 2,
+      strokeWidth: 1.5,
       cornerRadius: 2,
       fill: 'white',
     });

packages/lib/universal/field-renderer/render-radio-field.ts

@@ -159,7 +159,7 @@ export const renderRadioFieldElement = (
       y: itemInputY,
       radius: calculateRadioSize(fontSize) / 2,
       stroke: '#374151',
-      strokeWidth: 2,
+      strokeWidth: 1.5,
       fill: 'white',
     });
 

packages/lib/utils/fields.ts

@@ -81,6 +81,10 @@ export const mapFieldToLegacyField = (
 };
 
 export const parseCheckboxCustomText = (customText: string): number[] => {
+  if (!customText) {
+    return [];
+  }
+
   return JSON.parse(customText);
 };
 

packages/prisma/seed/initial-seed.ts

@@ -1,11 +1,22 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { formatAlignmentTestFields } from '@documenso/app-tests/constants/field-alignment-pdf';
+import { FIELD_META_TEST_FIELDS } from '@documenso/app-tests/constants/field-meta-pdf';
+import { isBase64Image } from '@documenso/lib/constants/signatures';
 import { incrementDocumentId } from '@documenso/lib/server-only/envelope/increment-id';
-import { prefixedId } from '@documenso/lib/universal/id';
+import { nanoid, prefixedId } from '@documenso/lib/universal/id';
 
 import { prisma } from '..';
-import { DocumentDataType, DocumentSource, EnvelopeType } from '../client';
+import {
+  DocumentDataType,
+  DocumentSource,
+  DocumentStatus,
+  EnvelopeType,
+  ReadStatus,
+  SendStatus,
+  SigningStatus,
+} from '../client';
 import { seedPendingDocument } from './documents';
 import { seedDirectTemplate, seedTemplate } from './templates';
 import { seedUser } from './users';
@@ -155,7 +166,6 @@ export const seedDatabase = async () => {
       userId: exampleUser.user.id,
       teamId: exampleUser.team.id,
     }),
-
     seedTemplate({
       title: 'Template 1',
       userId: adminUser.user.id,
@@ -166,5 +176,185 @@ export const seedDatabase = async () => {
       userId: adminUser.user.id,
       teamId: adminUser.team.id,
     }),
+    seedAlignmentTestDocument({
+      userId: exampleUser.user.id,
+      teamId: exampleUser.team.id,
+      recipientName: exampleUser.user.name || '',
+      recipientEmail: exampleUser.user.email,
+      insertFields: false,
+      status: DocumentStatus.DRAFT,
+    }),
+    seedAlignmentTestDocument({
+      userId: exampleUser.user.id,
+      teamId: exampleUser.team.id,
+      recipientName: exampleUser.user.name || '',
+      recipientEmail: exampleUser.user.email,
+      insertFields: true,
+      status: DocumentStatus.PENDING,
+    }),
+    seedAlignmentTestDocument({
+      userId: adminUser.user.id,
+      teamId: adminUser.team.id,
+      recipientName: adminUser.user.name || '',
+      recipientEmail: adminUser.user.email,
+      insertFields: false,
+      status: DocumentStatus.DRAFT,
+    }),
+    seedAlignmentTestDocument({
+      userId: adminUser.user.id,
+      teamId: adminUser.team.id,
+      recipientName: adminUser.user.name || '',
+      recipientEmail: adminUser.user.email,
+      insertFields: true,
+      status: DocumentStatus.PENDING,
+    }),
   ]);
 };
+
+export const seedAlignmentTestDocument = async ({
+  userId,
+  teamId,
+  recipientName,
+  recipientEmail,
+  insertFields,
+  status,
+}: {
+  userId: number;
+  teamId: number;
+  recipientName: string;
+  recipientEmail: string;
+  insertFields: boolean;
+  status: DocumentStatus;
+}) => {
+  const alignmentPdf = fs
+    .readFileSync(path.join(__dirname, '../../../assets/field-font-alignment.pdf'))
+    .toString('base64');
+
+  const fieldMetaPdf = fs
+    .readFileSync(path.join(__dirname, '../../../assets/field-meta.pdf'))
+    .toString('base64');
+
+  const alignmentDocumentData = await createDocumentData({ documentData: alignmentPdf });
+  const fieldMetaDocumentData = await createDocumentData({ documentData: fieldMetaPdf });
+
+  const documentId = await incrementDocumentId();
+
+  const documentMeta = await prisma.documentMeta.create({
+    data: {},
+  });
+
+  const createdEnvelope = await prisma.envelope.create({
+    data: {
+      id: prefixedId('envelope'),
+      secondaryId: documentId.formattedDocumentId,
+      internalVersion: 2,
+      type: EnvelopeType.DOCUMENT,
+      documentMetaId: documentMeta.id,
+      source: DocumentSource.DOCUMENT,
+      title: `Envelope Full Field Test`,
+      status,
+      envelopeItems: {
+        createMany: {
+          data: [
+            {
+              id: prefixedId('envelope_item'),
+              title: `alignment-pdf`,
+              documentDataId: alignmentDocumentData.id,
+              order: 1,
+            },
+            {
+              id: prefixedId('envelope_item'),
+              title: `field-meta-pdf`,
+              documentDataId: fieldMetaDocumentData.id,
+              order: 2,
+            },
+          ],
+        },
+      },
+      userId,
+      teamId,
+      recipients: {
+        create: {
+          name: recipientName,
+          email: recipientEmail,
+          token: nanoid(),
+          sendStatus: status === 'DRAFT' ? SendStatus.NOT_SENT : SendStatus.SENT,
+          signingStatus: status === 'COMPLETED' ? SigningStatus.SIGNED : SigningStatus.NOT_SIGNED,
+          readStatus: status !== 'DRAFT' ? ReadStatus.OPENED : ReadStatus.NOT_OPENED,
+        },
+      },
+    },
+    include: {
+      recipients: true,
+      envelopeItems: true,
+    },
+  });
+
+  const { id, recipients, envelopeItems } = createdEnvelope;
+
+  const recipientId = recipients[0].id;
+  const envelopeItemAlignmentItem = envelopeItems.find((item) => item.order === 1)?.id;
+  const envelopeItemFieldMetaItem = envelopeItems.find((item) => item.order === 2)?.id;
+
+  if (!envelopeItemAlignmentItem || !envelopeItemFieldMetaItem) {
+    throw new Error('Envelope item not found');
+  }
+
+  await Promise.all(
+    formatAlignmentTestFields.map(async (field) => {
+      await prisma.field.create({
+        data: {
+          ...field,
+          recipientId,
+          envelopeItemId: envelopeItemAlignmentItem,
+          envelopeId: id,
+          customText: insertFields ? field.customText : '',
+          inserted: insertFields,
+          signature: field.signature
+            ? {
+                create: {
+                  recipientId,
+                  signatureImageAsBase64: isBase64Image(field.signature) ? field.signature : null,
+                  typedSignature: isBase64Image(field.signature) ? null : field.signature,
+                },
+              }
+            : undefined,
+        },
+      });
+    }),
+  );
+
+  await Promise.all(
+    FIELD_META_TEST_FIELDS.map(async (field) => {
+      await prisma.field.create({
+        data: {
+          ...field,
+          recipientId,
+          envelopeItemId: envelopeItemFieldMetaItem,
+          envelopeId: id,
+          customText: insertFields ? field.customText : '',
+          inserted: insertFields,
+          signature: field.signature
+            ? {
+                create: {
+                  recipientId,
+                  signatureImageAsBase64: isBase64Image(field.signature) ? field.signature : null,
+                  typedSignature: isBase64Image(field.signature) ? null : field.signature,
+                },
+              }
+            : undefined,
+        },
+      });
+    }),
+  );
+
+  return await prisma.envelope.findFirstOrThrow({
+    where: {
+      id: createdEnvelope.id,
+    },
+    include: {
+      recipients: true,
+      envelopeItems: true,
+    },
+  });
+};

packages/prisma/seed/templates.ts

@@ -28,6 +28,7 @@ type SeedTemplateOptions = {
   title?: string;
   userId: number;
   teamId: number;
+  internalVersion?: 1 | 2;
   createTemplateOptions?: Partial<Prisma.EnvelopeUncheckedCreateInput>;
 };
 
@@ -167,7 +168,7 @@ export const seedDirectTemplate = async (options: SeedTemplateOptions) => {
     data: {
       id: prefixedId('envelope'),
       secondaryId: templateId.formattedTemplateId,
-      internalVersion: 1,
+      internalVersion: options.internalVersion ?? 1,
       type: EnvelopeType.TEMPLATE,
       title,
       envelopeItems: {
@@ -184,6 +185,7 @@ export const seedDirectTemplate = async (options: SeedTemplateOptions) => {
       teamId,
       recipients: {
         create: {
+          signingOrder: 1,
           email: DIRECT_TEMPLATE_RECIPIENT_EMAIL,
           name: DIRECT_TEMPLATE_RECIPIENT_NAME,
           token: Math.random().toString().slice(2, 7),

packages/trpc/server/admin-router/get-admin-organisation.ts

@@ -39,6 +39,11 @@ export const getAdminOrganisation = async ({ organisationId }: GetOrganisationOp
       teams: true,
       members: {
         include: {
+          organisationGroupMembers: {
+            include: {
+              group: true,
+            },
+          },
           user: {
             select: {
               id: true,

packages/trpc/server/admin-router/get-admin-organisation.types.ts

@@ -3,6 +3,8 @@ import { z } from 'zod';
 import { ZOrganisationSchema } from '@documenso/lib/types/organisation';
 import OrganisationClaimSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationClaimSchema';
 import OrganisationGlobalSettingsSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGlobalSettingsSchema';
+import OrganisationGroupMemberSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGroupMemberSchema';
+import OrganisationGroupSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGroupSchema';
 import OrganisationMemberSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationMemberSchema';
 import SubscriptionSchema from '@documenso/prisma/generated/zod/modelSchema/SubscriptionSchema';
 import TeamSchema from '@documenso/prisma/generated/zod/modelSchema/TeamSchema';
@@ -30,6 +32,18 @@ export const ZGetAdminOrganisationResponseSchema = ZOrganisationSchema.extend({
       email: true,
       name: true,
     }),
+    organisationGroupMembers: z.array(
+      OrganisationGroupMemberSchema.pick({
+        id: true,
+        groupId: true,
+      }).extend({
+        group: OrganisationGroupSchema.pick({
+          id: true,
+          type: true,
+          organisationRole: true,
+        }),
+      }),
+    ),
   }).array(),
   subscription: SubscriptionSchema.nullable(),
   organisationClaim: OrganisationClaimSchema,

packages/trpc/server/admin-router/router.ts

@@ -17,6 +17,7 @@ import { promoteMemberToOwnerRoute } from './promote-member-to-owner';
 import { resealDocumentRoute } from './reseal-document';
 import { resetTwoFactorRoute } from './reset-two-factor-authentication';
 import { updateAdminOrganisationRoute } from './update-admin-organisation';
+import { updateOrganisationMemberRoleRoute } from './update-organisation-member-role';
 import { updateRecipientRoute } from './update-recipient';
 import { updateSiteSettingRoute } from './update-site-setting';
 import { updateSubscriptionClaimRoute } from './update-subscription-claim';
@@ -31,6 +32,7 @@ export const adminRouter = router({
   },
   organisationMember: {
     promoteToOwner: promoteMemberToOwnerRoute,
+    updateRole: updateOrganisationMemberRoleRoute,
   },
   claims: {
     find: findSubscriptionClaimsRoute,

packages/trpc/server/admin-router/update-organisation-member-role.ts

@@ -0,0 +1,220 @@
+import { OrganisationGroupType, OrganisationMemberRole } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { generateDatabaseId } from '@documenso/lib/universal/id';
+import { getHighestOrganisationRoleInGroup } from '@documenso/lib/utils/organisations';
+import { prisma } from '@documenso/prisma';
+
+import { adminProcedure } from '../trpc';
+import {
+  ZUpdateOrganisationMemberRoleRequestSchema,
+  ZUpdateOrganisationMemberRoleResponseSchema,
+} from './update-organisation-member-role.types';
+
+/**
+ * Admin mutation to update organisation member role or transfer ownership.
+ *
+ * This mutation handles two scenarios:
+ * 1. When role='OWNER': Transfers organisation ownership and promotes to ADMIN
+ * 2. When role=ADMIN/MANAGER/MEMBER: Updates group membership
+ *
+ * Admin privileges bypass normal hierarchy restrictions.
+ */
+export const updateOrganisationMemberRoleRoute = adminProcedure
+  .input(ZUpdateOrganisationMemberRoleRequestSchema)
+  .output(ZUpdateOrganisationMemberRoleResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { organisationId, userId, role } = input;
+
+    ctx.logger.info({
+      input: {
+        organisationId,
+        userId,
+        role,
+      },
+    });
+
+    const organisation = await prisma.organisation.findUnique({
+      where: {
+        id: organisationId,
+      },
+      include: {
+        groups: {
+          where: {
+            type: OrganisationGroupType.INTERNAL_ORGANISATION,
+          },
+        },
+        members: {
+          where: {
+            userId,
+          },
+          include: {
+            organisationGroupMembers: {
+              include: {
+                group: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!organisation) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Organisation not found',
+      });
+    }
+
+    const [member] = organisation.members;
+
+    if (!member) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'User is not a member of this organisation',
+      });
+    }
+
+    const currentOrganisationRole = getHighestOrganisationRoleInGroup(
+      member.organisationGroupMembers.flatMap((member) => member.group),
+    );
+
+    if (role === 'OWNER') {
+      if (organisation.ownerUserId === userId) {
+        throw new AppError(AppErrorCode.INVALID_REQUEST, {
+          message: 'User is already the owner of this organisation',
+        });
+      }
+
+      const currentMemberGroup = organisation.groups.find(
+        (group) => group.organisationRole === currentOrganisationRole,
+      );
+
+      const adminGroup = organisation.groups.find(
+        (group) => group.organisationRole === OrganisationMemberRole.ADMIN,
+      );
+
+      if (!currentMemberGroup) {
+        ctx.logger.error({
+          message: '[CRITICAL]: Missing internal group',
+          organisationId,
+          userId,
+          role: currentOrganisationRole,
+        });
+
+        throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+          message: 'Current member group not found',
+        });
+      }
+
+      if (!adminGroup) {
+        ctx.logger.error({
+          message: '[CRITICAL]: Missing internal group',
+          organisationId,
+          userId,
+          targetRole: 'ADMIN',
+        });
+
+        throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+          message: 'Admin group not found',
+        });
+      }
+
+      await prisma.$transaction(async (tx) => {
+        await tx.organisation.update({
+          where: {
+            id: organisationId,
+          },
+          data: {
+            ownerUserId: userId,
+          },
+        });
+
+        if (currentOrganisationRole !== OrganisationMemberRole.ADMIN) {
+          await tx.organisationGroupMember.delete({
+            where: {
+              organisationMemberId_groupId: {
+                organisationMemberId: member.id,
+                groupId: currentMemberGroup.id,
+              },
+            },
+          });
+
+          await tx.organisationGroupMember.create({
+            data: {
+              id: generateDatabaseId('group_member'),
+              organisationMemberId: member.id,
+              groupId: adminGroup.id,
+            },
+          });
+        }
+      });
+
+      return;
+    }
+
+    const targetRole = role as OrganisationMemberRole;
+
+    if (currentOrganisationRole === targetRole) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'User already has this role',
+      });
+    }
+
+    if (userId === organisation.ownerUserId && targetRole !== OrganisationMemberRole.ADMIN) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Organisation owner must be an admin. Transfer ownership first.',
+      });
+    }
+
+    const currentMemberGroup = organisation.groups.find(
+      (group) => group.organisationRole === currentOrganisationRole,
+    );
+
+    const newMemberGroup = organisation.groups.find(
+      (group) => group.organisationRole === targetRole,
+    );
+
+    if (!currentMemberGroup) {
+      ctx.logger.error({
+        message: '[CRITICAL]: Missing internal group',
+        organisationId,
+        userId,
+        role: currentOrganisationRole,
+      });
+
+      throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+        message: 'Current member group not found',
+      });
+    }
+
+    if (!newMemberGroup) {
+      ctx.logger.error({
+        message: '[CRITICAL]: Missing internal group',
+        organisationId,
+        userId,
+        targetRole,
+      });
+
+      throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+        message: 'New member group not found',
+      });
+    }
+
+    await prisma.$transaction(async (tx) => {
+      await tx.organisationGroupMember.delete({
+        where: {
+          organisationMemberId_groupId: {
+            organisationMemberId: member.id,
+            groupId: currentMemberGroup.id,
+          },
+        },
+      });
+
+      await tx.organisationGroupMember.create({
+        data: {
+          id: generateDatabaseId('group_member'),
+          organisationMemberId: member.id,
+          groupId: newMemberGroup.id,
+        },
+      });
+    });
+  });

packages/trpc/server/admin-router/update-organisation-member-role.types.ts

@@ -0,0 +1,30 @@
+import { OrganisationMemberRole } from '@prisma/client';
+import { z } from 'zod';
+
+/**
+ * Admin-only role selection that includes OWNER as a special case.
+ * OWNER is not a database role but triggers ownership transfer.
+ */
+export const ZAdminRoleSelection = z.enum([
+  'OWNER',
+  OrganisationMemberRole.ADMIN,
+  OrganisationMemberRole.MANAGER,
+  OrganisationMemberRole.MEMBER,
+]);
+
+export type TAdminRoleSelection = z.infer<typeof ZAdminRoleSelection>;
+
+export const ZUpdateOrganisationMemberRoleRequestSchema = z.object({
+  organisationId: z.string().min(1),
+  userId: z.number().min(1),
+  role: ZAdminRoleSelection,
+});
+
+export const ZUpdateOrganisationMemberRoleResponseSchema = z.void();
+
+export type TUpdateOrganisationMemberRoleRequest = z.infer<
+  typeof ZUpdateOrganisationMemberRoleRequestSchema
+>;
+export type TUpdateOrganisationMemberRoleResponse = z.infer<
+  typeof ZUpdateOrganisationMemberRoleResponseSchema
+>;

packages/trpc/server/envelope-router/attachment/create-attachment.ts

@@ -13,7 +13,7 @@ export const createAttachmentRoute = authenticatedProcedure
       path: '/envelope/attachment/create',
       summary: 'Create attachment',
       description: 'Create a new attachment for an envelope',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZCreateAttachmentRequestSchema)

packages/trpc/server/envelope-router/attachment/delete-attachment.ts

@@ -13,7 +13,7 @@ export const deleteAttachmentRoute = authenticatedProcedure
       path: '/envelope/attachment/delete',
       summary: 'Delete attachment',
       description: 'Delete an attachment from an envelope',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZDeleteAttachmentRequestSchema)

packages/trpc/server/envelope-router/attachment/find-attachments.ts

@@ -2,20 +2,20 @@ import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { findAttachmentsByEnvelopeId } from '@documenso/lib/server-only/envelope-attachment/find-attachments-by-envelope-id';
 import { findAttachmentsByToken } from '@documenso/lib/server-only/envelope-attachment/find-attachments-by-token';
 
-import { procedure } from '../../trpc';
+import { maybeAuthenticatedProcedure } from '../../trpc';
 import {
   ZFindAttachmentsRequestSchema,
   ZFindAttachmentsResponseSchema,
 } from './find-attachments.types';
 
-export const findAttachmentsRoute = procedure
+export const findAttachmentsRoute = maybeAuthenticatedProcedure
   .meta({
     openapi: {
       method: 'GET',
       path: '/envelope/attachment',
       summary: 'Find attachments',
       description: 'Find all attachments for an envelope',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZFindAttachmentsRequestSchema)

packages/trpc/server/envelope-router/attachment/update-attachment.ts

@@ -13,7 +13,7 @@ export const updateAttachmentRoute = authenticatedProcedure
       path: '/envelope/attachment/update',
       summary: 'Update attachment',
       description: 'Update an existing attachment',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZUpdateAttachmentRequestSchema)

packages/trpc/server/envelope-router/create-envelope-items.ts

@@ -13,11 +13,21 @@ import {
 } from './create-envelope-items.types';
 
 export const createEnvelopeItemsRoute = authenticatedProcedure
+  // Todo: Envelopes - Pending direct uploads
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/item/create-many',
+      summary: 'Create envelope items',
+      description: 'Create multiple envelope items for an envelope',
+      tags: ['Envelope Item'],
+    },
+  })
   .input(ZCreateEnvelopeItemsRequestSchema)
   .output(ZCreateEnvelopeItemsResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { user, teamId, metadata } = ctx;
-    const { envelopeId, items } = input;
+    const { envelopeId, data: items } = input;
 
     ctx.logger.info({
       input: {

packages/trpc/server/envelope-router/create-envelope-items.types.ts

@@ -7,7 +7,7 @@ import { ZDocumentTitleSchema } from '../document-router/schema';
 
 export const ZCreateEnvelopeItemsRequestSchema = z.object({
   envelopeId: z.string(),
-  items: z
+  data: z
     .object({
       title: ZDocumentTitleSchema,
       documentDataId: z.string(),

packages/trpc/server/envelope-router/create-envelope.ts

@@ -9,6 +9,15 @@ import {
 } from './create-envelope.types';
 
 export const createEnvelopeRoute = authenticatedProcedure
+  // Todo: Envelopes - Pending direct uploads
+  // .meta({
+  //   openapi: {
+  //     method: 'POST',
+  //     path: '/envelope/create',
+  //     summary: 'Create envelope',
+  //     tags: ['Envelope'],
+  //   },
+  // })
   .input(ZCreateEnvelopeRequestSchema)
   .output(ZCreateEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/create-envelope.types.ts

@@ -24,16 +24,6 @@ import {
 } from '../document-router/schema';
 import { ZCreateRecipientSchema } from '../recipient-router/schema';
 
-// Currently not in use until we allow passthrough documents on create.
-// export const createEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/create',
-//     summary: 'Create envelope',
-//     tags: ['Envelope'],
-//   },
-// };
-
 export const ZCreateEnvelopeRequestSchema = z.object({
   title: ZDocumentTitleSchema,
   type: z.nativeEnum(EnvelopeType),

packages/trpc/server/envelope-router/delete-envelope-item.ts

@@ -12,6 +12,15 @@ import {
 } from './delete-envelope-item.types';
 
 export const deleteEnvelopeItemRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/item/delete',
+      summary: 'Delete envelope item',
+      description: 'Delete an envelope item from an envelope',
+      tags: ['Envelope Item'],
+    },
+  })
   .input(ZDeleteEnvelopeItemRequestSchema)
   .output(ZDeleteEnvelopeItemResponseSchema)
   .mutation(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/delete-envelope.ts

@@ -1,8 +1,10 @@
 import { EnvelopeType } from '@prisma/client';
 import { match } from 'ts-pattern';
 
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { deleteDocument } from '@documenso/lib/server-only/document/delete-document';
 import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
+import { prisma } from '@documenso/prisma';
 
 import { authenticatedProcedure } from '../trpc';
 import {
@@ -11,12 +13,19 @@ import {
 } from './delete-envelope.types';
 
 export const deleteEnvelopeRoute = authenticatedProcedure
-  // .meta(deleteEnvelopeMeta)
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/delete',
+      summary: 'Delete envelope',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZDeleteEnvelopeRequestSchema)
   .output(ZDeleteEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { teamId } = ctx;
-    const { envelopeId, envelopeType } = input;
+    const { envelopeId } = input;
 
     ctx.logger.info({
       input: {
@@ -24,7 +33,22 @@ export const deleteEnvelopeRoute = authenticatedProcedure
       },
     });
 
-    await match(envelopeType)
+    const unsafeEnvelope = await prisma.envelope.findUnique({
+      where: {
+        id: envelopeId,
+      },
+      select: {
+        type: true,
+      },
+    });
+
+    if (!unsafeEnvelope) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Envelope not found',
+      });
+    }
+
+    await match(unsafeEnvelope.type)
       .with(EnvelopeType.DOCUMENT, async () =>
         deleteDocument({
           userId: ctx.user.id,

packages/trpc/server/envelope-router/delete-envelope.types.ts

@@ -1,18 +1,7 @@
-import { EnvelopeType } from '@prisma/client';
 import { z } from 'zod';
 
-// export const deleteEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/delete',
-//     summary: 'Delete envelope',
-//     tags: ['Envelope'],
-//   },
-// };
-
 export const ZDeleteEnvelopeRequestSchema = z.object({
   envelopeId: z.string(),
-  envelopeType: z.nativeEnum(EnvelopeType),
 });
 
 export const ZDeleteEnvelopeResponseSchema = z.void();

packages/trpc/server/envelope-router/distribute-envelope.ts

@@ -8,7 +8,15 @@ import {
 } from './distribute-envelope.types';
 
 export const distributeEnvelopeRoute = authenticatedProcedure
-  // .meta(distributeEnvelopeMeta)
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/distribute',
+      summary: 'Distribute envelope',
+      description: 'Send the envelope to recipients based on your distribution method',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZDistributeEnvelopeRequestSchema)
   .output(ZDistributeEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/distribute-envelope.types.ts

@@ -2,16 +2,6 @@ import { z } from 'zod';
 
 import { ZDocumentMetaUpdateSchema } from '@documenso/lib/types/document-meta';
 
-// export const distributeEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/distribute',
-//     summary: 'Distribute envelope',
-//     description: 'Send the document out to recipients based on your distribution method',
-//     tags: ['Envelope'],
-//   },
-// };
-
 export const ZDistributeEnvelopeRequestSchema = z.object({
   envelopeId: z.string().describe('The ID of the envelope to send.'),
   meta: ZDocumentMetaUpdateSchema.pick({

packages/trpc/server/envelope-router/duplicate-envelope.ts

@@ -7,6 +7,15 @@ import {
 } from './duplicate-envelope.types';
 
 export const duplicateEnvelopeRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/duplicate',
+      summary: 'Duplicate envelope',
+      description: 'Duplicate an envelope with all its settings',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZDuplicateEnvelopeRequestSchema)
   .output(ZDuplicateEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.ts

@@ -0,0 +1,41 @@
+import { createEnvelopeFields } from '@documenso/lib/server-only/field/create-envelope-fields';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZCreateEnvelopeFieldsRequestSchema,
+  ZCreateEnvelopeFieldsResponseSchema,
+} from './create-envelope-fields.types';
+
+export const createEnvelopeFieldsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/field/create-many',
+      summary: 'Create envelope fields',
+      description: 'Create multiple fields for an envelope',
+      tags: ['Envelope Fields'],
+    },
+  })
+  .input(ZCreateEnvelopeFieldsRequestSchema)
+  .output(ZCreateEnvelopeFieldsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { envelopeId, data: fields } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await createEnvelopeFields({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      fields,
+      requestMetadata: metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.types.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+  ZFieldPageNumberSchema,
+  ZFieldSchema,
+} from '@documenso/lib/types/field';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+const ZCreateFieldSchema = ZFieldAndMetaSchema.and(
+  z.object({
+    recipientId: z.number().describe('The ID of the recipient to create the field for'),
+    envelopeItemId: z
+      .string()
+      .optional()
+      .describe(
+        'The ID of the envelope item to put the field on. If not provided, field will be placed on the first item.',
+      ),
+    page: ZFieldPageNumberSchema,
+    positionX: ZClampedFieldPositionXSchema,
+    positionY: ZClampedFieldPositionYSchema,
+    width: ZClampedFieldWidthSchema,
+    height: ZClampedFieldHeightSchema,
+  }),
+);
+
+export const ZCreateEnvelopeFieldsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZCreateFieldSchema.array(),
+});
+
+export const ZCreateEnvelopeFieldsResponseSchema = z.object({
+  fields: z.array(ZFieldSchema),
+});
+
+export type TCreateEnvelopeFieldsRequest = z.infer<typeof ZCreateEnvelopeFieldsRequestSchema>;
+export type TCreateEnvelopeFieldsResponse = z.infer<typeof ZCreateEnvelopeFieldsResponseSchema>;

packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.ts

@@ -0,0 +1,125 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
+import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
+import { canRecipientFieldsBeModified } from '@documenso/lib/utils/recipients';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZDeleteEnvelopeFieldRequestSchema,
+  ZDeleteEnvelopeFieldResponseSchema,
+} from './delete-envelope-field.types';
+
+export const deleteEnvelopeFieldRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/field/delete',
+      summary: 'Delete envelope field',
+      description: 'Delete an envelope field',
+      tags: ['Envelope Field'],
+    },
+  })
+  .input(ZDeleteEnvelopeFieldRequestSchema)
+  .output(ZDeleteEnvelopeFieldResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { fieldId } = input;
+
+    ctx.logger.info({
+      input: {
+        fieldId,
+      },
+    });
+
+    const unsafeField = await prisma.field.findUnique({
+      where: {
+        id: fieldId,
+      },
+      select: {
+        envelopeId: true,
+      },
+    });
+
+    if (!unsafeField) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Field not found',
+      });
+    }
+
+    const { envelopeWhereInput } = await getEnvelopeWhereInput({
+      id: {
+        type: 'envelopeId',
+        id: unsafeField.envelopeId,
+      },
+      type: null,
+      userId: user.id,
+      teamId,
+    });
+
+    const envelope = await prisma.envelope.findUnique({
+      where: envelopeWhereInput,
+      include: {
+        recipients: {
+          include: {
+            fields: true,
+          },
+        },
+      },
+    });
+
+    const recipientWithFields = envelope?.recipients.find((recipient) =>
+      recipient.fields.some((field) => field.id === fieldId),
+    );
+    const fieldToDelete = recipientWithFields?.fields.find((field) => field.id === fieldId);
+
+    if (!envelope || !recipientWithFields || !fieldToDelete) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Field not found',
+      });
+    }
+
+    if (envelope.completedAt) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Envelope already complete',
+      });
+    }
+
+    // Check whether the recipient associated with the field can have new fields created.
+    if (!canRecipientFieldsBeModified(recipientWithFields, recipientWithFields.fields)) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Recipient has already interacted with the document.',
+      });
+    }
+
+    await prisma.$transaction(async (tx) => {
+      const deletedField = await tx.field.delete({
+        where: {
+          id: fieldToDelete.id,
+          envelopeId: envelope.id,
+        },
+      });
+
+      // Handle field deleted audit log.
+      if (envelope.type === EnvelopeType.DOCUMENT) {
+        await tx.documentAuditLog.create({
+          data: createDocumentAuditLogData({
+            type: DOCUMENT_AUDIT_LOG_TYPE.FIELD_DELETED,
+            envelopeId: envelope.id,
+            metadata,
+            data: {
+              fieldId: deletedField.secondaryId,
+              fieldRecipientEmail: recipientWithFields.email,
+              fieldRecipientId: deletedField.recipientId,
+              fieldType: deletedField.type,
+            },
+          }),
+        });
+      }
+
+      return deletedField;
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.types.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const ZDeleteEnvelopeFieldRequestSchema = z.object({
+  fieldId: z.number(),
+});
+
+export const ZDeleteEnvelopeFieldResponseSchema = z.void();
+
+export type TDeleteEnvelopeFieldRequest = z.infer<typeof ZDeleteEnvelopeFieldRequestSchema>;
+export type TDeleteEnvelopeFieldResponse = z.infer<typeof ZDeleteEnvelopeFieldResponseSchema>;

packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.ts

@@ -0,0 +1,36 @@
+import { getFieldById } from '@documenso/lib/server-only/field/get-field-by-id';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZGetEnvelopeFieldRequestSchema,
+  ZGetEnvelopeFieldResponseSchema,
+} from './get-envelope-field.types';
+
+export const getEnvelopeFieldRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'GET',
+      path: '/envelope/field/{fieldId}',
+      summary: 'Get envelope field',
+      description: 'Returns an envelope field given an ID',
+      tags: ['Envelope Field'],
+    },
+  })
+  .input(ZGetEnvelopeFieldRequestSchema)
+  .output(ZGetEnvelopeFieldResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { fieldId } = input;
+
+    ctx.logger.info({
+      input: {
+        fieldId,
+      },
+    });
+
+    return await getFieldById({
+      userId: user.id,
+      teamId,
+      fieldId,
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+import { ZEnvelopeFieldSchema } from '@documenso/lib/types/field';
+
+export const ZGetEnvelopeFieldRequestSchema = z.object({
+  fieldId: z.number(),
+});
+
+export const ZGetEnvelopeFieldResponseSchema = ZEnvelopeFieldSchema;
+
+export type TGetEnvelopeFieldRequest = z.infer<typeof ZGetEnvelopeFieldRequestSchema>;
+export type TGetEnvelopeFieldResponse = z.infer<typeof ZGetEnvelopeFieldResponseSchema>;

packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.ts

@@ -0,0 +1,42 @@
+import { updateEnvelopeFields } from '@documenso/lib/server-only/field/update-envelope-fields';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZUpdateEnvelopeFieldsRequestSchema,
+  ZUpdateEnvelopeFieldsResponseSchema,
+} from './update-envelope-fields.types';
+
+export const updateEnvelopeFieldsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/field/update-many',
+      summary: 'Update envelope fields',
+      description: 'Update multiple envelope fields for an envelope',
+      tags: ['Envelope Field'],
+    },
+  })
+  .input(ZUpdateEnvelopeFieldsRequestSchema)
+  .output(ZUpdateEnvelopeFieldsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, data: fields } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await updateEnvelopeFields({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: null,
+      fields,
+      requestMetadata: ctx.metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.types.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+  ZFieldPageNumberSchema,
+  ZFieldSchema,
+} from '@documenso/lib/types/field';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+const ZUpdateFieldSchema = ZFieldAndMetaSchema.and(
+  z.object({
+    id: z.number().describe('The ID of the field to update.'),
+    envelopeItemId: z
+      .string()
+      .optional()
+      .describe(
+        'The ID of the envelope item to put the field on. If not provided, field will be placed on the first item.',
+      ),
+    page: ZFieldPageNumberSchema.optional(),
+    positionX: ZClampedFieldPositionXSchema.optional(),
+    positionY: ZClampedFieldPositionYSchema.optional(),
+    width: ZClampedFieldWidthSchema.optional(),
+    height: ZClampedFieldHeightSchema.optional(),
+  }),
+);
+
+export const ZUpdateEnvelopeFieldsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZUpdateFieldSchema.array(),
+});
+
+export const ZUpdateEnvelopeFieldsResponseSchema = z.object({
+  fields: z.array(ZFieldSchema),
+});
+
+export type TUpdateEnvelopeFieldsRequest = z.infer<typeof ZUpdateEnvelopeFieldsRequestSchema>;
+export type TUpdateEnvelopeFieldsResponse = z.infer<typeof ZUpdateEnvelopeFieldsResponseSchema>;

packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.ts

@@ -0,0 +1,41 @@
+import { createEnvelopeRecipients } from '@documenso/lib/server-only/recipient/create-envelope-recipients';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZCreateEnvelopeRecipientsRequestSchema,
+  ZCreateEnvelopeRecipientsResponseSchema,
+} from './create-envelope-recipients.types';
+
+export const createEnvelopeRecipientsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/recipient/create-many',
+      summary: 'Create envelope recipients',
+      description: 'Create multiple recipients for an envelope',
+      tags: ['Envelope Recipients'],
+    },
+  })
+  .input(ZCreateEnvelopeRecipientsRequestSchema)
+  .output(ZCreateEnvelopeRecipientsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { envelopeId, data: recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await createEnvelopeRecipients({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      recipients,
+      requestMetadata: metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.types.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+import { ZEnvelopeRecipientLiteSchema } from '@documenso/lib/types/recipient';
+
+import { ZCreateRecipientSchema } from '../../recipient-router/schema';
+
+export const ZCreateEnvelopeRecipientsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZCreateRecipientSchema.array(),
+});
+
+export const ZCreateEnvelopeRecipientsResponseSchema = z.object({
+  recipients: ZEnvelopeRecipientLiteSchema.array(),
+});
+
+export type TCreateEnvelopeRecipientsRequest = z.infer<
+  typeof ZCreateEnvelopeRecipientsRequestSchema
+>;
+export type TCreateEnvelopeRecipientsResponse = z.infer<
+  typeof ZCreateEnvelopeRecipientsResponseSchema
+>;

packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.ts

@@ -0,0 +1,37 @@
+import { deleteEnvelopeRecipient } from '@documenso/lib/server-only/recipient/delete-envelope-recipient';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZDeleteEnvelopeRecipientRequestSchema,
+  ZDeleteEnvelopeRecipientResponseSchema,
+} from './delete-envelope-recipient.types';
+
+export const deleteEnvelopeRecipientRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/recipient/delete',
+      summary: 'Delete envelope recipient',
+      description: 'Delete an envelope recipient',
+      tags: ['Envelope Recipient'],
+    },
+  })
+  .input(ZDeleteEnvelopeRecipientRequestSchema)
+  .output(ZDeleteEnvelopeRecipientResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { recipientId } = input;
+
+    ctx.logger.info({
+      input: {
+        recipientId,
+      },
+    });
+
+    await deleteEnvelopeRecipient({
+      userId: user.id,
+      teamId,
+      recipientId,
+      requestMetadata: metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const ZDeleteEnvelopeRecipientRequestSchema = z.object({
+  recipientId: z.number(),
+});
+
+export const ZDeleteEnvelopeRecipientResponseSchema = z.void();
+
+export type TDeleteEnvelopeRecipientRequest = z.infer<typeof ZDeleteEnvelopeRecipientRequestSchema>;
+export type TDeleteEnvelopeRecipientResponse = z.infer<
+  typeof ZDeleteEnvelopeRecipientResponseSchema
+>;

packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.ts

@@ -0,0 +1,52 @@
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { buildTeamWhereQuery } from '@documenso/lib/utils/teams';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZGetEnvelopeRecipientRequestSchema,
+  ZGetEnvelopeRecipientResponseSchema,
+} from './get-envelope-recipient.types';
+
+export const getEnvelopeRecipientRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'GET',
+      path: '/envelope/recipient/{recipientId}',
+      summary: 'Get envelope recipient',
+      description: 'Returns an envelope recipient given an ID',
+      tags: ['Envelope Recipient'],
+    },
+  })
+  .input(ZGetEnvelopeRecipientRequestSchema)
+  .output(ZGetEnvelopeRecipientResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { recipientId } = input;
+
+    ctx.logger.info({
+      input: {
+        recipientId,
+      },
+    });
+
+    const recipient = await prisma.recipient.findFirst({
+      where: {
+        id: recipientId,
+        envelope: {
+          team: buildTeamWhereQuery({ teamId, userId: user.id }),
+        },
+      },
+      include: {
+        fields: true,
+      },
+    });
+
+    if (!recipient) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Recipient not found',
+      });
+    }
+
+    return recipient;
+  });

packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+import { ZEnvelopeRecipientSchema } from '@documenso/lib/types/recipient';
+
+export const ZGetEnvelopeRecipientRequestSchema = z.object({
+  recipientId: z.number(),
+});
+
+export const ZGetEnvelopeRecipientResponseSchema = ZEnvelopeRecipientSchema;
+
+export type TGetEnvelopeRecipientRequest = z.infer<typeof ZGetEnvelopeRecipientRequestSchema>;
+export type TGetEnvelopeRecipientResponse = z.infer<typeof ZGetEnvelopeRecipientResponseSchema>;

packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.ts

@@ -0,0 +1,41 @@
+import { updateEnvelopeRecipients } from '@documenso/lib/server-only/recipient/update-envelope-recipients';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZUpdateEnvelopeRecipientsRequestSchema,
+  ZUpdateEnvelopeRecipientsResponseSchema,
+} from './update-envelope-recipients.types';
+
+export const updateEnvelopeRecipientsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/recipient/update-many',
+      summary: 'Update envelope recipients',
+      description: 'Update multiple recipients for an envelope',
+      tags: ['Envelope Recipient'],
+    },
+  })
+  .input(ZUpdateEnvelopeRecipientsRequestSchema)
+  .output(ZUpdateEnvelopeRecipientsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, data: recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await updateEnvelopeRecipients({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      recipients,
+      requestMetadata: ctx.metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.types.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+import { ZRecipientLiteSchema } from '@documenso/lib/types/recipient';
+
+import { ZUpdateRecipientSchema } from '../../recipient-router/schema';
+
+export const ZUpdateEnvelopeRecipientsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZUpdateRecipientSchema.array(),
+});
+
+export const ZUpdateEnvelopeRecipientsResponseSchema = z.object({
+  recipients: ZRecipientLiteSchema.array(),
+});
+
+export type TUpdateEnvelopeRecipientsRequest = z.infer<
+  typeof ZUpdateEnvelopeRecipientsRequestSchema
+>;
+export type TUpdateEnvelopeRecipientsResponse = z.infer<
+  typeof ZUpdateEnvelopeRecipientsResponseSchema
+>;

packages/trpc/server/envelope-router/get-envelope.ts

@@ -4,7 +4,15 @@ import { authenticatedProcedure } from '../trpc';
 import { ZGetEnvelopeRequestSchema, ZGetEnvelopeResponseSchema } from './get-envelope.types';
 
 export const getEnvelopeRoute = authenticatedProcedure
-  // .meta(getEnvelopeMeta)
+  .meta({
+    openapi: {
+      method: 'GET',
+      path: '/envelope/{envelopeId}',
+      summary: 'Get envelope',
+      description: 'Returns an envelope given an ID',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZGetEnvelopeRequestSchema)
   .output(ZGetEnvelopeResponseSchema)
   .query(async ({ input, ctx }) => {