Implement prior archive cutoff API

Co-authored-by: Cursor <cursoragent@cursor.com>

apps/api/test/organizations.test.ts

@@ -0,0 +1,130 @@
+import 'reflect-metadata';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { BadRequestException } from '@nestjs/common';
+import type { UpdatePriorArchiveCutoffRequest } from '@mento/shared';
+import { ROLES_KEY } from '../src/auth/roles.decorator';
+import { OrganizationsController } from '../src/organizations/organizations.controller';
+import { OrganizationsService } from '../src/organizations/organizations.service';
+
+const cutoff = new Date('2026-10-01T00:00:00.000Z');
+
+function makeOrg(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'org-1',
+    name: 'Org',
+    slug: 'org',
+    businessField: 'personal',
+    baseCurrency: 'IRR',
+    enabledCurrencies: ['IRR'],
+    enabledModules: ['prior_data_archive'],
+    priorArchiveEnabledAt: cutoff,
+    exchangeRates: [],
+    ...overrides,
+  };
+}
+
+function makeService(org = makeOrg()) {
+  const calls: Array<{ where: unknown; data: unknown }> = [];
+  const prisma = {
+    organization: {
+      findUnique: async () => org,
+      update: async (args: { where: unknown; data: unknown }) => {
+        calls.push(args);
+        return org;
+      },
+    },
+  };
+  const billing = {
+    normalizeModules: (modules?: string[]) => modules ?? [],
+  };
+  const service = new OrganizationsService(
+    prisma as never,
+    {} as never,
+    {} as never,
+    {} as never,
+    billing as never,
+  );
+  return { service, calls };
+}
+
+describe('OrganizationsService prior archive cutoff', () => {
+  it('returns the current cutoff in the organization dto', async () => {
+    const { service } = makeService();
+
+    const dto = await service.getCurrent('org-1');
+
+    assert.equal(dto.priorArchiveCutoffAt, cutoff.toISOString());
+  });
+
+  it('updates and clears the cutoff when prior archive is enabled', async () => {
+    const { service, calls } = makeService();
+
+    await service.updatePriorArchiveCutoff('org-1', '2026-11-02T00:00:00.000Z');
+    await service.updatePriorArchiveCutoff('org-1', null);
+
+    assert.deepEqual(calls.map((call) => call.data), [
+      { priorArchiveEnabledAt: new Date('2026-11-02T00:00:00.000Z') },
+      { priorArchiveEnabledAt: null },
+    ]);
+  });
+
+  it('rejects invalid cutoffs and disabled modules', async () => {
+    const enabled = makeService();
+    await assert.rejects(
+      () => enabled.service.updatePriorArchiveCutoff('org-1', 'not-a-date'),
+      BadRequestException,
+    );
+
+    const disabled = makeService(makeOrg({ enabledModules: [] }));
+    await assert.rejects(
+      () =>
+        disabled.service.updatePriorArchiveCutoff(
+          'org-1',
+          '2026-11-02T00:00:00.000Z',
+        ),
+      BadRequestException,
+    );
+  });
+});
+
+describe('OrganizationsController prior archive cutoff', () => {
+  it('exposes an owner-only explicit cutoff patch', async () => {
+    const calls: Array<UpdatePriorArchiveCutoffRequest['cutoffAt']> = [];
+    const controller = new OrganizationsController(
+      {
+        updatePriorArchiveCutoff: async (
+          _organizationId: string,
+          cutoffAt: UpdatePriorArchiveCutoffRequest['cutoffAt'],
+        ) => {
+          calls.push(cutoffAt);
+          return makeOrg();
+        },
+      } as never,
+      {} as never,
+    );
+
+    assert.deepEqual(
+      Reflect.getMetadata(
+        ROLES_KEY,
+        controller.updatePriorArchiveCutoff,
+      ),
+      ['owner'],
+    );
+    assert.throws(
+      () =>
+        controller.updatePriorArchiveCutoff(
+          { organizationId: 'org-1' },
+          {} as UpdatePriorArchiveCutoffRequest,
+        ),
+      BadRequestException,
+    );
+
+    await controller.updatePriorArchiveCutoff(
+      { organizationId: 'org-1' },
+      { cutoffAt: null },
+    );
+
+    assert.deepEqual(calls, [null]);
+  });
+});