@tailor-platform/erp-kit 0.5.1 → 0.6.0

package/src/modules/manufacturing/query/getProductionOrder.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { ProductionOrderNotFoundError } from "../lib/errors.generated";
+import {
+  baseReleasedProductionOrder,
+  baseBomSnapshot,
+  baseRoutingSnapshot,
+  baseCostBaseline,
+  baseMaterialRequirement,
+  basePendingWorkOrder,
+  baseInProgressWorkOrder,
+  baseCollectingCostSummary,
+} from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { run } from "./getProductionOrder";
+
+describe("getProductionOrder", () => {
+  it("returns a production order with material requirements, work orders, and cost summary when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const materialReq = {
+      ...baseMaterialRequirement,
+      productionOrderId: baseReleasedProductionOrder.id,
+    };
+    const workOrder1 = {
+      ...basePendingWorkOrder,
+      productionOrderId: baseReleasedProductionOrder.id,
+    };
+    const workOrder2 = {
+      ...baseInProgressWorkOrder,
+      productionOrderId: baseReleasedProductionOrder.id,
+    };
+    const costSummary = {
+      ...baseCollectingCostSummary,
+      productionOrderId: baseReleasedProductionOrder.id,
+    };
+
+    // 1st select: productionOrder
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // 2nd-4th select: snapshots and baseline
+    spies.select.mockReturnValueOnce(baseBomSnapshot);
+    spies.select.mockReturnValueOnce(baseRoutingSnapshot);
+    spies.select.mockReturnValueOnce(baseCostBaseline);
+    // 5th select: materialRequirements
+    spies.select.mockReturnValueOnce([materialReq]);
+    // 6th select: workOrders
+    spies.select.mockReturnValueOnce([workOrder1, workOrder2]);
+    // 7th select: costSummary
+    spies.select.mockReturnValueOnce(costSummary);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id });
+    const {
+      productionOrder,
+      bomSnapshot,
+      routingSnapshot,
+      costBaseline,
+      materialRequirements,
+      workOrders,
+      quantityRollup,
+      costSummary: cs,
+    } = expectOk<{
+      productionOrder: { id: string; status: string; selectedBomVersionId: string | null };
+      bomSnapshot: { productionOrderId: string } | null;
+      routingSnapshot: { routingId: string } | null;
+      costBaseline: { currencyCode: string } | null;
+      materialRequirements: { id: string; itemId: string }[];
+      workOrders: { id: string; status: string }[];
+      quantityRollup: { completedQuantity: number; openWorkOrderCount: number };
+      costSummary: { id: string; status: string } | null;
+    }>(result as never);
+
+    expect(productionOrder.id).toBe(baseReleasedProductionOrder.id);
+    expect(productionOrder.status).toBe("RELEASED");
+    expect(productionOrder.selectedBomVersionId).toBe("bom-2");
+    expect(bomSnapshot?.productionOrderId).toBe(baseReleasedProductionOrder.id);
+    expect(routingSnapshot?.routingId).toBe(baseRoutingSnapshot.routingId);
+    expect(costBaseline?.currencyCode).toBe("USD");
+    expect(materialRequirements).toHaveLength(1);
+    expect(materialRequirements[0].itemId).toBe("item-2");
+    expect(workOrders).toHaveLength(2);
+    expect(quantityRollup.completedQuantity).toBe(50);
+    expect(quantityRollup.openWorkOrderCount).toBe(2);
+    expect(cs).not.toBeNull();
+    expect(cs!.status).toBe("COLLECTING");
+  });
+
+  it("returns a production order with no cost summary when none exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+
+    // 1st select: productionOrder
+    spies.select.mockReturnValueOnce(baseReleasedProductionOrder);
+    // 2nd-4th select: snapshots and baseline
+    spies.select.mockReturnValueOnce(undefined);
+    spies.select.mockReturnValueOnce(undefined);
+    spies.select.mockReturnValueOnce(undefined);
+    // 5th select: materialRequirements
+    spies.select.mockReturnValueOnce([]);
+    // 6th select: workOrders
+    spies.select.mockReturnValueOnce([]);
+    // 7th select: costSummary returns undefined
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: baseReleasedProductionOrder.id });
+    const {
+      productionOrder,
+      bomSnapshot,
+      routingSnapshot,
+      costBaseline,
+      materialRequirements,
+      workOrders,
+      costSummary,
+    } = expectOk<{
+      productionOrder: { id: string };
+      bomSnapshot: null;
+      routingSnapshot: null;
+      costBaseline: null;
+      materialRequirements: unknown[];
+      workOrders: unknown[];
+      costSummary: null;
+    }>(result as never);
+
+    expect(productionOrder.id).toBe(baseReleasedProductionOrder.id);
+    expect(bomSnapshot).toBeNull();
+    expect(routingSnapshot).toBeNull();
+    expect(costBaseline).toBeNull();
+    expect(materialRequirements).toHaveLength(0);
+    expect(workOrders).toHaveLength(0);
+    expect(costSummary).toBeNull();
+  });
+
+  it("returns error when the production order does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // 1st select: productionOrder returns undefined
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+    expectErr(result as never, ProductionOrderNotFoundError);
+  });
+});

package/src/modules/manufacturing/query/getProductionOrder.ts

@@ -0,0 +1,84 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ProductionOrderNotFoundError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetProductionOrderInput {
+  id: string;
+}
+
+/**
+ * Function: getProductionOrder
+ *
+ * Returns one production order with release snapshots, material and work-order
+ * details, and execution rollups for end-to-end planner review.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetProductionOrderInput) {
+  const productionOrder = await db
+    .selectFrom("ProductionOrder")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!productionOrder) {
+    return err(new ProductionOrderNotFoundError(input.id));
+  }
+
+  const bomSnapshot = await db
+    .selectFrom("ProductionOrderBomSnapshot")
+    .selectAll()
+    .where("productionOrderId", "=", productionOrder.id)
+    .executeTakeFirst();
+
+  const routingSnapshot = await db
+    .selectFrom("ProductionOrderRoutingSnapshot")
+    .selectAll()
+    .where("productionOrderId", "=", productionOrder.id)
+    .executeTakeFirst();
+
+  const costBaseline = await db
+    .selectFrom("ProductionOrderCostBaseline")
+    .selectAll()
+    .where("productionOrderId", "=", productionOrder.id)
+    .executeTakeFirst();
+
+  const materialRequirements = await db
+    .selectFrom("ProductionOrderMaterialRequirement")
+    .selectAll()
+    .where("productionOrderId", "=", productionOrder.id)
+    .execute();
+
+  const workOrders = await db
+    .selectFrom("WorkOrder")
+    .selectAll()
+    .where("productionOrderId", "=", productionOrder.id)
+    .orderBy("routingOperationSequenceNumber", "asc")
+    .execute();
+
+  const costSummary = await db
+    .selectFrom("ManufacturingCostSummary")
+    .selectAll()
+    .where("productionOrderId", "=", productionOrder.id)
+    .executeTakeFirst();
+
+  const quantityRollup = {
+    plannedQuantity: productionOrder.plannedQuantity,
+    completedQuantity: workOrders.reduce((sum, workOrder) => sum + workOrder.completedQuantity, 0),
+    scrapQuantity: workOrders.reduce((sum, workOrder) => sum + workOrder.scrapQuantity, 0),
+    actualSetupTime: workOrders.reduce((sum, workOrder) => sum + workOrder.actualSetupTime, 0),
+    actualRunTime: workOrders.reduce((sum, workOrder) => sum + workOrder.actualRunTime, 0),
+    openWorkOrderCount: workOrders.filter(
+      (workOrder) => workOrder.status !== "COMPLETE" && workOrder.status !== "CANCELLED",
+    ).length,
+  };
+
+  return ok({
+    productionOrder,
+    bomSnapshot: bomSnapshot ?? null,
+    routingSnapshot: routingSnapshot ?? null,
+    costBaseline: costBaseline ?? null,
+    materialRequirements,
+    workOrders,
+    quantityRollup,
+    costSummary: costSummary ?? null,
+  });
+}

package/src/modules/manufacturing/query/getRouting.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getRouting";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getRouting = defineQuery(run);

package/src/modules/manufacturing/query/getRouting.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  baseDraftRouting,
+  baseActiveRouting,
+  baseInactiveRouting,
+  baseRoutingOperation,
+  baseRoutingOperation2,
+} from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { RoutingNotFoundError, CompanyScopeRequiredError } from "../lib/errors.generated";
+import { run } from "./getRouting";
+
+describe("getRouting", () => {
+  it("returns a routing with ordered operations when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveRouting);
+    spies.select.mockReturnValueOnce([baseRoutingOperation, baseRoutingOperation2]);
+
+    const result = await run(db, { id: baseActiveRouting.id, companyId: "company-1" });
+    const { routing, operations } = expectOk<{
+      routing: unknown;
+      operations: unknown[];
+    }>(result as never);
+
+    expect(routing).toMatchObject({ id: baseActiveRouting.id });
+    expect(operations).toHaveLength(2);
+  });
+
+  it("returns inactive routing revisions when requested", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInactiveRouting);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseInactiveRouting.id, companyId: "company-1" });
+    const { routing } = expectOk<{
+      routing: { status: string };
+    }>(result as never);
+
+    expect(routing.status).toBe("INACTIVE");
+  });
+
+  it("returns routing data for the requested company scope", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftRouting);
+    spies.select.mockReturnValueOnce([baseRoutingOperation]);
+
+    const result = await run(db, { id: baseDraftRouting.id, companyId: "company-1" });
+    const { routing } = expectOk<{
+      routing: { companyId: string };
+    }>(result as never);
+
+    expect(routing.companyId).toBe("company-1");
+  });
+
+  it("returns error when the routing does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id", companyId: "company-1" });
+    expectErr(result as never, RoutingNotFoundError);
+  });
+
+  it("returns error when company scope is not provided", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { id: "routing-1", companyId: "" });
+    expectErr(result as never, CompanyScopeRequiredError);
+  });
+});

package/src/modules/manufacturing/query/getRouting.ts

@@ -0,0 +1,34 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { RoutingNotFoundError, CompanyScopeRequiredError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetRoutingInput {
+  id: string;
+  companyId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetRoutingInput) {
+  if (!input.companyId) {
+    return err(new CompanyScopeRequiredError(input.id));
+  }
+
+  const routing = await db
+    .selectFrom("Routing")
+    .selectAll()
+    .where("id", "=", input.id)
+    .where("companyId", "=", input.companyId)
+    .executeTakeFirst();
+
+  if (!routing) {
+    return err(new RoutingNotFoundError(input.id));
+  }
+
+  const operations = await db
+    .selectFrom("RoutingOperation")
+    .selectAll()
+    .where("routingId", "=", routing.id)
+    .orderBy("sequenceNumber", "asc")
+    .execute();
+
+  return ok({ routing, operations });
+}

package/src/modules/manufacturing/query/getWorkCenter.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getWorkCenter";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getWorkCenter = defineQuery(run);

package/src/modules/manufacturing/query/getWorkCenter.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveWorkCenter, baseInactiveWorkCenter } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { WorkCenterNotFoundError } from "../lib/errors.generated";
+import { run } from "./getWorkCenter";
+
+describe("getWorkCenter", () => {
+  it("returns a work center when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(db, { id: baseActiveWorkCenter.id });
+    const { workCenter } = expectOk<{ workCenter: unknown }>(result as never);
+
+    expect(workCenter).toMatchObject({ id: baseActiveWorkCenter.id });
+  });
+
+  it("returns inactive work centers when requested", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInactiveWorkCenter);
+
+    const result = await run(db, { id: baseInactiveWorkCenter.id });
+    const { workCenter } = expectOk<{ workCenter: { status: string } }>(result as never);
+
+    expect(workCenter.status).toBe("INACTIVE");
+  });
+
+  it("returns error when the work center does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    expectErr(result as never, WorkCenterNotFoundError);
+  });
+});

package/src/modules/manufacturing/query/getWorkCenter.ts

@@ -0,0 +1,21 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { WorkCenterNotFoundError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetWorkCenterInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetWorkCenterInput) {
+  const workCenter = await db
+    .selectFrom("WorkCenter")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!workCenter) {
+    return err(new WorkCenterNotFoundError(input.id));
+  }
+
+  return ok({ workCenter });
+}

package/src/modules/manufacturing/query/getWorkOrder.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getWorkOrder";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getWorkOrder = defineQuery(run);

package/src/modules/manufacturing/query/getWorkOrder.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { WorkOrderNotFoundError } from "../lib/errors.generated";
+import {
+  baseInProgressWorkOrder,
+  basePausedWorkOrder,
+  baseStartedEvent,
+  baseProgressEvent,
+} from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { run } from "./getWorkOrder";
+
+describe("getWorkOrder", () => {
+  it("returns a work order with execution history when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInProgressWorkOrder);
+    spies.select.mockReturnValueOnce([baseStartedEvent, baseProgressEvent]);
+
+    const result = await run(db, { id: baseInProgressWorkOrder.id });
+    const { workOrder, executionEvents } = expectOk<{
+      workOrder: { id: string; status: string };
+      executionEvents: unknown[];
+    }>(result as never);
+
+    expect(workOrder.id).toBe(baseInProgressWorkOrder.id);
+    expect(workOrder.status).toBe("IN_PROGRESS");
+    expect(executionEvents).toHaveLength(2);
+  });
+
+  it("returns paused work orders with prior pause data", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePausedWorkOrder);
+    spies.select.mockReturnValueOnce([baseStartedEvent]);
+
+    const result = await run(db, { id: basePausedWorkOrder.id });
+    const { workOrder, executionEvents } = expectOk<{
+      workOrder: { id: string; status: string; pauseReason: string | null };
+      executionEvents: unknown[];
+    }>(result as never);
+
+    expect(workOrder.status).toBe("PAUSED");
+    expect(workOrder.pauseReason).toBeDefined();
+    expect(executionEvents).toHaveLength(1);
+  });
+
+  it("returns a work order with handoff evidence and parent order context", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInProgressWorkOrder);
+    spies.select.mockReturnValueOnce([baseStartedEvent]);
+
+    const result = await run(db, { id: baseInProgressWorkOrder.id });
+    const { workOrder } = expectOk<{
+      workOrder: {
+        id: string;
+        productionOrderId: string;
+        workCenterId: string;
+      };
+      executionEvents: unknown[];
+    }>(result as never);
+
+    expect(workOrder.productionOrderId).toBe(baseInProgressWorkOrder.productionOrderId);
+    expect(workOrder.workCenterId).toBe(baseInProgressWorkOrder.workCenterId);
+  });
+
+  it("returns error when the work order does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+    expectErr(result as never, WorkOrderNotFoundError);
+  });
+});

package/src/modules/manufacturing/query/getWorkOrder.ts

@@ -0,0 +1,28 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { WorkOrderNotFoundError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetWorkOrderInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetWorkOrderInput) {
+  const workOrder = await db
+    .selectFrom("WorkOrder")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!workOrder) {
+    return err(new WorkOrderNotFoundError(input.id));
+  }
+
+  const executionEvents = await db
+    .selectFrom("WorkOrderExecutionEvent")
+    .selectAll()
+    .where("workOrderId", "=", workOrder.id)
+    .orderBy("timestamp", "asc")
+    .execute();
+
+  return ok({ workOrder, executionEvents });
+}

package/src/modules/manufacturing/query/listBillOfMaterialsByItem.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./listBillOfMaterialsByItem";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const listBillOfMaterialsByItem = defineQuery(run);

package/src/modules/manufacturing/query/listBillOfMaterialsByItem.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { CompanyScopeRequiredError, ParentItemRequiredError } from "../lib/errors.generated";
+import { baseActiveBom, baseDraftBom, baseInactiveBom } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { run } from "./listBillOfMaterialsByItem";
+
+describe("listBillOfMaterialsByItem", () => {
+  it("lists BOM versions for a manufactured item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveBom, baseDraftBom]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("filters BOM versions by site when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveBom]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      siteId: "site-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters BOM versions by status when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveBom]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      status: "ACTIVE",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters BOM versions by bomType when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveBom]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      bomType: "MANUFACTURE",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("returns all statuses by default", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveBom, baseDraftBom, baseInactiveBom]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(3);
+  });
+
+  it("returns an empty list when no BOM versions exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(0);
+  });
+
+  it("returns error when the parent item reference is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "",
+    });
+    expectErr(result as never, ParentItemRequiredError);
+  });
+
+  it("returns error when company scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { companyId: "", parentItemId: "item-1" });
+    expectErr(result as never, CompanyScopeRequiredError);
+  });
+});