@ftisindia/create-app 0.1.5 → 0.2.0

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

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+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.createMany({
+      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,
+        },
+      ],
+      skipDuplicates: true,
+    });
+  }
+
+  /**
+   * Claims due PENDING jobs and stale PROCESSING jobs with row-level locks so
+   * multiple app instances can poll without double-delivering the same job.
+   */
+  async claimDue(now: Date, batchSize: number): Promise<OutboxJobRecord[]> {
+    if (batchSize <= 0) {
+      return [];
+    }
+
+    const staleProcessingBefore = new Date(now.getTime() - PROCESSING_LEASE_MS);
+    const claimedBy = randomUUID();
+    const claimed = await this.prisma.$transaction(
+      (tx) =>
+        tx.$queryRaw<FormOutboxJobRow[]>`
+        WITH due AS (
+          SELECT "id"
+          FROM "FormOutboxJob"
+          WHERE (
+            "status" = 'PENDING'
+            AND ("runAfter" IS NULL OR "runAfter" <= (${now}::timestamptz AT TIME ZONE 'UTC'))
+          )
+          OR (
+            "status" = 'PROCESSING'
+            AND "updatedAt" <= (${staleProcessingBefore}::timestamptz AT TIME ZONE 'UTC')
+          )
+          ORDER BY "createdAt" ASC
+          LIMIT ${batchSize}
+          FOR UPDATE SKIP LOCKED
+        )
+        UPDATE "FormOutboxJob" AS job
+        SET "status" = 'PROCESSING',
+            "claimedBy" = ${claimedBy},
+            "updatedAt" = (CURRENT_TIMESTAMP AT TIME ZONE 'UTC')
+        FROM due
+        WHERE job."id" = due."id"
+        RETURNING job.*
+      `,
+    );
+
+    return claimed.map((row) => this.toRecord(row));
+  }
+
+  async markDone(id: string, claimedBy: string): Promise<boolean> {
+    const result = await this.client().formOutboxJob.updateMany({
+      where: { id, status: 'PROCESSING', claimedBy },
+      data: { status: 'DONE', claimedBy: null },
+    });
+    return result.count === 1;
+  }
+
+  async markRetry(
+    id: string,
+    claimedBy: string,
+    attempts: number,
+    runAfter: Date,
+    lastError: string,
+  ): Promise<boolean> {
+    const result = await this.client().formOutboxJob.updateMany({
+      where: { id, status: 'PROCESSING', claimedBy },
+      data: {
+        status: 'PENDING',
+        claimedBy: null,
+        attempts,
+        runAfter,
+        lastError,
+      },
+    });
+    return result.count === 1;
+  }
+
+  async markFailed(id: string, claimedBy: string, attempts: number, lastError: string): Promise<boolean> {
+    const result = await this.client().formOutboxJob.updateMany({
+      where: { id, status: 'PROCESSING', claimedBy },
+      data: {
+        status: 'FAILED',
+        claimedBy: null,
+        attempts,
+        lastError,
+      },
+    });
+    return result.count === 1;
+  }
+
+  async touchProcessing(id: string, claimedBy: string): Promise<boolean> {
+    const touched = await this.prisma.$executeRaw`
+      UPDATE "FormOutboxJob"
+      SET "updatedAt" = (CURRENT_TIMESTAMP AT TIME ZONE 'UTC')
+      WHERE "id" = ${id}
+        AND "status" = 'PROCESSING'
+        AND "claimedBy" = ${claimedBy}
+    `;
+    return touched === 1;
+  }
+
+  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,
+      claimedBy: row.claimedBy,
+      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);
+  }
+}

package/template/src/modules/forms/presentation/forms-definitions.controller.ts

@@ -0,0 +1,191 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiCreatedResponse,
+  ApiOkResponse,
+  ApiOperation,
+  ApiParam,
+  ApiTags,
+  ApiUnprocessableEntityResponse,
+} from '@nestjs/swagger';
+import { ErrorResponseDto } from '../../../common/dto/error-response.dto';
+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 { CreateFormDefinitionDto } from '../dto/create-form-definition.dto';
+import {
+  FormDefinitionListResponseDto,
+  FormDefinitionResponseDto,
+} from '../dto/form-definition-response.dto';
+import { FormRenderResponseDto } from '../dto/form-render-response.dto';
+import { ListFormDefinitionsQueryDto } from '../dto/list-form-definitions-query.dto';
+import { SetPublicAccessDto } from '../dto/set-public-access.dto';
+import { UpdateFormDefinitionDto } from '../dto/update-form-definition.dto';
+
+@ApiTags('Forms')
+@ApiBearerAuth()
+@ApiParam({ name: 'orgId', description: 'Organisation ID.', format: 'uuid' })
+@ApiProtectedErrorResponses(404, 409)
+@ApiUnprocessableEntityResponse({
+  description: 'The form definition failed engine validation or linting.',
+  type: ErrorResponseDto,
+})
+@Controller('organisations/:orgId/forms')
+@UseGuards(JwtAuthGuard, OrgScopeGuard, PermissionGuard)
+export class FormsDefinitionsController {
+  constructor(private readonly formsDefinitionsService: FormsDefinitionsService) {}
+
+  @Get()
+  @RequirePermissions('forms.read')
+  @ApiOperation({ summary: 'List form definitions.' })
+  @ApiOkResponse({
+    description: 'Form definitions.',
+    type: FormDefinitionListResponseDto,
+  })
+  list(@Param('orgId') orgId: string, @Query() query: ListFormDefinitionsQueryDto) {
+    return this.formsDefinitionsService.list(orgId, query);
+  }
+
+  @Post()
+  @RequirePermissions('forms.create')
+  @ApiOperation({ summary: 'Create a new draft form definition version.' })
+  @ApiCreatedResponse({
+    description: 'Created draft definition.',
+    type: FormDefinitionResponseDto,
+  })
+  create(@Param('orgId') orgId: string, @Body() dto: CreateFormDefinitionDto) {
+    return this.formsDefinitionsService.create(orgId, dto);
+  }
+
+  @Get(':formKey')
+  @RequirePermissions('forms.read')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiOperation({ summary: 'Return the latest version of a form definition.' })
+  @ApiOkResponse({
+    description: 'Latest definition version.',
+    type: FormDefinitionResponseDto,
+  })
+  getLatest(@Param('orgId') orgId: string, @Param('formKey') formKey: string) {
+    return this.formsDefinitionsService.getLatest(orgId, formKey);
+  }
+
+  @Get(':formKey/render')
+  @RequirePermissions('formSubmissions.create')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiOperation({
+    summary: 'Return the published definition plus resolved data-source options.',
+  })
+  @ApiOkResponse({
+    description: 'Renderable definition.',
+    type: FormRenderResponseDto,
+  })
+  render(@Param('orgId') orgId: string, @Param('formKey') formKey: string) {
+    return this.formsDefinitionsService.render(orgId, formKey);
+  }
+
+  @Get(':formKey/versions/:version')
+  @RequirePermissions('forms.read')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiParam({ name: 'version', description: 'Definition version number.', type: Number })
+  @ApiOperation({ summary: 'Return a specific form definition version.' })
+  @ApiOkResponse({
+    description: 'Definition version.',
+    type: FormDefinitionResponseDto,
+  })
+  getVersion(
+    @Param('orgId') orgId: string,
+    @Param('formKey') formKey: string,
+    @Param('version', ParseIntPipe) version: number,
+  ) {
+    return this.formsDefinitionsService.getVersion(orgId, formKey, version);
+  }
+
+  @Patch(':formKey/versions/:version')
+  @RequirePermissions('forms.update')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiParam({ name: 'version', description: 'Definition version number.', type: Number })
+  @ApiOperation({ summary: 'Update a draft form definition version.' })
+  @ApiOkResponse({
+    description: 'Updated draft definition.',
+    type: FormDefinitionResponseDto,
+  })
+  update(
+    @Param('orgId') orgId: string,
+    @Param('formKey') formKey: string,
+    @Param('version', ParseIntPipe) version: number,
+    @Body() dto: UpdateFormDefinitionDto,
+  ) {
+    return this.formsDefinitionsService.update(orgId, formKey, version, dto);
+  }
+
+  @Post(':formKey/versions/:version/publish')
+  @HttpCode(200)
+  @RequirePermissions('forms.publish')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiParam({ name: 'version', description: 'Definition version number.', type: Number })
+  @ApiOperation({ summary: 'Publish a draft form definition version.' })
+  @ApiOkResponse({
+    description: 'Published definition.',
+    type: FormDefinitionResponseDto,
+  })
+  publish(
+    @Param('orgId') orgId: string,
+    @Param('formKey') formKey: string,
+    @Param('version', ParseIntPipe) version: number,
+  ) {
+    return this.formsDefinitionsService.publish(orgId, formKey, version);
+  }
+
+  @Post(':formKey/versions/:version/archive')
+  @HttpCode(200)
+  @RequirePermissions('forms.archive')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiParam({ name: 'version', description: 'Definition version number.', type: Number })
+  @ApiOperation({ summary: 'Archive a form definition version.' })
+  @ApiOkResponse({
+    description: 'Archived definition.',
+    type: FormDefinitionResponseDto,
+  })
+  archive(
+    @Param('orgId') orgId: string,
+    @Param('formKey') formKey: string,
+    @Param('version', ParseIntPipe) version: number,
+  ) {
+    return this.formsDefinitionsService.archive(orgId, formKey, version);
+  }
+
+  @Post(':formKey/versions/:version/public-access')
+  @HttpCode(200)
+  @RequirePermissions('forms.managePublicAccess')
+  @ApiParam({ name: 'formKey', description: 'Form definition key.' })
+  @ApiParam({ name: 'version', description: 'Definition version number.', type: Number })
+  @ApiOperation({
+    summary: 'Flip the public/private access setting on a form definition version.',
+  })
+  @ApiOkResponse({
+    description: 'Updated definition.',
+    type: FormDefinitionResponseDto,
+  })
+  setPublicAccess(
+    @Param('orgId') orgId: string,
+    @Param('formKey') formKey: string,
+    @Param('version', ParseIntPipe) version: number,
+    @Body() dto: SetPublicAccessDto,
+  ) {
+    return this.formsDefinitionsService.setPublicAccess(orgId, formKey, version, dto);
+  }
+}

package/template/src/modules/forms/presentation/forms-files.controller.ts

@@ -0,0 +1,79 @@
+import {
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Post,
+  Query,
+  UploadedFile,
+  UseGuards,
+  UseInterceptors,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiBody,
+  ApiConsumes,
+  ApiOkResponse,
+  ApiOperation,
+  ApiParam,
+  ApiTags,
+} from '@nestjs/swagger';
+import { ApiProtectedErrorResponses } from '../../../common/swagger/api-error-responses';
+import { CurrentUser } from '../../auth/presentation/current-user.decorator';
+import { JwtAuthGuard } from '../../auth/infrastructure/passport/jwt-auth.guard';
+import { AuthenticatedUser } from '../../auth/types/authenticated-user';
+import { PermissionGuard } from '../../access-control/application/services/permission.guard';
+import { RequirePermissions } from '../../access-control/presentation/permissions.decorator';
+import { OrgScopeGuard } from '../../request-context/presentation/org-scope.guard';
+import { FileUploadResponseDto } from '../dto/file-upload-response.dto';
+import { UploadFileQueryDto } from '../dto/upload-file-query.dto';
+import { FormsFilesService } from '../application/services/forms-files.service';
+import { FormsUploadInterceptor } from './forms-upload.interceptor';
+
+@ApiTags('Forms')
+@ApiBearerAuth()
+@ApiParam({ name: 'orgId', description: 'Organisation ID.', format: 'uuid' })
+@ApiParam({ name: 'formKey', description: 'Form definition key.' })
+@ApiProtectedErrorResponses(404, 409)
+@Controller('organisations/:orgId/forms/:formKey/files')
+@UseGuards(JwtAuthGuard, OrgScopeGuard, PermissionGuard)
+export class FormsFilesController {
+  constructor(private readonly filesService: FormsFilesService) {}
+
+  @Post()
+  @RequirePermissions('formSubmissions.create')
+  @UseInterceptors(FormsUploadInterceptor)
+  @ApiConsumes('multipart/form-data')
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: { file: { type: 'string', format: 'binary' } },
+      required: ['file'],
+    },
+  })
+  @ApiOperation({
+    summary:
+      'Upload a file for a form field (before submit). The submission then references the returned fileId.',
+  })
+  @ApiOkResponse({ description: 'Uploaded file reference.', type: FileUploadResponseDto })
+  upload(
+    @CurrentUser() user: AuthenticatedUser,
+    @Param('orgId') orgId: string,
+    @Param('formKey') formKey: string,
+    @Query() query: UploadFileQueryDto,
+    @UploadedFile() file: { originalname: string; size: number; buffer: Buffer } | undefined,
+  ) {
+    return this.filesService.upload(orgId, formKey, query, file, user);
+  }
+
+  @Get(':fileId')
+  @RequirePermissions('formSubmissions.read')
+  @ApiOperation({ summary: 'Return metadata for an uploaded file.' })
+  @ApiOkResponse({ description: 'Uploaded file metadata.', type: FileUploadResponseDto })
+  getMeta(
+    @Param('orgId') orgId: string,
+    @Param('fileId', ParseUUIDPipe) fileId: string,
+  ) {
+    return this.filesService.getMeta(orgId, fileId);
+  }
+}