@unifiedcommerce/plugin-marketplace 0.0.1

package/src/mcp-tools.ts

@@ -0,0 +1,210 @@
+import type { MCPTool } from "@unifiedcommerce/core";
+import type { VendorService } from "./services/vendor";
+import type { SubOrderService } from "./services/sub-order";
+import type { CommissionService } from "./services/commission";
+import type { PayoutService } from "./services/payout";
+import type { DisputeService } from "./services/dispute";
+import type { ReviewService } from "./services/review";
+import type { RFQService } from "./services/rfq";
+import type { MarketplacePluginOptions } from "./types";
+
+interface MCPServices {
+  vendor: VendorService;
+  subOrder: SubOrderService;
+  commission: CommissionService;
+  payout: PayoutService;
+  dispute: DisputeService;
+  review: ReviewService;
+  rfq?: RFQService | undefined;
+}
+
+function p(params: unknown): Record<string, unknown> {
+  return (params ?? {}) as Record<string, unknown>;
+}
+
+export function buildMCPTools(services: MCPServices, _options: MarketplacePluginOptions): MCPTool[] {
+  const tools: MCPTool[] = [
+    {
+      name: "marketplace_vendor_list",
+      description: "List marketplace vendors with optional status/tier filters.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: { type: "string" },
+          tier: { type: "string" },
+          search: { type: "string" },
+        },
+      },
+      async handler(params: unknown) {
+        const rows = await services.vendor.list(p(params) as { status?: string; tier?: string; search?: string });
+        return { content: [{ type: "text", text: JSON.stringify(rows, null, 2) }] };
+      },
+    },
+    {
+      name: "marketplace_vendor_performance",
+      description: "Get vendor performance metrics including rating, tier, and score.",
+      inputSchema: {
+        type: "object",
+        required: ["vendorId"],
+        properties: { vendorId: { type: "string" } },
+      },
+      async handler(params: unknown) {
+        const { vendorId } = p(params) as { vendorId: string };
+        const vendor = await services.vendor.getById(vendorId);
+        if (!vendor) return { error: { code: "NOT_FOUND", message: "Vendor not found." } };
+
+        const rating = await services.review.getAggregateRating(vendorId);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              vendorId: vendor.id,
+              name: vendor.name,
+              tier: vendor.tier,
+              performanceScore: vendor.performanceScore,
+              rating,
+            }, null, 2),
+          }],
+        };
+      },
+    },
+    {
+      name: "marketplace_vendor_balance",
+      description: "Get vendor current balance and recent ledger entries.",
+      inputSchema: {
+        type: "object",
+        required: ["vendorId"],
+        properties: { vendorId: { type: "string" } },
+      },
+      async handler(params: unknown) {
+        const { vendorId } = p(params) as { vendorId: string };
+        const balance = await services.payout.getBalance(vendorId);
+        const ledger = await services.payout.getLedger(vendorId, 20);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ vendorId, balance, recentEntries: ledger }, null, 2),
+          }],
+        };
+      },
+    },
+    {
+      name: "marketplace_suborder_update",
+      description: "Transition a sub-order status (confirm, ship, deliver, cancel).",
+      inputSchema: {
+        type: "object",
+        required: ["subOrderId", "action"],
+        properties: {
+          subOrderId: { type: "string" },
+          action: { type: "string", enum: ["confirm", "ship", "deliver", "cancel"] },
+          trackingNumber: { type: "string" },
+          carrier: { type: "string" },
+          reason: { type: "string" },
+        },
+      },
+      async handler(params: unknown) {
+        const args = p(params) as {
+          subOrderId: string; action: string;
+          trackingNumber?: string; carrier?: string; reason?: string;
+        };
+        try {
+          let result;
+          switch (args.action) {
+            case "confirm":
+              result = await services.subOrder.confirm(args.subOrderId);
+              break;
+            case "ship":
+              result = await services.subOrder.ship(args.subOrderId, {
+                trackingNumber: args.trackingNumber ?? "",
+                carrier: args.carrier ?? "",
+              });
+              break;
+            case "deliver":
+              result = await services.subOrder.deliver(args.subOrderId);
+              break;
+            case "cancel":
+              result = await services.subOrder.cancel(args.subOrderId, args.reason);
+              break;
+            default:
+              return { error: { code: "INVALID_ACTION", message: `Unknown action: ${args.action}` } };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } catch (err: unknown) {
+          return { error: { code: "TRANSITION_ERROR", message: err instanceof Error ? err.message : "Unknown error" } };
+        }
+      },
+    },
+    {
+      name: "marketplace_dispute_summary",
+      description: "List open disputes with deadlines.",
+      inputSchema: { type: "object" },
+      async handler() {
+        const open = await services.dispute.list({ status: "open" });
+        const pending = await services.dispute.list({ status: "vendor_response_pending" });
+        const escalated = await services.dispute.list({ status: "escalated" });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ open, vendorResponsePending: pending, escalated }, null, 2),
+          }],
+        };
+      },
+    },
+    {
+      name: "marketplace_payout_run",
+      description: "Trigger a payout cycle for all eligible vendors.",
+      inputSchema: { type: "object" },
+      async handler() {
+        const results = await services.payout.runPayoutCycle();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ payoutsProcessed: results.length, details: results }, null, 2),
+          }],
+        };
+      },
+    },
+    {
+      name: "marketplace_commission_preview",
+      description: "Preview effective commission rate for a vendor+category+amount.",
+      inputSchema: {
+        type: "object",
+        required: ["vendorId"],
+        properties: {
+          vendorId: { type: "string" },
+          categorySlug: { type: "string" },
+          volumeCents: { type: "number" },
+        },
+      },
+      async handler(params: unknown) {
+        const { vendorId, categorySlug, volumeCents } = p(params) as {
+          vendorId: string; categorySlug?: string; volumeCents?: number;
+        };
+        const preview = await services.commission.previewRate(vendorId, categorySlug, volumeCents);
+        return { content: [{ type: "text", text: JSON.stringify(preview, null, 2) }] };
+      },
+    },
+  ];
+
+  // B2B: RFQ tool
+  if (services.rfq) {
+    const rfqService = services.rfq;
+    tools.push({
+      name: "marketplace_rfq_list",
+      description: "List open RFQs with optional category filter.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: { type: "string" },
+          categorySlug: { type: "string" },
+        },
+      },
+      async handler(params: unknown) {
+        const rows = await rfqService.list(p(params) as { status?: string; categorySlug?: string });
+        return { content: [{ type: "text", text: JSON.stringify(rows, null, 2) }] };
+      },
+    });
+  }
+
+  return tools;
+}

package/src/routes/b2b.ts

@@ -0,0 +1,179 @@
+import { router } from "@unifiedcommerce/core";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+import type { z } from "@hono/zod-openapi";
+import type { RFQService } from "../services/rfq";
+import type { ContractPriceService } from "../services/contract-price";
+import type { MarketplacePluginOptions } from "../types";
+import {
+  CreateRFQBodySchema,
+  RespondRFQBodySchema,
+  AwardRFQBodySchema,
+  CreateContractPriceBodySchema,
+  UpdateContractPriceBodySchema,
+} from "../schemas/b2b";
+import { stripUndefined } from "./util";
+
+export function buildB2BRoutes(services: {
+  rfq?: RFQService | undefined;
+  contractPrice?: ContractPriceService | undefined;
+}, options: MarketplacePluginOptions): PluginRouteRegistration[] {
+  const allRoutes: PluginRouteRegistration[] = [];
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // RFQ (Request for Quote)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  if (services.rfq) {
+    const rfqSvc = services.rfq;
+    const rfq = router("Marketplace - B2B", "/marketplace/rfq");
+
+    rfq.post("/")
+      .summary("Create a Request for Quote")
+      .auth()
+      .input(CreateRFQBodySchema)
+      .handler(async ({ input }) => {
+        const body = input as z.infer<typeof CreateRFQBodySchema>;
+        return rfqSvc.create(stripUndefined({
+          buyerId: body.buyerId,
+          title: body.title,
+          description: body.description,
+          categorySlug: body.categorySlug,
+          quantity: body.quantity,
+          budgetCents: body.budgetCents,
+          currency: body.currency,
+          deadlineAt: body.deadlineAt ? new Date(body.deadlineAt) : undefined,
+          metadata: body.metadata,
+        }));
+      });
+
+    rfq.get("/")
+      .summary("List Requests for Quote")
+      .auth()
+      .handler(async ({ query }) => {
+        return rfqSvc.list(stripUndefined({
+          status: query.status as string | undefined,
+          categorySlug: query.categorySlug as string | undefined,
+        }));
+      });
+
+    rfq.get("/{id}")
+      .summary("Get RFQ detail")
+      .auth()
+      .handler(async ({ params }) => {
+        const item = await rfqSvc.getById(params.id!);
+        if (!item) throw new Error("RFQ not found");
+        const responses = await rfqSvc.getResponses(item.id);
+        return { ...item, responses };
+      });
+
+    rfq.post("/{id}/respond")
+      .summary("Submit a vendor response to an RFQ")
+      .auth()
+      .input(RespondRFQBodySchema)
+      .handler(async ({ params, input }) => {
+        const body = input as z.infer<typeof RespondRFQBodySchema>;
+        const item = await rfqSvc.getById(params.id!);
+        if (!item) throw new Error("RFQ not found");
+        return rfqSvc.respond(item.id, stripUndefined({
+          vendorId: body.vendorId,
+          unitPriceCents: body.unitPriceCents,
+          totalPriceCents: body.totalPriceCents,
+          leadTimeDays: body.leadTimeDays,
+          notes: body.notes,
+        }));
+      });
+
+    rfq.post("/{id}/award")
+      .summary("Award an RFQ to a vendor")
+      .auth()
+      .permission("marketplace:admin")
+      .input(AwardRFQBodySchema)
+      .handler(async ({ params, input }) => {
+        const body = input as z.infer<typeof AwardRFQBodySchema>;
+        const updated = await rfqSvc.award(params.id!, body.vendorId);
+        if (!updated) throw new Error("RFQ not found");
+        return updated;
+      });
+
+    rfq.post("/{id}/close")
+      .summary("Close an RFQ")
+      .auth()
+      .permission("marketplace:admin")
+      .handler(async ({ params }) => {
+        const updated = await rfqSvc.close(params.id!);
+        if (!updated) throw new Error("RFQ not found");
+        return updated;
+      });
+
+    allRoutes.push(...rfq.routes());
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CONTRACT PRICES
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  if (services.contractPrice) {
+    const cpSvc = services.contractPrice;
+    const cp = router("Marketplace - B2B", "/marketplace/contract-prices");
+
+    cp.get("/")
+      .summary("List contract prices")
+      .auth()
+      .handler(async ({ query }) => {
+        return cpSvc.list(stripUndefined({
+          vendorId: query.vendorId as string | undefined,
+          buyerId: query.buyerId as string | undefined,
+        }));
+      });
+
+    cp.post("/")
+      .summary("Create a contract price")
+      .auth()
+      .permission("marketplace:admin")
+      .input(CreateContractPriceBodySchema)
+      .handler(async ({ input }) => {
+        const body = input as z.infer<typeof CreateContractPriceBodySchema>;
+        return cpSvc.create(stripUndefined({
+          vendorId: body.vendorId,
+          buyerId: body.buyerId,
+          entityId: body.entityId,
+          variantId: body.variantId,
+          priceCents: body.priceCents,
+          minQuantity: body.minQuantity,
+          currency: body.currency,
+          validFrom: body.validFrom ? new Date(body.validFrom) : undefined,
+          validUntil: body.validUntil ? new Date(body.validUntil) : undefined,
+        }));
+      });
+
+    cp.patch("/{id}")
+      .summary("Update a contract price")
+      .auth()
+      .permission("marketplace:admin")
+      .input(UpdateContractPriceBodySchema)
+      .handler(async ({ params, input }) => {
+        const body = input as z.infer<typeof UpdateContractPriceBodySchema>;
+        const updateData: Record<string, unknown> = {};
+        if (body.priceCents !== undefined) updateData.priceCents = body.priceCents;
+        if (body.minQuantity !== undefined) updateData.minQuantity = body.minQuantity;
+        if (body.validFrom !== undefined) updateData.validFrom = body.validFrom ? new Date(body.validFrom) : null;
+        if (body.validUntil !== undefined) updateData.validUntil = body.validUntil ? new Date(body.validUntil) : null;
+        const updated = await cpSvc.update(params.id!, updateData);
+        if (!updated) throw new Error("Contract price not found");
+        return updated;
+      });
+
+    cp.delete("/{id}")
+      .summary("Delete a contract price")
+      .auth()
+      .permission("marketplace:admin")
+      .handler(async ({ params }) => {
+        await cpSvc.delete(params.id!);
+        return { deleted: true };
+      });
+
+    allRoutes.push(...cp.routes());
+  }
+
+  return allRoutes;
+}

package/src/routes/commission.ts

@@ -0,0 +1,95 @@
+import { router } from "@unifiedcommerce/core";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+import type { z } from "@hono/zod-openapi";
+import type { CommissionService } from "../services/commission";
+import {
+  CreateCommissionRuleBodySchema,
+  UpdateCommissionRuleBodySchema,
+  PreviewCommissionBodySchema,
+} from "../schemas/commission";
+import { stripUndefined } from "./util";
+
+export function buildCommissionRoutes(services: {
+  commission: CommissionService;
+}): PluginRouteRegistration[] {
+  const r = router("Marketplace - Commission", "/marketplace/commission-rules");
+
+  // ─── List commission rules ─────────────────────────────────────────────────
+  r.get("/")
+    .summary("List all commission rules")
+    .permission("marketplace:admin")
+    .handler(async () => {
+      return services.commission.listRules();
+    });
+
+  // ─── Create commission rule ────────────────────────────────────────────────
+  r.post("/")
+    .summary("Create a commission rule")
+    .permission("marketplace:admin")
+    .input(CreateCommissionRuleBodySchema)
+    .handler(async ({ input }) => {
+      const body = input as z.infer<typeof CreateCommissionRuleBodySchema>;
+      return services.commission.createRule(stripUndefined({
+        name: body.name,
+        type: body.type,
+        rateBps: body.rateBps,
+        categorySlug: body.categorySlug,
+        vendorId: body.vendorId,
+        vendorTier: body.vendorTier,
+        minVolumeCents: body.minVolumeCents,
+        maxVolumeCents: body.maxVolumeCents,
+        validFrom: body.validFrom ? new Date(body.validFrom) : undefined,
+        validUntil: body.validUntil ? new Date(body.validUntil) : undefined,
+        priority: body.priority,
+      }));
+    });
+
+  // ─── Update commission rule ────────────────────────────────────────────────
+  r.patch("/{id}")
+    .summary("Update a commission rule")
+    .permission("marketplace:admin")
+    .input(UpdateCommissionRuleBodySchema)
+    .handler(async ({ params, input }) => {
+      const body = input as z.infer<typeof UpdateCommissionRuleBodySchema>;
+      const updateData: Record<string, unknown> = {};
+      if (body.name !== undefined) updateData.name = body.name;
+      if (body.rateBps !== undefined) updateData.rateBps = body.rateBps;
+      if (body.categorySlug !== undefined) updateData.categorySlug = body.categorySlug;
+      if (body.vendorTier !== undefined) updateData.vendorTier = body.vendorTier;
+      if (body.minVolumeCents !== undefined) updateData.minVolumeCents = body.minVolumeCents;
+      if (body.maxVolumeCents !== undefined) updateData.maxVolumeCents = body.maxVolumeCents;
+      if (body.validFrom !== undefined) updateData.validFrom = body.validFrom ? new Date(body.validFrom) : null;
+      if (body.validUntil !== undefined) updateData.validUntil = body.validUntil ? new Date(body.validUntil) : null;
+      if (body.priority !== undefined) updateData.priority = body.priority;
+      if (body.isActive !== undefined) updateData.isActive = body.isActive;
+
+      const updated = await services.commission.updateRule(params.id!, updateData);
+      if (!updated) throw new Error("Commission rule not found");
+      return updated;
+    });
+
+  // ─── Delete commission rule ────────────────────────────────────────────────
+  r.delete("/{id}")
+    .summary("Delete a commission rule")
+    .permission("marketplace:admin")
+    .handler(async ({ params }) => {
+      await services.commission.deleteRule(params.id!);
+      return { deleted: true };
+    });
+
+  // ─── Preview commission rate ───────────────────────────────────────────────
+  r.post("/preview")
+    .summary("Preview the commission rate for a vendor")
+    .permission("marketplace:admin")
+    .input(PreviewCommissionBodySchema)
+    .handler(async ({ input }) => {
+      const body = input as z.infer<typeof PreviewCommissionBodySchema>;
+      return services.commission.previewRate(
+        body.vendorId,
+        body.categorySlug,
+        body.volumeCents,
+      );
+    });
+
+  return r.routes();
+}

package/src/routes/disputes-returns-reviews.ts

@@ -0,0 +1,209 @@
+import { router } from "@unifiedcommerce/core";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+import type { z } from "@hono/zod-openapi";
+import type { DisputeService } from "../services/dispute";
+import type { ReturnService } from "../services/return";
+import type { ReviewService } from "../services/review";
+import type { DisputeResolution, ReviewStatus } from "../types";
+import {
+  OpenDisputeBodySchema,
+  RespondDisputeBodySchema,
+  ResolveDisputeBodySchema,
+  RequestReturnBodySchema,
+  ShipBackReturnBodySchema,
+  CreateReviewBodySchema,
+  ModerateReviewBodySchema,
+} from "../schemas/disputes-returns-reviews";
+import { stripUndefined } from "./util";
+
+export function buildDisputesReturnsReviewsRoutes(services: {
+  dispute: DisputeService;
+  return: ReturnService;
+  review: ReviewService;
+}): PluginRouteRegistration[] {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // DISPUTES
+  // ═══════════════════════════════════════════════════════════════════════════
+  const disputes = router("Marketplace - Disputes", "/marketplace/disputes");
+
+  disputes.post("/")
+    .summary("Open a dispute")
+    .auth()
+    .input(OpenDisputeBodySchema)
+    .handler(async ({ input }) => {
+      const body = input as z.infer<typeof OpenDisputeBodySchema>;
+      return services.dispute.open(stripUndefined({
+        subOrderId: body.subOrderId,
+        openedBy: body.openedBy,
+        reason: body.reason,
+        description: body.description,
+      }));
+    });
+
+  disputes.get("/")
+    .summary("List disputes")
+    .auth()
+    .handler(async ({ query }) => {
+      return services.dispute.list(stripUndefined({
+        status: query.status as string | undefined,
+        subOrderId: query.subOrderId as string | undefined,
+      }));
+    });
+
+  disputes.get("/{id}")
+    .summary("Get dispute by ID")
+    .auth()
+    .handler(async ({ params }) => {
+      const dispute = await services.dispute.getById(params.id!);
+      if (!dispute) throw new Error("Dispute not found");
+      return dispute;
+    });
+
+  disputes.post("/{id}/respond")
+    .summary("Respond to a dispute")
+    .auth()
+    .input(RespondDisputeBodySchema)
+    .handler(async ({ params, input }) => {
+      const body = input as z.infer<typeof RespondDisputeBodySchema>;
+      return services.dispute.respond(params.id!, stripUndefined({
+        party: body.party,
+        note: body.note,
+        url: body.url,
+      }));
+    });
+
+  disputes.post("/{id}/escalate")
+    .summary("Escalate a dispute")
+    .auth()
+    .permission("marketplace:admin")
+    .handler(async ({ params }) => {
+      const updated = await services.dispute.escalate(params.id!);
+      if (!updated) throw new Error("Dispute not found");
+      return updated;
+    });
+
+  disputes.post("/{id}/resolve")
+    .summary("Resolve a dispute")
+    .auth()
+    .permission("marketplace:admin")
+    .input(ResolveDisputeBodySchema)
+    .handler(async ({ params, input }) => {
+      const body = input as z.infer<typeof ResolveDisputeBodySchema>;
+      const updated = await services.dispute.resolve(params.id!, stripUndefined({
+        resolution: body.resolution as DisputeResolution,
+        notes: body.notes,
+        refundAmountCents: body.refundAmountCents,
+        resolvedBy: body.resolvedBy,
+      }));
+      if (!updated) throw new Error("Dispute not found");
+      return updated;
+    });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // RETURNS
+  // ═══════════════════════════════════════════════════════════════════════════
+  const returns = router("Marketplace - Returns", "/marketplace/returns");
+
+  returns.post("/")
+    .summary("Request a return")
+    .auth()
+    .input(RequestReturnBodySchema)
+    .handler(async ({ input }) => {
+      const body = input as z.infer<typeof RequestReturnBodySchema>;
+      return services.return.request(stripUndefined({
+        subOrderId: body.subOrderId,
+        customerId: body.customerId,
+        reason: body.reason,
+        description: body.description,
+        lineItems: body.lineItems as { entityId: string; quantity: number; reason?: string }[] | undefined,
+      }));
+    });
+
+  returns.get("/")
+    .summary("List returns")
+    .auth()
+    .handler(async ({ query }) => {
+      return services.return.list(stripUndefined({
+        subOrderId: query.subOrderId as string | undefined,
+        status: query.status as string | undefined,
+      }));
+    });
+
+  returns.get("/{id}")
+    .summary("Get return by ID")
+    .auth()
+    .handler(async ({ params }) => {
+      const ret = await services.return.getById(params.id!);
+      if (!ret) throw new Error("Return not found");
+      return ret;
+    });
+
+  returns.post("/{id}/ship-back")
+    .summary("Ship back a return")
+    .auth()
+    .input(ShipBackReturnBodySchema)
+    .handler(async ({ params, input }) => {
+      const body = input as z.infer<typeof ShipBackReturnBodySchema>;
+      const updated = await services.return.shipBack(params.id!, body.trackingNumber);
+      if (!updated) throw new Error("Return not found");
+      return updated;
+    });
+
+  returns.post("/{id}/receive")
+    .summary("Mark a return as received")
+    .auth()
+    .handler(async ({ params }) => {
+      const updated = await services.return.receive(params.id!);
+      if (!updated) throw new Error("Return not found");
+      return updated;
+    });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // REVIEWS
+  // ═══════════════════════════════════════════════════════════════════════════
+  const vendorReviews = router("Marketplace - Reviews", "/marketplace/vendors");
+
+  vendorReviews.post("/{id}/reviews")
+    .summary("Create a vendor review")
+    .auth()
+    .input(CreateReviewBodySchema)
+    .handler(async ({ params, input }) => {
+      const body = input as z.infer<typeof CreateReviewBodySchema>;
+      return services.review.create(stripUndefined({
+        vendorId: params.id!,
+        customerId: body.customerId,
+        orderId: body.orderId,
+        rating: body.rating,
+        title: body.title,
+        body: body.body,
+      }));
+    });
+
+  vendorReviews.get("/{id}/reviews")
+    .summary("List reviews for a vendor")
+    .auth()
+    .handler(async ({ params }) => {
+      return services.review.getForVendor(params.id!);
+    });
+
+  const reviewsMod = router("Marketplace - Reviews", "/marketplace/reviews");
+
+  reviewsMod.patch("/{id}")
+    .summary("Moderate a review (update status)")
+    .auth()
+    .permission("marketplace:admin")
+    .input(ModerateReviewBodySchema)
+    .handler(async ({ params, input }) => {
+      const body = input as z.infer<typeof ModerateReviewBodySchema>;
+      const updated = await services.review.moderate(params.id!, body.status as ReviewStatus);
+      if (!updated) throw new Error("Review not found");
+      return updated;
+    });
+
+  return [
+    ...disputes.routes(),
+    ...returns.routes(),
+    ...vendorReviews.routes(),
+    ...reviewsMod.routes(),
+  ];
+}