Skip to content

armgit / papra

Public Imported from GitHub
0

The minimalistic document archiving platform.

refactor(orgs): decouple invitation flow (#1533)

Corentin Thomasset0b3d004466ee
diff --git a/apps/papra-server/src/modules/organizations/organizations.routes.ts b/apps/papra-server/src/modules/organizations/organizations.routes.ts
index 1d8d34fd..002098c6 100644
--- a/apps/papra-server/src/modules/organizations/organizations.routes.ts
+++ b/apps/papra-server/src/modules/organizations/organizations.routes.ts
@@ -5,6 +5,7 @@ import { requireAuthentication } from '../app/auth/auth.middleware';
import { getUser } from '../app/auth/auth.models';
import { createPlanEntitlementsRepository } from '../plan-entitlements/plan-entitlements.repository';
import { createPlansRepository } from '../plans/plans.repository';
+import { createGetOrganizationPlanUsecase } from '../plans/plans.usecases';
import { validateJsonBody, validateParams } from '../shared/validation/validation';
import { createSubscriptionsRepository } from '../subscriptions/subscriptions.repository';
import { createUsersRepository } from '../users/users.repository';
@@ -17,12 +18,14 @@ import {
import { ORGANIZATION_ROLES } from './organizations.constants';
import { createOrganizationsRepository } from './organizations.repository';
import {
+ buildInviteMemberToOrganization,
checkIfUserCanCreateNewOrganization,
+ checkIfUserHasReachedOrganizationInvitationLimit,
createOrganization,
ensureUserIsInOrganization,
- inviteMemberToOrganization,
removeMemberFromOrganization,
restoreOrganization,
+ sendOrganizationInvitationEmail,
softDeleteOrganization,
updateOrganizationMemberRole,
} from './organizations.usecases';
@@ -332,6 +335,33 @@ function setupInviteOrganizationMemberRoute({
emailsServices,
planEntitlementDefinitionRegistry,
}: RouteDefinitionContext) {
+ const organizationsRepository = createOrganizationsRepository({ db });
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: createGetOrganizationPlanUsecase({
+ subscriptionsRepository: createSubscriptionsRepository({ db }),
+ plansRepository: createPlansRepository({ config }),
+ planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
+ planEntitlementDefinitionRegistry,
+ }),
+ checkIfUserHasReachedOrganizationInvitationLimit: async ({ userId, now }) =>
+ checkIfUserHasReachedOrganizationInvitationLimit({
+ userId,
+ now,
+ maxInvitationsPerDay: config.organizations.maxUserInvitationsPerDay,
+ organizationsRepository,
+ }),
+ sendOrganizationInvitationEmail: async ({ email, organizationId }) =>
+ sendOrganizationInvitationEmail({
+ email,
+ organizationId,
+ organizationsRepository,
+ emailsServices,
+ config,
+ }),
+ expirationDelayDays: config.organizations.invitationExpirationDelayDays,
+ });
+
app.post(
'/api/organizations/:organizationId/members/invitations',
requireAuthentication(),
@@ -351,27 +381,13 @@ function setupInviteOrganizationMemberRoute({
const { organizationId } = context.req.valid('param');
const { email, role } = context.req.valid('json');
- const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const plansRepository = createPlansRepository({ config });
- const planEntitlementsRepository = createPlanEntitlementsRepository({ db });
-
await ensureUserIsInOrganization({ userId, organizationId, organizationsRepository });
await inviteMemberToOrganization({
email,
role,
organizationId,
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository,
- planEntitlementDefinitionRegistry,
inviterId: userId,
- expirationDelayDays: config.organizations.invitationExpirationDelayDays,
- maxInvitationsPerDay: config.organizations.maxUserInvitationsPerDay,
- emailsServices,
- config,
});
return context.body(null, 204);
diff --git a/apps/papra-server/src/modules/organizations/organizations.usecases.test.ts b/apps/papra-server/src/modules/organizations/organizations.usecases.test.ts
index 8d181f53..bb501c2d 100644
--- a/apps/papra-server/src/modules/organizations/organizations.usecases.test.ts
+++ b/apps/papra-server/src/modules/organizations/organizations.usecases.test.ts
@@ -1,14 +1,12 @@
import type { StorageService } from '../storage/storage.services';
import type { EmailsServices } from '../emails/emails.services';
-import type { PlansRepository } from '../plans/plans.repository';
import type { SubscriptionsServices } from '../subscriptions/subscriptions.services';
import { assert, describe, expect, test } from 'vitest';
import { createForbiddenError } from '../app/auth/auth.errors';
import { createInMemoryDatabase } from '../app/database/database.test-utils';
import { overrideConfig } from '../config/config.test-utils';
import { createDocumentsRepository } from '../documents/documents.repository';
-import { createPlanEntitlementsRepository } from '../plan-entitlements/plan-entitlements.repository';
-import { createPlanEntitlementDefinitionRegistry } from '../plan-entitlements/plan-entitlements.registry';
+import { createTestClock } from '../shared/clock/clock.test-utils';
import { createTestLogger } from '../shared/logger/logger.test-utils';
import { createSubscriptionsRepository } from '../subscriptions/subscriptions.repository';
import { createUsersRepository } from '../users/users.repository';
@@ -31,14 +29,16 @@ import {
organizationsTable,
} from './organizations.table';
import {
+ buildInviteMemberToOrganization,
checkIfUserCanCreateNewOrganization,
+ checkIfUserHasReachedOrganizationInvitationLimit,
ensureUserIsInOrganization,
ensureUserIsOwnerOfOrganization,
getOrCreateOrganizationCustomerId,
- inviteMemberToOrganization,
purgeExpiredSoftDeletedOrganization,
purgeExpiredSoftDeletedOrganizations,
removeMemberFromOrganization,
+ sendOrganizationInvitationEmail,
softDeleteOrganization,
} from './organizations.usecases';
@@ -471,62 +471,40 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const config = overrideConfig({
- organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 10 },
- });
- const plansRepository = {
- getOrganizationPlanById: async () => ({
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
organizationPlan: {
limits: {
maxOrganizationsMembersCount: 100,
},
},
}),
- } as unknown as PlansRepository;
-
- const sentEmails: unknown[] = [];
- const emailsServices = {
- sendEmail: async (args: unknown) => sentEmails.push(args),
- } as unknown as EmailsServices;
+ checkIfUserHasReachedOrganizationInvitationLimit: async () => {},
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ logger,
+ });
// Owner can invite
const { organizationInvitation: ownerInvitation } = await inviteMemberToOrganization({
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-1',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- emailsServices,
- config,
});
- expect(ownerInvitation?.email).toBe('[email protected]');
+ expect(ownerInvitation?.email).toEqual('[email protected]');
// Admin can invite
const { organizationInvitation: adminInvitation } = await inviteMemberToOrganization({
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-2',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- emailsServices,
- config,
});
- expect(adminInvitation?.email).toBe('[email protected]');
+ expect(adminInvitation?.email).toEqual('[email protected]');
// Member cannot invite
await expect(
@@ -534,17 +512,7 @@ describe('organizations usecases', () => {
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-3',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- logger,
- emailsServices,
- config,
}),
).rejects.toThrow(createForbiddenError());
@@ -561,7 +529,7 @@ describe('organizations usecases', () => {
]);
});
- test('it is not possible to create an invitation for the owner role to prevent multiple owners in an organization', async () => {
+ test('an invitation for the owner role cannot be created to prevent multiple owners in an organization', async () => {
const { logger, getLogs } = createTestLogger();
const { db } = await createInMemoryDatabase({
users: [{ id: 'user-1', email: '[email protected]' }],
@@ -572,40 +540,27 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const config = overrideConfig({
- organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 10 },
- });
- const plansRepository = {
- getOrganizationPlanById: async () => ({
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
organizationPlan: {
limits: {
maxOrganizationsMembersCount: 100,
},
},
}),
- } as unknown as PlansRepository;
-
- const emailsServices = {
- sendEmail: async () => {},
- } as unknown as EmailsServices;
+ checkIfUserHasReachedOrganizationInvitationLimit: async () => {},
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ logger,
+ });
await expect(
inviteMemberToOrganization({
role: ORGANIZATION_ROLES.OWNER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-1',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- logger,
- emailsServices,
- config,
}),
).rejects.toThrow(createForbiddenError());
@@ -642,40 +597,27 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const config = overrideConfig({
- organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 10 },
- });
- const plansRepository = {
- getOrganizationPlanById: async () => ({
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
organizationPlan: {
limits: {
maxOrganizationsMembersCount: 100,
},
},
}),
- } as unknown as PlansRepository;
-
- const emailsServices = {
- sendEmail: async () => {},
- } as unknown as EmailsServices;
+ checkIfUserHasReachedOrganizationInvitationLimit: async () => {},
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ logger,
+ });
await expect(
inviteMemberToOrganization({
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-1',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- logger,
- emailsServices,
- config,
}),
).rejects.toThrow(createUserAlreadyInOrganizationError());
@@ -717,40 +659,27 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const config = overrideConfig({
- organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 10 },
- });
- const plansRepository = {
- getOrganizationPlanById: async () => ({
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
organizationPlan: {
limits: {
maxOrganizationsMembersCount: 100,
},
},
}),
- } as unknown as PlansRepository;
-
- const emailsServices = {
- sendEmail: async () => {},
- } as unknown as EmailsServices;
+ checkIfUserHasReachedOrganizationInvitationLimit: async () => {},
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ logger,
+ });
await expect(
inviteMemberToOrganization({
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-1',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- logger,
- emailsServices,
- config,
}),
).rejects.toThrow(createOrganizationInvitationAlreadyExistsError());
@@ -790,40 +719,27 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const config = overrideConfig({
- organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 10 },
- });
- const plansRepository = {
- getOrganizationPlanById: async () => ({
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
organizationPlan: {
limits: {
maxOrganizationsMembersCount: 2,
},
},
}),
- } as unknown as PlansRepository;
-
- const emailsServices = {
- sendEmail: async () => {},
- } as unknown as EmailsServices;
+ checkIfUserHasReachedOrganizationInvitationLimit: async () => {},
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ logger,
+ });
await expect(
inviteMemberToOrganization({
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-1',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- logger,
- emailsServices,
- config,
}),
).rejects.toThrow(createMaxOrganizationMembersCountReachedError());
@@ -872,42 +788,95 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const config = overrideConfig({
- organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 2 },
- });
- const plansRepository = {
- getOrganizationPlanById: async () => ({
+ const { clock } = createTestClock({ now: '2025-10-05T18:00:00Z' });
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
organizationPlan: {
limits: {
maxOrganizationsMembersCount: 100,
},
},
}),
- } as unknown as PlansRepository;
+ checkIfUserHasReachedOrganizationInvitationLimit: async ({ userId, now }) =>
+ checkIfUserHasReachedOrganizationInvitationLimit({
+ userId,
+ now,
+ maxInvitationsPerDay: 2,
+ organizationsRepository,
+ }),
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ clock,
+ });
- const emailsServices = {
- sendEmail: async () => {},
- } as unknown as EmailsServices;
+ await expect(
+ inviteMemberToOrganization({
+ email: '[email protected]',
+ role: ORGANIZATION_ROLES.MEMBER,
+ organizationId: 'organization-1',
+ inviterId: 'user-1',
+ }),
+ ).rejects.toThrow(createUserOrganizationInvitationLimitReachedError());
+ });
+
+ test('daily invitation limits and expiration use the current time when the use case is reused', async () => {
+ const { db } = await createInMemoryDatabase({
+ users: [{ id: 'user-1', email: '[email protected]' }],
+ organizations: [{ id: 'organization-1', name: 'Organization 1' }],
+ organizationMembers: [
+ { organizationId: 'organization-1', userId: 'user-1', role: ORGANIZATION_ROLES.OWNER },
+ ],
+ organizationInvitations: [
+ {
+ organizationId: 'organization-1',
+ email: '[email protected]',
+ role: ORGANIZATION_ROLES.MEMBER,
+ inviterId: 'user-1',
+ status: 'pending',
+ expiresAt: new Date('2025-10-12T10:00:00Z'),
+ createdAt: new Date('2025-10-05T10:00:00Z'),
+ },
+ ],
+ });
+ const organizationsRepository = createOrganizationsRepository({ db });
+ const { clock } = createTestClock({ now: '2025-10-05T18:00:00Z' });
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
+ organizationPlan: { limits: { maxOrganizationsMembersCount: 100 } },
+ }),
+ checkIfUserHasReachedOrganizationInvitationLimit: async ({ userId, now }) =>
+ checkIfUserHasReachedOrganizationInvitationLimit({
+ userId,
+ now,
+ maxInvitationsPerDay: 1,
+ organizationsRepository,
+ }),
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ clock,
+ });
await expect(
inviteMemberToOrganization({
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-1',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 2,
- now: new Date('2025-10-05T18:00:00Z'),
- emailsServices,
- config,
}),
).rejects.toThrow(createUserOrganizationInvitationLimitReachedError());
+
+ clock.advanceBy({ hours: 24 });
+
+ const { organizationInvitation } = await inviteMemberToOrganization({
+ email: '[email protected]',
+ role: ORGANIZATION_ROLES.MEMBER,
+ organizationId: 'organization-1',
+ inviterId: 'user-1',
+ });
+
+ expect(organizationInvitation?.expiresAt).toEqual(new Date('2025-10-13T18:00:00Z'));
});
test('invitations are created with the correct expiration date and an email notification is sent to the invited user', async () => {
@@ -920,42 +889,55 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
const config = overrideConfig({
organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 10 },
client: { baseUrl: 'https://app.example.com' },
});
- const plansRepository = {
- getOrganizationPlanById: async () => ({
- organizationPlan: {
- limits: {
- maxOrganizationsMembersCount: 100,
+ const sentEmails: Parameters<EmailsServices['sendEmail']>[0][] = [];
+ const emailsServices: EmailsServices = {
+ name: 'test',
+ sendEmail: async (args) => {
+ sentEmails.push(args);
+ },
+ };
+ const { clock } = createTestClock({ now: '2025-10-05T12:00:00Z' });
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async ({ organizationId }) => {
+ expect(organizationId).toEqual('organization-1');
+
+ return {
+ organizationPlan: {
+ limits: {
+ maxOrganizationsMembersCount: 100,
+ },
},
- },
- }),
- } as unknown as PlansRepository;
-
- const sentEmails: unknown[] = [];
- const emailsServices = {
- sendEmail: async (args: unknown) => sentEmails.push(args),
- } as unknown as EmailsServices;
+ };
+ },
+ checkIfUserHasReachedOrganizationInvitationLimit: async ({ userId, now }) =>
+ checkIfUserHasReachedOrganizationInvitationLimit({
+ userId,
+ now,
+ maxInvitationsPerDay: config.organizations.maxUserInvitationsPerDay,
+ organizationsRepository,
+ }),
+ sendOrganizationInvitationEmail: async ({ email, organizationId }) =>
+ sendOrganizationInvitationEmail({
+ email,
+ organizationId,
+ organizationsRepository,
+ emailsServices,
+ config,
+ }),
+ expirationDelayDays: config.organizations.invitationExpirationDelayDays,
+ clock,
+ });
- const now = new Date('2025-10-05T12:00:00Z');
const { organizationInvitation } = await inviteMemberToOrganization({
role: ORGANIZATION_ROLES.ADMIN,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-1',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- now,
- emailsServices,
- config,
});
expect(organizationInvitation).toMatchObject({
@@ -1000,40 +982,27 @@ describe('organizations usecases', () => {
});
const organizationsRepository = createOrganizationsRepository({ db });
- const subscriptionsRepository = createSubscriptionsRepository({ db });
- const config = overrideConfig({
- organizations: { invitationExpirationDelayDays: 7, maxUserInvitationsPerDay: 10 },
- });
- const plansRepository = {
- getOrganizationPlanById: async () => ({
+ const inviteMemberToOrganization = buildInviteMemberToOrganization({
+ organizationsRepository,
+ getOrganizationPlan: async () => ({
organizationPlan: {
limits: {
maxOrganizationsMembersCount: 100,
},
},
}),
- } as unknown as PlansRepository;
-
- const emailsServices = {
- sendEmail: async () => {},
- } as unknown as EmailsServices;
+ checkIfUserHasReachedOrganizationInvitationLimit: async () => {},
+ sendOrganizationInvitationEmail: async () => {},
+ expirationDelayDays: 7,
+ logger,
+ });
await expect(
inviteMemberToOrganization({
role: ORGANIZATION_ROLES.MEMBER,
organizationId: 'organization-1',
- organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
- planEntitlementDefinitionRegistry: createPlanEntitlementDefinitionRegistry({ config }),
inviterId: 'user-2',
- expirationDelayDays: 7,
- maxInvitationsPerDay: 10,
- logger,
- emailsServices,
- config,
}),
).rejects.toThrow(createUserNotInOrganizationError());
diff --git a/apps/papra-server/src/modules/organizations/organizations.usecases.ts b/apps/papra-server/src/modules/organizations/organizations.usecases.ts
index 4bc7c631..38b73524 100644
--- a/apps/papra-server/src/modules/organizations/organizations.usecases.ts
+++ b/apps/papra-server/src/modules/organizations/organizations.usecases.ts
@@ -5,6 +5,7 @@ import type { EmailsServices } from '../emails/emails.services';
import type { PlanEntitlementsRepository } from '../plan-entitlements/plan-entitlements.repository';
import type { PlanEntitlementDefinitionRegistry } from '../plan-entitlements/plan-entitlements.registry';
import type { PlansRepository } from '../plans/plans.repository';
+import type { Clock } from '../shared/clock/clock.types';
import type { Logger } from '../shared/logger/logger';
import type { SubscriptionsRepository } from '../subscriptions/subscriptions.repository';
import type { SubscriptionsServices } from '../subscriptions/subscriptions.services';
@@ -15,6 +16,7 @@ import { buildUrl } from '@corentinth/chisels';
import { createForbiddenError } from '../app/auth/auth.errors';
import { getClientBaseUrl } from '../config/config.models';
import { getOrganizationPlan } from '../plans/plans.usecases';
+import { systemClock } from '../shared/clock/clock';
import { addDays } from '../shared/date';
import { escapeHtml } from '../shared/html/html';
import { createLogger } from '../shared/logger/logger';
@@ -228,142 +230,144 @@ export async function checkIfUserHasReachedOrganizationInvitationLimit({
}
}
-export async function inviteMemberToOrganization({
- email,
- role,
- organizationId,
+export function buildInviteMemberToOrganization({
organizationsRepository,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository,
- planEntitlementDefinitionRegistry,
- inviterId,
+ getOrganizationPlan,
+ checkIfUserHasReachedOrganizationInvitationLimit,
+ sendOrganizationInvitationEmail,
expirationDelayDays,
- maxInvitationsPerDay,
- now = new Date(),
logger = createLogger({ namespace: 'organizations.usecases' }),
- emailsServices,
- config,
+ clock = systemClock,
}: {
- email: string;
- role: OrganizationRole;
- organizationId: string;
- organizationsRepository: OrganizationsRepository;
- subscriptionsRepository: SubscriptionsRepository;
- plansRepository: PlansRepository;
- planEntitlementsRepository: PlanEntitlementsRepository;
- planEntitlementDefinitionRegistry: PlanEntitlementDefinitionRegistry;
- inviterId: string;
+ organizationsRepository: Pick<
+ OrganizationsRepository,
+ | 'getOrganizationMemberByUserId'
+ | 'getOrganizationMemberByEmail'
+ | 'getInvitationForEmailAndOrganization'
+ | 'getOrganizationMembersCount'
+ | 'getOrganizationPendingInvitationsCount'
+ | 'saveOrganizationInvitation'
+ >;
+ getOrganizationPlan: (args: { organizationId: string }) => Promise<{
+ organizationPlan: { limits: { maxOrganizationsMembersCount: number } };
+ }>;
+ checkIfUserHasReachedOrganizationInvitationLimit: (args: {
+ userId: string;
+ now: Date;
+ }) => Promise<void>;
+ sendOrganizationInvitationEmail: (args: {
+ email: string;
+ organizationId: string;
+ }) => Promise<void>;
expirationDelayDays: number;
- maxInvitationsPerDay: number;
- now?: Date;
logger?: Logger;
- emailsServices: EmailsServices;
- config: Config;
+ clock?: Clock;
}) {
- const { member: inviterMember } = await organizationsRepository.getOrganizationMemberByUserId({
- userId: inviterId,
+ return async ({
+ email,
+ role,
organizationId,
- });
-
- if (!inviterMember) {
- logger.error({ inviterId, organizationId }, 'Inviter not found in organization');
- throw createUserNotInOrganizationError();
- }
-
- if (![ORGANIZATION_ROLES.OWNER, ORGANIZATION_ROLES.ADMIN].includes(inviterMember.role)) {
- logger.error(
- { inviterId, organizationId },
- 'Inviter does not have permission to invite members to organization',
- );
- throw createForbiddenError();
- }
+ inviterId,
+ }: {
+ email: string;
+ role: OrganizationRole;
+ organizationId: string;
+ inviterId: string;
+ }) => {
+ const now = new Date(clock.now().epochMilliseconds);
+ const { member: inviterMember } = await organizationsRepository.getOrganizationMemberByUserId({
+ userId: inviterId,
+ organizationId,
+ });
- if (role === ORGANIZATION_ROLES.OWNER) {
- logger.error({ inviterId, organizationId }, 'Cannot create another owner in organization');
- throw createForbiddenError();
- }
+ if (!inviterMember) {
+ logger.error({ inviterId, organizationId }, 'Inviter not found in organization');
+ throw createUserNotInOrganizationError();
+ }
- const { member } = await organizationsRepository.getOrganizationMemberByEmail({
- email,
- organizationId,
- });
+ if (![ORGANIZATION_ROLES.OWNER, ORGANIZATION_ROLES.ADMIN].includes(inviterMember.role)) {
+ logger.error(
+ { inviterId, organizationId },
+ 'Inviter does not have permission to invite members to organization',
+ );
+ throw createForbiddenError();
+ }
- if (member) {
- logger.error(
- { inviterId, organizationId, email, memberId: member.id, memberUserId: member.userId },
- 'User already in organization',
- );
- throw createUserAlreadyInOrganizationError();
- }
+ if (role === ORGANIZATION_ROLES.OWNER) {
+ logger.error({ inviterId, organizationId }, 'Cannot create another owner in organization');
+ throw createForbiddenError();
+ }
- const { invitation } = await organizationsRepository.getInvitationForEmailAndOrganization({
- email,
- organizationId,
- });
+ const { member } = await organizationsRepository.getOrganizationMemberByEmail({
+ email,
+ organizationId,
+ });
- if (invitation) {
- logger.error(
- { inviterId, organizationId, email, invitationId: invitation.id },
- 'Invitation already exists',
- );
- throw createOrganizationInvitationAlreadyExistsError();
- }
+ if (member) {
+ logger.error(
+ { inviterId, organizationId, email, memberId: member.id, memberUserId: member.userId },
+ 'User already in organization',
+ );
+ throw createUserAlreadyInOrganizationError();
+ }
- const { membersCount } = await organizationsRepository.getOrganizationMembersCount({
- organizationId,
- });
- const { pendingInvitationsCount } =
- await organizationsRepository.getOrganizationPendingInvitationsCount({ organizationId });
- const { organizationPlan } = await getOrganizationPlan({
- organizationId,
- subscriptionsRepository,
- plansRepository,
- planEntitlementsRepository,
- planEntitlementDefinitionRegistry,
- });
+ const { invitation } = await organizationsRepository.getInvitationForEmailAndOrganization({
+ email,
+ organizationId,
+ });
- if (
- membersCount + pendingInvitationsCount >=
- organizationPlan.limits.maxOrganizationsMembersCount
- ) {
- logger.error(
- {
- inviterId,
- organizationId,
- membersCount,
- maxMembers: organizationPlan.limits.maxOrganizationsMembersCount,
- },
- 'Organization has reached its maximum number of members',
- );
- throw createMaxOrganizationMembersCountReachedError();
- }
+ if (invitation) {
+ logger.error(
+ { inviterId, organizationId, email, invitationId: invitation.id },
+ 'Invitation already exists',
+ );
+ throw createOrganizationInvitationAlreadyExistsError();
+ }
- await checkIfUserHasReachedOrganizationInvitationLimit({
- userId: inviterId,
- maxInvitationsPerDay,
- organizationsRepository,
- now,
- });
+ const { membersCount } = await organizationsRepository.getOrganizationMembersCount({
+ organizationId,
+ });
+ const { pendingInvitationsCount } =
+ await organizationsRepository.getOrganizationPendingInvitationsCount({ organizationId });
+ const { organizationPlan } = await getOrganizationPlan({ organizationId });
+
+ if (
+ membersCount + pendingInvitationsCount >=
+ organizationPlan.limits.maxOrganizationsMembersCount
+ ) {
+ logger.error(
+ {
+ inviterId,
+ organizationId,
+ membersCount,
+ maxMembers: organizationPlan.limits.maxOrganizationsMembersCount,
+ },
+ 'Organization has reached its maximum number of members',
+ );
+ throw createMaxOrganizationMembersCountReachedError();
+ }
- const { organizationInvitation } = await organizationsRepository.saveOrganizationInvitation({
- organizationId,
- email,
- role,
- inviterId,
- expirationDelayDays,
- now,
- });
+ await checkIfUserHasReachedOrganizationInvitationLimit({
+ userId: inviterId,
+ now,
+ });
- await sendOrganizationInvitationEmail({
- email,
- organizationId,
- organizationsRepository,
- emailsServices,
- config,
- });
+ const { organizationInvitation } = await organizationsRepository.saveOrganizationInvitation({
+ organizationId,
+ email,
+ role,
+ inviterId,
+ expirationDelayDays,
+ now,
+ });
+
+ await sendOrganizationInvitationEmail({
+ email,
+ organizationId,
+ });
- return { organizationInvitation };
+ return { organizationInvitation };
+ };
}
export async function sendOrganizationInvitationEmail({