@ftisindia/create-app 0.1.5 → 0.1.6

package/template/src/modules/forms/infrastructure/stores/prisma-action-log.store.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import type { ActionLogEntry, ActionLogStore, EngineTx } from '@ftisindia/form-builder';
+import { PrismaService } from '../../../../database/prisma/prisma.service';
+
+@Injectable()
+export class PrismaActionLogStore implements ActionLogStore {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private client(tx?: EngineTx) {
+    return tx ? (tx as unknown as Prisma.TransactionClient) : this.prisma;
+  }
+
+  async write(entry: ActionLogEntry, tx?: EngineTx): Promise<void> {
+    await this.client(tx).formActionLog.create({
+      data: {
+        orgId: entry.orgId,
+        submissionId: entry.submissionId ?? null,
+        formKey: entry.formKey,
+        formVersion: entry.formVersion ?? null,
+        action: entry.action,
+        status: entry.status,
+        ...(entry.input !== undefined
+          ? { input: entry.input as unknown as Prisma.InputJsonValue }
+          : {}),
+        ...(entry.output !== undefined
+          ? { output: entry.output as unknown as Prisma.InputJsonValue }
+          : {}),
+        errorCode: entry.errorCode ?? null,
+        errorMessage: entry.errorMessage ?? null,
+        actorId: entry.actorId ?? null,
+        requestId: entry.requestId ?? null,
+        durationMs: entry.durationMs ?? null,
+      },
+    });
+  }
+}

package/template/src/modules/forms/infrastructure/stores/prisma-file.store.ts

@@ -0,0 +1,108 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma, UploadedFile as UploadedFileRow } from '@prisma/client';
+import type {
+  EngineTx,
+  FileStatus,
+  FileStore,
+  NewUploadedFileRecord,
+  UploadedFileRecord,
+} from '@ftisindia/form-builder';
+import { PrismaService } from '../../../../database/prisma/prisma.service';
+
+@Injectable()
+export class PrismaFileStore implements FileStore {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private client(tx?: EngineTx) {
+    return tx ? (tx as unknown as Prisma.TransactionClient) : this.prisma;
+  }
+
+  async create(record: NewUploadedFileRecord, tx?: EngineTx): Promise<UploadedFileRecord> {
+    const row = await this.client(tx).uploadedFile.create({
+      data: {
+        storageKey: record.storageKey,
+        originalName: record.originalName,
+        mimeType: record.mimeType,
+        size: record.size,
+        checksum: record.checksum,
+        ownerId: record.ownerId,
+        orgId: record.orgId,
+        status: record.status,
+      },
+    });
+
+    return this.toRecord(row);
+  }
+
+  async findById(orgId: string, id: string, tx?: EngineTx): Promise<UploadedFileRecord | null> {
+    const row = await this.client(tx).uploadedFile.findFirst({
+      where: { id, orgId },
+    });
+
+    return row ? this.toRecord(row) : null;
+  }
+
+  async updateStatus(
+    orgId: string,
+    id: string,
+    status: FileStatus,
+    submissionId?: string,
+    tx?: EngineTx,
+  ): Promise<UploadedFileRecord> {
+    const client = this.client(tx);
+
+    const existing = await client.uploadedFile.findFirst({
+      where: { id, orgId },
+      select: { id: true },
+    });
+
+    if (!existing) {
+      throw new Error(`Uploaded file ${id} was not found in this organisation.`);
+    }
+
+    const row = await client.uploadedFile.update({
+      where: { id: existing.id },
+      data: {
+        status,
+        ...(submissionId !== undefined ? { submissionId } : {}),
+      },
+    });
+
+    return this.toRecord(row);
+  }
+
+  async listGcEligible(cutoff: Date, limit: number): Promise<UploadedFileRecord[]> {
+    const rows = await this.client().uploadedFile.findMany({
+      where: {
+        status: 'TEMPORARY',
+        createdAt: { lte: cutoff },
+      },
+      orderBy: { createdAt: 'asc' },
+      take: limit,
+    });
+
+    return rows.map((row) => this.toRecord(row));
+  }
+
+  async delete(id: string, tx?: EngineTx): Promise<void> {
+    await this.client(tx).uploadedFile.deleteMany({
+      where: { id },
+    });
+  }
+
+  private toRecord(row: UploadedFileRow): UploadedFileRecord {
+    return {
+      id: row.id,
+      storageKey: row.storageKey,
+      originalName: row.originalName,
+      mimeType: row.mimeType,
+      size: row.size,
+      checksum: row.checksum,
+      ownerId: row.ownerId,
+      orgId: row.orgId,
+      status: row.status as FileStatus,
+      submissionId: row.submissionId,
+      createdAt: row.createdAt,
+    };
+  }
+}

package/template/src/modules/forms/infrastructure/stores/prisma-form-definition.store.ts

@@ -0,0 +1,147 @@
+import { Injectable } from '@nestjs/common';
+import { FormDefinition as FormDefinitionRow, Prisma } from '@prisma/client';
+import type {
+  EngineTx,
+  FormDefinition,
+  FormDefinitionPatch,
+  FormDefinitionRecord,
+  FormDefinitionStatus,
+  FormDefinitionStore,
+  NewFormDefinitionRecord,
+} from '@ftisindia/form-builder';
+import { PrismaService } from '../../../../database/prisma/prisma.service';
+
+@Injectable()
+export class PrismaFormDefinitionStore implements FormDefinitionStore {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private client(tx?: EngineTx) {
+    return tx ? (tx as unknown as Prisma.TransactionClient) : this.prisma;
+  }
+
+  async create(record: NewFormDefinitionRecord, tx?: EngineTx): Promise<FormDefinitionRecord> {
+    const row = await this.client(tx).formDefinition.create({
+      data: {
+        orgId: record.orgId,
+        key: record.key,
+        version: record.version,
+        status: record.status,
+        schema: record.schema as unknown as Prisma.InputJsonValue,
+      },
+    });
+
+    return this.toRecord(row);
+  }
+
+  async update(
+    orgId: string,
+    key: string,
+    version: number,
+    patch: FormDefinitionPatch,
+    tx?: EngineTx,
+  ): Promise<FormDefinitionRecord> {
+    const client = this.client(tx);
+
+    const existing = await client.formDefinition.findUnique({
+      where: { orgId_key_version: { orgId, key, version } },
+      select: { id: true },
+    });
+
+    if (!existing) {
+      throw new Error(`Form definition ${key} v${version} was not found in this organisation.`);
+    }
+
+    const row = await client.formDefinition.update({
+      where: { id: existing.id },
+      data: {
+        ...(patch.status !== undefined ? { status: patch.status } : {}),
+        ...(patch.schema !== undefined
+          ? { schema: patch.schema as unknown as Prisma.InputJsonValue }
+          : {}),
+      },
+    });
+
+    return this.toRecord(row);
+  }
+
+  async findByKeyVersion(
+    orgId: string,
+    key: string,
+    version: number,
+    tx?: EngineTx,
+  ): Promise<FormDefinitionRecord | null> {
+    const row = await this.client(tx).formDefinition.findUnique({
+      where: { orgId_key_version: { orgId, key, version } },
+    });
+
+    return row ? this.toRecord(row) : null;
+  }
+
+  async findLatest(
+    orgId: string,
+    key: string,
+    status?: FormDefinitionStatus,
+  ): Promise<FormDefinitionRecord | null> {
+    const row = await this.client().formDefinition.findFirst({
+      where: { orgId, key, ...(status ? { status } : {}) },
+      orderBy: { version: 'desc' },
+    });
+
+    return row ? this.toRecord(row) : null;
+  }
+
+  async findAllByKeyStatus(
+    orgId: string,
+    key: string,
+    status: FormDefinitionStatus,
+    tx?: EngineTx,
+  ): Promise<FormDefinitionRecord[]> {
+    const rows = await this.client(tx).formDefinition.findMany({
+      where: { orgId, key, status },
+      orderBy: { version: 'desc' },
+    });
+
+    return rows.map((row) => this.toRecord(row));
+  }
+
+  async list(
+    orgId: string,
+    options: { status?: FormDefinitionStatus; cursor?: string; limit: number },
+  ): Promise<FormDefinitionRecord[]> {
+    const rows = await this.client().formDefinition.findMany({
+      where: { orgId, ...(options.status ? { status: options.status } : {}) },
+      orderBy: [{ key: 'asc' }, { version: 'desc' }],
+      take: options.limit,
+      ...(options.cursor
+        ? {
+            cursor: { id: options.cursor },
+            skip: 1,
+          }
+        : {}),
+    });
+
+    return rows.map((row) => this.toRecord(row));
+  }
+
+  async maxVersion(orgId: string, key: string, tx?: EngineTx): Promise<number> {
+    const result = await this.client(tx).formDefinition.aggregate({
+      _max: { version: true },
+      where: { orgId, key },
+    });
+
+    return result._max.version ?? 0;
+  }
+
+  private toRecord(row: FormDefinitionRow): FormDefinitionRecord {
+    return {
+      id: row.id,
+      orgId: row.orgId,
+      key: row.key,
+      version: row.version,
+      status: row.status as FormDefinitionStatus,
+      schema: row.schema as unknown as FormDefinition,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+}

package/template/src/modules/forms/infrastructure/stores/prisma-outbox.store.ts

@@ -0,0 +1,133 @@
+import { Injectable } from '@nestjs/common';
+import { FormOutboxJob as FormOutboxJobRow, Prisma } from '@prisma/client';
+import type {
+  EngineTx,
+  OutboxJobInput,
+  OutboxJobRecord,
+  OutboxStatus,
+  OutboxStore,
+} from '@ftisindia/form-builder';
+import { PrismaService } from '../../../../database/prisma/prisma.service';
+
+const PROCESSING_LEASE_MS = 5 * 60 * 1000;
+
+@Injectable()
+export class PrismaOutboxStore implements OutboxStore {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private client(tx?: EngineTx) {
+    return tx ? (tx as unknown as Prisma.TransactionClient) : this.prisma;
+  }
+
+  async enqueue(job: OutboxJobInput, tx: EngineTx): Promise<void> {
+    await this.client(tx).formOutboxJob.create({
+      data: {
+        type: job.type,
+        payload: job.payload as unknown as Prisma.InputJsonValue,
+        status: 'PENDING',
+        attempts: 0,
+        maxAttempts: job.maxAttempts ?? 8,
+        idempotencyKey: job.idempotencyKey ?? null,
+        runAfter: job.runAfter ?? null,
+        orgId: job.orgId ?? null,
+        actorUserId: job.actorUserId ?? null,
+        originRequestId: job.originRequestId ?? null,
+      },
+    });
+  }
+
+  /**
+   * Claims due PENDING jobs and stale PROCESSING jobs by selecting candidates
+   * and flipping them to PROCESSING with a guarded updateMany. This is safe
+   * for the template's single in-process dispatcher; multi-instance
+   * deployments should move the claim to `SELECT ... FOR UPDATE SKIP LOCKED`.
+   */
+  async claimDue(now: Date, batchSize: number): Promise<OutboxJobRecord[]> {
+    const staleProcessingBefore = new Date(now.getTime() - PROCESSING_LEASE_MS);
+    const claimableWhere: Prisma.FormOutboxJobWhereInput = {
+      OR: [
+        {
+          status: 'PENDING',
+          OR: [{ runAfter: null }, { runAfter: { lte: now } }],
+        },
+        {
+          status: 'PROCESSING',
+          updatedAt: { lte: staleProcessingBefore },
+        },
+      ],
+    };
+
+    const due = await this.client().formOutboxJob.findMany({
+      where: claimableWhere,
+      orderBy: { createdAt: 'asc' },
+      take: batchSize,
+      select: { id: true },
+    });
+
+    if (due.length === 0) {
+      return [];
+    }
+
+    const ids = due.map((row) => row.id);
+
+    await this.client().formOutboxJob.updateMany({
+      where: { id: { in: ids }, ...claimableWhere },
+      data: { status: 'PROCESSING' },
+    });
+
+    const claimed = await this.client().formOutboxJob.findMany({
+      where: { id: { in: ids }, status: 'PROCESSING' },
+    });
+
+    return claimed.map((row) => this.toRecord(row));
+  }
+
+  async markDone(id: string): Promise<void> {
+    await this.client().formOutboxJob.update({
+      where: { id },
+      data: { status: 'DONE' },
+    });
+  }
+
+  async markRetry(id: string, attempts: number, runAfter: Date, lastError: string): Promise<void> {
+    await this.client().formOutboxJob.update({
+      where: { id },
+      data: {
+        status: 'PENDING',
+        attempts,
+        runAfter,
+        lastError,
+      },
+    });
+  }
+
+  async markFailed(id: string, attempts: number, lastError: string): Promise<void> {
+    await this.client().formOutboxJob.update({
+      where: { id },
+      data: {
+        status: 'FAILED',
+        attempts,
+        lastError,
+      },
+    });
+  }
+
+  private toRecord(row: FormOutboxJobRow): OutboxJobRecord {
+    return {
+      id: row.id,
+      type: row.type,
+      payload: row.payload as unknown as Record<string, unknown>,
+      status: row.status as OutboxStatus,
+      attempts: row.attempts,
+      maxAttempts: row.maxAttempts,
+      idempotencyKey: row.idempotencyKey,
+      lastError: row.lastError,
+      runAfter: row.runAfter,
+      orgId: row.orgId,
+      actorUserId: row.actorUserId,
+      originRequestId: row.originRequestId,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+}

package/template/src/modules/forms/infrastructure/stores/prisma-submission.store.ts

@@ -0,0 +1,164 @@
+import { Injectable } from '@nestjs/common';
+import { FormSubmission as FormSubmissionRow, Prisma } from '@prisma/client';
+import type {
+  EngineTx,
+  NewSubmissionRecord,
+  SubmissionListFilters,
+  SubmissionPatch,
+  SubmissionRecord,
+  SubmissionStatus,
+  SubmissionStore,
+} from '@ftisindia/form-builder';
+import { PrismaService } from '../../../../database/prisma/prisma.service';
+
+@Injectable()
+export class PrismaSubmissionStore implements SubmissionStore {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private client(tx?: EngineTx) {
+    return tx ? (tx as unknown as Prisma.TransactionClient) : this.prisma;
+  }
+
+  async create(record: NewSubmissionRecord, tx?: EngineTx): Promise<SubmissionRecord> {
+    const row = await this.client(tx).formSubmission.create({
+      data: {
+        orgId: record.orgId,
+        formKey: record.formKey,
+        formVersion: record.formVersion,
+        data: record.data as unknown as Prisma.InputJsonValue,
+        status: record.status,
+        createdBy: record.createdBy ?? null,
+        ipAddress: record.ipAddress ?? null,
+        userAgent: record.userAgent ?? null,
+      },
+    });
+
+    return this.toRecord(row);
+  }
+
+  async update(
+    orgId: string,
+    id: string,
+    patch: SubmissionPatch,
+    tx?: EngineTx,
+  ): Promise<SubmissionRecord> {
+    const client = this.client(tx);
+
+    const existing = await client.formSubmission.findFirst({
+      where: { id, orgId },
+      select: { id: true },
+    });
+
+    if (!existing) {
+      throw new Error(`Form submission ${id} was not found in this organisation.`);
+    }
+
+    const row = await client.formSubmission.update({
+      where: { id: existing.id },
+      data: {
+        ...(patch.data !== undefined
+          ? { data: patch.data as unknown as Prisma.InputJsonValue }
+          : {}),
+        ...(patch.status !== undefined ? { status: patch.status } : {}),
+        ...(patch.locked !== undefined ? { locked: patch.locked } : {}),
+      },
+    });
+
+    return this.toRecord(row);
+  }
+
+  async findById(orgId: string, id: string, tx?: EngineTx): Promise<SubmissionRecord | null> {
+    const row = await this.client(tx).formSubmission.findFirst({
+      where: { id, orgId },
+    });
+
+    return row ? this.toRecord(row) : null;
+  }
+
+  async list(
+    orgId: string,
+    formKey: string,
+    filters: SubmissionListFilters,
+  ): Promise<SubmissionRecord[]> {
+    const rows = await this.client().formSubmission.findMany({
+      where: this.filterWhere(orgId, formKey, filters),
+      orderBy: { createdAt: 'desc' },
+      take: filters.limit,
+      ...(filters.cursor
+        ? {
+            cursor: { id: filters.cursor },
+            skip: 1,
+          }
+        : {}),
+    });
+
+    return rows.map((row) => this.toRecord(row));
+  }
+
+  async countByIpSince(
+    orgId: string,
+    formKey: string,
+    ipAddress: string,
+    since: Date,
+  ): Promise<number> {
+    return this.client().formSubmission.count({
+      where: {
+        orgId,
+        formKey,
+        ipAddress,
+        createdAt: { gte: since },
+      },
+    });
+  }
+
+  async listForExport(
+    orgId: string,
+    formKey: string,
+    filters: Omit<SubmissionListFilters, 'cursor' | 'limit'>,
+  ): Promise<SubmissionRecord[]> {
+    const rows = await this.client().formSubmission.findMany({
+      where: this.filterWhere(orgId, formKey, filters),
+      orderBy: { createdAt: 'asc' },
+    });
+
+    return rows.map((row) => this.toRecord(row));
+  }
+
+  private filterWhere(
+    orgId: string,
+    formKey: string,
+    filters: Omit<SubmissionListFilters, 'cursor' | 'limit'>,
+  ): Prisma.FormSubmissionWhereInput {
+    return {
+      orgId,
+      formKey,
+      ...(filters.status ? { status: filters.status } : {}),
+      ...(filters.createdBy ? { createdBy: filters.createdBy } : {}),
+      ...(filters.createdFrom || filters.createdTo
+        ? {
+            createdAt: {
+              ...(filters.createdFrom ? { gte: filters.createdFrom } : {}),
+              ...(filters.createdTo ? { lte: filters.createdTo } : {}),
+            },
+          }
+        : {}),
+    };
+  }
+
+  private toRecord(row: FormSubmissionRow): SubmissionRecord {
+    return {
+      id: row.id,
+      orgId: row.orgId,
+      formKey: row.formKey,
+      formVersion: row.formVersion,
+      data: row.data as unknown as Record<string, unknown>,
+      status: row.status as SubmissionStatus,
+      locked: row.locked,
+      createdBy: row.createdBy,
+      ipAddress: row.ipAddress,
+      userAgent: row.userAgent,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+}

package/template/src/modules/forms/presentation/forms-data-sources.controller.ts

@@ -0,0 +1,58 @@
+import { Controller, Get, Param, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiOkResponse, ApiOperation, ApiParam, ApiTags } from '@nestjs/swagger';
+import { ApiProtectedErrorResponses } from '../../../common/swagger/api-error-responses';
+import { PermissionGuard } from '../../access-control/application/services/permission.guard';
+import { RequirePermissions } from '../../access-control/presentation/permissions.decorator';
+import { JwtAuthGuard } from '../../auth/infrastructure/passport/jwt-auth.guard';
+import { OrgScopeGuard } from '../../request-context/presentation/org-scope.guard';
+import { FormsDefinitionsService } from '../application/services/forms-definitions.service';
+import {
+  DataSourceKeysResponseDto,
+  DataSourceOptionsResponseDto,
+} from '../dto/data-source-response.dto';
+
+/**
+ * MUST be registered BEFORE FormsDefinitionsController in the module's
+ * controllers array: both controllers share the 'organisations/:orgId/forms'
+ * base path, and the literal 'data-sources' segment has to win over the
+ * ':formKey' parameter route.
+ */
+@ApiTags('Forms')
+@ApiBearerAuth()
+@ApiParam({ name: 'orgId', description: 'Organisation ID.', format: 'uuid' })
+@ApiProtectedErrorResponses(404)
+@Controller('organisations/:orgId/forms')
+@UseGuards(JwtAuthGuard, OrgScopeGuard, PermissionGuard)
+export class FormsDataSourcesController {
+  constructor(private readonly formsDefinitionsService: FormsDefinitionsService) {}
+
+  @Get('data-sources')
+  @RequirePermissions('formDataSources.manage')
+  @ApiOperation({ summary: 'List registered data source keys.' })
+  @ApiOkResponse({
+    description: 'Registered data source keys.',
+    type: DataSourceKeysResponseDto,
+  })
+  listDataSourceKeys(@Param('orgId') orgId: string) {
+    return this.formsDefinitionsService.listDataSourceKeys(orgId);
+  }
+
+  @Get(':formKey/data-sources/:dataSourceKey/options')
+  @RequirePermissions('formSubmissions.create')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiParam({ name: 'dataSourceKey', description: 'Registered data source key.' })
+  @ApiOperation({
+    summary: 'Resolve options for a data source bound to fields of a published form.',
+  })
+  @ApiOkResponse({
+    description: 'Resolved data-source options.',
+    type: DataSourceOptionsResponseDto,
+  })
+  dataSourceOptions(
+    @Param('orgId') orgId: string,
+    @Param('formKey') formKey: string,
+    @Param('dataSourceKey') dataSourceKey: string,
+  ) {
+    return this.formsDefinitionsService.dataSourceOptions(orgId, formKey, dataSourceKey);
+  }
+}