Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

feat(api): notify approvers and applicants about registrations

Hampus7a4f0379cedb
diff --git a/fluxer_api/src/api/admin/tests/InstanceConfigPendingRegistrationApproval.test.ts b/fluxer_api/src/api/admin/tests/InstanceConfigPendingRegistrationApproval.test.ts
index b4434e950..6aa819a85 100644
--- a/fluxer_api/src/api/admin/tests/InstanceConfigPendingRegistrationApproval.test.ts
+++ b/fluxer_api/src/api/admin/tests/InstanceConfigPendingRegistrationApproval.test.ts
@@ -1,9 +1,11 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
import {
+ clearTestEmails,
createTestAccount,
createUniqueEmail,
createUniqueUsername,
+ listTestEmails,
setUserACLs,
} from '@app/api/auth/tests/AuthTestUtils';
import {Config} from '@app/api/Config';
@@ -13,6 +15,7 @@ import type {ApiTestHarness} from '@app/api/test/ApiTestHarness';
import {createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';
+import {setPendingDeletionAt, triggerDeletionWorker} from '@app/api/user/tests/UserTestUtils';
import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
import type {PendingRegistrationListResponse} from '@fluxer/schema/src/domains/admin/AdminSchemas';
import type {AdminUsersMeResponse} from '@fluxer/schema/src/domains/admin/AdminUserSchemas';
@@ -361,4 +364,76 @@ describe('pending registration approval and the stock community', () => {
.execute();
expect(decided.pending_registrations).toEqual([]);
});
+
+ it('emails the applicant when the registration is approved, and not when it is rejected', async () => {
+ const admin = await setUserACLs(harness, await createTestAccount(harness), [
+ AdminACLs.AUTHENTICATE,
+ AdminACLs.REGISTRATION_REVIEW,
+ ]);
+ await getInstanceConfigRepository().setRegistrationConfig({mode: 'approval'});
+ const approvedBody = invitedRegistrationBody('approvedmail');
+ const rejectedBody = invitedRegistrationBody('rejectedmail');
+ const approved = await createBuilderWithoutAuth<PendingRegistrationResponse>(harness)
+ .post('/auth/register')
+ .body(approvedBody)
+ .execute();
+ const rejected = await createBuilderWithoutAuth<PendingRegistrationResponse>(harness)
+ .post('/auth/register')
+ .body(rejectedBody)
+ .execute();
+ await clearTestEmails(harness);
+
+ await createBuilder(harness, admin.token)
+ .patch(`/admin/instance/pending-registrations/${approved.user_id}`)
+ .body({status: 'approved'})
+ .expect(HTTP_STATUS.OK)
+ .execute();
+ await createBuilder(harness, admin.token)
+ .patch(`/admin/instance/pending-registrations/${rejected.user_id}`)
+ .body({status: 'rejected'})
+ .expect(HTTP_STATUS.OK)
+ .execute();
+
+ const approvedEmails = await listTestEmails(harness, {recipient: approvedBody.email as string});
+ expect(approvedEmails.map((email) => email.type)).toEqual(['registration_approved']);
+ expect(await listTestEmails(harness, {recipient: rejectedBody.email as string})).toEqual([]);
+ });
+
+ it('sends no approval email for an account that was not waiting', async () => {
+ const admin = await setUserACLs(harness, await createTestAccount(harness), [
+ AdminACLs.AUTHENTICATE,
+ AdminACLs.REGISTRATION_REVIEW,
+ ]);
+ const outsider = await createTestAccount(harness);
+ await clearTestEmails(harness);
+
+ await createBuilder(harness, admin.token)
+ .patch(`/admin/instance/pending-registrations/${outsider.userId}`)
+ .body({status: 'approved'})
+ .expect(HTTP_STATUS.OK)
+ .execute();
+
+ expect(await listTestEmails(harness, {recipient: outsider.email})).toEqual([]);
+ });
+
+ it('drops the pending registration when the account is deleted', async () => {
+ const admin = await setUserACLs(harness, await createTestAccount(harness), [
+ AdminACLs.AUTHENTICATE,
+ AdminACLs.REGISTRATION_REVIEW,
+ ]);
+ await getInstanceConfigRepository().setRegistrationConfig({mode: 'approval'});
+ const pending = await createBuilderWithoutAuth<PendingRegistrationResponse>(harness)
+ .post('/auth/register')
+ .body(invitedRegistrationBody('deletedpending'))
+ .execute();
+
+ await setPendingDeletionAt(harness, pending.user_id, new Date(Date.now() - 1000));
+ await triggerDeletionWorker(harness);
+
+ const listed = await createBuilder<PendingRegistrationListResponse>(harness, admin.token)
+ .get('/admin/instance/pending-registrations')
+ .expect(HTTP_STATUS.OK)
+ .execute();
+ expect(listed.pending_registrations.map((entry) => entry.user_id)).not.toContain(pending.user_id);
+ });
});
diff --git a/fluxer_api/src/api/admin/tests/RegistrationApprovalNotice.test.ts b/fluxer_api/src/api/admin/tests/RegistrationApprovalNotice.test.ts
new file mode 100644
index 000000000..6c28c248f
--- /dev/null
+++ b/fluxer_api/src/api/admin/tests/RegistrationApprovalNotice.test.ts
@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {
+ clearTestEmails,
+ createTestAccount,
+ listTestEmails,
+ setUserACLs,
+ type TestAccount,
+} from '@app/api/auth/tests/AuthTestUtils';
+import {getConfig} from '@app/api/Config';
+import {getWorkerService, setInjectedWorkerService} from '@app/api/middleware/ServiceRegistry';
+import {getEmailService, getInstanceConfigRepository, getUserRepository} from '@app/api/middleware/ServiceSingletons';
+import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
+import {RecordingWorkerService} from '@app/api/test/RecordingWorkerService';
+import {createTestWorkerHelpers} from '@app/api/test/SyncTaskWorkerService';
+import {createBuilder} from '@app/api/test/TestRequestBuilder';
+import notifyRegistrationApprovers from '@app/api/worker/tasks/NotifyRegistrationApprovers';
+import {clearWorkerDependencies, setWorkerDependenciesForTest} from '@app/api/worker/WorkerContext';
+import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it} from 'vitest';
+
+describe('notice to registration approvers', () => {
+ let harness: ApiTestHarness;
+ let owner: TestAccount;
+ let reviewer: TestAccount;
+ let bystander: TestAccount;
+ let worker: RecordingWorkerService;
+ let previousWorker: ReturnType<typeof getWorkerService>;
+ let helpers: ReturnType<typeof createTestWorkerHelpers>;
+ const adminEndpoint = getConfig().endpoints.admin;
+ const selfHosted = getConfig().instance.selfHosted;
+
+ beforeAll(async () => {
+ harness = await createApiTestHarness();
+ });
+
+ beforeEach(async () => {
+ await harness.reset();
+ previousWorker = getWorkerService();
+ worker = new RecordingWorkerService();
+ setInjectedWorkerService(worker);
+ helpers = createTestWorkerHelpers({addJob: worker.addJob.bind(worker)});
+ owner = await setUserACLs(harness, await createTestAccount(harness), [AdminACLs.WILDCARD]);
+ reviewer = await setUserACLs(harness, await createTestAccount(harness), [
+ AdminACLs.AUTHENTICATE,
+ AdminACLs.REGISTRATION_REVIEW,
+ ]);
+ bystander = await setUserACLs(harness, await createTestAccount(harness), [
+ AdminACLs.AUTHENTICATE,
+ AdminACLs.USER_LOOKUP,
+ ]);
+ setWorkerDependenciesForTest({
+ userRepository: getUserRepository(),
+ kvClient: harness.kvProvider,
+ instanceConfigRepository: getInstanceConfigRepository(),
+ emailService: getEmailService(),
+ });
+ worker.jobs.length = 0;
+ await clearTestEmails(harness);
+ getConfig().endpoints.admin = 'https://admin.example.test///';
+ getConfig().instance.selfHosted = true;
+ });
+
+ afterEach(() => {
+ getConfig().instance.selfHosted = selfHosted;
+ clearWorkerDependencies();
+ getConfig().endpoints.admin = adminEndpoint;
+ setInjectedWorkerService(previousWorker);
+ });
+
+ afterAll(async () => {
+ await harness.shutdown();
+ });
+
+ async function notifiedApprovers(): Promise<Set<string>> {
+ await notifyRegistrationApprovers({user_id: '125'}, helpers);
+ const jobs = worker.byTask('sendSystemDm');
+ expect(jobs).toHaveLength(1);
+ const recipients = jobs[0]?.payload.user_ids;
+ if (!Array.isArray(recipients) || !recipients.every((id) => typeof id === 'string')) {
+ throw new Error('Expected registration notice recipient IDs');
+ }
+ return new Set(recipients);
+ }
+
+ function setAcls(target: TestAccount, acls: Array<string>) {
+ return createBuilder(harness, owner.token).put(`/admin/users/${target.userId}/acls`).body({acls}).execute();
+ }
+
+ it('notifies an approver granted the ACL and drops one whose ACL was revoked', async () => {
+ await setAcls(reviewer, [AdminACLs.AUTHENTICATE, AdminACLs.USER_LOOKUP]);
+ await setAcls(bystander, [AdminACLs.AUTHENTICATE, AdminACLs.REGISTRATION_REVIEW]);
+ expect(await notifiedApprovers()).toEqual(new Set([owner.userId, bystander.userId]));
+ });
+
+ it('sends one system message to each approver and holds back repeats for a while', async () => {
+ await notifyRegistrationApprovers({user_id: '123'}, helpers);
+ const firstNotice = [
+ {
+ taskType: 'sendSystemDm',
+ payload: {
+ user_ids: [owner.userId, reviewer.userId],
+ content:
+ 'New sign-ups are waiting for approval. Review pending registrations at https://admin.example.test/pending-registrations',
+ },
+ options: undefined,
+ },
+ ];
+ expect(worker.jobs).toEqual(firstNotice);
+ await notifyRegistrationApprovers({user_id: '124'}, helpers);
+ expect(worker.jobs).toEqual(firstNotice);
+ });
+
+ it('emails each approver instead of a hidden DM when the instance turned DMs off', async () => {
+ await getInstanceConfigRepository().setInstancePolicyConfig({direct_messages_disabled: true});
+ await getInstanceConfigRepository().setInstanceIntegrationsConfig({email: {enabled: true}});
+ await notifyRegistrationApprovers({user_id: '126'}, helpers);
+ expect(worker.jobs).toEqual([]);
+ const emails = await listTestEmails(harness);
+ expect(emails.map(({to, type, metadata}) => ({to, type, metadata}))).toEqual([
+ {
+ to: owner.email,
+ type: 'registration_pending',
+ metadata: {review_url: 'https://admin.example.test/pending-registrations'},
+ },
+ {
+ to: reviewer.email,
+ type: 'registration_pending',
+ metadata: {review_url: 'https://admin.example.test/pending-registrations'},
+ },
+ ]);
+ });
+
+ it('sends nothing when DMs are off and the instance sends no email', async () => {
+ await getInstanceConfigRepository().setInstancePolicyConfig({direct_messages_disabled: true});
+ await getInstanceConfigRepository().setInstanceIntegrationsConfig({email: {enabled: false}});
+ await notifyRegistrationApprovers({user_id: '127'}, helpers);
+ expect(worker.jobs).toEqual([]);
+ expect(await listTestEmails(harness)).toEqual([]);
+ });
+});
diff --git a/fluxer_api/src/api/admin/tests/audit_coverage/InstanceConfigAdminAuditCases.ts b/fluxer_api/src/api/admin/tests/audit_coverage/InstanceConfigAdminAuditCases.ts
index dd63b45f1..c3495dcf6 100644
--- a/fluxer_api/src/api/admin/tests/audit_coverage/InstanceConfigAdminAuditCases.ts
+++ b/fluxer_api/src/api/admin/tests/audit_coverage/InstanceConfigAdminAuditCases.ts
@@ -90,7 +90,7 @@ export const InstanceConfigAdminAuditCases: ReadonlyArray<AdminAuditCoverageCase
action: 'test_smtp_connection',
targetType: 'instance_config',
targetId: '0',
- metadata: {port: '1', tls_mode: 'none', ok: 'false'},
+ metadata: {port: '1', tls_mode: 'none', ok: 'false', sent_message: 'false'},
},
};
},
@@ -129,6 +129,22 @@ export const InstanceConfigAdminAuditCases: ReadonlyArray<AdminAuditCoverageCase
};
},
},
+ {
+ method: 'PATCH',
+ route: '/admin/instance/registration-urls/:registration_url_id',
+ async prepare({harness, admin}) {
+ const registrationUrlId = await createRegistrationUrl(harness, admin);
+ return {
+ request: {path: `/admin/instance/registration-urls/${registrationUrlId}`, body: {label: 'Renamed'}},
+ expected: {
+ action: 'rename_registration_url',
+ targetType: 'registration_url',
+ targetId: '0',
+ metadata: {},
+ },
+ };
+ },
+ },
{
method: 'GET',
route: '/admin/instance/pending-registrations',
diff --git a/fluxer_api/src/api/instance/RegistrationApprovalNotice.ts b/fluxer_api/src/api/instance/RegistrationApprovalNotice.ts
new file mode 100644
index 000000000..380f668e4
--- /dev/null
+++ b/fluxer_api/src/api/instance/RegistrationApprovalNotice.ts
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {Config} from '@app/api/Config';
+import {Logger} from '@app/api/Logger';
+import {getWorkerService} from '@app/api/middleware/ServiceRegistry';
+
+export async function enqueueRegistrationApprovalNotice(userId: string): Promise<void> {
+ if (!Config.instance.selfHosted) return;
+ try {
+ await getWorkerService().addJob('notifyRegistrationApprovers', {user_id: userId});
+ } catch (error) {
+ Logger.warn({userId, error}, 'Could not queue the notice to registration approvers');
+ }
+}
diff --git a/fluxer_api/src/api/worker/tasks/NotifyRegistrationApprovers.ts b/fluxer_api/src/api/worker/tasks/NotifyRegistrationApprovers.ts
new file mode 100644
index 000000000..de65949dd
--- /dev/null
+++ b/fluxer_api/src/api/worker/tasks/NotifyRegistrationApprovers.ts
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {Config} from '@app/api/Config';
+import type {User} from '@app/api/models/User';
+import {noticeEmailAddress, systemDmsHidden} from '@app/api/user/services/SystemDmMessage';
+import {getWorkerDependencies} from '@app/api/worker/WorkerContext';
+import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
+import {UserFlags} from '@fluxer/constants/src/UserConstants';
+import type {WorkerTaskHandler} from '@pkgs/worker/src/contracts/WorkerTask';
+import {z} from 'zod';
+
+const REVIEW_ACLS = [AdminACLs.WILDCARD, AdminACLs.REGISTRATION_REVIEW];
+const NOTICE_INTERVAL_SECONDS = 10 * 60;
+const INELIGIBLE_FLAGS = UserFlags.DELETED | UserFlags.SELF_DELETED | UserFlags.DISABLED;
+const PayloadSchema = z.object({user_id: z.string().regex(/^\d+$/)});
+
+function canReviewRegistrations(user: User): boolean {
+ if (user.isBot || (user.flags & INELIGIBLE_FLAGS) !== 0n) return false;
+ if (user.acls.has(AdminACLs.WILDCARD)) return true;
+ return user.acls.has(AdminACLs.AUTHENTICATE) && user.acls.has(AdminACLs.REGISTRATION_REVIEW);
+}
+
+function pendingRegistrationsUrl(): string {
+ return `${Config.endpoints.admin.replace(/\/+$/, '')}/pending-registrations`;
+}
+
+function registrationApprovalNoticeContent(): string {
+ return `New sign-ups are waiting for approval. Review pending registrations at ${pendingRegistrationsUrl()}`;
+}
+
+async function findReviewers(): Promise<Array<User>> {
+ const {userRepository} = getWorkerDependencies();
+ const ids = new Set((await Promise.all(REVIEW_ACLS.map((acl) => userRepository.listUserIdsWithAcl(acl)))).flat());
+ const users = await userRepository.listUsers([...ids]);
+ return users.filter(canReviewRegistrations);
+}
+
+async function emailReviewers(reviewers: Array<User>): Promise<void> {
+ const {instanceConfigRepository, emailService} = getWorkerDependencies();
+ for (const reviewer of reviewers) {
+ const email = await noticeEmailAddress(reviewer, instanceConfigRepository);
+ if (email) {
+ await emailService.send('registration_pending', email, {reviewUrl: pendingRegistrationsUrl()}, reviewer.locale);
+ }
+ }
+}
+
+const notifyRegistrationApprovers: WorkerTaskHandler = async (payload, helpers) => {
+ const {kvClient, instanceConfigRepository} = getWorkerDependencies();
+ const {user_id: userId} = PayloadSchema.parse(payload);
+ const reviewers = await findReviewers();
+ const recipients: Array<User> = [];
+ for (const user of reviewers) {
+ if (await kvClient.setnx(`registration_approval_notice:${user.id}`, '1', NOTICE_INTERVAL_SECONDS)) {
+ recipients.push(user);
+ }
+ }
+ helpers.logger.info({userId, recipients: recipients.length}, 'Notifying registration approvers');
+ if (recipients.length === 0) return;
+ if (await systemDmsHidden(instanceConfigRepository)) {
+ await emailReviewers(recipients);
+ return;
+ }
+ await helpers.addJob('sendSystemDm', {
+ content: registrationApprovalNoticeContent(),
+ user_ids: recipients.map((user) => user.id.toString()),
+ });
+};
+
+export default notifyRegistrationApprovers;