sonamu 0.10.12 → 0.10.13

package/src/testing/__tests__/dev-vitest-manager.test.ts

@@ -1,28 +1,35 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-// vitest/node 모킹 - createVitest가 mock Vitest 인스턴스를 반환하도록 설정
+import { type ManagedVitest } from "../dev-vitest-manager";
+import { DevVitestManager } from "../dev-vitest-manager";
+
+// 매니저가 사용하는 Vitest 기능만 충실히 구현한 테스트 대역입니다.
 const mockVitest = {
   standalone: vi.fn().mockResolvedValue(undefined),
   onFilterWatchedSpecification: vi.fn(),
+  invalidateFile: vi.fn(),
   setGlobalTestNamePattern: vi.fn(),
   resetGlobalTestNamePattern: vi.fn(),
   globTestSpecifications: vi.fn(),
   runTestSpecifications: vi.fn(),
   close: vi.fn(),
-};
-
-vi.mock("vitest/node", () => ({
-  createVitest: vi.fn().mockResolvedValue(mockVitest),
-}));
+} satisfies ManagedVitest;
 
-import { DevVitestManager } from "../dev-vitest-manager";
+function createModule(duration: number) {
+  return {
+    moduleId: "dup.test.ts",
+    children: [],
+    state: () => "passed" as const,
+    diagnostic: () => ({ duration }),
+  };
+}
 
 describe("DevVitestManager", () => {
   let manager: DevVitestManager;
 
   beforeEach(() => {
     vi.clearAllMocks();
-    manager = new DevVitestManager();
+    manager = new DevVitestManager(async () => mockVitest);
 
     // 기본 mock: 빈 테스트 결과
     const mockTestModule = {
@@ -114,13 +121,6 @@ describe("DevVitestManager", () => {
     await manager.start();
     mockVitest.globTestSpecifications.mockResolvedValue([{ moduleId: "dup.test.ts" }]);
 
-    const createModule = (duration: number) => ({
-      moduleId: "dup.test.ts",
-      children: [],
-      state: () => "passed" as const,
-      diagnostic: () => ({ duration }),
-    });
-
     mockVitest.runTestSpecifications.mockResolvedValue({
       testModules: [createModule(10), createModule(25)],
     });

package/src/testing/_relation-graph.ts

@@ -44,7 +44,10 @@ export class RelationGraph {
             }
           } else if (isManyToManyRelationProp(prop)) {
             // ManyToMany 관계의 경우 양방향 의존성 추가
-            const relatedIds = column.value as unknown as (number | string)[];
+            if (!Array.isArray(column.value)) {
+              throw new Error(`${fixture.fixtureId}.${prop.name} 관계 값은 배열이어야 합니다.`);
+            }
+            const relatedIds = column.value;
             for (const relatedId of relatedIds) {
               const relatedFixtureId = `${prop.with}#${relatedId}`;
               if (this.graph.has(relatedFixtureId)) {

package/src/testing/bootstrap.ts

@@ -57,14 +57,21 @@ export function bootstrap(vi: VitestUtils, options?: BootstrapOptions) {
 }
 
 function getMockContext(): Context {
+  // SAFETY: 테스트 컨텍스트에서는 Fastify 요청과 응답을 사용하지 않으며 접근 시 즉시 실패해야 합니다.
+  const request: Context["request"] = null as never;
+  // SAFETY: 테스트 컨텍스트에서는 Fastify 요청과 응답을 사용하지 않으며 접근 시 즉시 실패해야 합니다.
+  const reply: Context["reply"] = null as never;
+  // SAFETY: 모의 구현은 실제 createSSE와 같은 호출 계약을 유지하되 항상 명시적으로 실패합니다.
+  const createSSE = (() => {
+    throw new Error("createSSE is not available in mock context");
+  }) as Context["createSSE"];
+
   return {
     transport: "http",
-    request: null as unknown as Context["request"],
-    reply: null as unknown as Context["reply"],
+    request,
+    reply,
     headers: {},
-    createSSE: (() => {
-      throw new Error("createSSE is not available in mock context");
-    }) as Context["createSSE"],
+    createSSE,
     session: null,
     user: null,
     naiteStore: Naite.createStore(),

package/src/testing/data-explorer.ts

@@ -1,22 +1,67 @@
 import { type Knex } from "knex";
+import { z } from "zod";
 
 import { type CacheManager } from "../cache/types";
 import { type Entity } from "../entity/entity";
 import { type EntityManager } from "../entity/entity-manager";
 import { isBelongsToOneRelationProp, isOneToOneRelationProp, isRelationProp } from "../types/types";
-import { nonNullable } from "../utils/utils";
+import { isFunctionValue } from "../utils/runtime-value";
 
 export type DataExplorerStrategy = "sample" | "ids" | "query" | "file" | "recent" | "random";
 
+export type DataExplorerValue =
+  | string
+  | number
+  | boolean
+  | bigint
+  | Date
+  | Uint8Array
+  | null
+  | undefined
+  | DataExplorerValue[]
+  | DataExplorerRecord;
+
+export type DataExplorerRecord = {
+  [columnName: string]: DataExplorerValue;
+};
+
+export const dataExplorerValueSchema: z.ZodType<DataExplorerValue> = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.bigint(),
+    z.date(),
+    z.instanceof(Uint8Array),
+    z.null(),
+    z.undefined(),
+    z.array(dataExplorerValueSchema),
+    z.record(z.string(), dataExplorerValueSchema),
+  ]),
+);
+export const dataExplorerRecordSchema = z.record(z.string(), dataExplorerValueSchema);
+export const dataExplorerRecordsSchema = z.array(dataExplorerRecordSchema);
+const dataExplorerDirectionSchema = z.enum(["asc", "desc"]);
+export const dataSourceConfigSchema = z.object({
+  strategy: z.enum(["sample", "ids", "query", "file", "recent", "random"]).optional(),
+  limit: z.number().optional(),
+  where: z.record(z.string(), dataExplorerValueSchema).optional(),
+  orderBy: z.string().optional(),
+  ids: z.array(z.union([z.number(), z.string()])).optional(),
+  filePath: z.string().optional(),
+  useCache: z.boolean().optional(),
+  cacheTtl: z.number().optional(),
+});
+
 /** WHERE 조건 타입 (객체 또는 Knex QueryBuilder 함수) */
-export type WhereCondition = Record<string, unknown> | ((queryBuilder: Knex.QueryBuilder) => void);
+export type WhereCondition = object | ((queryBuilder: Knex.QueryBuilder) => void);
 
 export type DataExplorerOptions = {
   strategy: DataExplorerStrategy;
   limit?: number;
   where?: WhereCondition;
   orderBy?: string;
-  ids?: number[];
+  ids?: (number | string)[];
   filePath?: string;
   /** 캐싱 사용 여부 (기본값: false) */
   useCache?: boolean;
@@ -35,10 +80,10 @@ export type ExploreWithRelationsResult = {
   /** 메인 entity 데이터 */
   main: {
     entityId: string;
-    records: Record<string, unknown>[];
+    records: DataExplorerRecord[];
   };
   /** 관련 entity 데이터 (entityId -> records) */
-  related: Map<string, Record<string, unknown>[]>;
+  related: Map<string, DataExplorerRecord[]>;
 };
 
 // 기존 DB 데이터를 탐색하여 fixture 생성 시 참조할 수 있는 시스템
@@ -53,10 +98,7 @@ export class DataExplorer {
     this.cache = cacheManager;
   }
 
-  async explore(
-    entityName: string,
-    options: DataExplorerOptions,
-  ): Promise<Record<string, unknown>[]> {
+  async explore(entityName: string, options: DataExplorerOptions): Promise<DataExplorerRecord[]> {
     const entity = this.entityManager.get(entityName);
     if (!entity) {
       throw new Error(`Entity not found: ${entityName}`);
@@ -78,7 +120,7 @@ export class DataExplorer {
   private async exploreInternal(
     entity: Entity,
     options: DataExplorerOptions,
-  ): Promise<Record<string, unknown>[]> {
+  ): Promise<DataExplorerRecord[]> {
     const query = this.db(entity.table);
 
     switch (options.strategy) {
@@ -90,7 +132,7 @@ export class DataExplorer {
         if (createdAtCol) {
           query.orderBy(createdAtCol, "desc");
         }
-        return await query.limit(options.limit || 10);
+        return dataExplorerRecordsSchema.parse(await query.limit(options.limit || 10));
       }
 
       case "random":
@@ -100,22 +142,30 @@ export class DataExplorer {
         if (options.ids && options.ids.length > 0) {
           query.whereIn("id", options.ids);
         }
-        return await query;
+        return dataExplorerRecordsSchema.parse(await query);
 
       case "query":
         if (options.where) {
-          query.where(options.where);
+          const whereCallback = z
+            .custom<(queryBuilder: Knex.QueryBuilder) => void>(isFunctionValue)
+            .safeParse(options.where);
+          if (whereCallback.success) {
+            query.where(whereCallback.data);
+          } else {
+            query.where(dataExplorerRecordSchema.parse(options.where));
+          }
         }
         if (options.orderBy) {
           const [col, dir = "asc"] = options.orderBy.split(":");
+          const direction = dataExplorerDirectionSchema.parse(dir);
           // id 컬럼은 숫자로 캐스팅하여 정렬합니다 (문자열 정렬 방지)
           if (col === "id") {
-            query.orderByRaw(`CAST(?? AS INTEGER) ${dir}`, [col]);
+            query.orderByRaw(`CAST(?? AS INTEGER) ${direction}`, [col]);
           } else {
-            query.orderBy(col, dir as "asc" | "desc");
+            query.orderBy(col, direction);
           }
         }
-        return await query.limit(options.limit || 10);
+        return dataExplorerRecordsSchema.parse(await query.limit(options.limit || 10));
 
       case "file":
         if (!options.filePath) {
@@ -129,15 +179,12 @@ export class DataExplorer {
   }
 
   // 균등 샘플링 (PostgreSQL ROW_NUMBER 사용)
-  private async sampleData(
-    query: Knex.QueryBuilder,
-    limit: number,
-  ): Promise<Record<string, unknown>[]> {
+  private async sampleData(query: Knex.QueryBuilder, limit: number): Promise<DataExplorerRecord[]> {
     const [{ count }] = await query.clone().count("* as count");
     const total = Number(count);
 
     if (total <= limit) {
-      return await query.limit(limit);
+      return dataExplorerRecordsSchema.parse(await query.limit(limit));
     }
 
     // 균등 간격 계산
@@ -163,14 +210,14 @@ export class DataExplorer {
       [tableName, interval, limit],
     );
 
-    return result.rows;
+    return dataExplorerRecordsSchema.parse(result.rows);
   }
 
   private async randomSample(
     query: Knex.QueryBuilder,
     limit: number,
-  ): Promise<Record<string, unknown>[]> {
-    return await query.orderByRaw("RANDOM()").limit(limit);
+  ): Promise<DataExplorerRecord[]> {
+    return dataExplorerRecordsSchema.parse(await query.orderByRaw("RANDOM()").limit(limit));
   }
 
   private findTimestampColumn(entity: Entity, columnName: string): string | null {
@@ -178,29 +225,29 @@ export class DataExplorer {
     return prop?.name || null;
   }
 
-  private async loadFromFile(filePath: string): Promise<Record<string, unknown>[]> {
+  private async loadFromFile(filePath: string): Promise<DataExplorerRecord[]> {
     const fs = await import("fs/promises");
     const content = await fs.readFile(filePath, "utf-8");
 
     if (filePath.endsWith(".json")) {
-      const parsed = JSON.parse(content);
-      if (!Array.isArray(parsed)) {
-        throw new Error("JSON file must contain an array");
+      try {
+        const parsed = dataExplorerRecordsSchema.safeParse(JSON.parse(content));
+        if (!parsed.success) {
+          throw new Error("JSON file must contain an array of records");
+        }
+        return parsed.data;
+      } catch (error) {
+        throw new Error("JSON file must contain a valid array of records", { cause: error });
       }
-      return parsed as Record<string, unknown>[];
     } else if (filePath.endsWith(".csv")) {
       const lines = content.split("\n").filter((line) => line.trim());
       if (lines.length === 0) return [];
 
       const headers = lines[0].split(",").map((h) => h.trim());
-      return lines.slice(1).map((line) => {
+      return lines.slice(1).map((line): DataExplorerRecord => {
         const values = line.split(",");
-        return headers.reduce(
-          (obj: Record<string, unknown>, header: string, i: number) => {
-            obj[header] = values[i]?.trim();
-            return obj;
-          },
-          {} as Record<string, unknown>,
+        return Object.fromEntries(
+          headers.map((header, index) => [header, values[index]?.trim()] as const),
         );
       });
     }
@@ -212,7 +259,7 @@ export class DataExplorer {
     entityName: string,
     relationProp: string,
     options?: Partial<DataExplorerOptions>,
-  ): Promise<Record<string, unknown>[]> {
+  ): Promise<DataExplorerRecord[]> {
     const entity = this.entityManager.get(entityName);
     const prop = entity.props.find((p) => p.name === relationProp);
 
@@ -222,17 +269,15 @@ export class DataExplorer {
 
     const dataSource = prop.cone?.dataSource;
     const strategy = dataSource?.strategy || options?.strategy || "sample";
-    const config =
-      dataSource?.config && typeof dataSource.config === "object"
-        ? (dataSource.config as Record<string, unknown>)
-        : {};
-
-    return this.explore(prop.with, {
+    const config = dataSourceConfigSchema.parse(dataSource?.config ?? {});
+    const exploreOptions: DataExplorerOptions = {
       strategy,
-      limit: options?.limit || (typeof config.limit === "number" ? config.limit : 10),
-      ...(typeof config === "object" ? config : {}),
+      limit: options?.limit ?? config.limit ?? 10,
+      ...config,
       ...options,
-    });
+    };
+
+    return this.explore(prop.with, exploreOptions);
   }
 
   /**
@@ -242,7 +287,7 @@ export class DataExplorer {
     entityName: string,
     relationProps: string[],
     options?: Partial<DataExplorerOptions>,
-  ): Promise<Record<string, Record<string, unknown>[]>> {
+  ): Promise<Record<string, DataExplorerRecord[]>> {
     const results = await Promise.all(
       relationProps.map(async (prop) => {
         const data = await this.exploreRelation(entityName, prop, options);
@@ -314,8 +359,8 @@ export class DataExplorer {
    */
   private async collectRelatedData(
     entityName: string,
-    records: Record<string, unknown>[],
-    relatedMap: Map<string, Record<string, unknown>[]>,
+    records: DataExplorerRecord[],
+    relatedMap: Map<string, DataExplorerRecord[]>,
     visited: Set<string>,
     remainingDepth: number,
   ): Promise<void> {
@@ -324,7 +369,10 @@ export class DataExplorer {
     }
 
     const entity = this.entityManager.get(entityName);
-    const recordIds = records.map((r) => r.id).filter(nonNullable);
+    const recordIds = records.flatMap((record) => {
+      const parsedId = z.union([z.number(), z.string()]).safeParse(record.id);
+      return parsedId.success ? [parsedId.data] : [];
+    });
 
     // 1. Forward references: 이 entity가 참조하는 다른 entity
     const forwardRelationProps = entity.props.filter(
@@ -345,9 +393,10 @@ export class DataExplorer {
 
       // 참조하는 ID들 수집
       const foreignKeyName = `${prop.name}_id`;
-      const referencedIds = records
-        .map((record) => record[foreignKeyName])
-        .filter(Boolean) as number[];
+      const referencedIds = records.flatMap((record) => {
+        const parsedId = z.union([z.number(), z.string()]).safeParse(record[foreignKeyName]);
+        return parsedId.success ? [parsedId.data] : [];
+      });
 
       if (referencedIds.length === 0) {
         continue;

package/src/testing/dev-test-routes.ts

@@ -8,12 +8,34 @@ import { Sonamu } from "../api/sonamu";
 import { type SerializedTrace } from "../naite/naite";
 import { createSSEFactory } from "../stream/sse";
 import { type SSEConnection } from "../stream/sse";
-import { type ManagerStatus, type RunResult, type TestCaseResult } from "./dev-vitest-manager";
+import {
+  type ManagerStatus,
+  type RunResult,
+  type TestCaseResult,
+  type TestEventPayload,
+} from "./dev-vitest-manager";
 import { DevVitestManager } from "./dev-vitest-manager";
 
 const SCHEMA_VERSION = 1;
 const HEARTBEAT_INTERVAL_MS = 30_000;
 
+export type DevTestRouteManager = Pick<
+  DevVitestManager,
+  | "start"
+  | "run"
+  | "getStatus"
+  | "emitEvent"
+  | "addEventListener"
+  | "removeEventListener"
+  | "shutdown"
+>;
+
+export type DevTestRouteDependencies = {
+  manager?: DevTestRouteManager;
+  apiRootPath?: string;
+  sseAvailable?: boolean;
+};
+
 const SerializedTraceSchema = z.object({
   key: z.string(),
   value: z.unknown(),
@@ -48,6 +70,22 @@ const TestCaseResultSchema: z.ZodType<TestCaseResult> = z.lazy(() =>
   }),
 );
 
+const RunResultSchema: z.ZodType<RunResult> = z.object({
+  ok: z.boolean(),
+  summary: z.object({
+    total: z.number(),
+    passed: z.number(),
+    failed: z.number(),
+    skipped: z.number(),
+    durationMs: z.number(),
+  }),
+  results: z.array(TestCaseResultSchema),
+});
+const RunRequestSchema = z.object({
+  files: z.array(z.string()).optional(),
+  pattern: z.string().optional(),
+});
+
 const TestEventSchema = z.object({
   snapshot: z.object({
     schemaVersion: z.number(),
@@ -56,6 +94,7 @@ const TestEventSchema = z.object({
       ready: z.boolean(),
       running: z.boolean(),
       lastRunAt: z.string().nullable(),
+      sseAvailable: z.boolean(),
     }),
   }),
   runQueued: z.object({
@@ -77,7 +116,7 @@ const TestEventSchema = z.object({
     runId: z.string(),
     startedAt: z.string(),
     finishedAt: z.string(),
-    result: z.record(z.string(), z.unknown()),
+    result: RunResultSchema,
   }),
   runErrored: z.object({
     schemaVersion: z.number(),
@@ -107,6 +146,15 @@ const TestEventSchema = z.object({
 });
 
 type TestEvents = z.infer<typeof TestEventSchema>;
+const TestEventNameSchema = z.enum([
+  "snapshot",
+  "runQueued",
+  "runStarted",
+  "runCompleted",
+  "runErrored",
+  "runNodeProgress",
+  "heartbeat",
+]);
 
 function toPathPrefix(basePath: string): string {
   return basePath.endsWith("/") ? basePath : `${basePath}/`;
@@ -127,24 +175,6 @@ function relativizeNode(node: TestCaseResult, basePath: string): TestCaseResult
   };
 }
 
-function isRunNodeProgressData(data: unknown): data is TestEvents["runNodeProgress"] {
-  if (typeof data !== "object" || data === null) return false;
-  const d = data as Record<string, unknown>;
-  return (
-    d.schemaVersion === 1 &&
-    typeof d.runId === "string" &&
-    typeof d.startedAt === "string" &&
-    typeof d.at === "string" &&
-    (d.kind === "file" || d.kind === "suite" || d.kind === "test") &&
-    (d.phase === "ready" || d.phase === "result") &&
-    typeof d.fileId === "string" &&
-    typeof d.nodeId === "string" &&
-    (d.parentId === null || typeof d.parentId === "string") &&
-    typeof d.node === "object" &&
-    d.node !== null
-  );
-}
-
 function relativizeResult(result: RunResult, basePath: string): RunResult {
   const prefix = toPathPrefix(basePath);
   return {
@@ -156,14 +186,21 @@ function relativizeResult(result: RunResult, basePath: string): RunResult {
 export async function registerDevTestRoutes(
   server: FastifyInstance,
   config: SonamuDevRunnerConfig,
+  dependencies?: DevTestRouteDependencies,
 ): Promise<void> {
   const prefix = config.routePrefix ?? "/__test__";
 
-  const manager = new DevVitestManager();
+  const defaultManager = dependencies?.manager === undefined ? new DevVitestManager() : null;
+  const manager = dependencies?.manager ?? defaultManager;
+  if (manager === null) {
+    throw new Error("DevVitestManager dependency is unavailable");
+  }
   await manager.start(config.vitestConfigPath);
-  Sonamu.devVitestManager = manager;
+  if (defaultManager !== null) {
+    Sonamu.devVitestManager = defaultManager;
+  }
 
-  const sseAvailable = !!Sonamu.config.server.plugins?.sse;
+  const sseAvailable = dependencies?.sseAvailable ?? !!Sonamu.config.server.plugins?.sse;
 
   if (sseAvailable) {
     server.get(`${prefix}/events`, (request, reply): void => {
@@ -177,7 +214,8 @@ export async function registerDevTestRoutes(
       sse.publish("snapshot", {
         schemaVersion: SCHEMA_VERSION,
         serverTime: new Date().toISOString(),
-        status,
+        // UI는 HTTP status와 같은 형태를 기대하므로 SSE 스냅샷에도 sseAvailable을 포함합니다.
+        status: { ...status, sseAvailable },
       });
 
       const heartbeatTimer = setInterval(() => {
@@ -187,19 +225,29 @@ export async function registerDevTestRoutes(
         });
       }, HEARTBEAT_INTERVAL_MS);
 
-      const basePath = Sonamu.apiRootPath;
-      const listener = (event: string, data: unknown) => {
-        const key = event as keyof TestEvents;
+      const basePath = dependencies?.apiRootPath ?? Sonamu.apiRootPath;
+      const listener = (event: string, data: TestEventPayload) => {
+        const parsedKey = TestEventNameSchema.safeParse(event);
+        if (!parsedKey.success) return;
+        const key = parsedKey.data;
         if (key === "runNodeProgress") {
-          if (!isRunNodeProgressData(data)) return;
+          const progressEnvelope = TestEventSchema.partial().safeParse({ runNodeProgress: data });
+          if (!progressEnvelope.success || progressEnvelope.data.runNodeProgress === undefined) {
+            return;
+          }
+          const progress = progressEnvelope.data.runNodeProgress;
           const relativized = {
-            ...data,
-            node: relativizeNode(data.node, basePath),
+            ...progress,
+            node: relativizeNode(progress.node, basePath),
           };
           sse.publish(key, relativized);
           return;
         }
-        sse.publish(key, data as TestEvents[typeof key]);
+        const parsedEnvelope = TestEventSchema.partial().safeParse({ [key]: data });
+        if (!parsedEnvelope.success || parsedEnvelope.data[key] === undefined) return;
+        const parsedData = parsedEnvelope.data[key];
+        // SAFETY: key와 payload는 같은 TestEventSchema 항목으로 함께 검증되었습니다.
+        sse.publish(key, parsedData as TestEvents[typeof key]);
       };
       manager.addEventListener(listener);
 
@@ -216,17 +264,8 @@ export async function registerDevTestRoutes(
   }
 
   server.post(`${prefix}/run`, async (request, reply) => {
-    if (!Sonamu.devVitestManager) {
-      reply.status(503);
-      return { ok: false, error: "DevVitestManager is not initialized" };
-    }
-
     const runId = randomUUID();
-    const body = request.body as { files?: string[]; pattern?: string } | null;
-    const runRequest = {
-      files: body?.files,
-      pattern: body?.pattern,
-    };
+    const runRequest = RunRequestSchema.parse(request.body ?? {});
 
     manager.emitEvent("runQueued", {
       schemaVersion: SCHEMA_VERSION,
@@ -243,8 +282,8 @@ export async function registerDevTestRoutes(
         startedAt,
       });
 
-      const rawResult: RunResult = await Sonamu.devVitestManager.run(runRequest, runId);
-      const result = relativizeResult(rawResult, Sonamu.apiRootPath);
+      const rawResult: RunResult = await manager.run(runRequest, runId);
+      const result = relativizeResult(rawResult, dependencies?.apiRootPath ?? Sonamu.apiRootPath);
 
       const finishedAt = new Date().toISOString();
       manager.emitEvent("runCompleted", {
@@ -274,16 +313,14 @@ export async function registerDevTestRoutes(
   });
 
   server.get(`${prefix}/status`, async () => {
-    const status: ManagerStatus = Sonamu.devVitestManager?.getStatus() ?? {
-      ready: false,
-      running: false,
-      lastRunAt: null,
-    };
+    const status: ManagerStatus = manager.getStatus();
     return { ...status, sseAvailable };
   });
 
   server.addHook("onClose", async () => {
-    await Sonamu.devVitestManager?.shutdown();
-    Sonamu.devVitestManager = null;
+    await manager.shutdown();
+    if (defaultManager !== null) {
+      Sonamu.devVitestManager = null;
+    }
   });
 }