Merge branch 'main' into feat/auto-placing-fields

2025-11-19 11:12:06 +10:00 · 2025-11-17 12:14:28 +02:00
parent c615e30633 6aa56fe7e0
commit 86d11cc720
338 changed files with 32685 additions and 5284 deletions
--- a/packages/lib/server-only/admin/get-organisation-detailed-insights.ts
+++ b/packages/lib/server-only/admin/get-organisation-detailed-insights.ts
@ -0,0 +1,363 @@
+import type { DocumentStatus } from '@prisma/client';
+import { EnvelopeType } from '@prisma/client';
+
+import type { DateRange } from '@documenso/lib/types/search-params';
+import { kyselyPrisma, sql } from '@documenso/prisma';
+
+export type OrganisationSummary = {
+  totalTeams: number;
+  totalMembers: number;
+  totalDocuments: number;
+  activeDocuments: number;
+  completedDocuments: number;
+  volumeThisPeriod: number;
+  volumeAllTime: number;
+};
+
+export type OrganisationDetailedInsights = {
+  teams: TeamInsights[];
+  users: UserInsights[];
+  documents: DocumentInsights[];
+  totalPages: number;
+  summary?: OrganisationSummary;
+};
+
+export type TeamInsights = {
+  id: number;
+  name: string;
+  memberCount: number;
+  documentCount: number;
+  createdAt: Date;
+};
+
+export type UserInsights = {
+  id: number;
+  name: string;
+  email: string;
+  documentCount: number;
+  signedDocumentCount: number;
+  createdAt: Date;
+};
+
+export type DocumentInsights = {
+  id: string;
+  title: string;
+  status: DocumentStatus;
+  teamName: string;
+  createdAt: Date;
+  completedAt: Date | null;
+};
+
+export type GetOrganisationDetailedInsightsOptions = {
+  organisationId: string;
+  page?: number;
+  perPage?: number;
+  dateRange?: DateRange;
+  view: 'teams' | 'users' | 'documents';
+};
+
+export async function getOrganisationDetailedInsights({
+  organisationId,
+  page = 1,
+  perPage = 10,
+  dateRange = 'last30days',
+  view,
+}: GetOrganisationDetailedInsightsOptions): Promise<OrganisationDetailedInsights> {
+  const offset = Math.max(page - 1, 0) * perPage;
+
+  const now = new Date();
+  let createdAtFrom: Date | null = null;
+
+  switch (dateRange) {
+    case 'last30days': {
+      createdAtFrom = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+      break;
+    }
+    case 'last90days': {
+      createdAtFrom = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
+      break;
+    }
+    case 'lastYear': {
+      createdAtFrom = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
+      break;
+    }
+    case 'allTime':
+    default:
+      createdAtFrom = null;
+      break;
+  }
+
+  const summaryData = await getOrganisationSummary(organisationId, createdAtFrom);
+
+  const viewData = await (async () => {
+    switch (view) {
+      case 'teams':
+        return await getTeamInsights(organisationId, offset, perPage, createdAtFrom);
+      case 'users':
+        return await getUserInsights(organisationId, offset, perPage, createdAtFrom);
+      case 'documents':
+        return await getDocumentInsights(organisationId, offset, perPage, createdAtFrom);
+      default:
+        throw new Error(`Invalid view: ${view}`);
+    }
+  })();
+
+  return {
+    ...viewData,
+    summary: summaryData,
+  };
+}
+
+async function getTeamInsights(
+  organisationId: string,
+  offset: number,
+  perPage: number,
+  createdAtFrom: Date | null,
+): Promise<OrganisationDetailedInsights> {
+  const teamsQuery = kyselyPrisma.$kysely
+    .selectFrom('Team as t')
+    .leftJoin('Envelope as e', (join) =>
+      join
+        .onRef('t.id', '=', 'e.teamId')
+        .on('e.deletedAt', 'is', null)
+        .on('e.type', '=', sql.lit(EnvelopeType.DOCUMENT)),
+    )
+    .leftJoin('TeamGroup as tg', 'tg.teamId', 't.id')
+    .leftJoin('OrganisationGroup as og', 'og.id', 'tg.organisationGroupId')
+    .leftJoin('OrganisationGroupMember as ogm', 'ogm.groupId', 'og.id')
+    .leftJoin('OrganisationMember as om', 'om.id', 'ogm.organisationMemberId')
+    .where('t.organisationId', '=', organisationId)
+    .select([
+      't.id as id',
+      't.name as name',
+      't.createdAt as createdAt',
+      sql<number>`COUNT(DISTINCT om."userId")`.as('memberCount'),
+      (createdAtFrom
+        ? sql<number>`COUNT(DISTINCT CASE WHEN e.id IS NOT NULL AND e."createdAt" >= ${createdAtFrom} THEN e.id END)`
+        : sql<number>`COUNT(DISTINCT e.id)`
+      ).as('documentCount'),
+    ])
+    .groupBy(['t.id', 't.name', 't.createdAt'])
+    .orderBy('documentCount', 'desc')
+    .limit(perPage)
+    .offset(offset);
+
+  const countQuery = kyselyPrisma.$kysely
+    .selectFrom('Team as t')
+    .where('t.organisationId', '=', organisationId)
+    .select(({ fn }) => [fn.countAll().as('count')]);
+
+  const [teams, countResult] = await Promise.all([teamsQuery.execute(), countQuery.execute()]);
+  const count = Number(countResult[0]?.count || 0);
+
+  return {
+    teams: teams as TeamInsights[],
+    users: [],
+    documents: [],
+    totalPages: Math.ceil(Number(count) / perPage),
+  };
+}
+
+async function getUserInsights(
+  organisationId: string,
+  offset: number,
+  perPage: number,
+  createdAtFrom: Date | null,
+): Promise<OrganisationDetailedInsights> {
+  const usersBase = kyselyPrisma.$kysely
+    .selectFrom('OrganisationMember as om')
+    .innerJoin('User as u', 'u.id', 'om.userId')
+    .where('om.organisationId', '=', organisationId)
+    .leftJoin('Envelope as e', (join) =>
+      join
+        .onRef('e.userId', '=', 'u.id')
+        .on('e.deletedAt', 'is', null)
+        .on('e.type', '=', sql.lit(EnvelopeType.DOCUMENT)),
+    )
+    .leftJoin('Team as td', (join) =>
+      join.onRef('td.id', '=', 'e.teamId').on('td.organisationId', '=', organisationId),
+    )
+    .leftJoin('Recipient as r', (join) =>
+      join.onRef('r.email', '=', 'u.email').on('r.signedAt', 'is not', null),
+    )
+    .leftJoin('Envelope as se', (join) =>
+      join
+        .onRef('se.id', '=', 'r.envelopeId')
+        .on('se.deletedAt', 'is', null)
+        .on('se.type', '=', sql.lit(EnvelopeType.DOCUMENT)),
+    )
+    .leftJoin('Team as ts', (join) =>
+      join.onRef('ts.id', '=', 'se.teamId').on('ts.organisationId', '=', organisationId),
+    );
+
+  const usersQuery = usersBase
+    .select([
+      'u.id as id',
+      'u.name as name',
+      'u.email as email',
+      'u.createdAt as createdAt',
+      (createdAtFrom
+        ? sql<number>`COUNT(DISTINCT CASE WHEN e.id IS NOT NULL AND td.id IS NOT NULL AND e."createdAt" >= ${createdAtFrom} THEN e.id END)`
+        : sql<number>`COUNT(DISTINCT CASE WHEN td.id IS NOT NULL THEN e.id END)`
+      ).as('documentCount'),
+      (createdAtFrom
+        ? sql<number>`COUNT(DISTINCT CASE WHEN e.id IS NOT NULL AND td.id IS NOT NULL AND e.status = 'COMPLETED' AND e."createdAt" >= ${createdAtFrom} THEN e.id END)`
+        : sql<number>`COUNT(DISTINCT CASE WHEN e.id IS NOT NULL AND td.id IS NOT NULL AND e.status = 'COMPLETED' THEN e.id END)`
+      ).as('signedDocumentCount'),
+    ])
+    .groupBy(['u.id', 'u.name', 'u.email', 'u.createdAt'])
+    .orderBy('u.createdAt', 'desc')
+    .limit(perPage)
+    .offset(offset);
+
+  const countQuery = kyselyPrisma.$kysely
+    .selectFrom('OrganisationMember as om')
+    .innerJoin('User as u', 'u.id', 'om.userId')
+    .where('om.organisationId', '=', organisationId)
+    .select(({ fn }) => [fn.countAll().as('count')]);
+
+  const [users, countResult] = await Promise.all([usersQuery.execute(), countQuery.execute()]);
+  const count = Number(countResult[0]?.count || 0);
+
+  return {
+    teams: [],
+    users: users as UserInsights[],
+    documents: [],
+    totalPages: Math.ceil(Number(count) / perPage),
+  };
+}
+
+async function getDocumentInsights(
+  organisationId: string,
+  offset: number,
+  perPage: number,
+  createdAtFrom: Date | null,
+): Promise<OrganisationDetailedInsights> {
+  let documentsQuery = kyselyPrisma.$kysely
+    .selectFrom('Envelope as e')
+    .innerJoin('Team as t', 'e.teamId', 't.id')
+    .where('t.organisationId', '=', organisationId)
+    .where('e.deletedAt', 'is', null)
+    .where(() => sql`e.type = ${EnvelopeType.DOCUMENT}::"EnvelopeType"`);
+
+  if (createdAtFrom) {
+    documentsQuery = documentsQuery.where('e.createdAt', '>=', createdAtFrom);
+  }
+
+  documentsQuery = documentsQuery
+    .select([
+      'e.id as id',
+      'e.title as title',
+      'e.status as status',
+      'e.createdAt as createdAt',
+      'e.completedAt as completedAt',
+      't.name as teamName',
+    ])
+    .orderBy('e.createdAt', 'desc')
+    .limit(perPage)
+    .offset(offset);
+
+  let countQuery = kyselyPrisma.$kysely
+    .selectFrom('Envelope as e')
+    .innerJoin('Team as t', 'e.teamId', 't.id')
+    .where('t.organisationId', '=', organisationId)
+    .where('e.deletedAt', 'is', null)
+    .where(() => sql`e.type = ${EnvelopeType.DOCUMENT}::"EnvelopeType"`);
+
+  if (createdAtFrom) {
+    countQuery = countQuery.where('e.createdAt', '>=', createdAtFrom);
+  }
+
+  countQuery = countQuery.select(({ fn }) => [fn.countAll().as('count')]);
+
+  const [documents, countResult] = await Promise.all([
+    documentsQuery.execute(),
+    countQuery.execute(),
+  ]);
+
+  const count = Number((countResult[0] as { count: number })?.count || 0);
+
+  return {
+    teams: [],
+    users: [],
+    documents: documents.map((doc) => ({
+      ...doc,
+      id: String((doc as { id: number }).id),
+    })) as DocumentInsights[],
+    totalPages: Math.ceil(Number(count) / perPage),
+  };
+}
+
+async function getOrganisationSummary(
+  organisationId: string,
+  createdAtFrom: Date | null,
+): Promise<OrganisationSummary> {
+  const summaryQuery = kyselyPrisma.$kysely
+    .selectFrom('Organisation as o')
+    .where('o.id', '=', organisationId)
+    .select([
+      sql<number>`(SELECT COUNT(DISTINCT t2.id) FROM "Team" AS t2 WHERE t2."organisationId" = o.id)`.as(
+        'totalTeams',
+      ),
+      sql<number>`(SELECT COUNT(DISTINCT om2."userId") FROM "OrganisationMember" AS om2 WHERE om2."organisationId" = o.id)`.as(
+        'totalMembers',
+      ),
+      sql<number>`(
+        SELECT COUNT(DISTINCT e2.id)
+        FROM "Envelope" AS e2
+        INNER JOIN "Team" AS t2 ON t2.id = e2."teamId"
+        WHERE t2."organisationId" = o.id AND e2."deletedAt" IS NULL AND e2.type = 'DOCUMENT'
+      )`.as('totalDocuments'),
+      sql<number>`(
+        SELECT COUNT(DISTINCT e2.id)
+        FROM "Envelope" AS e2
+        INNER JOIN "Team" AS t2 ON t2.id = e2."teamId"
+        WHERE t2."organisationId" = o.id AND e2."deletedAt" IS NULL AND e2.type = 'DOCUMENT' AND e2.status IN ('DRAFT', 'PENDING')
+      )`.as('activeDocuments'),
+      sql<number>`(
+        SELECT COUNT(DISTINCT e2.id)
+        FROM "Envelope" AS e2
+        INNER JOIN "Team" AS t2 ON t2.id = e2."teamId"
+        WHERE t2."organisationId" = o.id AND e2."deletedAt" IS NULL AND e2.type = 'DOCUMENT' AND e2.status = 'COMPLETED'
+      )`.as('completedDocuments'),
+      (createdAtFrom
+        ? sql<number>`(
+            SELECT COUNT(DISTINCT e2.id)
+            FROM "Envelope" AS e2
+            INNER JOIN "Team" AS t2 ON t2.id = e2."teamId"
+            WHERE t2."organisationId" = o.id
+              AND e2."deletedAt" IS NULL
+              AND e2.type = 'DOCUMENT'
+              AND e2.status = 'COMPLETED'
+              AND e2."createdAt" >= ${createdAtFrom}
+          )`
+        : sql<number>`(
+            SELECT COUNT(DISTINCT e2.id)
+            FROM "Envelope" AS e2
+            INNER JOIN "Team" AS t2 ON t2.id = e2."teamId"
+            WHERE t2."organisationId" = o.id
+              AND e2."deletedAt" IS NULL
+              AND e2.type = 'DOCUMENT'
+              AND e2.status = 'COMPLETED'
+          )`
+      ).as('volumeThisPeriod'),
+      sql<number>`(
+        SELECT COUNT(DISTINCT e2.id)
+        FROM "Envelope" AS e2
+        INNER JOIN "Team" AS t2 ON t2.id = e2."teamId"
+        WHERE t2."organisationId" = o.id AND e2."deletedAt" IS NULL AND e2.type = 'DOCUMENT' AND e2.status = 'COMPLETED'
+      )`.as('volumeAllTime'),
+    ]);
+
+  const result = await summaryQuery.executeTakeFirst();
+
+  return {
+    totalTeams: Number(result?.totalTeams || 0),
+    totalMembers: Number(result?.totalMembers || 0),
+    totalDocuments: Number(result?.totalDocuments || 0),
+    activeDocuments: Number(result?.activeDocuments || 0),
+    completedDocuments: Number(result?.completedDocuments || 0),
+    volumeThisPeriod: Number(result?.volumeThisPeriod || 0),
+    volumeAllTime: Number(result?.volumeAllTime || 0),
+  };
+}
--- a/packages/lib/server-only/admin/get-signing-volume.ts
+++ b/packages/lib/server-only/admin/get-signing-volume.ts
@ -1,13 +1,17 @@
-import { DocumentStatus, EnvelopeType, SubscriptionStatus } from '@prisma/client';
+import { DocumentStatus, EnvelopeType } from '@prisma/client';

+import type { DateRange } from '@documenso/lib/types/search-params';
 import { kyselyPrisma, sql } from '@documenso/prisma';

-export type SigningVolume = {
+export type OrganisationInsights = {
  id: number;
  name: string;
  signingVolume: number;
  createdAt: Date;
-  planId: string;
+  customerId: string | null;
+  subscriptionStatus?: string;
+  teamCount?: number;
+  memberCount?: number;
 };

 export type GetSigningVolumeOptions = {
@ -28,28 +32,26 @@ export async function getSigningVolume({
  const offset = Math.max(page - 1, 0) * perPage;

  let findQuery = kyselyPrisma.$kysely
-    .selectFrom('Subscription as s')
-    .innerJoin('Organisation as o', 's.organisationId', 'o.id')
+    .selectFrom('Organisation as o')
    .leftJoin('Team as t', 'o.id', 't.organisationId')
    .leftJoin('Envelope as e', (join) =>
      join
        .onRef('t.id', '=', 'e.teamId')
        .on('e.status', '=', sql.lit(DocumentStatus.COMPLETED))
-        .on('e.deletedAt', 'is', null),
+        .on('e.deletedAt', 'is', null)
+        .on('e.type', '=', sql.lit(EnvelopeType.DOCUMENT)),
    )
-    .where(sql`s.status = ${SubscriptionStatus.ACTIVE}::"SubscriptionStatus"`)
    .where((eb) =>
      eb.or([eb('o.name', 'ilike', `%${search}%`), eb('t.name', 'ilike', `%${search}%`)]),
    )
-    .where('e.type', '=', EnvelopeType.DOCUMENT)
    .select([
-      's.id as id',
-      's.createdAt as createdAt',
-      's.planId as planId',
+      'o.id as id',
+      'o.createdAt as createdAt',
+      'o.customerId as customerId',
      sql<string>`COALESCE(o.name, 'Unknown')`.as('name'),
      sql<number>`COUNT(DISTINCT e.id)`.as('signingVolume'),
    ])
-    .groupBy(['s.id', 'o.name']);
+    .groupBy(['o.id', 'o.name', 'o.customerId']);

  switch (sortBy) {
    case 'name':
@ -68,19 +70,127 @@ export async function getSigningVolume({
  findQuery = findQuery.limit(perPage).offset(offset);

  const countQuery = kyselyPrisma.$kysely
-    .selectFrom('Subscription as s')
-    .innerJoin('Organisation as o', 's.organisationId', 'o.id')
+    .selectFrom('Organisation as o')
    .leftJoin('Team as t', 'o.id', 't.organisationId')
-    .where(sql`s.status = ${SubscriptionStatus.ACTIVE}::"SubscriptionStatus"`)
    .where((eb) =>
      eb.or([eb('o.name', 'ilike', `%${search}%`), eb('t.name', 'ilike', `%${search}%`)]),
    )
-    .select(({ fn }) => [fn.countAll().as('count')]);
+    .select(() => [sql<number>`COUNT(DISTINCT o.id)`.as('count')]);

  const [results, [{ count }]] = await Promise.all([findQuery.execute(), countQuery.execute()]);

  return {
-    leaderboard: results,
+    organisations: results,
+    totalPages: Math.ceil(Number(count) / perPage),
+  };
+}
+
+export type GetOrganisationInsightsOptions = GetSigningVolumeOptions & {
+  dateRange?: DateRange;
+  startDate?: Date;
+  endDate?: Date;
+};
+
+export async function getOrganisationInsights({
+  search = '',
+  page = 1,
+  perPage = 10,
+  sortBy = 'signingVolume',
+  sortOrder = 'desc',
+  dateRange = 'last30days',
+  startDate,
+  endDate,
+}: GetOrganisationInsightsOptions) {
+  const offset = Math.max(page - 1, 0) * perPage;
+
+  const now = new Date();
+  let dateCondition = sql`1=1`;
+
+  if (startDate && endDate) {
+    dateCondition = sql`e."createdAt" >= ${startDate} AND e."createdAt" <= ${endDate}`;
+  } else {
+    switch (dateRange) {
+      case 'last30days': {
+        const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+        dateCondition = sql`e."createdAt" >= ${thirtyDaysAgo}`;
+        break;
+      }
+      case 'last90days': {
+        const ninetyDaysAgo = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
+        dateCondition = sql`e."createdAt" >= ${ninetyDaysAgo}`;
+        break;
+      }
+      case 'lastYear': {
+        const oneYearAgo = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
+        dateCondition = sql`e."createdAt" >= ${oneYearAgo}`;
+        break;
+      }
+      case 'allTime':
+      default:
+        dateCondition = sql`1=1`;
+        break;
+    }
+  }
+
+  let findQuery = kyselyPrisma.$kysely
+    .selectFrom('Organisation as o')
+    .leftJoin('Team as t', 'o.id', 't.organisationId')
+    .leftJoin('Envelope as e', (join) =>
+      join
+        .onRef('t.id', '=', 'e.teamId')
+        .on('e.status', '=', sql.lit(DocumentStatus.COMPLETED))
+        .on('e.deletedAt', 'is', null)
+        .on('e.type', '=', sql.lit(EnvelopeType.DOCUMENT)),
+    )
+    .leftJoin('OrganisationMember as om', 'o.id', 'om.organisationId')
+    .leftJoin('Subscription as s', 'o.id', 's.organisationId')
+    .where((eb) =>
+      eb.or([eb('o.name', 'ilike', `%${search}%`), eb('t.name', 'ilike', `%${search}%`)]),
+    )
+    .select([
+      'o.id as id',
+      'o.createdAt as createdAt',
+      'o.customerId as customerId',
+      sql<string>`COALESCE(o.name, 'Unknown')`.as('name'),
+      sql<number>`COUNT(DISTINCT CASE WHEN e.id IS NOT NULL AND ${dateCondition} THEN e.id END)`.as(
+        'signingVolume',
+      ),
+      sql<number>`GREATEST(COUNT(DISTINCT t.id), 1)`.as('teamCount'),
+      sql<number>`COUNT(DISTINCT om."userId")`.as('memberCount'),
+      sql<string>`CASE WHEN s.status IS NOT NULL THEN s.status ELSE NULL END`.as(
+        'subscriptionStatus',
+      ),
+    ])
+    .groupBy(['o.id', 'o.name', 'o.customerId', 's.status']);
+
+  switch (sortBy) {
+    case 'name':
+      findQuery = findQuery.orderBy('name', sortOrder);
+      break;
+    case 'createdAt':
+      findQuery = findQuery.orderBy('createdAt', sortOrder);
+      break;
+    case 'signingVolume':
+      findQuery = findQuery.orderBy('signingVolume', sortOrder);
+      break;
+    default:
+      findQuery = findQuery.orderBy('signingVolume', 'desc');
+  }
+
+  findQuery = findQuery.limit(perPage).offset(offset);
+
+  const countQuery = kyselyPrisma.$kysely
+    .selectFrom('Organisation as o')
+    .leftJoin('Team as t', 'o.id', 't.organisationId')
+    .where((eb) =>
+      eb.or([eb('o.name', 'ilike', `%${search}%`), eb('t.name', 'ilike', `%${search}%`)]),
+    )
+    .select(() => [sql<number>`COUNT(DISTINCT o.id)`.as('count')]);
+
+  const [results, [{ count }]] = await Promise.all([findQuery.execute(), countQuery.execute()]);
+
+  return {
+    organisations: results,
    totalPages: Math.ceil(Number(count) / perPage),
  };
 }
--- a/packages/lib/server-only/document/complete-document-with-token.ts
+++ b/packages/lib/server-only/document/complete-document-with-token.ts
@ -19,7 +19,7 @@ import { prisma } from '@documenso/prisma';

 import { AppError, AppErrorCode } from '../../errors/app-error';
 import { jobs } from '../../jobs/client';
-import type { TRecipientAccessAuth, TRecipientActionAuth } from '../../types/document-auth';
+import type { TRecipientAccessAuth } from '../../types/document-auth';
 import { DocumentAuth } from '../../types/document-auth';
 import {
  ZWebhookDocumentSchema,
@ -37,7 +37,6 @@ export type CompleteDocumentWithTokenOptions = {
  token: string;
  id: EnvelopeIdOptions;
  userId?: number;
-  authOptions?: TRecipientActionAuth;
  accessAuthOptions?: TRecipientAccessAuth;
  requestMetadata?: RequestMetadata;
  nextSigner?: {
--- a/packages/lib/server-only/document/resend-document.ts
+++ b/packages/lib/server-only/document/resend-document.ts
@ -44,7 +44,7 @@ export const resendDocument = async ({
  recipients,
  teamId,
  requestMetadata,
-}: ResendDocumentOptions): Promise<void> => {
+}: ResendDocumentOptions) => {
  const user = await prisma.user.findFirstOrThrow({
    where: {
      id: userId,
@ -103,7 +103,7 @@ export const resendDocument = async ({
  ).recipientSigningRequest;

  if (!isRecipientSigningRequestEmailEnabled) {
-    return;
+    return envelope;
  }

  const { branding, emailLanguage, organisationType, senderEmail, replyToEmail } =
@ -230,4 +230,6 @@ export const resendDocument = async ({
      );
    }),
  );
+
+  return envelope;
 };
--- a/packages/lib/server-only/document/send-document.ts
+++ b/packages/lib/server-only/document/send-document.ts
@ -1,4 +1,4 @@
-import type { DocumentData, Envelope, EnvelopeItem } from '@prisma/client';
+import type { DocumentData, Envelope, EnvelopeItem, Field } from '@prisma/client';
 import {
  DocumentSigningOrder,
  DocumentStatus,
@ -24,7 +24,9 @@ import {
  ZCheckboxFieldMeta,
  ZDropdownFieldMeta,
  ZFieldAndMetaSchema,
+  ZNumberFieldMeta,
  ZRadioFieldMeta,
+  ZTextFieldMeta,
 } from '../../types/field-meta';
 import {
  ZWebhookDocumentSchema,
@ -182,80 +184,19 @@ export const sendDocument = async ({
  // Validate and autoinsert fields for V2 envelopes.
  if (envelope.internalVersion === 2) {
    for (const unknownField of envelope.fields) {
-      const parsedField = ZFieldAndMetaSchema.safeParse(unknownField);
+      const recipient = envelope.recipients.find((r) => r.id === unknownField.recipientId);

-      if (parsedField.error) {
-        throw new AppError(AppErrorCode.INVALID_REQUEST, {
-          message: 'One or more fields have invalid metadata. Error: ' + parsedField.error.message,
+      if (!recipient) {
+        throw new AppError(AppErrorCode.NOT_FOUND, {
+          message: 'Recipient not found',
        });
      }

-      const field = parsedField.data;
-      const fieldId = unknownField.id;
+      const fieldToAutoInsert = extractFieldAutoInsertValues(unknownField);

-      if (field.type === FieldType.RADIO) {
-        const { values = [] } = ZRadioFieldMeta.parse(field.fieldMeta);
-
-        const checkedItemIndex = values.findIndex((value) => value.checked);
-
-        if (checkedItemIndex !== -1) {
-          fieldsToAutoInsert.push({
-            fieldId,
-            customText: toRadioCustomText(checkedItemIndex),
-          });
-        }
-      }
-
-      if (field.type === FieldType.DROPDOWN) {
-        const { defaultValue, values = [] } = ZDropdownFieldMeta.parse(field.fieldMeta);
-
-        if (defaultValue && values.some((value) => value.value === defaultValue)) {
-          fieldsToAutoInsert.push({
-            fieldId,
-            customText: defaultValue,
-          });
-        }
-      }
-
-      if (field.type === FieldType.CHECKBOX) {
-        const {
-          values = [],
-          validationRule,
-          validationLength,
-        } = ZCheckboxFieldMeta.parse(field.fieldMeta);
-
-        const checkedIndices: number[] = [];
-
-        values.forEach((value, i) => {
-          if (value.checked) {
-            checkedIndices.push(i);
-          }
-        });
-
-        let isValid = true;
-
-        if (validationRule && validationLength) {
-          const validation = checkboxValidationSigns.find((sign) => sign.label === validationRule);
-
-          if (!validation) {
-            throw new AppError(AppErrorCode.INVALID_REQUEST, {
-              message: 'Invalid checkbox validation rule',
-            });
-          }
-
-          isValid = validateCheckboxLength(
-            checkedIndices.length,
-            validation.value,
-            validationLength,
-          );
-        }
-
-        if (isValid && checkedIndices.length > 0) {
-          fieldsToAutoInsert.push({
-            fieldId,
-            customText: toCheckboxCustomText(checkedIndices),
-          });
-        }
+      // Only auto-insert fields if the recipient has not been sent the document yet.
+      if (fieldToAutoInsert && recipient.sendStatus !== SendStatus.SENT) {
+        fieldsToAutoInsert.push(fieldToAutoInsert);
      }
    }
  }
@ -275,6 +216,7 @@ export const sendDocument = async ({
    if (envelope.internalVersion === 2) {
      const autoInsertedFields = await Promise.all(
        fieldsToAutoInsert.map(async (field) => {
+          // Warning: Only auto-insert fields if the recipient has not been sent the document yet.
          return await tx.field.update({
            where: {
              id: field.fieldId,
@ -387,3 +329,113 @@ const injectFormValuesIntoDocument = async (
    },
  });
 };
+
+/**
+ * Extracts the auto insertion values for a given field.
+ *
+ * If field is not auto insertable, returns `null`.
+ */
+export const extractFieldAutoInsertValues = (
+  unknownField: Field,
+): { fieldId: number; customText: string } | null => {
+  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;
+
+  // Auto insert text fields with prefilled values.
+  if (field.type === FieldType.TEXT) {
+    const { text } = ZTextFieldMeta.parse(field.fieldMeta);
+
+    if (text) {
+      return {
+        fieldId,
+        customText: text,
+      };
+    }
+  }
+
+  // Auto insert number fields with prefilled values.
+  if (field.type === FieldType.NUMBER) {
+    const { value } = ZNumberFieldMeta.parse(field.fieldMeta);
+
+    if (value) {
+      return {
+        fieldId,
+        customText: value,
+      };
+    }
+  }
+
+  // Auto insert radio fields with the pre-checked value.
+  if (field.type === FieldType.RADIO) {
+    const { values = [] } = ZRadioFieldMeta.parse(field.fieldMeta);
+
+    const checkedItemIndex = values.findIndex((value) => value.checked);
+
+    if (checkedItemIndex !== -1) {
+      return {
+        fieldId,
+        customText: toRadioCustomText(checkedItemIndex),
+      };
+    }
+  }
+
+  // Auto insert dropdown fields with the default value.
+  if (field.type === FieldType.DROPDOWN) {
+    const { defaultValue, values = [] } = ZDropdownFieldMeta.parse(field.fieldMeta);
+
+    if (defaultValue && values.some((value) => value.value === defaultValue)) {
+      return {
+        fieldId,
+        customText: defaultValue,
+      };
+    }
+  }
+
+  // Auto insert checkbox fields with the pre-checked values.
+  if (field.type === FieldType.CHECKBOX) {
+    const {
+      values = [],
+      validationRule,
+      validationLength,
+    } = ZCheckboxFieldMeta.parse(field.fieldMeta);
+
+    const checkedIndices: number[] = [];
+
+    values.forEach((value, i) => {
+      if (value.checked) {
+        checkedIndices.push(i);
+      }
+    });
+
+    let isValid = true;
+
+    if (validationRule && validationLength) {
+      const validation = checkboxValidationSigns.find((sign) => sign.label === validationRule);
+
+      if (!validation) {
+        throw new AppError(AppErrorCode.INVALID_REQUEST, {
+          message: 'Invalid checkbox validation rule',
+        });
+      }
+
+      isValid = validateCheckboxLength(checkedIndices.length, validation.value, validationLength);
+    }
+
+    if (isValid && checkedIndices.length > 0) {
+      return {
+        fieldId,
+        customText: toCheckboxCustomText(checkedIndices),
+      };
+    }
+  }
+
+  return null;
+};
--- a/packages/lib/server-only/envelope/get-envelope-for-direct-template-signing.ts
+++ b/packages/lib/server-only/envelope/get-envelope-for-direct-template-signing.ts
@ -6,6 +6,7 @@ import { prisma } from '@documenso/prisma';
 import { AppError, AppErrorCode } from '../../errors/app-error';
 import { DocumentAccessAuth, type TDocumentAuthMethods } from '../../types/document-auth';
 import { extractDocumentAuthMethods } from '../../utils/document-auth';
+import { extractFieldAutoInsertValues } from '../document/send-document';
 import { getTeamSettings } from '../team/get-team-settings';
 import type { EnvelopeForSigningResponse } from './get-envelope-for-recipient-signing';
 import { ZEnvelopeForSigningResponse } from './get-envelope-for-recipient-signing';
@ -144,6 +145,19 @@ export const getEnvelopeForDirectTemplateSigning = async ({
    recipient: {
      ...recipient,
      directToken: envelope.directLink?.token || '',
+      fields: recipient.fields.map((field) => {
+        const autoInsertValue = extractFieldAutoInsertValues(field);
+
+        if (!autoInsertValue) {
+          return field;
+        }
+
+        return {
+          ...field,
+          inserted: true,
+          customText: autoInsertValue.customText,
+        };
+      }),
    },
    recipientSignature: null,
    isRecipientsTurn: true,
--- a/packages/lib/server-only/envelope/get-envelope-for-recipient-signing.ts
+++ b/packages/lib/server-only/envelope/get-envelope-for-recipient-signing.ts
@ -11,7 +11,7 @@ import UserSchema from '@documenso/prisma/generated/zod/modelSchema/UserSchema';

 import { AppError, AppErrorCode } from '../../errors/app-error';
 import type { TDocumentAuthMethods } from '../../types/document-auth';
-import { ZFieldSchema } from '../../types/field';
+import { ZEnvelopeFieldSchema, ZFieldSchema } from '../../types/field';
 import { ZRecipientLiteSchema } from '../../types/recipient';
 import { isRecipientAuthorized } from '../document/is-recipient-authorized';
 import { getTeamSettings } from '../team/get-team-settings';
@ -63,9 +63,11 @@ export const ZEnvelopeForSigningResponse = z.object({
      rejectionReason: true,
    })
      .extend({
-        fields: ZFieldSchema.omit({
-          documentId: true,
-          templateId: true,
+        fields: ZEnvelopeFieldSchema.extend({
+          signature: SignatureSchema.pick({
+            signatureImageAsBase64: true,
+            typedSignature: true,
+          }).nullish(),
        }).array(),
      })
      .array(),
--- a/packages/lib/server-only/field/set-fields-for-template.ts
+++ b/packages/lib/server-only/field/set-fields-for-template.ts
@ -129,7 +129,7 @@ export const setFieldsForTemplate = async ({
      if (field.type === FieldType.NUMBER && field.fieldMeta) {
        const numberFieldParsedMeta = ZNumberFieldMeta.parse(field.fieldMeta);
        const errors = validateNumberField(
-          String(numberFieldParsedMeta.value),
+          String(numberFieldParsedMeta.value || ''),
          numberFieldParsedMeta,
        );
        if (errors.length > 0) {
--- a/packages/lib/server-only/organisation/accept-organisation-invitation.ts
+++ b/packages/lib/server-only/organisation/accept-organisation-invitation.ts
@ -88,11 +88,13 @@ export const addUserToOrganisation = async ({
  organisationId,
  organisationGroups,
  organisationMemberRole,
+  bypassEmail = false,
 }: {
  userId: number;
  organisationId: string;
  organisationGroups: OrganisationGroup[];
  organisationMemberRole: OrganisationMemberRole;
+  bypassEmail?: boolean;
 }) => {
  const organisationGroupToUse = organisationGroups.find(
    (group) =>
@ -122,13 +124,15 @@ export const addUserToOrganisation = async ({
        },
      });

-      await jobs.triggerJob({
-        name: 'send.organisation-member-joined.email',
-        payload: {
-          organisationId,
-          memberUserId: userId,
-        },
-      });
+      if (!bypassEmail) {
+        await jobs.triggerJob({
+          name: 'send.organisation-member-joined.email',
+          payload: {
+            organisationId,
+            memberUserId: userId,
+          },
+        });
+      }
    },
    { timeout: 30_000 },
  );
--- a/packages/lib/server-only/pdf/insert-field-in-pdf-v2.ts
+++ b/packages/lib/server-only/pdf/insert-field-in-pdf-v2.ts
@ -1,5 +1,7 @@
-import Konva from 'konva';
+// sort-imports-ignore
 import 'konva/skia-backend';
+
+import Konva from 'konva';
 import path from 'node:path';
 import type { Canvas } from 'skia-canvas';
 import { FontLibrary } from 'skia-canvas';
@ -21,21 +23,19 @@ export const insertFieldInPDFV2 = async ({
 }: InsertFieldInPDFV2Options) => {
  const fontPath = path.join(process.cwd(), 'public/fonts');

-  FontLibrary.use([
-    path.join(fontPath, 'caveat.ttf'),
-    path.join(fontPath, 'noto-sans.ttf'),
-    path.join(fontPath, 'noto-sans-japanese.ttf'),
-    path.join(fontPath, 'noto-sans-chinese.ttf'),
-    path.join(fontPath, 'noto-sans-korean.ttf'),
-  ]);
+  FontLibrary.use({
+    ['Caveat']: [path.join(fontPath, 'caveat.ttf')],
+    ['Noto Sans']: [path.join(fontPath, 'noto-sans.ttf')],
+    ['Noto Sans Japanese']: [path.join(fontPath, 'noto-sans-japanese.ttf')],
+    ['Noto Sans Chinese']: [path.join(fontPath, 'noto-sans-chinese.ttf')],
+    ['Noto Sans Korean']: [path.join(fontPath, 'noto-sans-korean.ttf')],
+  });

  const stage = new Konva.Stage({ width: pageWidth, height: pageHeight });
  const layer = new Konva.Layer();

-  const insertedFields = fields.filter((field) => field.inserted);
-
  // Render the fields onto the layer.
-  for (const field of insertedFields) {
+  for (const field of fields) {
    renderField({
      scale: 1,
      field: {
--- a/packages/lib/server-only/template/create-document-from-direct-template.ts
+++ b/packages/lib/server-only/template/create-document-from-direct-template.ts
@ -215,6 +215,12 @@ export const createDocumentFromDirectTemplate = async ({
  const fieldsToProcess = directTemplateRecipient.fields.filter((templateField) => {
    const signedFieldValue = signedFieldValues.find((value) => value.fieldId === templateField.id);

+    // Custom logic for V2 to include all fields, since v1 excludes read only
+    // and prefilled fields.
+    if (directTemplateEnvelope.internalVersion === 2) {
+      return true;
+    }
+
    // Include if it's required or has a signed value
    return isRequiredField(templateField) || signedFieldValue !== undefined;
  });
@ -468,19 +474,28 @@ export const createDocumentFromDirectTemplate = async ({
        signingOrder: directTemplateRecipient.signingOrder,
        fields: {
          createMany: {
-            data: directTemplateNonSignatureFields.map(({ templateField, customText }) => ({
-              envelopeId: createdEnvelope.id,
-              envelopeItemId: oldEnvelopeItemToNewEnvelopeItemIdMap[templateField.envelopeItemId],
-              type: templateField.type,
-              page: templateField.page,
-              positionX: templateField.positionX,
-              positionY: templateField.positionY,
-              width: templateField.width,
-              height: templateField.height,
-              customText: customText ?? '',
-              inserted: true,
-              fieldMeta: templateField.fieldMeta || Prisma.JsonNull,
-            })),
+            data: directTemplateNonSignatureFields.map(({ templateField, customText }) => {
+              let inserted = true;
+
+              // Custom logic for V2 to only insert if values exist.
+              if (directTemplateEnvelope.internalVersion === 2) {
+                inserted = customText !== '';
+              }
+
+              return {
+                envelopeId: createdEnvelope.id,
+                envelopeItemId: oldEnvelopeItemToNewEnvelopeItemIdMap[templateField.envelopeItemId],
+                type: templateField.type,
+                page: templateField.page,
+                positionX: templateField.positionX,
+                positionY: templateField.positionY,
+                width: templateField.width,
+                height: templateField.height,
+                customText: customText ?? '',
+                inserted,
+                fieldMeta: templateField.fieldMeta || Prisma.JsonNull,
+              };
+            }),
          },
        },
      },