@aurios/mizzle 1.1.2 → 1.1.4

package/test/core/snapshot-gen.test.ts

@@ -0,0 +1,155 @@
+import { expect, test, describe, beforeEach, afterEach } from "vitest";
+import {
+  generateSnapshot,
+  getNextMigrationVersion,
+  saveSnapshot,
+  loadSnapshot,
+  type MizzleSnapshot,
+} from "@aurios/mizzle/snapshot";
+import { PhysicalTable } from "@aurios/mizzle/table";
+import type { ColumnBuider } from "@aurios/mizzle/core/column-builder";
+import { TABLE_SYMBOLS, ENTITY_SYMBOLS } from "@repo/shared";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// Mock helpers
+const mockColumn = (name: string, type: string) => ({
+  name,
+  getDynamoType: () => type,
+  _: { name, type },
+});
+
+const mockTable = (name: string, pkName: string, pkType: string) => {
+  const table = new PhysicalTable(name, {
+    pk: { build: () => mockColumn(pkName, pkType) } as unknown as ColumnBuider,
+  });
+  table[TABLE_SYMBOLS.TABLE_NAME] = name;
+  table[TABLE_SYMBOLS.PARTITION_KEY] = mockColumn(pkName, pkType);
+  return table;
+};
+
+const mockEntity = (table: PhysicalTable, columns: Record<string, string>) => {
+  const colBuilders = Object.fromEntries(
+    Object.entries(columns).map(([name, type]) => [name, mockColumn(name, type)]),
+  );
+  return {
+    [ENTITY_SYMBOLS.PHYSICAL_TABLE]: table,
+    [ENTITY_SYMBOLS.COLUMNS]: colBuilders,
+  } as any;
+};
+
+const TEMP_DIR = join(tmpdir(), "mizzle-snapshot-test-" + Date.now());
+
+describe("Snapshot Persistence", () => {
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should save and load snapshot", async () => {
+    const snapshot: MizzleSnapshot = {
+      version: "1",
+      tables: {
+        test: {
+          TableName: "test",
+          AttributeDefinitions: [],
+          KeySchema: [],
+        },
+      },
+    };
+
+    await saveSnapshot(TEMP_DIR, snapshot);
+    const loaded = await loadSnapshot(TEMP_DIR);
+
+    expect(loaded).toEqual(snapshot);
+  });
+
+  test("should return null if snapshot does not exist", async () => {
+    const loaded = await loadSnapshot(TEMP_DIR);
+    expect(loaded).toBeNull();
+  });
+});
+
+describe("Snapshot Generation", () => {
+  test("should generate MizzleSnapshot from tables and entities", () => {
+    const table = mockTable("users", "id", "S");
+    const schema = { tables: [table], entities: [] };
+
+    const snapshot = generateSnapshot(schema);
+
+    expect(snapshot.version).toBe("1");
+    expect(snapshot.tables["users"]).toBeDefined();
+    expect(snapshot.tables["users"]!.TableName).toBe("users");
+    expect(snapshot.tables["users"]!.AttributeDefinitions).toEqual([
+      { AttributeName: "id", AttributeType: "S" },
+    ]);
+  });
+
+  test("should include indexes in snapshot", () => {
+    const table = mockTable("users", "id", "S");
+    table[TABLE_SYMBOLS.INDEXES] = {
+      byEmail: { type: "gsi", config: { pk: "email" } },
+      byDate: { type: "lsi", config: { sk: "date" } },
+    };
+
+    const entity = mockEntity(table, {
+      id: "S",
+      email: "S",
+      date: "N",
+    });
+
+    const snapshot = generateSnapshot({
+      tables: [table],
+      entities: [entity],
+    });
+    const userTable = snapshot.tables["users"]!;
+
+    expect(userTable.GlobalSecondaryIndexes).toHaveLength(1);
+    expect(userTable.GlobalSecondaryIndexes![0]!.IndexName).toBe("byEmail");
+    expect(userTable.LocalSecondaryIndexes).toHaveLength(1);
+    expect(userTable.LocalSecondaryIndexes![0]!.IndexName).toBe("byDate");
+
+    // Verify Attributes
+    const attrs = userTable.AttributeDefinitions;
+    expect(attrs).toContainEqual({
+      AttributeName: "email",
+      AttributeType: "S",
+    });
+    expect(attrs).toContainEqual({
+      AttributeName: "date",
+      AttributeType: "N",
+    });
+  });
+});
+
+describe("Migration Versioning", () => {
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should return '0000' if no migrations exist", async () => {
+    const version = await getNextMigrationVersion(TEMP_DIR);
+    expect(version).toBe("0000");
+  });
+
+  test("should return '0001' if '0000_init.ts' exists", async () => {
+    writeFileSync(join(TEMP_DIR, "0000_init.ts"), "");
+    const version = await getNextMigrationVersion(TEMP_DIR);
+    expect(version).toBe("0001");
+  });
+
+  test("should handle gaps and return next sequential", async () => {
+    writeFileSync(join(TEMP_DIR, "0000_init.ts"), "");
+    writeFileSync(join(TEMP_DIR, "0002_foo.ts"), ""); // Gap
+    const version = await getNextMigrationVersion(TEMP_DIR);
+    expect(version).toBe("0003"); // Should be max + 1
+  });
+});

package/test/core/snapshot.test.ts

@@ -0,0 +1,52 @@
+import { expect, test, describe, beforeEach, afterEach } from "vitest";
+import { saveSnapshot, loadSnapshot, type MizzleSnapshot } from "@aurios/mizzle/snapshot";
+import { mkdirSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const TEMP_DIR = join(tmpdir(), "mizzle-snapshot-test-" + Date.now());
+const MIGRATIONS_DIR = join(TEMP_DIR, "migrations");
+
+describe("Snapshot Storage", () => {
+  beforeEach(() => {
+    mkdirSync(MIGRATIONS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should save and load a snapshot", async () => {
+    const snapshot: MizzleSnapshot = {
+      version: "1",
+      tables: {
+        users: {
+          TableName: "users",
+          AttributeDefinitions: [{ AttributeName: "id", AttributeType: "S" }],
+          KeySchema: [{ AttributeName: "id", KeyType: "HASH" }],
+        },
+      },
+    };
+
+    const snapshotPath = join(MIGRATIONS_DIR, "snapshot.json");
+    await saveSnapshot(MIGRATIONS_DIR, snapshot);
+
+    expect(existsSync(snapshotPath)).toBe(true);
+
+    const loaded = await loadSnapshot(MIGRATIONS_DIR);
+    expect(loaded).toEqual(snapshot);
+  });
+
+  test("should create directory if it does not exist", async () => {
+    const newDir = join(TEMP_DIR, "new-migrations");
+    const snapshot: MizzleSnapshot = { version: "1", tables: {} };
+
+    await saveSnapshot(newDir, snapshot);
+    expect(existsSync(join(newDir, "snapshot.json"))).toBe(true);
+  });
+
+  test("should return null if no snapshot exists", async () => {
+    const loaded = await loadSnapshot(join(TEMP_DIR, "empty"));
+    expect(loaded).toBeNull();
+  });
+});

package/test/date-column.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi } from "vitest";
+import { date } from "@aurios/mizzle/columns";
+import { dynamoTable, dynamoEntity } from "@aurios/mizzle/table";
+import { InsertBase, UpdateBuilder, eq, buildExpression } from "@aurios/mizzle";
+import type { IMizzleClient } from "@aurios/mizzle/core/client";
+
+describe("date column", () => {
+  it("should define a date column", () => {
+    const col = date("created_at");
+    const c = col as unknown as { config: { name: string; dataType: string; columnType: string } };
+    expect(c.config.name).toBe("created_at");
+    expect(c.config.dataType).toBe("date");
+    expect(c.config.columnType).toBe("S");
+  });
+
+  const table = dynamoTable("test", {
+    pk: date("pk").partitionKey(),
+  });
+  const entity = dynamoEntity(table, "test", {
+    pk: date("pk"),
+  });
+  const col = entity.pk;
+
+  describe("serialization (mapToDynamoValue)", () => {
+    it("should serialize Date objects to ISO strings", () => {
+      const d = new Date("2023-01-01T10:00:00.000Z");
+      expect(col.mapToDynamoValue(d)).toBe("2023-01-01T10:00:00.000Z");
+    });
+
+    it("should pass through valid ISO strings", () => {
+      const iso = "2023-01-01T10:00:00.000Z";
+      expect(col.mapToDynamoValue(iso)).toBe(iso);
+    });
+
+    it("should convert numeric timestamps to ISO strings", () => {
+      const d = new Date("2023-01-01T10:00:00.000Z");
+      const ts = d.getTime();
+      expect(col.mapToDynamoValue(ts)).toBe("2023-01-01T10:00:00.000Z");
+    });
+
+    it("should throw error for invalid dates", () => {
+      expect(() => col.mapToDynamoValue("invalid-date")).toThrow();
+      expect(() => col.mapToDynamoValue(NaN)).toThrow();
+    });
+  });
+
+  describe("deserialization (mapFromDynamoValue)", () => {
+    it("should deserialize ISO strings to Date objects", () => {
+      const iso = "2023-01-01T10:00:00.000Z";
+      const result = col.mapFromDynamoValue(iso);
+      expect(result).toBeInstanceOf(Date);
+      expect((result as Date).toISOString()).toBe(iso);
+    });
+
+    it("should handle null/undefined gracefully (pass through)", () => {
+      expect(col.mapFromDynamoValue(null)).toBe(null);
+      expect(col.mapFromDynamoValue(undefined)).toBe(undefined);
+    });
+  });
+
+  describe("InsertBase integration", () => {
+    it("should serialize date in buildItem()", () => {
+      const mockClient = {} as unknown;
+      const d = new Date("2023-10-27T10:00:00.000Z");
+
+      const insert = new InsertBase(entity, mockClient as unknown as any, {
+        pk: d,
+      });
+
+      const item = (insert as unknown as any).buildItem();
+      expect(item.pk).toBe("2023-10-27T10:00:00.000Z");
+    });
+
+    it("should apply defaultNow()", () => {
+      const t = dynamoTable("test", { pk: date("pk").partitionKey() });
+      const e = dynamoEntity(t, "test", {
+        pk: date("pk"),
+        createdAt: date("createdAt").defaultNow(),
+      });
+      const insert = new InsertBase(e, {} as unknown as any, { pk: new Date() });
+      const item = (insert as unknown as { buildItem: () => Record<string, unknown> }).buildItem();
+      expect(item.createdAt).toBeDefined();
+      expect(typeof item.createdAt).toBe("string");
+      expect(new Date(item.createdAt as string).getTime()).toBeLessThanOrEqual(Date.now());
+    });
+  });
+
+  describe("UpdateBuilder integration", () => {
+    it("should serialize date in set()", () => {
+      const mockClient = {} as unknown;
+      const update = new UpdateBuilder(entity, mockClient as unknown as any);
+      const d = new Date("2023-10-27T10:00:00.000Z");
+
+      update.set({ pk: d });
+
+      expect(
+        (update as unknown as { _state: { set: Record<string, { value: unknown }> } })._state.set.pk
+          ?.value,
+      ).toBe("2023-10-27T10:00:00.000Z");
+    });
+
+    it("should apply onUpdateNow()", async () => {
+      const t = dynamoTable("test", { pk: date("pk").partitionKey() });
+      const e = dynamoEntity(t, "test", {
+        pk: date("pk"),
+        updatedAt: date("updatedAt").onUpdateNow(),
+      });
+      const mockClient = { send: vi.fn().mockResolvedValue({ Attributes: {} }) } as unknown;
+      const update = new UpdateBuilder(e, mockClient as unknown as any);
+      update.set({ pk: new Date() });
+
+      await (update as unknown as any).execute();
+
+      const state = (update as unknown as any)._state;
+      expect(state.set.updatedAt).toBeDefined();
+      expect(typeof state.set.updatedAt!.value).toBe("string");
+    });
+  });
+
+  describe("Integration & Sorting", () => {
+    it("should sort ISO strings chronologically", () => {
+      const d1 = new Date("2023-01-01T10:00:00.000Z").toISOString();
+      const d2 = new Date("2023-01-02T10:00:00.000Z").toISOString();
+      const d3 = new Date("2024-01-01T10:00:00.000Z").toISOString();
+
+      const dates = [d3, d1, d2];
+      dates.sort();
+
+      expect(dates).toEqual([d1, d2, d3]);
+    });
+
+    it("should handle reserved words as column names", () => {
+      const t = dynamoTable("test", { pk: date("date").partitionKey() });
+      const e = dynamoEntity(t, "test", {
+        pk: date("date"),
+      });
+
+      const expression = eq(e.pk, new Date("2023-10-27T10:00:00.000Z"));
+
+      const names: Record<string, string> = {};
+      const values: Record<string, unknown> = {};
+      const addName = (n: string) => {
+        const k = `#n${Object.keys(names).length}`;
+        names[k] = n;
+        return k;
+      };
+      const addValue = (v: unknown) => {
+        const k = `:v${Object.keys(values).length}`;
+        values[k] = v;
+        return k;
+      };
+
+      const result = buildExpression(expression, addName, addValue);
+
+      expect(result).toBe("#n0 = :v0");
+      expect(names["#n0"]).toBe("date");
+    });
+  });
+});

package/test/fluent-writes.integration.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { dynamoTable, dynamoEntity } from "@aurios/mizzle/table";
+import { string, uuid, number, list } from "@aurios/mizzle/columns";
+import { prefixKey, staticKey, add, append, remove, ifNotExists } from "@aurios/mizzle";
+import { DynamoDBClient, CreateTableCommand, DeleteTableCommand, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
+import { mizzle } from "@aurios/mizzle/db";
+import { eq } from "@aurios/mizzle/expressions/operators";
+
+const client = new DynamoDBClient({
+  endpoint: "http://localhost:8000",
+  region: "us-east-1",
+  credentials: {
+    accessKeyId: "local",
+    secretAccessKey: "local",
+  },
+});
+
+describe("Fluent Writes Integration", () => {
+  const tableName = "FluentWritesTable";
+  const table = dynamoTable(tableName, {
+    pk: string("pk"),
+    sk: string("sk"),
+  });
+
+  const user = dynamoEntity(
+    table,
+    "User",
+    {
+      id: uuid(),
+      name: string(), // Reserved Word
+      status: string(), // Reserved Word
+      order: number(), // Reserved Word
+      loginCount: number(),
+      tags: list(),
+      bio: string(),
+    },
+    (cols) => ({
+      pk: prefixKey("USER#", cols.id),
+      sk: staticKey("METADATA"),
+    }),
+  );
+
+  beforeAll(async () => {
+    try {
+      await client.send(
+        new CreateTableCommand({
+          TableName: tableName,
+          KeySchema: [
+            { AttributeName: "pk", KeyType: "HASH" },
+            { AttributeName: "sk", KeyType: "RANGE" },
+          ],
+          AttributeDefinitions: [
+            { AttributeName: "pk", AttributeType: "S" },
+            { AttributeName: "sk", AttributeType: "S" },
+          ],
+          ProvisionedThroughput: { ReadCapacityUnits: 5, WriteCapacityUnits: 5 },
+        }),
+      );
+
+      // Wait for table to be active
+      let active = false;
+      while (!active) {
+        const { Table } = await client.send(new DescribeTableCommand({ TableName: tableName }));
+        if (Table?.TableStatus === "ACTIVE") active = true;
+        else await new Promise((r) => setTimeout(r, 100));
+      }
+    } catch {
+      /* ignore */
+    }
+  });
+
+  afterAll(async () => {
+    try {
+      await client.send(new DeleteTableCommand({ TableName: tableName }));
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it("should handle reserved words and multiple actions in one set()", async () => {
+    const db = mizzle(client);
+
+    // 1. Insert
+    const newUser = await db
+      .insert(user)
+      .values({
+        name: "Alice",
+        status: "pending",
+        order: 1,
+        loginCount: 0,
+        tags: ["initial"],
+        bio: "Old bio",
+      })
+      .returning()
+      .execute();
+
+    // 2. Multi-Action Update using .set() with helpers
+    // We test SET (name, status), ADD (loginCount), REMOVE (bio), SET list_append (tags)
+    const updated = await db
+      .update(user)
+      .set({
+        name: "Alice Smith",
+        status: "active",
+        order: add(1),
+        loginCount: add(5),
+        tags: append(["pro"]),
+        bio: remove(),
+      })
+      .where(eq(user.id, newUser.id))
+      .returning("ALL_NEW")
+      .execute();
+
+    const res = updated as Record<string, unknown>;
+    expect(res.name).toBe("Alice Smith");
+    expect(res.status).toBe("active");
+    expect(res.order).toBe(2);
+    expect(res.loginCount).toBe(5);
+    expect(res.tags).toEqual(["initial", "pro"]);
+    expect(res.bio).toBeUndefined();
+  });
+
+  it("should handle ifNotExists helper", async () => {
+    const db = mizzle(client);
+
+    const newUser = await db
+      .insert(user)
+      .values({
+        name: "Bob",
+        loginCount: 0,
+      })
+      .returning()
+      .execute();
+
+    // Use ifNotExists on existing field and non-existing field
+    await db
+      .update(user)
+      .set({
+        name: ifNotExists("ShouldNotChange"),
+        status: ifNotExists("initialized"),
+      })
+      .where(eq(user.id, newUser.id))
+      .execute();
+
+    const final = await db.select().from(user).where(eq(user.id, newUser.id));
+    expect(final[0]!.name).toBe("Bob"); // Stayed "Bob" because it existed
+    expect(final[0]!.status).toBe("initialized"); // Set because it was missing
+  });
+});

package/test/integration-retry.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mizzle } from "@aurios/mizzle";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@repo/shared";
+
+// Mock send method
+const mockSend = vi.fn();
+const mockDocClient = {
+  send: mockSend,
+  middlewareStack: {
+    add: vi.fn(),
+    remove: vi.fn(),
+  },
+};
+
+describe("Integration Retry", () => {
+  beforeEach(() => {
+    vi.spyOn(DynamoDBDocumentClient, "from").mockReturnValue(mockDocClient as any);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+  const mockTable = {
+    [ENTITY_SYMBOLS.PHYSICAL_TABLE]: {
+      [TABLE_SYMBOLS.TABLE_NAME]: "test-table",
+      [TABLE_SYMBOLS.PARTITION_KEY]: { name: "pk" },
+      [TABLE_SYMBOLS.SORT_KEY]: undefined,
+      [TABLE_SYMBOLS.INDEXES]: {},
+    },
+    [ENTITY_SYMBOLS.ENTITY_STRATEGY]: { pk: { type: "static", segments: ["test"] } },
+  } as any;
+
+  it("should retry operations via mizzle client", async () => {
+    const client = new DynamoDBClient({});
+
+    // Mock error
+    const error = new Error("ThrottlingException");
+    error.name = "ThrottlingException";
+
+    mockSend.mockReset();
+    mockSend.mockRejectedValueOnce(error).mockResolvedValue({ Items: [] }); // Success on 2nd try
+
+    const db = mizzle({
+      client: client,
+      retry: { maxAttempts: 3, baseDelay: 10 },
+    });
+
+    // Use select builder which calls client.send
+    // We use .executeScan() path if no keys provided, but resolveKeys is called first.
+    // resolveKeys might complain if strategies/values don't match.
+    // Let's force a scan or just rely on the fact that resolveKeys returns something.
+
+    await db.select().from(mockTable).execute();
+
+    expect(mockSend).toHaveBeenCalledTimes(2);
+  });
+
+  it("should throw after max attempts", async () => {
+    const client = new DynamoDBClient({});
+
+    const error = new Error("ThrottlingException");
+    error.name = "ThrottlingException";
+
+    mockSend.mockReset();
+    mockSend.mockRejectedValue(error);
+
+    const db = mizzle({
+      client: client,
+      retry: { maxAttempts: 3, baseDelay: 10 },
+    });
+
+    await expect(db.select().from(mockTable).execute()).rejects.toThrow("ThrottlingException");
+    expect(mockSend).toHaveBeenCalledTimes(3);
+  });
+});

package/test/integration.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { dynamoTable, dynamoEntity } from "@aurios/mizzle/table";
+import { string, uuid, number, boolean, list, map } from "@aurios/mizzle/columns";
+import { prefixKey, staticKey } from "@aurios/mizzle";
+import { DynamoDBClient, CreateTableCommand, DeleteTableCommand, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
+import { mizzle } from "@aurios/mizzle/db";
+import { eq } from "@aurios/mizzle/expressions/operators";
+
+const client = new DynamoDBClient({
+  endpoint: "http://localhost:8000",
+  region: "us-east-1",
+  credentials: {
+    accessKeyId: "local",
+    secretAccessKey: "local",
+  },
+});
+
+describe("End-to-End Integration", () => {
+  const tableName = "IntegrationTestTable";
+  const table = dynamoTable(tableName, {
+    pk: string("pk"),
+    sk: string("sk"),
+  });
+
+  const project = dynamoEntity(
+    table,
+    "Project",
+    {
+      id: uuid(),
+      name: string(),
+      description: string(),
+      stars: number(),
+      isPublic: boolean(),
+      tags: list(),
+      config: map(),
+    },
+    (cols) => ({
+      pk: prefixKey("PROJ#", cols.id),
+      sk: staticKey("INFO"),
+    }),
+  );
+
+  beforeAll(async () => {
+    try {
+      await client.send(
+        new CreateTableCommand({
+          TableName: tableName,
+          KeySchema: [
+            { AttributeName: "pk", KeyType: "HASH" },
+            { AttributeName: "sk", KeyType: "RANGE" },
+          ],
+          AttributeDefinitions: [
+            { AttributeName: "pk", AttributeType: "S" },
+            { AttributeName: "sk", AttributeType: "S" },
+          ],
+          ProvisionedThroughput: {
+            ReadCapacityUnits: 5,
+            WriteCapacityUnits: 5,
+          },
+        }),
+      );
+    } catch {
+      /* ignore */
+    }
+  });
+
+  afterAll(async () => {
+    try {
+      await client.send(new DeleteTableCommand({ TableName: tableName }));
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it("should perform a full Create -> Read lifecycle", async () => {
+    const db = mizzle(client);
+
+    // 1. Insert
+    const newProject = {
+      name: "Mizzle",
+      description: "Lightweight DynamoDB ORM",
+      stars: 100,
+      isPublic: true,
+      tags: ["typescript", "orm"],
+      config: { version: "1.0.0" },
+    } as unknown as any; // Cast to unknown because 'id' is generated but usually required by type
+
+    const inserted = (await db.insert(project).values(newProject).returning().execute()) as any;
+
+    expect(inserted.id).toBeDefined();
+    expect(inserted.pk).toBe(`PROJ#${inserted.id}`);
+    expect(inserted.sk).toBe("INFO");
+
+    // 2. Select
+    const results = await db.select().from(project).where(eq(project.id, inserted.id));
+
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject({
+      id: inserted.id,
+      name: "Mizzle",
+      stars: 100,
+      config: { version: "1.0.0" },
+    });
+  });
+});