chore: fix merge conflicts

packages/trpc/package.json

@@ -13,9 +13,9 @@
     "@documenso/lib": "*",
     "@documenso/prisma": "*",
     "@tanstack/react-query": "5.90.10",
-    "@trpc/client": "11.7.1",
-    "@trpc/react-query": "11.7.1",
-    "@trpc/server": "11.7.1",
+    "@trpc/client": "11.8.1",
+    "@trpc/react-query": "11.8.1",
+    "@trpc/server": "11.8.1",
     "@ts-rest/core": "^3.52.1",
     "formidable": "^3.5.4",
     "luxon": "^3.7.2",
@@ -29,4 +29,4 @@
   "devDependencies": {
     "@types/formidable": "^3.4.6"
   }
-}
+}

packages/trpc/server/document-router/get-documents-by-ids.ts

@@ -0,0 +1,65 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { getMultipleEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelopes-by-ids';
+import { mapEnvelopesToDocumentMany } from '@documenso/lib/utils/document';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZGetDocumentsByIdsRequestSchema,
+  ZGetDocumentsByIdsResponseSchema,
+  getDocumentsByIdsMeta,
+} from './get-documents-by-ids.types';
+
+export const getDocumentsByIdsRoute = authenticatedProcedure
+  .meta(getDocumentsByIdsMeta)
+  .input(ZGetDocumentsByIdsRequestSchema)
+  .output(ZGetDocumentsByIdsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { documentIds } = input;
+
+    ctx.logger.info({
+      input: {
+        documentIds,
+      },
+    });
+
+    const { envelopeWhereInput } = await getMultipleEnvelopeWhereInput({
+      ids: {
+        type: 'documentId',
+        ids: documentIds,
+      },
+      userId: user.id,
+      teamId,
+      type: EnvelopeType.DOCUMENT,
+    });
+
+    const envelopes = await prisma.envelope.findMany({
+      where: envelopeWhereInput,
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+        recipients: {
+          orderBy: {
+            id: 'asc',
+          },
+        },
+        team: {
+          select: {
+            id: true,
+            url: true,
+          },
+        },
+      },
+    });
+
+    return {
+      data: envelopes.map((envelope) => mapEnvelopesToDocumentMany(envelope)),
+    };
+  });

packages/trpc/server/document-router/get-documents-by-ids.types.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+import { ZDocumentManySchema } from '@documenso/lib/types/document';
+
+import type { TrpcRouteMeta } from '../trpc';
+
+export const getDocumentsByIdsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/document/get-many',
+    summary: 'Get multiple documents',
+    description: 'Retrieve multiple documents by their IDs',
+    tags: ['Document'],
+  },
+};
+
+export const ZGetDocumentsByIdsRequestSchema = z.object({
+  documentIds: z.array(z.number()).min(1),
+});
+
+export const ZGetDocumentsByIdsResponseSchema = z.object({
+  data: z.array(ZDocumentManySchema),
+});
+
+export type TGetDocumentsByIdsRequest = z.infer<typeof ZGetDocumentsByIdsRequestSchema>;
+export type TGetDocumentsByIdsResponse = z.infer<typeof ZGetDocumentsByIdsResponseSchema>;

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

@@ -19,6 +19,7 @@ import { findDocumentsInternalRoute } from './find-documents-internal';
 import { findInboxRoute } from './find-inbox';
 import { getDocumentRoute } from './get-document';
 import { getDocumentByTokenRoute } from './get-document-by-token';
+import { getDocumentsByIdsRoute } from './get-documents-by-ids';
 import { getInboxCountRoute } from './get-inbox-count';
 import { redistributeDocumentRoute } from './redistribute-document';
 import { searchDocumentRoute } from './search-document';
@@ -27,6 +28,7 @@ import { updateDocumentRoute } from './update-document';
 
 export const documentRouter = router({
   get: getDocumentRoute,
+  getMany: getDocumentsByIdsRoute,
   find: findDocumentsRoute,
   create: createDocumentRoute,
   update: updateDocumentRoute,

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

@@ -33,6 +33,7 @@ export const createEnvelopeRoute = authenticatedProcedure
       folderId,
       meta,
       attachments,
+      delegatedDocumentOwner,
     } = payload;
 
     ctx.logger.info({
@@ -144,6 +145,7 @@ export const createEnvelopeRoute = authenticatedProcedure
         recipients: recipientsToCreate,
         folderId,
         envelopeItems,
+        delegatedDocumentOwner,
       },
       attachments,
       meta,

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

@@ -41,6 +41,11 @@ export const createEnvelopeMeta: TrpcRouteMeta = {
 export const ZCreateEnvelopePayloadSchema = z.object({
   title: ZDocumentTitleSchema,
   type: z.nativeEnum(EnvelopeType),
+  delegatedDocumentOwner: z
+    .string()
+    .email()
+    .describe('The email of the user who will own the document.')
+    .optional(),
   externalId: ZDocumentExternalIdSchema.optional(),
   visibility: ZDocumentVisibilitySchema.optional(),
   globalAccessAuth: z.array(ZDocumentAccessAuthTypesSchema).optional(),

packages/trpc/server/envelope-router/find-envelopes.ts

@@ -0,0 +1,56 @@
+import { findEnvelopes } from '@documenso/lib/server-only/envelope/find-envelopes';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZFindEnvelopesRequestSchema,
+  ZFindEnvelopesResponseSchema,
+  findEnvelopesMeta,
+} from './find-envelopes.types';
+
+export const findEnvelopesRoute = authenticatedProcedure
+  .meta(findEnvelopesMeta)
+  .input(ZFindEnvelopesRequestSchema)
+  .output(ZFindEnvelopesResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+
+    const {
+      query,
+      type,
+      templateId,
+      page,
+      perPage,
+      orderByDirection,
+      orderByColumn,
+      source,
+      status,
+      folderId,
+    } = input;
+
+    ctx.logger.info({
+      input: {
+        query,
+        type,
+        templateId,
+        source,
+        status,
+        folderId,
+        page,
+        perPage,
+      },
+    });
+
+    return await findEnvelopes({
+      userId: user.id,
+      teamId,
+      type,
+      templateId,
+      query,
+      source,
+      status,
+      page,
+      perPage,
+      folderId,
+      orderBy: orderByColumn ? { column: orderByColumn, direction: orderByDirection } : undefined,
+    });
+  });

packages/trpc/server/envelope-router/find-envelopes.types.ts

@@ -0,0 +1,46 @@
+import { DocumentSource, DocumentStatus, EnvelopeType } from '@prisma/client';
+import { z } from 'zod';
+
+import { ZEnvelopeManySchema } from '@documenso/lib/types/envelope';
+import { ZFindResultResponse, ZFindSearchParamsSchema } from '@documenso/lib/types/search-params';
+
+import type { TrpcRouteMeta } from '../trpc';
+
+export const findEnvelopesMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'GET',
+    path: '/envelope',
+    summary: 'Find envelopes',
+    description: 'Find envelopes based on search criteria',
+    tags: ['Envelope'],
+  },
+};
+
+export const ZFindEnvelopesRequestSchema = ZFindSearchParamsSchema.extend({
+  type: z
+    .nativeEnum(EnvelopeType)
+    .describe('Filter envelopes by type (DOCUMENT or TEMPLATE).')
+    .optional(),
+  templateId: z
+    .number()
+    .describe('Filter envelopes by the template ID used to create it.')
+    .optional(),
+  source: z
+    .nativeEnum(DocumentSource)
+    .describe('Filter envelopes by how it was created.')
+    .optional(),
+  status: z
+    .nativeEnum(DocumentStatus)
+    .describe('Filter envelopes by the current status.')
+    .optional(),
+  folderId: z.string().describe('Filter envelopes by folder ID.').optional(),
+  orderByColumn: z.enum(['createdAt']).optional(),
+  orderByDirection: z.enum(['asc', 'desc']).describe('Sort direction.').default('desc'),
+});
+
+export const ZFindEnvelopesResponseSchema = ZFindResultResponse.extend({
+  data: ZEnvelopeManySchema.array(),
+});
+
+export type TFindEnvelopesRequest = z.infer<typeof ZFindEnvelopesRequestSchema>;
+export type TFindEnvelopesResponse = z.infer<typeof ZFindEnvelopesResponseSchema>;

packages/trpc/server/envelope-router/get-envelopes-by-ids.ts

@@ -0,0 +1,34 @@
+import { getEnvelopesByIds } from '@documenso/lib/server-only/envelope/get-envelopes-by-ids';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZGetEnvelopesByIdsRequestSchema,
+  ZGetEnvelopesByIdsResponseSchema,
+  getEnvelopesByIdsMeta,
+} from './get-envelopes-by-ids.types';
+
+export const getEnvelopesByIdsRoute = authenticatedProcedure
+  .meta(getEnvelopesByIdsMeta)
+  .input(ZGetEnvelopesByIdsRequestSchema)
+  .output(ZGetEnvelopesByIdsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { ids } = input;
+
+    ctx.logger.info({
+      input: {
+        ids,
+      },
+    });
+
+    const envelopes = await getEnvelopesByIds({
+      ids,
+      userId: user.id,
+      teamId,
+      type: null,
+    });
+
+    return {
+      data: envelopes,
+    };
+  });

packages/trpc/server/envelope-router/get-envelopes-by-ids.types.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+
+import { ZEnvelopeSchema } from '@documenso/lib/types/envelope';
+
+import type { TrpcRouteMeta } from '../trpc';
+
+export const getEnvelopesByIdsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/get-many',
+    summary: 'Get multiple envelopes',
+    description: 'Retrieve multiple envelopes by their IDs',
+    tags: ['Envelope'],
+  },
+};
+
+export const ZEnvelopeIdsSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('envelopeId'),
+    ids: z.array(z.string()).min(1).max(20),
+  }),
+  z.object({
+    type: z.literal('documentId'),
+    ids: z.array(z.number()).min(1).max(20),
+  }),
+  z.object({
+    type: z.literal('templateId'),
+    ids: z.array(z.number()).min(1).max(20),
+  }),
+]);
+
+export const ZGetEnvelopesByIdsRequestSchema = z.object({
+  ids: ZEnvelopeIdsSchema,
+});
+
+export const ZGetEnvelopesByIdsResponseSchema = z.object({
+  data: z.array(ZEnvelopeSchema),
+});
+
+export type TGetEnvelopesByIdsRequest = z.infer<typeof ZGetEnvelopesByIdsRequestSchema>;
+export type TGetEnvelopesByIdsResponse = z.infer<typeof ZGetEnvelopesByIdsResponseSchema>;

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

@@ -19,9 +19,11 @@ import { deleteEnvelopeRecipientRoute } from './envelope-recipients/delete-envel
 import { getEnvelopeRecipientRoute } from './envelope-recipients/get-envelope-recipient';
 import { updateEnvelopeRecipientsRoute } from './envelope-recipients/update-envelope-recipients';
 import { findEnvelopeAuditLogsRoute } from './find-envelope-audit-logs';
+import { findEnvelopesRoute } from './find-envelopes';
 import { getEnvelopeRoute } from './get-envelope';
 import { getEnvelopeItemsRoute } from './get-envelope-items';
 import { getEnvelopeItemsByTokenRoute } from './get-envelope-items-by-token';
+import { getEnvelopesByIdsRoute } from './get-envelopes-by-ids';
 import { redistributeEnvelopeRoute } from './redistribute-envelope';
 import { setEnvelopeFieldsRoute } from './set-envelope-fields';
 import { setEnvelopeRecipientsRoute } from './set-envelope-recipients';
@@ -66,10 +68,12 @@ export const envelopeRouter = router({
     set: setEnvelopeFieldsRoute,
     sign: signEnvelopeFieldRoute,
   },
+  find: findEnvelopesRoute,
   auditLog: {
     find: findEnvelopeAuditLogsRoute,
   },
   get: getEnvelopeRoute,
+  getMany: getEnvelopesByIdsRoute,
   create: createEnvelopeRoute,
   use: useEnvelopeRoute,
   update: updateEnvelopeRoute,

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

@@ -3,6 +3,7 @@ import {
   ORGANISATION_USER_ACCOUNT_TYPE,
 } from '@documenso/lib/constants/organisations';
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { orphanEnvelopes } from '@documenso/lib/server-only/envelope/orphan-envelopes';
 import { buildOrganisationWhereQuery } from '@documenso/lib/utils/organisations';
 import { prisma } from '@documenso/prisma';
 
@@ -32,6 +33,19 @@ export const deleteOrganisationRoute = authenticatedProcedure
         userId: user.id,
         roles: ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP['DELETE_ORGANISATION'],
       }),
+      select: {
+        id: true,
+        owner: {
+          select: {
+            id: true,
+          },
+        },
+        teams: {
+          select: {
+            id: true,
+          },
+        },
+      },
     });
 
     if (!organisation) {
@@ -40,6 +54,9 @@ export const deleteOrganisationRoute = authenticatedProcedure
       });
     }
 
+    // Orphan all envelopes to get rid of foreign key constraints.
+    await Promise.all(organisation.teams.map(async (team) => orphanEnvelopes({ teamId: team.id })));
+
     await prisma.$transaction(async (tx) => {
       await tx.account.deleteMany({
         where: {

packages/trpc/server/organisation-router/update-organisation-settings.ts

@@ -36,6 +36,7 @@ export const updateOrganisationSettingsRoute = authenticatedProcedure
       typedSignatureEnabled,
       uploadSignatureEnabled,
       drawSignatureEnabled,
+      delegateDocumentOwnership,
 
       // Branding related settings.
       brandingEnabled,
@@ -99,6 +100,10 @@ export const updateOrganisationSettingsRoute = authenticatedProcedure
     const derivedDrawSignatureEnabled =
       drawSignatureEnabled ?? organisation.organisationGlobalSettings.drawSignatureEnabled;
 
+    const derivedDelegateDocumentOwnership =
+      delegateDocumentOwnership ??
+      organisation.organisationGlobalSettings.delegateDocumentOwnership;
+
     if (
       derivedTypedSignatureEnabled === false &&
       derivedUploadSignatureEnabled === false &&
@@ -140,6 +145,7 @@ export const updateOrganisationSettingsRoute = authenticatedProcedure
             typedSignatureEnabled,
             uploadSignatureEnabled,
             drawSignatureEnabled,
+            delegateDocumentOwnership: derivedDelegateDocumentOwnership,
 
             // Branding related settings.
             brandingEnabled,

packages/trpc/server/organisation-router/update-organisation-settings.types.ts

@@ -22,6 +22,7 @@ export const ZUpdateOrganisationSettingsRequestSchema = z.object({
     typedSignatureEnabled: z.boolean().optional(),
     uploadSignatureEnabled: z.boolean().optional(),
     drawSignatureEnabled: z.boolean().optional(),
+    delegateDocumentOwnership: z.boolean().nullish(),
 
     // Branding related settings.
     brandingEnabled: z.boolean().optional(),

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

@@ -1,4 +1,10 @@
+import { TeamMemberRole } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { orphanEnvelopes } from '@documenso/lib/server-only/envelope/orphan-envelopes';
+import { transferTeamEnvelopes } from '@documenso/lib/server-only/envelope/transfer-team-envelopes';
 import { deleteTeam } from '@documenso/lib/server-only/team/delete-team';
+import { getTeamById } from '@documenso/lib/server-only/team/get-team';
 
 import { authenticatedProcedure } from '../trpc';
 import { ZDeleteTeamRequestSchema, ZDeleteTeamResponseSchema } from './delete-team.types';
@@ -8,15 +14,40 @@ export const deleteTeamRoute = authenticatedProcedure
   .input(ZDeleteTeamRequestSchema)
   .output(ZDeleteTeamResponseSchema)
   .mutation(async ({ input, ctx }) => {
-    const { teamId } = input;
+    const { teamId, transferTeamId } = input;
     const { user } = ctx;
 
+    const team = await getTeamById({ userId: user.id, teamId });
+
+    if (team.currentTeamRole !== TeamMemberRole.ADMIN) {
+      throw new AppError(AppErrorCode.UNAUTHORIZED, {
+        message: 'You are not allowed to delete this team',
+      });
+    }
+
     ctx.logger.info({
       input: {
         teamId,
       },
     });
 
+    const transferTeam = transferTeamId
+      ? await getTeamById({ userId: user.id, teamId: transferTeamId }).catch(() => {
+          throw new AppError(AppErrorCode.INVALID_REQUEST, {
+            message: 'Invalid transfer team ID',
+          });
+        })
+      : undefined;
+
+    if (transferTeam) {
+      await transferTeamEnvelopes({
+        sourceTeamId: teamId,
+        targetTeamId: transferTeam.id,
+      });
+    } else {
+      await orphanEnvelopes({ teamId });
+    }
+
     await deleteTeam({
       userId: user.id,
       teamId,

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

@@ -12,6 +12,7 @@ import { z } from 'zod';
 
 export const ZDeleteTeamRequestSchema = z.object({
   teamId: z.number(),
+  transferTeamId: z.number().optional(),
 });
 
 export const ZDeleteTeamResponseSchema = z.void();

packages/trpc/server/team-router/update-team-settings.ts

@@ -39,6 +39,7 @@ export const updateTeamSettingsRoute = authenticatedProcedure
       typedSignatureEnabled,
       uploadSignatureEnabled,
       drawSignatureEnabled,
+      delegateDocumentOwnership,
 
       // Branding related settings.
       brandingEnabled,
@@ -150,6 +151,7 @@ export const updateTeamSettingsRoute = authenticatedProcedure
             typedSignatureEnabled,
             uploadSignatureEnabled,
             drawSignatureEnabled,
+            delegateDocumentOwnership,
 
             // Branding related settings.
             brandingEnabled,

packages/trpc/server/team-router/update-team-settings.types.ts

@@ -26,6 +26,7 @@ export const ZUpdateTeamSettingsRequestSchema = z.object({
     typedSignatureEnabled: z.boolean().nullish(),
     uploadSignatureEnabled: z.boolean().nullish(),
     drawSignatureEnabled: z.boolean().nullish(),
+    delegateDocumentOwnership: z.boolean().nullish(),
 
     // Branding related settings.
     brandingEnabled: z.boolean().nullish(),

packages/trpc/server/template-router/get-templates-by-ids.ts

@@ -0,0 +1,125 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { getMultipleEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelopes-by-ids';
+import { mapSecondaryIdToTemplateId } from '@documenso/lib/utils/envelope';
+import { mapFieldToLegacyField } from '@documenso/lib/utils/fields';
+import { mapRecipientToLegacyRecipient } from '@documenso/lib/utils/recipients';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZGetTemplatesByIdsRequestSchema,
+  ZGetTemplatesByIdsResponseSchema,
+  getTemplatesByIdsMeta,
+} from './get-templates-by-ids.types';
+
+export const getTemplatesByIdsRoute = authenticatedProcedure
+  .meta(getTemplatesByIdsMeta)
+  .input(ZGetTemplatesByIdsRequestSchema)
+  .output(ZGetTemplatesByIdsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { templateIds } = input;
+
+    ctx.logger.info({
+      input: {
+        templateIds,
+      },
+    });
+
+    const { envelopeWhereInput } = await getMultipleEnvelopeWhereInput({
+      ids: {
+        type: 'templateId',
+        ids: templateIds,
+      },
+      userId: user.id,
+      teamId,
+      type: EnvelopeType.TEMPLATE,
+    });
+
+    const envelopes = await prisma.envelope.findMany({
+      where: envelopeWhereInput,
+      include: {
+        recipients: {
+          orderBy: {
+            id: 'asc',
+          },
+        },
+        envelopeItems: {
+          select: {
+            documentData: true,
+          },
+        },
+        fields: true,
+        team: {
+          select: {
+            id: true,
+            url: true,
+          },
+        },
+        documentMeta: {
+          select: {
+            signingOrder: true,
+            distributionMethod: true,
+          },
+        },
+        directLink: {
+          select: {
+            token: true,
+            enabled: true,
+          },
+        },
+      },
+    });
+
+    const templates = envelopes.map((envelope) => {
+      const legacyTemplateId = mapSecondaryIdToTemplateId(envelope.secondaryId);
+
+      const firstTemplateDocumentData = envelope.envelopeItems[0].documentData;
+
+      return {
+        id: legacyTemplateId,
+        envelopeId: envelope.id,
+        type: envelope.templateType,
+        visibility: envelope.visibility,
+        externalId: envelope.externalId,
+        title: envelope.title,
+        userId: envelope.userId,
+        teamId: envelope.teamId,
+        authOptions: envelope.authOptions,
+        createdAt: envelope.createdAt,
+        updatedAt: envelope.updatedAt,
+        publicTitle: envelope.publicTitle,
+        publicDescription: envelope.publicDescription,
+        folderId: envelope.folderId,
+        useLegacyFieldInsertion: envelope.useLegacyFieldInsertion,
+        team: envelope.team
+          ? {
+              id: envelope.team.id,
+              url: envelope.team.url,
+            }
+          : null,
+        fields: envelope.fields.map((field) => mapFieldToLegacyField(field, envelope)),
+        recipients: envelope.recipients.map((recipient) =>
+          mapRecipientToLegacyRecipient(recipient, envelope),
+        ),
+        templateMeta: envelope.documentMeta
+          ? {
+              signingOrder: envelope.documentMeta.signingOrder,
+              distributionMethod: envelope.documentMeta.distributionMethod,
+            }
+          : null,
+        directLink: envelope.directLink
+          ? {
+              token: envelope.directLink.token,
+              enabled: envelope.directLink.enabled,
+            }
+          : null,
+        templateDocumentDataId: firstTemplateDocumentData.id, // Backwards compatibility.
+      };
+    });
+
+    return {
+      data: templates,
+    };
+  });

packages/trpc/server/template-router/get-templates-by-ids.types.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+import { ZTemplateManySchema } from '@documenso/lib/types/template';
+
+import type { TrpcRouteMeta } from '../trpc';
+
+export const getTemplatesByIdsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/template/get-many',
+    summary: 'Get multiple templates',
+    description: 'Retrieve multiple templates by their IDs',
+    tags: ['Template'],
+  },
+};
+
+export const ZGetTemplatesByIdsRequestSchema = z.object({
+  templateIds: z.array(z.number()).min(1),
+});
+
+export const ZGetTemplatesByIdsResponseSchema = z.object({
+  data: z.array(ZTemplateManySchema),
+});
+
+export type TGetTemplatesByIdsRequest = z.infer<typeof ZGetTemplatesByIdsRequestSchema>;
+export type TGetTemplatesByIdsResponse = z.infer<typeof ZGetTemplatesByIdsResponseSchema>;

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

@@ -30,6 +30,7 @@ import { mapEnvelopeToTemplateLite } from '@documenso/lib/utils/templates';
 
 import { ZGenericSuccessResponse, ZSuccessResponseSchema } from '../schema';
 import { authenticatedProcedure, maybeAuthenticatedProcedure, router } from '../trpc';
+import { getTemplatesByIdsRoute } from './get-templates-by-ids';
 import {
   ZBulkSendTemplateMutationSchema,
   ZCreateDocumentFromDirectTemplateRequestSchema,
@@ -154,6 +155,11 @@ export const templateRouter = router({
       });
     }),
 
+  /**
+   * @public
+   */
+  getMany: getTemplatesByIdsRoute,
+
   /**
    * Wait until RR7 so we can passthrough documents.
    *