@ftisindia/create-app 0.1.5 → 0.2.0

package/template/test/reports-advanced.e2e-spec.ts

@@ -0,0 +1,381 @@
+import { INestApplication, ValidationPipe } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import request, { type Response } from 'supertest';
+import { HttpExceptionFilter } from '../src/common/filters/http-exception.filter';
+import { PrismaService } from '../src/database/prisma/prisma.service';
+import { ReportsExportDispatcherService } from '../src/modules/reports/application/services/reports-export-dispatcher.service';
+
+/**
+ * Reports e2e — the surfaces the README/checklist claim but the basic query
+ * spec does not exercise: the §6.3 byFilter prepare/execute token protocol
+ * (drift + idempotency), the reports-OWNED async export worker + download,
+ * XLSX validity, the PII-egress audit row, shared-view partial-unique
+ * enforcement, and the indexed-tier publish lint emitting its migration
+ * snippet. All run against a real Postgres over the org-members CUSTOM source
+ * (no form builder involved).
+ */
+jest.setTimeout(60_000);
+
+describe('Reports advanced lifecycle (e2e)', () => {
+  let app: INestApplication;
+  let prisma: PrismaService;
+  let dispatcher: ReportsExportDispatcherService;
+
+  beforeAll(async () => {
+    process.env.DATABASE_URL = process.env.TEST_DATABASE_URL ?? process.env.DATABASE_URL;
+    process.env.JWT_SECRET ||= 'test-jwt-secret-at-least-32-characters-long';
+    process.env.AUTH_GOOGLE_ENABLED ||= 'false';
+    process.env.NODE_ENV = 'test';
+    process.env.FORMS_OUTBOX_ENABLED = 'false';
+    // Drive the export worker manually via runOnce() for determinism.
+    process.env.REPORTS_EXPORT_WORKER_ENABLED = 'false';
+    process.env.REPORTS_EXPORT_STORAGE_DIR = './var/test-report-exports';
+
+    const { AppModule } = await import('../src/app.module');
+    const moduleRef = await Test.createTestingModule({ imports: [AppModule] }).compile();
+
+    app = moduleRef.createNestApplication();
+    app.useGlobalFilters(new HttpExceptionFilter());
+    app.useGlobalPipes(
+      new ValidationPipe({ forbidNonWhitelisted: true, transform: true, whitelist: true }),
+    );
+    await app.init();
+    prisma = app.get(PrismaService);
+    dispatcher = app.get(ReportsExportDispatcherService);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it('runs a byFilter bulk action via the prepare/execute token protocol, idempotently', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-bulk');
+    await createMemberInOrg(orgId, 'rep-bulk-b', ['reports.read']);
+    const key = uniqueKey('bulk');
+    await publishOrgMembers(accessToken, orgId, key);
+
+    const prep = await api()
+      .post(`/organisations/${orgId}/reports/${key}/actions/manageTags/prepare`)
+      .set(auth(accessToken))
+      .send({ selection: { byFilter: {} } })
+      .expect(200);
+    expect(prep.body.expectedCount).toBe(2);
+    expect(typeof prep.body.actionToken).toBe('string');
+
+    const exec = await api()
+      .post(`/organisations/${orgId}/reports/${key}/actions/manageTags`)
+      .set(auth(accessToken))
+      .send({
+        selection: { byFilter: {} },
+        actionToken: prep.body.actionToken,
+        input: { add: ['reviewed'] },
+        idempotencyKey: 'bulk-1',
+      })
+      .expect(200);
+    expect(exec.body.affectedRows).toBe(2);
+    expect(exec.body.replayed).toBe(false);
+
+    // Same idempotency key ⇒ the recorded outcome replays, no re-run.
+    const replay = await api()
+      .post(`/organisations/${orgId}/reports/${key}/actions/manageTags`)
+      .set(auth(accessToken))
+      .send({
+        selection: { byFilter: {} },
+        actionToken: prep.body.actionToken,
+        input: { add: ['reviewed'] },
+        idempotencyKey: 'bulk-1',
+      })
+      .expect(200);
+    expect(replay.body.replayed).toBe(true);
+
+    const tagged = await api()
+      .post(`/organisations/${orgId}/reports/${key}/query`)
+      .set(auth(accessToken))
+      .send({ filters: [{ column: '$tags', op: 'hasTag', value: 'reviewed' }] })
+      .expect(200);
+    expect(tagged.body.rows).toHaveLength(2);
+  });
+
+  it('rejects a byFilter action whose selection drifted since prepare (409)', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-drift');
+    await createMemberInOrg(orgId, 'rep-drift-b', ['reports.read']);
+    const key = uniqueKey('drift');
+    await publishOrgMembers(accessToken, orgId, key);
+
+    const prep = await api()
+      .post(`/organisations/${orgId}/reports/${key}/actions/manageTags/prepare`)
+      .set(auth(accessToken))
+      .send({ selection: { byFilter: {} } })
+      .expect(200);
+    expect(prep.body.expectedCount).toBe(2);
+
+    // The selection grows between prepare and execute.
+    await createMemberInOrg(orgId, 'rep-drift-c', ['reports.read']);
+
+    const res = await api()
+      .post(`/organisations/${orgId}/reports/${key}/actions/manageTags`)
+      .set(auth(accessToken))
+      .send({
+        selection: { byFilter: {} },
+        actionToken: prep.body.actionToken,
+        input: { add: ['x'] },
+        idempotencyKey: 'drift-1',
+      })
+      .expect(409);
+    // The app envelope carries engine-typed extras under error.details.
+    expect(res.body.error.details.currentCount).toBe(3);
+    expect(res.body.error.details.code).toBe('REPORTS_SELECTION_DRIFT');
+  });
+
+  it('produces an async export job, the worker streams it, and it downloads', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-async');
+    await createMemberInOrg(orgId, 'rep-async-b', ['reports.read']);
+    const key = uniqueKey('async');
+    await publishOrgMembers(accessToken, orgId, key);
+
+    // Force the async path: cap sync at 1 row, then export 2.
+    await api()
+      .patch(`/organisations/${orgId}/settings`)
+      .set(auth(accessToken))
+      .send({ key: 'reports.maxRowsSync', value: 1 })
+      .expect(200);
+
+    const queued = await api()
+      .post(`/organisations/${orgId}/reports/${key}/export`)
+      .set(auth(accessToken))
+      .send({ format: 'csv' })
+      .expect(202);
+    expect(queued.body.status).toBe('PENDING');
+    const jobId = queued.body.id as string;
+
+    // Drain the reports-owned worker deterministically (no forms outbox).
+    const cycle = await dispatcher.runOnce();
+    expect(cycle.done).toBeGreaterThanOrEqual(1);
+
+    const status = await api()
+      .get(`/organisations/${orgId}/reports/exports/${jobId}`)
+      .set(auth(accessToken))
+      .expect(200);
+    expect(status.body.status).toBe('DONE');
+    expect(status.body.rowCount).toBe(2);
+    expect(status.body.asOf).not.toBeNull();
+
+    const download = await api()
+      .get(`/organisations/${orgId}/reports/exports/${jobId}/download`)
+      .set(auth(accessToken))
+      .expect(200);
+    expect(download.headers['content-disposition']).toContain('attachment');
+    expect(download.text).toContain('Name');
+    expect(download.text.split(/\r?\n/).filter(Boolean).length).toBe(3); // header + 2 rows
+
+    await prisma.reportExportJob.update({
+      where: { id: jobId },
+      data: { updatedAt: new Date(Date.now() - 365 * 24 * 60 * 60 * 1000) },
+    });
+    await expect(dispatcher.cleanupExpiredFiles()).resolves.toBeGreaterThanOrEqual(1);
+
+    const expired = await prisma.reportExportJob.findUnique({ where: { id: jobId } });
+    expect(expired?.fileId).toBeNull();
+    await api()
+      .get(`/organisations/${orgId}/reports/exports/${jobId}/download`)
+      .set(auth(accessToken))
+      .expect(404);
+  });
+
+  it('streams a structurally valid XLSX synchronously', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-xlsx');
+    const key = uniqueKey('xlsx');
+    await publishOrgMembers(accessToken, orgId, key);
+
+    const res = await api()
+      .post(`/organisations/${orgId}/reports/${key}/export`)
+      .set(auth(accessToken))
+      .send({ format: 'xlsx' })
+      .buffer(true)
+      .parse(binaryParser)
+      .expect(200);
+    const body = res.body as Buffer;
+    expect(res.headers['content-type']).toContain('spreadsheetml');
+    // Every .xlsx is a ZIP — the local file header magic is "PK\x03\x04".
+    expect(body.subarray(0, 2).toString('latin1')).toBe('PK');
+    expect(body.byteLength).toBeGreaterThan(200);
+  });
+
+  it('writes a PII-egress audit row for every export', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-audit');
+    const key = uniqueKey('audit');
+    await publishOrgMembers(accessToken, orgId, key);
+
+    await api()
+      .post(`/organisations/${orgId}/reports/${key}/export`)
+      .set(auth(accessToken))
+      .send({ format: 'csv' })
+      .expect(200);
+
+    const row = await pollFor(() =>
+      prisma.auditLog.findFirst({
+        where: { orgId, action: 'reports.export' },
+        orderBy: { createdAt: 'desc' },
+      }),
+    );
+    expect(row).not.toBeNull();
+    const metadata = row!.metadata as Record<string, unknown>;
+    expect(metadata.reportKey).toBe(key);
+    expect(metadata.columns).toEqual(expect.arrayContaining(['displayName']));
+    expect(metadata.rowCount).toBe(1);
+  });
+
+  it('enforces unique shared-view names via the partial unique index', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-uq');
+    const key = uniqueKey('uq');
+    await publishOrgMembers(accessToken, orgId, key);
+
+    await api()
+      .post(`/organisations/${orgId}/reports/${key}/views/shared`)
+      .set(auth(accessToken))
+      .send({ name: 'Review board', spec: {} })
+      .expect(201);
+
+    await api()
+      .post(`/organisations/${orgId}/reports/${key}/views/shared`)
+      .set(auth(accessToken))
+      .send({ name: 'Review board', spec: {} })
+      .expect(409);
+  });
+
+  it('fails an indexed-tier publish with the exact migration snippet attached', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-indexed');
+    const key = uniqueKey('indexed');
+    const def = orgMembersDefinition(key);
+    def.performanceTier = 'indexed';
+
+    // The draft saves (save-time lint does not touch the catalog)...
+    await api()
+      .post(`/organisations/${orgId}/reports`)
+      .set(auth(accessToken))
+      .send(def)
+      .expect(201);
+
+    // ...but publishing runs the catalog lint: the manifest's declared indexes
+    // do not exist, so it fails constructively with CREATE INDEX SQL (§8).
+    const res = await api()
+      .post(`/organisations/${orgId}/reports/${key}/publish`)
+      .set(auth(accessToken))
+      .expect(422);
+    expect(JSON.stringify(res.body)).toContain('CREATE INDEX');
+  });
+
+  // ── helpers ─────────────────────────────────────────────────────────────────
+
+  function api() {
+    return request(app.getHttpServer());
+  }
+
+  function auth(token: string) {
+    return { Authorization: `Bearer ${token}` };
+  }
+
+  function uniqueSuffix() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+
+  function uniqueKey(label: string) {
+    return `${label}-${uniqueSuffix()}`.toLowerCase();
+  }
+
+  function orgMembersDefinition(key: string): Record<string, unknown> {
+    return {
+      key,
+      title: 'Organisation members',
+      source: { kind: 'custom', key: 'org-members' },
+      columns: [
+        { id: 'displayName', header: 'Name', columnId: 'displayName', type: 'text', sortable: true, filterable: true, searchable: true },
+        { id: 'email', header: 'Email', columnId: 'email', type: 'text', sortable: true, filterable: true },
+        { id: 'role', header: 'Role', columnId: 'role', type: 'text', sortable: true, filterable: true },
+        { id: 'status', header: 'Status', columnId: 'status', type: 'enum', filterable: true, enum: ['ACTIVE', 'SUSPENDED', 'REVOKED'] },
+        { id: 'joinedAt', header: 'Joined', columnId: 'joinedAt', type: 'datetime', sortable: true },
+      ],
+      defaultSort: [{ column: 'joinedAt', dir: 'desc' }],
+      search: { columns: ['displayName'] },
+      rowActions: ['manageTags'],
+      export: { formats: ['csv', 'xlsx'] },
+      performanceTier: 'live',
+    };
+  }
+
+  async function publishOrgMembers(accessToken: string, orgId: string, key: string) {
+    await api()
+      .post(`/organisations/${orgId}/reports`)
+      .set(auth(accessToken))
+      .send(orgMembersDefinition(key))
+      .expect(201);
+    await api()
+      .post(`/organisations/${orgId}/reports/${key}/publish`)
+      .set(auth(accessToken))
+      .expect(200);
+  }
+
+  async function createUserAndOrg(label: string) {
+    const user = await createUser(label);
+    const org = await createOrganisation(user.accessToken, label);
+    return { ...user, orgId: org.orgId };
+  }
+
+  async function createUser(label: string) {
+    const suffix = uniqueSuffix();
+    const signup = await api()
+      .post('/auth/signup')
+      .send({ email: `${label}-${suffix}@example.com`, password: 'test-password-123', displayName: label })
+      .expect(201);
+    return {
+      accessToken: signup.body.accessToken as string,
+      userId: signup.body.user.id as string,
+    };
+  }
+
+  async function createOrganisation(accessToken: string, label: string) {
+    const suffix = uniqueSuffix();
+    const org = await api()
+      .post('/organisations')
+      .set(auth(accessToken))
+      .send({ name: `${label} ${suffix}`, slug: `${label}-${suffix}` })
+      .expect(201);
+    return { orgId: org.body.organisation.id as string };
+  }
+
+  async function createMemberInOrg(orgId: string, label: string, permissionKeys: string[]) {
+    const user = await createUser(label);
+    const permissions = await prisma.permission.findMany({
+      where: { key: { in: permissionKeys } },
+      select: { id: true },
+    });
+    const role = await prisma.role.create({
+      data: {
+        orgId,
+        name: `${label}-${uniqueSuffix()}`,
+        permissions: { create: permissions.map((permission) => ({ permissionId: permission.id })) },
+      },
+      select: { id: true },
+    });
+    await prisma.membership.create({ data: { userId: user.userId, orgId, roleId: role.id } });
+    return user;
+  }
+
+  async function pollFor<T>(fn: () => Promise<T | null>, attempts = 20): Promise<T | null> {
+    for (let i = 0; i < attempts; i += 1) {
+      const value = await fn();
+      if (value !== null) {
+        return value;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return fn();
+  }
+});
+
+/** Collect a binary response body (StreamableFile) into one Buffer. */
+function binaryParser(res: Response, cb: (err: Error | null, body: Buffer) => void): void {
+  const chunks: Buffer[] = [];
+  res.on('data', (chunk: Buffer) => chunks.push(Buffer.from(chunk)));
+  res.on('end', () => cb(null, Buffer.concat(chunks)));
+}

package/template/test/reports-permission-sync.spec.ts

@@ -0,0 +1,30 @@
+import { REPORT_PERMISSION_KEYS } from '@ftisindia/report-builder';
+import { permissionKeys } from '../src/modules/access-control/types/permission-key';
+
+/**
+ * The template carries the report permission keys as literals (so the
+ * as-const tuple stays narrow and gen:module's insertion markers keep
+ * working); this test is the mechanical guarantee they can never drift from
+ * the engine's REPORT_PERMISSION_KEYS export — in either direction.
+ */
+describe('reports permission sync', () => {
+  const templateReportKeys = permissionKeys.filter(
+    (key) => key.startsWith('reports.') || key.startsWith('reportTags.'),
+  );
+
+  it('contains every engine report permission key', () => {
+    for (const key of REPORT_PERMISSION_KEYS) {
+      expect(permissionKeys).toContain(key);
+    }
+  });
+
+  it('has no report keys the engine does not declare', () => {
+    expect([...templateReportKeys].sort()).toEqual([...REPORT_PERMISSION_KEYS].sort());
+  });
+
+  it('carries the formSubmissions.update key the delegated grid verbs require', () => {
+    // Report design §6.1: editSubmission/updateStatus delegate to the form
+    // engine and are gated by this key from the FORM taxonomy.
+    expect(permissionKeys).toContain('formSubmissions.update');
+  });
+});