@ftisindia/create-app 0.1.5 → 0.2.0

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

@@ -0,0 +1,343 @@
+import { INestApplication, ValidationPipe } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import request from 'supertest';
+import { ReportSourceRegistry } from '@ftisindia/report-builder';
+import type { ReportSourceDef } from '@ftisindia/report-builder';
+import { HttpExceptionFilter } from '../src/common/filters/http-exception.filter';
+import { PrismaService } from '../src/database/prisma/prisma.service';
+import { ReportsSchemaCheckService } from '../src/modules/reports/infrastructure/schema-check/reports-schema-check.service';
+
+/**
+ * Reports e2e for the production-critical surfaces the basic specs do not
+ * reach: the indexed-tier publish → apply-migration → republish ROUND TRIP,
+ * the materialized tier over a real materialized view, and the boot
+ * schema-check FAILURE mode. All against real Postgres; test-only sources are
+ * registered into the engine's source registry at runtime (no shipped
+ * production code needed to exercise them).
+ */
+jest.setTimeout(60_000);
+
+describe('Reports performance tiers + schema check (e2e)', () => {
+  let app: INestApplication;
+  let prisma: PrismaService;
+  let sources: ReportSourceRegistry;
+
+  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';
+    process.env.REPORTS_EXPORT_WORKER_ENABLED = 'false';
+
+    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);
+    sources = app.get(ReportSourceRegistry);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it('indexed tier: publish fails with the migration snippet, then SUCCEEDS after applying it', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-idxrt');
+    const tag = uniqueTag();
+    const sourceKey = `idx-test-${tag}`;
+    const statusIdx = `idx_rb_test_status_${tag}`;
+    const joinedIdx = `idx_rb_test_joined_${tag}`;
+    sources.register(indexedTestSource(sourceKey, statusIdx, joinedIdx));
+
+    const key = uniqueKey('idxrt');
+    const def = indexedDefinition(key, sourceKey);
+
+    try {
+      await api()
+        .post(`/organisations/${orgId}/reports`)
+        .set(auth(accessToken))
+        .send(def)
+        .expect(201);
+
+      // Publish runs the catalog lint: the declared indexes do not exist yet,
+      // so it fails CONSTRUCTIVELY with the exact CREATE INDEX SQL (§8).
+      const failed = await api()
+        .post(`/organisations/${orgId}/reports/${key}/publish`)
+        .set(auth(accessToken))
+        .expect(422);
+      expect(JSON.stringify(failed.body)).toContain('CREATE INDEX');
+      expect(JSON.stringify(failed.body)).toContain(statusIdx);
+
+      // Apply the suggested indexes (org-leading btrees on the physical columns).
+      await prisma.$executeRawUnsafe(
+        `CREATE INDEX "${statusIdx}" ON "Membership" ("orgId", "status")`,
+      );
+      await prisma.$executeRawUnsafe(
+        `CREATE INDEX "${joinedIdx}" ON "Membership" ("orgId", "createdAt")`,
+      );
+
+      // The SAME draft now publishes: catalog + plan lint pass.
+      await api()
+        .post(`/organisations/${orgId}/reports/${key}/publish`)
+        .set(auth(accessToken))
+        .expect(200);
+
+      const result = await api()
+        .post(`/organisations/${orgId}/reports/${key}/query`)
+        .set(auth(accessToken))
+        .send({ sort: [{ column: 'joinedAt', dir: 'desc' }] })
+        .expect(200);
+      expect(result.body.rows.length).toBeGreaterThanOrEqual(1);
+    } finally {
+      await prisma.$executeRawUnsafe(`DROP INDEX IF EXISTS "${statusIdx}"`);
+      await prisma.$executeRawUnsafe(`DROP INDEX IF EXISTS "${joinedIdx}"`);
+    }
+  });
+
+  it('materialized tier: publishes against a materialized view and reports freshAsOf', async () => {
+    const { accessToken, orgId } = await createUserAndOrg('rep-matrt');
+    const tag = uniqueTag();
+    const mv = `rb_test_mv_${tag}`;
+
+    // Create the matview AFTER the org exists so it captures the owner row.
+    await prisma.$executeRawUnsafe(
+      `CREATE MATERIALIZED VIEW ${mv} AS ` +
+        `SELECT m."id" AS "rowId", m."orgId" AS "orgId", m."status"::text AS "status", ` +
+        `m."createdAt" AS "joinedAt" FROM "Membership" m`,
+    );
+    try {
+      const sourceKey = `mat-test-${tag}`;
+      sources.register(materializedTestSource(sourceKey, mv));
+
+      const key = uniqueKey('matrt');
+      const def = {
+        key,
+        title: 'Member stats (materialized)',
+        source: { kind: 'custom', key: sourceKey },
+        columns: [
+          {
+            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' }],
+        performanceTier: 'materialized',
+      };
+
+      await api()
+        .post(`/organisations/${orgId}/reports`)
+        .set(auth(accessToken))
+        .send(def)
+        .expect(201);
+      await api()
+        .post(`/organisations/${orgId}/reports/${key}/publish`)
+        .set(auth(accessToken))
+        .expect(200);
+
+      const result = await api()
+        .post(`/organisations/${orgId}/reports/${key}/query`)
+        .set(auth(accessToken))
+        .send({})
+        .expect(200);
+      expect(result.body.rows.length).toBeGreaterThanOrEqual(1);
+      expect(result.body.meta.freshAsOf).not.toBeNull();
+    } finally {
+      await prisma.$executeRawUnsafe(`DROP MATERIALIZED VIEW IF EXISTS ${mv}`);
+    }
+  });
+
+  it('boot schema check fails loudly when a required partial unique index is missing', async () => {
+    const check = app.get(ReportsSchemaCheckService);
+    // A freshly migrated DB passes.
+    await expect(check.check()).resolves.toBeUndefined();
+
+    await prisma.$executeRawUnsafe('DROP INDEX "report_view_shared_uq"');
+    try {
+      await expect(check.check()).rejects.toThrow(/report_view_shared_uq|CREATE UNIQUE INDEX/);
+    } finally {
+      // Restore so the rest of the suite (and the DB) stays intact.
+      await prisma.$executeRawUnsafe(
+        'CREATE UNIQUE INDEX "report_view_shared_uq" ON "ReportSavedView" ("orgId", "reportKey", "name") WHERE "ownerId" IS NULL',
+      );
+    }
+    // Green again after restore.
+    await expect(check.check()).resolves.toBeUndefined();
+  });
+
+  // ── test-only sources ───────────────────────────────────────────────────────
+
+  function indexedDefinition(key: string, sourceKey: string): Record<string, unknown> {
+    return {
+      key,
+      title: 'Indexed members',
+      source: { kind: 'custom', key: sourceKey },
+      columns: [
+        {
+          id: 'status',
+          header: 'Status',
+          columnId: 'status',
+          type: 'enum',
+          filterable: true,
+          sortable: true,
+          enum: ['ACTIVE', 'SUSPENDED', 'REVOKED'],
+        },
+        {
+          id: 'joinedAt',
+          header: 'Joined',
+          columnId: 'joinedAt',
+          type: 'datetime',
+          sortable: true,
+        },
+      ],
+      defaultSort: [{ column: 'joinedAt', dir: 'desc' }],
+      performanceTier: 'indexed',
+    };
+  }
+
+  function indexedTestSource(key: string, statusIdx: string, joinedIdx: string): ReportSourceDef {
+    return {
+      key,
+      manifest: () => ({
+        rowId: 'm."id"',
+        orgScoped: true,
+        columns: [
+          {
+            id: 'status',
+            sql: 'm."status"::text',
+            type: 'enum',
+            filterable: true,
+            sortable: true,
+            nullable: false,
+            index: {
+              name: statusIdx,
+              kind: 'btree',
+              table: 'Membership',
+              expr: '"orgId", "status"',
+            },
+          },
+          {
+            id: 'joinedAt',
+            sql: 'm."createdAt"',
+            type: 'datetime',
+            valueKind: 'native',
+            sortable: true,
+            nullable: false,
+            index: {
+              name: joinedIdx,
+              kind: 'btree',
+              table: 'Membership',
+              expr: '"orgId", "createdAt"',
+            },
+          },
+        ],
+      }),
+      baseQuery: () => ({
+        from: '"Membership" m',
+        orgColumn: 'm."orgId"',
+        primaryTable: 'Membership',
+      }),
+    };
+  }
+
+  function materializedTestSource(key: string, mv: string): ReportSourceDef {
+    return {
+      key,
+      manifest: () => ({
+        rowId: 'm."id"',
+        orgScoped: true,
+        columns: [
+          {
+            id: 'status',
+            sql: '"status"',
+            type: 'enum',
+            filterable: true,
+            nullable: false,
+          },
+          {
+            id: 'joinedAt',
+            sql: '"joinedAt"',
+            type: 'datetime',
+            valueKind: 'native',
+            sortable: true,
+            nullable: false,
+          },
+        ],
+        materialization: {
+          relation: mv,
+          orgColumn: '"orgId"',
+          rowIdColumn: 'rowId',
+          stalenessSeconds: 300,
+        },
+      }),
+      baseQuery: () => ({ from: mv, orgColumn: '"orgId"', primaryTable: mv }),
+      freshAsOf: () => Promise.resolve(new Date()),
+    };
+  }
+
+  // ── shared harness ──────────────────────────────────────────────────────────
+
+  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)}`;
+  }
+
+  /** A lowercase alphanumeric tag safe for SQL identifiers and report keys. */
+  function uniqueTag() {
+    return uniqueSuffix()
+      .replace(/[^a-z0-9]/gi, '')
+      .toLowerCase();
+  }
+
+  function uniqueKey(label: string) {
+    return `${label}-${uniqueTag()}`;
+  }
+
+  async function createUserAndOrg(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);
+    const accessToken = signup.body.accessToken as string;
+    const org = await api()
+      .post('/organisations')
+      .set(auth(accessToken))
+      .send({ name: `${label} ${suffix}`, slug: `${label}-${suffix}` })
+      .expect(201);
+    return { accessToken, orgId: org.body.organisation.id as string };
+  }
+});

package/template/test/route-registry.validator.spec.ts

@@ -8,9 +8,20 @@ import { PermissionKey } from '../src/modules/access-control/types/permission-ke
 import { routePermissionRegistry } from '../src/modules/access-control/types/route-permission-registry';
 import { AuditController } from '../src/modules/audit/presentation/audit.controller';
 import { AuthController } from '../src/modules/auth/presentation/auth.controller';
+import { FormsDataSourcesController } from '../src/modules/forms/presentation/forms-data-sources.controller';
+import { FormsDefinitionsController } from '../src/modules/forms/presentation/forms-definitions.controller';
+import { FormsFilesController } from '../src/modules/forms/presentation/forms-files.controller';
+import { FormsSubmissionsController } from '../src/modules/forms/presentation/forms-submissions.controller';
+import { PublicFormsController } from '../src/modules/forms/presentation/public-forms.controller';
 import { InvitationsController } from '../src/modules/invitations/presentation/invitations.controller';
 import { MembershipsController } from '../src/modules/memberships/presentation/memberships.controller';
 import { OrganisationsController } from '../src/modules/organisations/presentation/organisations.controller';
+import { ReportsActionsController } from '../src/modules/reports/presentation/reports-actions.controller';
+import { ReportsDefinitionsController } from '../src/modules/reports/presentation/reports-definitions.controller';
+import { ReportsExportController } from '../src/modules/reports/presentation/reports-export.controller';
+import { ReportsExportJobsController } from '../src/modules/reports/presentation/reports-export-jobs.controller';
+import { ReportsQueryController } from '../src/modules/reports/presentation/reports-query.controller';
+import { ReportsViewsController } from '../src/modules/reports/presentation/reports-views.controller';
 import { SampleController } from '../src/modules/sample/presentation/sample.controller';
 import { SettingsController } from '../src/modules/settings/presentation/settings.controller';
 
@@ -19,9 +30,20 @@ const controllers = [
   CurrentAccessControlController,
   AuditController,
   AuthController,
+  FormsDataSourcesController,
+  FormsDefinitionsController,
+  FormsFilesController,
+  FormsSubmissionsController,
+  PublicFormsController,
   InvitationsController,
   MembershipsController,
   OrganisationsController,
+  ReportsActionsController,
+  ReportsDefinitionsController,
+  ReportsExportController,
+  ReportsExportJobsController,
+  ReportsQueryController,
+  ReportsViewsController,
   SampleController,
   SettingsController,
 ];