@ftisindia/create-app 0.1.5 → 0.2.0

package/template/src/modules/forms/infrastructure/audit-sink.adapter.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import type { AuditEntry, EngineTx, FormsAuditSink } from '@ftisindia/form-builder';
+import { PrismaService } from '../../../database/prisma/prisma.service';
+import { AuditService } from '../../audit/application/services/audit.service';
+
+/**
+ * Routes engine audit entries through the template's AuditService. When the
+ * engine supplies a transaction, the audit row is written through it so it
+ * commits atomically with the change it describes (ecosystem guide §7).
+ */
+@Injectable()
+export class PrismaFormsAuditSink implements FormsAuditSink {
+  constructor(
+    private readonly audit: AuditService,
+    private readonly prisma: PrismaService,
+  ) {}
+
+  async write(entry: AuditEntry, tx?: EngineTx): Promise<void> {
+    const client = tx ? (tx as unknown as Prisma.TransactionClient) : this.prisma;
+    await this.audit.write(client, {
+      orgId: entry.orgId ?? null,
+      actorUserId: entry.actorUserId ?? null,
+      action: entry.action,
+      targetType: entry.targetType,
+      targetId: entry.targetId ?? null,
+      metadata: entry.metadata as Prisma.InputJsonValue | undefined,
+    });
+  }
+}

package/template/src/modules/forms/infrastructure/casl-forms-authorization.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+import type { FormPermissionKey, FormsAuthorization } from '@ftisindia/form-builder';
+import { AbilityFactory } from '../../access-control/application/services/ability.factory';
+import { permissionKeyToRule } from '../../access-control/types/permission-key';
+import { RequestContextService } from '../../request-context/application/services/request-context.service';
+
+/**
+ * The engine's internal authorization seam over CASL — mirrors
+ * PermissionGuard's own logic and fails closed when no RBAC context exists
+ * (anonymous/public requests). Route guards remain the first enforcement
+ * layer; this is the defense-in-depth second layer (ecosystem guide §5.3).
+ */
+@Injectable()
+export class CaslFormsAuthorization implements FormsAuthorization {
+  constructor(
+    private readonly abilities: AbilityFactory,
+    private readonly ctx: RequestContextService,
+  ) {}
+
+  can(required: FormPermissionKey[]): boolean {
+    const rbac = this.ctx.getRbacContext();
+    if (!rbac) {
+      return false;
+    }
+    const ability = this.abilities.createForContext(rbac);
+    return required.every((key) => {
+      const { action, subject } = permissionKeyToRule(key);
+      return ability.can(action, subject);
+    });
+  }
+}

package/template/src/modules/forms/infrastructure/prisma-tx-runner.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import type { EngineTx, TxRunner } from '@ftisindia/form-builder';
+import { PrismaService } from '../../../database/prisma/prisma.service';
+
+/**
+ * The engine's transaction seam over PrismaService.$transaction. The opaque
+ * EngineTx brand is a Prisma.TransactionClient underneath; the stores cast it
+ * back. One TxRunner.run call IS the design doc's Phase-2 atomicity boundary.
+ */
+@Injectable()
+export class PrismaTxRunner implements TxRunner {
+  constructor(private readonly prisma: PrismaService) {}
+
+  run<T>(fn: (tx: EngineTx) => Promise<T>): Promise<T> {
+    return this.prisma.$transaction((tx) => fn(tx as unknown as EngineTx));
+  }
+}

package/template/src/modules/forms/infrastructure/registry/form-extension.decorators.ts

@@ -0,0 +1,17 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const FORM_FIELD_TYPE_METADATA = 'ftis:forms:field-type';
+export const FORM_ACTION_METADATA = 'ftis:forms:action';
+export const FORM_DATA_SOURCE_METADATA = 'ftis:forms:data-source';
+export const FORM_LIFECYCLE_METADATA = 'ftis:forms:lifecycle';
+
+/**
+ * The standardized extension story: implement the engine interface
+ * (FieldTypeDef / FormAction / DataSourceDef / FormLifecycle), decorate the
+ * @Injectable class, list it as a provider — RegistryBootstrapService
+ * discovers and registers it at startup. Same three steps for every kind.
+ */
+export const FormFieldType = () => SetMetadata(FORM_FIELD_TYPE_METADATA, true);
+export const FormActionHandler = () => SetMetadata(FORM_ACTION_METADATA, true);
+export const FormDataSource = () => SetMetadata(FORM_DATA_SOURCE_METADATA, true);
+export const FormLifecycleHook = () => SetMetadata(FORM_LIFECYCLE_METADATA, true);

package/template/src/modules/forms/infrastructure/registry/registry-bootstrap.service.ts

@@ -0,0 +1,82 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import {
+  ActionRegistry,
+  DataSourceRegistry,
+  FieldTypeRegistry,
+  LifecycleRegistry,
+  OutboxHandlerRegistry,
+  ValidationEngine,
+  registerBuiltinActions,
+} from '@ftisindia/form-builder';
+import type {
+  DataSourceDef,
+  FieldTypeDef,
+  FormAction,
+  FormLifecycle,
+} from '@ftisindia/form-builder';
+import { PrismaSubmissionStore } from '../stores/prisma-submission.store';
+import { LoggingEmailHandler } from '../../application/services/handlers/logging-email.handler';
+import { WebhookOutboxHandler } from '../../application/services/handlers/webhook.handler';
+import {
+  FORM_ACTION_METADATA,
+  FORM_DATA_SOURCE_METADATA,
+  FORM_FIELD_TYPE_METADATA,
+  FORM_LIFECYCLE_METADATA,
+} from './form-extension.decorators';
+
+/**
+ * Populates the engine registries at startup: builtin actions first
+ * (validateAll/persist/persistDraft/lockEditing), the default outbox
+ * handlers, then every provider decorated with @FormFieldType /
+ * @FormActionHandler / @FormDataSource / @FormLifecycleHook — the app
+ * declares its extensions as ordinary providers; the engine finds them.
+ */
+@Injectable()
+export class RegistryBootstrapService implements OnModuleInit {
+  constructor(
+    private readonly discovery: DiscoveryService,
+    private readonly reflector: Reflector,
+    private readonly fieldTypes: FieldTypeRegistry,
+    private readonly actions: ActionRegistry,
+    private readonly dataSources: DataSourceRegistry,
+    private readonly lifecycles: LifecycleRegistry,
+    private readonly outboxHandlers: OutboxHandlerRegistry,
+    private readonly validation: ValidationEngine,
+    private readonly submissions: PrismaSubmissionStore,
+    private readonly emailHandler: LoggingEmailHandler,
+    private readonly webhookHandler: WebhookOutboxHandler,
+  ) {}
+
+  onModuleInit(): void {
+    registerBuiltinActions(this.actions, {
+      validate: (def, data, mode) => this.validation.validate(def, data, mode),
+      submissions: this.submissions,
+    });
+    this.outboxHandlers.register(this.emailHandler);
+    this.outboxHandlers.register(this.webhookHandler);
+
+    for (const wrapper of this.discovery.getProviders()) {
+      const instance: unknown = wrapper.instance;
+      if (!instance || typeof instance !== 'object') {
+        continue;
+      }
+      const ctor = instance.constructor as object | undefined;
+      if (!ctor || ctor === Object) {
+        continue;
+      }
+      if (this.reflector.get<boolean>(FORM_FIELD_TYPE_METADATA, ctor as never)) {
+        this.fieldTypes.register(instance as FieldTypeDef);
+      }
+      if (this.reflector.get<boolean>(FORM_ACTION_METADATA, ctor as never)) {
+        this.actions.register(instance as FormAction);
+      }
+      if (this.reflector.get<boolean>(FORM_DATA_SOURCE_METADATA, ctor as never)) {
+        this.dataSources.register(instance as DataSourceDef);
+      }
+      if (this.reflector.get<boolean>(FORM_LIFECYCLE_METADATA, ctor as never)) {
+        this.lifecycles.register(instance as FormLifecycle);
+      }
+    }
+  }
+}

package/template/src/modules/forms/infrastructure/request-forms-context.ts

@@ -0,0 +1,60 @@
+import { Injectable } from '@nestjs/common';
+import type { ContextPath, FormsContext } from '@ftisindia/form-builder';
+import { RequestContextService } from '../../request-context/application/services/request-context.service';
+
+/**
+ * Binds the engine's FormsContext seam to the app's AsyncLocalStorage request
+ * context. The closed ContextPath union IS the design doc's anti-tenant-leak
+ * rule for hidden fields, enforced by the type system (ecosystem guide §3).
+ */
+@Injectable()
+export class RequestFormsContext implements FormsContext {
+  constructor(private readonly ctx: RequestContextService) {}
+
+  requestId() {
+    return this.ctx.getRequestId();
+  }
+
+  source(): 'http' | 'worker' {
+    return this.ctx.get()?.source ?? 'worker';
+  }
+
+  userId() {
+    return this.ctx.getUserId();
+  }
+
+  orgId() {
+    return this.ctx.getOrgId();
+  }
+
+  permissionKeys() {
+    return this.ctx.getPermissions();
+  }
+
+  isOwner() {
+    return this.ctx.getRbacContext()?.isOwner ?? false;
+  }
+
+  assertOrgScope(orgId: string) {
+    this.ctx.assertOrgScope(orgId);
+  }
+
+  resolve(path: ContextPath) {
+    switch (path) {
+      case 'user.id':
+        return this.ctx.getUserId();
+      case 'org.id':
+        return this.ctx.getOrgId();
+      case 'request.id':
+        return this.ctx.getRequestId();
+    }
+  }
+
+  ipAddress() {
+    return this.ctx.getIpAddress();
+  }
+
+  userAgent() {
+    return this.ctx.getUserAgent();
+  }
+}

package/template/src/modules/forms/infrastructure/schema-check/forms-schema-check.service.ts

@@ -0,0 +1,76 @@
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { Prisma } from '@prisma/client';
+import {
+  ENGINE_SCHEMA_VERSION,
+  EXPECTED_FORMS_SCHEMA,
+  FORMS_PRISMA_SNIPPET_PATH,
+} from '@ftisindia/form-builder';
+import { PrismaService } from '../../../../database/prisma/prisma.service';
+
+/**
+ * Boot-time schema compatibility check (ecosystem guide §10.1): the app owns
+ * schema.prisma and migrations; the engine ships the canonical snippet and a
+ * tables/columns manifest. On mismatch the app fails fast at startup with an
+ * actionable message instead of crashing mid-request with a cryptic Prisma
+ * error. Escape hatch: FORMS_SCHEMA_CHECK=off.
+ */
+@Injectable()
+export class FormsSchemaCheckService implements OnApplicationBootstrap {
+  private readonly logger = new Logger('FormsSchemaCheck');
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly config: ConfigService,
+  ) {}
+
+  async onApplicationBootstrap(): Promise<void> {
+    if (this.config.get<string>('forms.schemaCheck') === 'off') {
+      this.logger.warn('Forms schema check is disabled (FORMS_SCHEMA_CHECK=off).');
+      return;
+    }
+    await this.check();
+    this.logger.log(`Forms schema check passed (engine schema version ${ENGINE_SCHEMA_VERSION}).`);
+  }
+
+  async check(): Promise<void> {
+    const tables = EXPECTED_FORMS_SCHEMA.map((expected) => expected.table);
+    const rows = await this.prisma.$queryRaw<Array<{ table_name: string; column_name: string }>>`
+      SELECT table_name, column_name
+      FROM information_schema.columns
+      WHERE table_schema = current_schema()
+        AND table_name IN (${Prisma.join(tables)})
+    `;
+
+    const present = new Map<string, Set<string>>();
+    for (const row of rows) {
+      const columns = present.get(row.table_name) ?? new Set<string>();
+      columns.add(row.column_name);
+      present.set(row.table_name, columns);
+    }
+
+    const problems: string[] = [];
+    for (const expected of EXPECTED_FORMS_SCHEMA) {
+      const columns = present.get(expected.table);
+      if (!columns) {
+        problems.push(`missing table "${expected.table}"`);
+        continue;
+      }
+      const missingColumns = expected.columns.filter((column) => !columns.has(column));
+      if (missingColumns.length > 0) {
+        problems.push(`table "${expected.table}" is missing column(s): ${missingColumns.join(', ')}`);
+      }
+    }
+
+    if (problems.length > 0) {
+      throw new Error(
+        [
+          `The database does not match @ftisindia/form-builder engine schema version ${ENGINE_SCHEMA_VERSION}:`,
+          ...problems.map((problem) => `  - ${problem}`),
+          `Fix: copy the canonical models from "${FORMS_PRISMA_SNIPPET_PATH}" (in node_modules) into prisma/schema.prisma and run "npx prisma migrate dev".`,
+          'To bypass temporarily (NOT recommended), set FORMS_SCHEMA_CHECK=off.',
+        ].join('\n'),
+      );
+    }
+  }
+}

package/template/src/modules/forms/infrastructure/storage/local-disk-storage.adapter.ts

@@ -0,0 +1,43 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, resolve, sep } from 'node:path';
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import type { FileStoragePort } from '@ftisindia/form-builder';
+
+/**
+ * Default byte storage under FORMS_FILE_STORAGE_DIR. Storage keys are always
+ * server-generated (orgId/uuid — never client-controlled names), and the
+ * resolved path is verified to stay inside the base directory as defense in
+ * depth against traversal. Swap this provider for an S3/GCS adapter without
+ * touching the engine.
+ */
+@Injectable()
+export class LocalDiskStorageAdapter implements FileStoragePort {
+  private readonly baseDir: string;
+
+  constructor(config: ConfigService) {
+    this.baseDir = resolve(config.get<string>('forms.storageDir') ?? './var/uploads');
+  }
+
+  async put(storageKey: string, bytes: Uint8Array): Promise<void> {
+    const path = this.fullPath(storageKey);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, bytes);
+  }
+
+  async get(storageKey: string): Promise<Uint8Array> {
+    return readFile(this.fullPath(storageKey));
+  }
+
+  async delete(storageKey: string): Promise<void> {
+    await rm(this.fullPath(storageKey), { force: true });
+  }
+
+  private fullPath(storageKey: string): string {
+    const path = resolve(this.baseDir, storageKey);
+    if (path !== this.baseDir && !path.startsWith(this.baseDir + sep)) {
+      throw new Error('Storage key resolves outside the configured storage directory.');
+    }
+    return path;
+  }
+}

package/template/src/modules/forms/infrastructure/stores/index.ts

@@ -0,0 +1,5 @@
+export * from './prisma-action-log.store';
+export * from './prisma-file.store';
+export * from './prisma-form-definition.store';
+export * from './prisma-outbox.store';
+export * from './prisma-submission.store';

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,
+    };
+  }
+}