The Open Source DocuSign Alternative.
TypeScript digital-signaturedocument-signingdocusign-alternativee-signatureesignesignaturenext-authnextjsopen-sourcepades-standardpdfpdf-signpdf-signaturepostgresqlprismaself-hostedsigningtypescript
feat: allow admins to create users (#2082)
Ephraim Duncan2cb4cc29eab4
diff --git a/apps/remix/app/components/dialogs/admin-user-create-dialog.tsx b/apps/remix/app/components/dialogs/admin-user-create-dialog.tsxnew file mode 100644index 000000000..d5200bbaf--- /dev/null+++ b/apps/remix/app/components/dialogs/admin-user-create-dialog.tsx@@ -0,0 +1,152 @@+import { AppError } from '@documenso/lib/errors/app-error';+import { trpc } from '@documenso/trpc/react';+import { ZCreateUserRequestSchema } from '@documenso/trpc/server/admin-router/create-user.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 { Input } from '@documenso/ui/primitives/input';+import { useToast } from '@documenso/ui/primitives/use-toast';+import { zodResolver } from '@hookform/resolvers/zod';+import { Trans, useLingui } from '@lingui/react/macro';+import type * as DialogPrimitive from '@radix-ui/react-dialog';+import { useEffect, useState } from 'react';+import { useForm } from 'react-hook-form';+import { useNavigate } from 'react-router';+import type { z } from 'zod';++export type AdminUserCreateDialogProps = {+ trigger?: React.ReactNode;+} & Omit<DialogPrimitive.DialogProps, 'children'>;++const ZFormSchema = ZCreateUserRequestSchema;++type TFormSchema = z.infer<typeof ZFormSchema>;++export const AdminUserCreateDialog = ({ trigger, ...props }: AdminUserCreateDialogProps) => {+ const { t } = useLingui();+ const { toast } = useToast();++ const [open, setOpen] = useState(false);++ const navigate = useNavigate();++ const form = useForm<TFormSchema>({+ resolver: zodResolver(ZFormSchema),+ defaultValues: {+ email: '',+ name: '',+ },+ });++ const { mutateAsync: createUser } = trpc.admin.user.create.useMutation();++ const onFormSubmit = async (data: TFormSchema) => {+ try {+ const result = await createUser(data);++ await navigate(`/admin/users/${result.userId}`);++ setOpen(false);++ toast({+ title: t`Success`,+ description: t`User created and welcome email sent`,+ duration: 5000,+ });+ } catch (err) {+ const error = AppError.parseError(err);++ console.error(error);++ toast({+ title: t`An error occurred`,+ description: error.message || t`We encountered an error while creating the user. Please try again later.`,+ variant: 'destructive',+ });+ }+ };++ useEffect(() => {+ form.reset();+ }, [open, form]);++ return (+ <Dialog {...props} open={open} onOpenChange={(value) => !form.formState.isSubmitting && setOpen(value)}>+ <DialogTrigger onClick={(e) => e.stopPropagation()} asChild={true}>+ {trigger ?? (+ <Button className="flex-shrink-0" variant="secondary">+ <Trans>Create User</Trans>+ </Button>+ )}+ </DialogTrigger>++ <DialogContent position="center">+ <DialogHeader>+ <DialogTitle>+ <Trans>Create User</Trans>+ </DialogTitle>++ <DialogDescription>+ <Trans>Create a new user. A welcome email will be sent with a link to set their password.</Trans>+ </DialogDescription>+ </DialogHeader>++ <Form {...form}>+ <form onSubmit={form.handleSubmit(onFormSubmit)}>+ <fieldset className="flex h-full flex-col space-y-4" disabled={form.formState.isSubmitting}>+ <FormField+ control={form.control}+ name="email"+ render={({ field }) => (+ <FormItem>+ <FormLabel required>+ <Trans>Email</Trans>+ </FormLabel>+ <FormControl>+ <Input {...field} type="email" />+ </FormControl>+ <FormMessage />+ </FormItem>+ )}+ />++ <FormField+ control={form.control}+ name="name"+ render={({ field }) => (+ <FormItem>+ <FormLabel required>+ <Trans>Name</Trans>+ </FormLabel>+ <FormControl>+ <Input {...field} />+ </FormControl>+ <FormMessage />+ </FormItem>+ )}+ />++ <DialogFooter>+ <Button type="button" variant="secondary" onClick={() => setOpen(false)}>+ <Trans>Cancel</Trans>+ </Button>++ <Button type="submit" data-testid="dialog-create-user-button" loading={form.formState.isSubmitting}>+ <Trans>Create</Trans>+ </Button>+ </DialogFooter>+ </fieldset>+ </form>+ </Form>+ </DialogContent>+ </Dialog>+ );+};diff --git a/apps/remix/app/routes/_authenticated+/admin+/users._index.tsx b/apps/remix/app/routes/_authenticated+/admin+/users._index.tsxindex bc5bdb0a1..f3b76034d 100644--- a/apps/remix/app/routes/_authenticated+/admin+/users._index.tsx+++ b/apps/remix/app/routes/_authenticated+/admin+/users._index.tsx@@ -1,6 +1,7 @@import { findUsers } from '@documenso/lib/server-only/user/get-all-users';import { Trans } from '@lingui/react/macro';+import { AdminUserCreateDialog } from '~/components/dialogs/admin-user-create-dialog';import { AdminDashboardUsersTable } from '~/components/tables/admin-dashboard-users-table';import type { Route } from './+types/users._index';@@ -27,9 +28,13 @@ export default function AdminManageUsersPage({ loaderData }: Route.ComponentPropreturn (<div>- <h2 className="font-semibold text-4xl">- <Trans>Manage users</Trans>- </h2>+ <div className="mb-6 flex items-center justify-between">+ <h2 className="font-semibold text-4xl">+ <Trans>Manage users</Trans>+ </h2>++ <AdminUserCreateDialog />+ </div><AdminDashboardUsersTable users={users} totalPages={totalPages} page={page} perPage={perPage} /></div>diff --git a/packages/app-tests/e2e/admin/users/create-user.spec.ts b/packages/app-tests/e2e/admin/users/create-user.spec.tsnew file mode 100644index 000000000..0b48a79b5--- /dev/null+++ b/packages/app-tests/e2e/admin/users/create-user.spec.ts@@ -0,0 +1,387 @@+import { prisma } from '@documenso/prisma';+import { seedTestEmail, seedUser } from '@documenso/prisma/seed/users';+import { expect, test } from '@playwright/test';++import { apiSignin } from '../../fixtures/authentication';++test.describe.configure({ mode: 'parallel' });++/**+ * Fill in the create-user dialog and submit it.+ * Assumes the dialog trigger is already visible on the page.+ */+const submitCreateUserDialog = async ({+ page,+ email,+ name,+}: {+ page: import('@playwright/test').Page;+ email: string;+ name: string;+}) => {+ await page.getByRole('button', { name: 'Create User' }).first().click();++ const dialog = page.getByRole('dialog');+ await expect(dialog).toBeVisible();++ await dialog.getByLabel('Email').fill(email);+ await dialog.getByLabel('Name').fill(name);++ await dialog.getByTestId('dialog-create-user-button').click();+};++// ─── Happy path ──────────────────────────────────────────────────────────────++test('[ADMIN][CREATE_USER]: admin can create a new user via the dialog', async ({ page }) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });++ const newUserEmail = seedTestEmail();+ const newUserName = 'New Created User';++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ await expect(page.getByRole('heading', { name: 'Manage users' })).toBeVisible();++ await submitCreateUserDialog({ page, email: newUserEmail, name: newUserName });++ // After success the dialog closes and we navigate to /admin/users/:id.+ await expect(page).toHaveURL(/\/admin\/users\/\d+$/, { timeout: 10_000 });++ // The user-detail page renders the user's name in the heading.+ await expect(page.getByRole('heading', { name: `Manage ${newUserName}'s profile` })).toBeVisible();++ // The user exists in the database.+ const created = await prisma.user.findUnique({+ where: { email: newUserEmail.toLowerCase() },+ });++ expect(created).not.toBeNull();+ expect(created?.name).toBe(newUserName);+});++// ─── emailVerified is set + password is null for admin-created users ────────++test('[ADMIN][CREATE_USER]: a newly created user has emailVerified set and no password', async ({ page }) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });++ const newUserEmail = seedTestEmail();++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ await submitCreateUserDialog({+ page,+ email: newUserEmail,+ name: 'Pending Password User',+ });++ // Wait for redirect to confirm the request finished.+ await expect(page).toHaveURL(/\/admin\/users\/\d+$/, { timeout: 10_000 });++ // Admin-created users start with:+ // - emailVerified set (the admin vouches for the email)+ // - password null (user must set it via the welcome email reset link)+ // The "password=null" state hard-blocks login at email-password.ts:101,+ // forcing the user through the reset-link flow before they can sign in.+ const created = await prisma.user.findUnique({+ where: { email: newUserEmail.toLowerCase() },+ select: { id: true, emailVerified: true, password: true },+ });++ expect(created, 'user should exist in the database').not.toBeNull();+ expect(+ created?.emailVerified,+ 'admin-created user should have emailVerified set — admin vouches for the email',+ ).not.toBeNull();+ expect(+ created?.password,+ 'admin-created user must have password=null — they must set one via the welcome reset link',+ ).toBeNull();+});++// ─── Welcome email side effect: a PasswordResetToken is issued ───────────────++test('[ADMIN][CREATE_USER]: creating a user issues a PasswordResetToken valid for ~24 hours', async ({ page }) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });+ const newUserEmail = seedTestEmail();++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ const beforeCreation = Date.now();++ await submitCreateUserDialog({+ page,+ email: newUserEmail,+ name: 'Token Recipient',+ });++ await expect(page).toHaveURL(/\/admin\/users\/\d+$/, { timeout: 10_000 });++ const created = await prisma.user.findUniqueOrThrow({+ where: { email: newUserEmail.toLowerCase() },+ select: { id: true },+ });++ // The PasswordResetToken is created by an async background job+ // (send.admin.user.created.email), so poll until it shows up.+ await expect+ .poll(+ async () => {+ const found = await prisma.passwordResetToken.findFirst({+ where: { userId: created.id },+ });+ return found === null ? null : 'found';+ },+ {+ message: `PasswordResetToken for user ${created.id} was not created by the welcome-email job in time`,+ timeout: 30_000,+ intervals: [250, 500, 1000],+ },+ )+ .toBe('found');++ // Now that we know it exists, fetch it with strict types.+ const token = await prisma.passwordResetToken.findFirstOrThrow({+ where: { userId: created.id },+ });++ // Token should be ~24h in the future (allow a generous fudge window).+ const expiry = token.expiry.getTime();+ const expectedExpiry = beforeCreation + 24 * 60 * 60 * 1000;+ const driftMs = Math.abs(expiry - expectedExpiry);++ // Allow up to 5 minutes of drift (test setup, db round-trips, clock skew,+ // plus job scheduling delay).+ expect(driftMs, `token expiry should be ~24h from now, drift was ${driftMs}ms`).toBeLessThan(5 * 60 * 1000);++ // The token value should be a non-trivial hex string.+ expect(token.token.length).toBeGreaterThanOrEqual(32);+ expect(token.token).toMatch(/^[a-f0-9]+$/);+});++// ─── Duplicate email is rejected ─────────────────────────────────────────────++test('[ADMIN][CREATE_USER]: creating a user with an email that already exists is rejected', async ({ page }) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });++ // Seed an existing user whose email we'll collide with.+ const { user: existingUser } = await seedUser({ isPersonalOrganisation: true });++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ await submitCreateUserDialog({+ page,+ email: existingUser.email,+ name: 'Collision Attempt',+ });++ // The dialog should stay open OR an error toast should surface. Either way+ // we must NOT navigate to a new user detail page.+ await page.waitForTimeout(1000);+ await expect(page).not.toHaveURL(/\/admin\/users\/\d+$/);++ // The existing user record must not have been mutated by the attempt.+ const stillExisting = await prisma.user.findUnique({+ where: { email: existingUser.email },+ select: { id: true, name: true, emailVerified: true },+ });++ expect(stillExisting?.id).toBe(existingUser.id);+ expect(stillExisting?.name).toBe(existingUser.name);+ // The seeded user was verified — make sure the failed create didn't+ // somehow flip the flag.+ expect(stillExisting?.emailVerified).not.toBeNull();++ // Count of users with this email must still be 1.+ const matching = await prisma.user.count({+ where: { email: existingUser.email },+ });+ expect(matching).toBe(1);+});++// ─── Validation: empty form ──────────────────────────────────────────────────++test('[ADMIN][CREATE_USER]: submitting an empty form shows validation errors and does not create a user', async ({+ page,+}) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ await page.getByRole('button', { name: 'Create User' }).first().click();++ const dialog = page.getByRole('dialog');+ await expect(dialog).toBeVisible();++ // Submit without filling anything.+ await dialog.getByTestId('dialog-create-user-button').click();++ // Validation errors are surfaced for both required fields. Their presence+ // proves react-hook-form's zodResolver blocked the submit before the+ // mutation ran, so no DB write could have happened.+ await expect(dialog.getByLabel('Email')).toHaveAttribute('aria-invalid', 'true');+ await expect(dialog.getByLabel('Name')).toHaveAttribute('aria-invalid', 'true');++ // Dialog stays open and we must not have navigated to a user detail page.+ await expect(dialog).toBeVisible();+ await expect(page).not.toHaveURL(/\/admin\/users\/\d+$/);+});++// ─── Validation: malformed email ─────────────────────────────────────────────++test('[ADMIN][CREATE_USER]: a malformed email is rejected client-side', async ({ page }) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ await page.getByRole('button', { name: 'Create User' }).first().click();++ const dialog = page.getByRole('dialog');+ await expect(dialog).toBeVisible();++ const emailInput = dialog.getByLabel('Email');++ await emailInput.fill('not-an-email');+ await dialog.getByLabel('Name').fill('Some Name');++ // The Email input is rendered with type="email" and the form does not set+ // noValidate, so the browser's native HTML5 constraint validation rejects+ // the malformed value and blocks the submit event from ever firing. (As a+ // result react-hook-form's zodResolver never runs and `aria-invalid` is+ // not flipped to true — the browser is the layer doing the rejection.) We+ // assert directly on the input's ValidityState to prove the value is+ // recognised as invalid client-side.+ await expect(emailInput).toHaveJSProperty('validity.valid', false);++ await dialog.getByTestId('dialog-create-user-button').click();++ // Dialog stays open and we must not have navigated.+ await expect(dialog).toBeVisible();+ await expect(page).not.toHaveURL(/\/admin\/users\/\d+$/);++ // The bogus email is definitely not present in the DB — a targeted check+ // on a specific row, not a global count, so it's safe to run in parallel.+ const bogus = await prisma.user.findFirst({+ where: { email: 'not-an-email' },+ });+ expect(bogus).toBeNull();+});++// ─── Cancel button closes dialog without creating ───────────────────────────++test('[ADMIN][CREATE_USER]: clicking Cancel closes the dialog and does not create a user', async ({ page }) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ const newUserEmail = seedTestEmail();++ await page.getByRole('button', { name: 'Create User' }).first().click();++ const dialog = page.getByRole('dialog');+ await expect(dialog).toBeVisible();++ // Fill in valid data but cancel anyway.+ await dialog.getByLabel('Email').fill(newUserEmail);+ await dialog.getByLabel('Name').fill('Cancelled User');++ await dialog.getByRole('button', { name: 'Cancel' }).click();++ await expect(dialog).not.toBeVisible();++ // No user was created with that email.+ const created = await prisma.user.findUnique({+ where: { email: newUserEmail.toLowerCase() },+ });+ expect(created).toBeNull();+});++// ─── Email is lowercased when stored ─────────────────────────────────────────++test('[ADMIN][CREATE_USER]: email entered with mixed case is normalised to lowercase', async ({ page }) => {+ const { user: adminUser } = await seedUser({ isAdmin: true });++ // Build a known mixed-case email.+ const rawEmail = seedTestEmail();+ const mixedCaseEmail = rawEmail.replace(/^./, (c) => c.toUpperCase());++ await apiSignin({+ page,+ email: adminUser.email,+ redirectPath: '/admin/users',+ });++ await submitCreateUserDialog({+ page,+ email: mixedCaseEmail,+ name: 'Mixed Case Email User',+ });++ await expect(page).toHaveURL(/\/admin\/users\/\d+$/, { timeout: 10_000 });++ // Look up by lowercased form — that's the canonical storage.+ const created = await prisma.user.findUnique({+ where: { email: rawEmail.toLowerCase() },+ select: { id: true, email: true, emailVerified: true },+ });++ expect(created).not.toBeNull();+ expect(created?.email).toBe(rawEmail.toLowerCase());+ // Verified — admin vouches for the email. Case normalisation must not+ // affect verification state.+ expect(created?.emailVerified).not.toBeNull();+});++// ─── Access control: non-admin cannot see the Create User affordance ────────++test('[ADMIN][CREATE_USER]: non-admin user redirected away from /admin/users and cannot see Create User button', async ({+ page,+}) => {+ const { user: nonAdminUser } = await seedUser({ isAdmin: false });++ await apiSignin({+ page,+ email: nonAdminUser.email,+ redirectPath: '/admin/users',+ });++ // Non-admins are redirected away from /admin/*; the admin heading must not+ // be visible.+ await expect(page.getByRole('heading', { name: 'Manage users' })).not.toBeVisible();+ await expect(page.getByRole('button', { name: 'Create User' })).not.toBeVisible();+});++test('[ADMIN][CREATE_USER]: unauthenticated user cannot access /admin/users', async ({ page }) => {+ // No apiSignin — just navigate directly.+ await page.goto('/admin/users');++ await expect(page).not.toHaveURL(/\/admin\/users$/);+ await expect(page.getByRole('button', { name: 'Create User' })).not.toBeVisible();+});diff --git a/packages/email/template-components/template-admin-user-created.tsx b/packages/email/template-components/template-admin-user-created.tsxnew file mode 100644index 000000000..810d27974--- /dev/null+++ b/packages/email/template-components/template-admin-user-created.tsx@@ -0,0 +1,57 @@+import { Trans } from '@lingui/react/macro';++import { Button, Link, Section, Text } from '../components';+import { TemplateDocumentImage } from './template-document-image';++export type TemplateAdminUserCreatedProps = {+ resetPasswordLink: string;+ assetBaseUrl: string;+};++export const TemplateAdminUserCreated = ({ resetPasswordLink, assetBaseUrl }: TemplateAdminUserCreatedProps) => {+ return (+ <>+ <TemplateDocumentImage className="mt-6" assetBaseUrl={assetBaseUrl} />++ <Section className="flex-row items-center justify-center">+ <Text className="mx-auto mb-0 max-w-[80%] text-center font-semibold text-lg text-primary">+ <Trans>Welcome to Documenso!</Trans>+ </Text>++ <Text className="my-1 text-center text-base text-slate-400">+ <Trans>An administrator has created a Documenso account for you.</Trans>+ </Text>++ <Text className="my-1 text-center text-base text-slate-400">+ <Trans>To get started, please set your password by clicking the button below:</Trans>+ </Text>++ <Section className="mt-8 mb-6 text-center">+ <Button+ className="inline-flex items-center justify-center rounded-lg bg-documenso-500 px-6 py-3 text-center font-medium text-black text-sm no-underline"+ href={resetPasswordLink}+ >+ <Trans>Set Password</Trans>+ </Button>+ <Text className="mt-8 text-center text-slate-400 text-sm italic">+ <Trans>+ You can also copy and paste this link into your browser: {resetPasswordLink} (link expires in 24 hours)+ </Trans>+ </Text>+ </Section>++ <Section className="mt-8">+ <Text className="text-center text-slate-400 text-sm">+ <Trans>+ If you didn't expect this account or have any questions, please{' '}+ <Link href="mailto:[email protected]" className="text-documenso-500">+ contact support+ </Link>+ .+ </Trans>+ </Text>+ </Section>+ </Section>+ </>+ );+};diff --git a/packages/email/templates/admin-user-created.tsx b/packages/email/templates/admin-user-created.tsxnew file mode 100644index 000000000..f9caaf799--- /dev/null+++ b/packages/email/templates/admin-user-created.tsx@@ -0,0 +1,45 @@+import { msg } from '@lingui/core/macro';+import { useLingui } from '@lingui/react';++import { Body, Container, Head, Html, Img, Preview, Section } from '../components';+import type { TemplateAdminUserCreatedProps } from '../template-components/template-admin-user-created';+import { TemplateAdminUserCreated } from '../template-components/template-admin-user-created';+import { TemplateFooter } from '../template-components/template-footer';++export const AdminUserCreatedTemplate = ({+ resetPasswordLink,+ assetBaseUrl = 'http://localhost:3002',+}: TemplateAdminUserCreatedProps) => {+ const { _ } = useLingui();++ const previewText = msg`Set your password for Documenso`;++ const getAssetUrl = (path: string) => {+ return new URL(path, assetBaseUrl).toString();+ };++ return (+ <Html>+ <Head />+ <Preview>{_(previewText)}</Preview>+ <Body className="mx-auto my-auto bg-white font-sans">+ <Section>+ <Container className="mx-auto mt-8 mb-2 max-w-xl rounded-lg border border-slate-200 border-solid p-4 backdrop-blur-sm">+ <Section>+ <Img src={getAssetUrl('/static/logo.png')} alt="Documenso Logo" className="mb-4 h-6" />++ <TemplateAdminUserCreated resetPasswordLink={resetPasswordLink} assetBaseUrl={assetBaseUrl} />+ </Section>+ </Container>+ <div className="mx-auto mt-12 max-w-xl" />++ <Container className="mx-auto max-w-xl">+ <TemplateFooter isDocument={false} />+ </Container>+ </Section>+ </Body>+ </Html>+ );+};++export default AdminUserCreatedTemplate;diff --git a/packages/lib/jobs/client.ts b/packages/lib/jobs/client.tsindex b2863dcc5..636f66b48 100644--- a/packages/lib/jobs/client.ts+++ b/packages/lib/jobs/client.ts@@ -1,4 +1,5 @@import { JobClient } from './client/client';+import { SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION } from './definitions/emails/send-admin-user-created-email';import { SEND_CONFIRMATION_EMAIL_JOB_DEFINITION } from './definitions/emails/send-confirmation-email';import { SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION } from './definitions/emails/send-document-cancelled-emails';import { SEND_DOCUMENT_CREATED_FROM_DIRECT_TEMPLATE_EMAIL_JOB_DEFINITION } from './definitions/emails/send-document-created-from-direct-template-email';@@ -29,6 +30,7 @@ import { SYNC_EMAIL_DOMAINS_JOB_DEFINITION } from './definitions/internal/sync-e* triggering jobs.*/export const jobsClient = new JobClient([+ SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION,SEND_SIGNING_EMAIL_JOB_DEFINITION,SEND_CONFIRMATION_EMAIL_JOB_DEFINITION,SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION,diff --git a/packages/lib/jobs/definitions/emails/send-admin-user-created-email.handler.ts b/packages/lib/jobs/definitions/emails/send-admin-user-created-email.handler.tsnew file mode 100644index 000000000..1fd5341ef--- /dev/null+++ b/packages/lib/jobs/definitions/emails/send-admin-user-created-email.handler.ts@@ -0,0 +1,67 @@+import { mailer } from '@documenso/email/mailer';+import { AdminUserCreatedTemplate } from '@documenso/email/templates/admin-user-created';+import { prisma } from '@documenso/prisma';+import { msg } from '@lingui/core/macro';+import crypto from 'crypto';+import { createElement } from 'react';+import { getI18nInstance } from '../../../client-only/providers/i18n-server';+import { NEXT_PUBLIC_WEBAPP_URL } from '../../../constants/app';+import { DOCUMENSO_INTERNAL_EMAIL } from '../../../constants/email';+import { ONE_DAY } from '../../../constants/time';+import { renderEmailWithI18N } from '../../../utils/render-email-with-i18n';+import type { JobRunIO } from '../../client/_internal/job';+import type { TSendAdminUserCreatedEmailJobDefinition } from './send-admin-user-created-email';++/**+ * Send notification email for admin-created users with password reset link.+ *+ * Creates a password reset token and sends an email explaining:+ * - An administrator created their account+ * - They need to set their password+ * - Support contact if they didn't expect this+ */+export const run = async ({ payload, io }: { payload: TSendAdminUserCreatedEmailJobDefinition; io: JobRunIO }) => {+ const user = await prisma.user.findFirstOrThrow({+ where: {+ id: payload.userId,+ },+ });++ const token = await io.runTask(`create-password-reset-token`, async () => {+ const passwordResetToken = await prisma.passwordResetToken.create({+ data: {+ token: crypto.randomBytes(18).toString('hex'),+ expiry: new Date(Date.now() + ONE_DAY),+ userId: user.id,+ },+ });++ return passwordResetToken.token;+ });++ const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';+ const resetPasswordLink = `${assetBaseUrl}/reset-password/${token}`;++ const emailTemplate = createElement(AdminUserCreatedTemplate, {+ assetBaseUrl,+ resetPasswordLink,+ });++ const [html, text] = await Promise.all([+ renderEmailWithI18N(emailTemplate),+ renderEmailWithI18N(emailTemplate, { plainText: true }),+ ]);++ const i18n = await getI18nInstance();++ return mailer.sendMail({+ to: {+ address: user.email,+ name: user.name || '',+ },+ from: DOCUMENSO_INTERNAL_EMAIL,+ subject: i18n._(msg`Welcome to Documenso`),+ html,+ text,+ });+};diff --git a/packages/lib/jobs/definitions/emails/send-admin-user-created-email.ts b/packages/lib/jobs/definitions/emails/send-admin-user-created-email.tsnew file mode 100644index 000000000..cfc16e2df--- /dev/null+++ b/packages/lib/jobs/definitions/emails/send-admin-user-created-email.ts@@ -0,0 +1,31 @@+import { z } from 'zod';++import type { JobDefinition } from '../../client/_internal/job';++const SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION_ID = 'send.admin.user.created.email';++const SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION_SCHEMA = z.object({+ userId: z.number(),+});++export type TSendAdminUserCreatedEmailJobDefinition = z.infer<+ typeof SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION_SCHEMA+>;++export const SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION = {+ id: SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION_ID,+ name: 'Send Admin User Created Email',+ version: '1.0.0',+ trigger: {+ name: SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION_ID,+ schema: SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION_SCHEMA,+ },+ handler: async ({ payload, io }) => {+ const handler = await import('./send-admin-user-created-email.handler');++ await handler.run({ payload, io });+ },+} as const satisfies JobDefinition<+ typeof SEND_ADMIN_USER_CREATED_EMAIL_JOB_DEFINITION_ID,+ TSendAdminUserCreatedEmailJobDefinition+>;diff --git a/packages/lib/server-only/user/create-admin-user.ts b/packages/lib/server-only/user/create-admin-user.tsnew file mode 100644index 000000000..90cb3d04a--- /dev/null+++ b/packages/lib/server-only/user/create-admin-user.ts@@ -0,0 +1,43 @@+import { prisma } from '@documenso/prisma';+import { AppError, AppErrorCode } from '../../errors/app-error';++export interface CreateAdminUserOptions {+ name: string;+ email: string;+}++/**+ * Create a user for admin-initiated flows.+ *+ * Unlike normal signup, this function:+ * - Leaves the password unset (`null`); the user must set it later via a password reset/onboarding link+ * - Marks the email as verified immediately because this route is only called by admins+ * - Does NOT create a personal organisation (user will be added to real org)+ * - Returns the user immediately without side effects+ */+export const createAdminUser = async ({ name, email }: CreateAdminUserOptions) => {+ const userExists = await prisma.user.findFirst({+ where: {+ email: email.toLowerCase(),+ },+ });++ if (userExists) {+ throw new AppError(AppErrorCode.ALREADY_EXISTS, {+ message: 'User with this email already exists',+ });+ }++ const user = await prisma.user.create({+ data: {+ name,+ email: email.toLowerCase(),+ password: null,+ // Verifying the email here instead of the password reset flow to reduce the+ // attack surface. This route is only called by admins.+ emailVerified: new Date(),+ },+ });++ return user;+};diff --git a/packages/lib/server-only/user/create-user.ts b/packages/lib/server-only/user/create-user.tsindex e95bda507..35b48bfe7 100644--- a/packages/lib/server-only/user/create-user.ts+++ b/packages/lib/server-only/user/create-user.ts@@ -26,29 +26,40 @@ export const createUser = async ({ name, email, password, signature }: CreateUsethrow new AppError(AppErrorCode.ALREADY_EXISTS);}- const user = await prisma.$transaction(async (tx) => {- const user = await tx.user.create({- data: {- name,- email: email.toLowerCase(),- password: hashedPassword, // Todo: (RR7) Drop password.- signature,- },- });+ const user = await prisma.user.create({+ data: {+ name,+ email: email.toLowerCase(),+ password: hashedPassword, // Todo: (RR7) Drop password.+ signature,+ },+ });- // Todo: (RR7) Migrate to use this after RR7.- // await tx.account.create({- // data: {- // userId: user.id,- // type: 'emailPassword', // Todo: (RR7)- // provider: 'DOCUMENSO', // Todo: (RR7) Enums- // providerAccountId: user.id.toString(),- // password: hashedPassword,- // },- // });+ // Todo: (RR7) Migrate to use this after RR7.+ // Note: If we actually ever proceed with this, there are multiple+ // locations where we will need to update this.+ // const user = await prisma.$transaction(async (tx) => {+ // const user = await tx.user.create({+ // data: {+ // name,+ // email: email.toLowerCase(),+ // password: hashedPassword, // Todo: (RR7) Drop password.+ // signature,+ // },+ // });- return user;- });+ // await tx.account.create({+ // data: {+ // userId: user.id,+ // type: 'emailPassword', // Todo: (RR7)+ // provider: 'DOCUMENSO', // Todo: (RR7) Enums+ // providerAccountId: user.id.toString(),+ // password: hashedPassword,+ // },+ // });++ // return user;+ // });// Not used at the moment, uncomment if required.await onCreateUserHook(user).catch((err) => {diff --git a/packages/trpc/server/admin-router/create-user.ts b/packages/trpc/server/admin-router/create-user.tsnew file mode 100644index 000000000..f5ab69e03--- /dev/null+++ b/packages/trpc/server/admin-router/create-user.ts@@ -0,0 +1,32 @@+import { jobsClient } from '@documenso/lib/jobs/client';+import { createAdminUser } from '@documenso/lib/server-only/user/create-admin-user';++import { adminProcedure } from '../trpc';+import { ZCreateUserRequestSchema, ZCreateUserResponseSchema } from './create-user.types';++export const createUserRoute = adminProcedure+ .input(ZCreateUserRequestSchema)+ .output(ZCreateUserResponseSchema)+ .mutation(async ({ input, ctx }) => {+ const { email, name } = input;++ const user = await createAdminUser({+ name,+ email,+ });++ ctx.logger.info({+ createdUserId: user.id,+ });++ await jobsClient.triggerJob({+ name: 'send.admin.user.created.email',+ payload: {+ userId: user.id,+ },+ });++ return {+ userId: user.id,+ };+ });diff --git a/packages/trpc/server/admin-router/create-user.types.ts b/packages/trpc/server/admin-router/create-user.types.tsnew file mode 100644index 000000000..6e1b65438--- /dev/null+++ b/packages/trpc/server/admin-router/create-user.types.ts@@ -0,0 +1,15 @@+import { ZNameSchema } from '@documenso/lib/constants/auth';+import { z } from 'zod';++export const ZCreateUserRequestSchema = z.object({+ email: z.string().email().min(1),+ name: ZNameSchema,+});++export type TCreateUserRequest = z.infer<typeof ZCreateUserRequestSchema>;++export const ZCreateUserResponseSchema = z.object({+ userId: z.number(),+});++export type TCreateUserResponse = z.infer<typeof ZCreateUserResponseSchema>;diff --git a/packages/trpc/server/admin-router/router.ts b/packages/trpc/server/admin-router/router.tsindex 7efc6de70..70fceb307 100644--- a/packages/trpc/server/admin-router/router.ts+++ b/packages/trpc/server/admin-router/router.ts@@ -2,6 +2,7 @@ import { router } from '../trpc';import { createAdminOrganisationRoute } from './create-admin-organisation';import { createStripeCustomerRoute } from './create-stripe-customer';import { createSubscriptionClaimRoute } from './create-subscription-claim';+import { createUserRoute } from './create-user';import { deleteDocumentRoute } from './delete-document';import { deleteOrganisationRoute } from './delete-organisation';import { deleteAdminOrganisationMemberRoute } from './delete-organisation-member';@@ -64,6 +65,7 @@ export const adminRouter = router({},user: {get: getUserRoute,+ create: createUserRoute,update: updateUserRoute,delete: deleteUserRoute,enable: enableUserRoute,