@unifiedcommerce/plugin-marketplace 0.0.1

package/dist/hooks.js

@@ -0,0 +1,187 @@
+import { eq } from "drizzle-orm";
+import { vendors, vendorEntities, vendorSubOrders } from "./schema";
+import { CommissionService } from "./services/commission";
+import { PayoutService } from "./services/payout";
+function getDbFromHookArgs(args) {
+    const a = args;
+    return a.context.services.database.db;
+}
+export function buildHooks(options) {
+    return [
+        // ─── catalog.beforeCreate ──────────────────────────────────────────────
+        {
+            key: "catalog.beforeCreate",
+            async handler(args) {
+                const { data } = args;
+                const metadata = data?.metadata;
+                const vendorId = metadata?.vendorId;
+                if (!vendorId)
+                    return data;
+                const db = getDbFromHookArgs(args);
+                const [vendor] = await db.select().from(vendors).where(eq(vendors.id, String(vendorId)));
+                if (!vendor)
+                    throw new Error("Vendor not found.");
+                if (vendor.status === "suspended")
+                    throw new Error("Vendor is suspended and cannot create listings.");
+                if (vendor.status !== "approved")
+                    throw new Error("Vendor must be approved before creating marketplace listings.");
+                // Check approved categories if set
+                const approvedCats = vendor.approvedCategories;
+                if (approvedCats && Array.isArray(approvedCats)) {
+                    const entityType = data.type;
+                    // approvedCategories holds category slugs; entityType may match
+                    // This is a basic check; real implementations would check category assignment
+                }
+                return data;
+            },
+        },
+        // ─── catalog.afterCreate ───────────────────────────────────────────────
+        {
+            key: "catalog.afterCreate",
+            async handler(args) {
+                const { result } = args;
+                const vendorId = result?.metadata?.vendorId;
+                if (!vendorId)
+                    return;
+                const db = getDbFromHookArgs(args);
+                await db.insert(vendorEntities).values({
+                    vendorId: String(vendorId),
+                    entityId: result.id,
+                });
+            },
+        },
+        // ─── catalog.beforeList ────────────────────────────────────────────────
+        {
+            key: "catalog.beforeList",
+            async handler(args) {
+                const { data, context: hookContext } = args;
+                hookContext.context.marketplaceVendorScope = hookContext.actor?.vendorId ?? null;
+                return data;
+            },
+        },
+        // ─── catalog.afterList ─────────────────────────────────────────────────
+        {
+            key: "catalog.afterList",
+            async handler(args) {
+                const { result, context: hookContext } = args;
+                const vendorScope = hookContext.context.marketplaceVendorScope;
+                if (!vendorScope || !Array.isArray(result?.items))
+                    return;
+                const db = getDbFromHookArgs(args);
+                const links = await db.select().from(vendorEntities).where(eq(vendorEntities.vendorId, vendorScope));
+                const linkedEntityIds = new Set(links.map((l) => l.entityId));
+                result.items = result.items.filter((item) => linkedEntityIds.has(item.id));
+            },
+        },
+        // ─── catalog.afterRead ─────────────────────────────────────────────────
+        {
+            key: "catalog.afterRead",
+            async handler(args) {
+                const { result } = args;
+                const db = getDbFromHookArgs(args);
+                const [link] = await db.select().from(vendorEntities).where(eq(vendorEntities.entityId, result.id));
+                if (!link)
+                    return;
+                const [vendor] = await db.select().from(vendors).where(eq(vendors.id, link.vendorId));
+                if (!vendor)
+                    return;
+                result.marketplace = {
+                    vendor: {
+                        id: vendor.id,
+                        name: vendor.name,
+                        slug: vendor.slug,
+                        status: vendor.status,
+                        tier: vendor.tier,
+                        logoUrl: vendor.logoUrl,
+                    },
+                };
+            },
+        },
+        // ─── orders.afterCreate ────────────────────────────────────────────────
+        {
+            key: "orders.afterCreate",
+            async handler(args) {
+                const { result, context: hookContext } = args;
+                const db = getDbFromHookArgs(args);
+                const commissionService = new CommissionService(db, options);
+                const payoutService = new PayoutService(db, options);
+                const grouped = new Map();
+                for (const lineItem of result.lineItems ?? []) {
+                    const [link] = await db.select().from(vendorEntities).where(eq(vendorEntities.entityId, lineItem.entityId));
+                    if (!link)
+                        continue;
+                    const [vendor] = await db.select().from(vendors).where(eq(vendors.id, link.vendorId));
+                    if (!vendor)
+                        continue;
+                    const existing = grouped.get(vendor.id) ?? [];
+                    existing.push({
+                        entityId: lineItem.entityId,
+                        quantity: lineItem.quantity,
+                        totalPrice: lineItem.totalPrice,
+                    });
+                    grouped.set(vendor.id, existing);
+                }
+                for (const [vendorId, lineItems] of grouped.entries()) {
+                    const subtotal = lineItems.reduce((sum, item) => sum + item.totalPrice, 0);
+                    // Resolve commission via rules engine
+                    const commissionRateBps = await commissionService.resolveRate(vendorId);
+                    const commissionAmount = Math.round((subtotal * commissionRateBps) / 10000);
+                    const payoutAmount = subtotal - commissionAmount;
+                    const [subOrder] = await db.insert(vendorSubOrders).values({
+                        orderId: result.id,
+                        vendorId,
+                        status: "pending",
+                        subtotal,
+                        commissionAmount,
+                        payoutAmount,
+                        notified: true,
+                        lineItems,
+                        metadata: {},
+                    }).returning();
+                    if (!subOrder)
+                        continue;
+                    // Credit vendor balance with full subtotal
+                    await payoutService.addLedgerEntry({
+                        vendorId,
+                        type: "sale",
+                        amountCents: subtotal,
+                        referenceType: "sub_order",
+                        referenceId: subOrder.id,
+                        description: `Sale from order ${result.id.slice(0, 8)}`,
+                    });
+                    // Record commission as separate entry
+                    await payoutService.addLedgerEntry({
+                        vendorId,
+                        type: "commission",
+                        amountCents: -commissionAmount,
+                        referenceType: "sub_order",
+                        referenceId: subOrder.id,
+                        description: `Commission (${commissionRateBps}bps) on order ${result.id.slice(0, 8)}`,
+                    });
+                    hookContext.logger.info("marketplace_sub_order_created", {
+                        orderId: result.id,
+                        subOrderId: subOrder.id,
+                        vendorId,
+                        commissionRateBps,
+                    });
+                }
+            },
+        },
+        // ─── orders.beforeStatusChange ─────────────────────────────────────────
+        {
+            key: "orders.beforeStatusChange",
+            async handler(args) {
+                const { data } = args;
+                if (data.newStatus !== "fulfilled")
+                    return data;
+                const db = getDbFromHookArgs(args);
+                const related = await db.select().from(vendorSubOrders).where(eq(vendorSubOrders.orderId, data.orderId));
+                const allDelivered = related.every((subOrder) => subOrder.status === "delivered");
+                if (!allDelivered) {
+                    throw new Error("Cannot fulfill parent order until all marketplace sub-orders are delivered.");
+                }
+                return data;
+            },
+        },
+    ];
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { MarketplacePluginOptions } from "./types";
+export type { MarketplacePluginOptions } from "./types";
+export declare function marketplacePlugin(options?: MarketplacePluginOptions): import("@unifiedcommerce/core").CommercePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,wBAAwB,EAAM,MAAM,SAAS,CAAC;AAE5D,YAAY,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AA4CxD,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,kDAmDvE"}

package/dist/index.js

@@ -0,0 +1,105 @@
+import { defineCommercePlugin } from "@unifiedcommerce/core";
+import { MARKETPLACE_ANALYTICS_MODELS } from "./analytics-models";
+import { vendors, vendorEntities, vendorSubOrders, vendorPayouts, vendorDocuments, commissionRules, vendorBalances, disputes, vendorReviews, returnRequests, rfqs, rfqResponses, contractPrices, } from "./schema";
+import { VendorService } from "./services/vendor";
+import { SubOrderService } from "./services/sub-order";
+import { CommissionService } from "./services/commission";
+import { PayoutService } from "./services/payout";
+import { DisputeService } from "./services/dispute";
+import { ReturnService } from "./services/return";
+import { ReviewService } from "./services/review";
+import { RFQService } from "./services/rfq";
+import { ContractPriceService } from "./services/contract-price";
+import { buildHooks } from "./hooks";
+import { buildMCPTools } from "./mcp-tools";
+import { buildVendorRoutes } from "./routes/vendors";
+import { buildVendorPortalRoutes } from "./routes/vendor-portal";
+import { buildSubOrderRoutes } from "./routes/sub-orders";
+import { buildCommissionRoutes } from "./routes/commission";
+import { buildPayoutRoutes } from "./routes/payouts";
+import { buildDisputesReturnsReviewsRoutes } from "./routes/disputes-returns-reviews";
+import { buildB2BRoutes } from "./routes/b2b";
+function createServices(db, options, kernelServices) {
+    const vendor = new VendorService(db);
+    const commission = new CommissionService(db, options);
+    const payout = new PayoutService(db, options);
+    const dispute = new DisputeService(db, options);
+    const returnSvc = new ReturnService(db);
+    const review = new ReviewService(db, options);
+    const rfq = options.b2b?.rfq ? new RFQService(db) : undefined;
+    const contractPrice = options.b2b?.contractPricing ? new ContractPriceService(db) : undefined;
+    // Cancel callback: release inventory on parent order + reverse balance
+    const subOrder = new SubOrderService(db, async (sub) => {
+        // Release inventory for cancelled vendor's line items
+        const inventory = kernelServices?.inventory;
+        if (inventory?.release && sub.lineItems) {
+            for (const item of sub.lineItems) {
+                await inventory.release({
+                    entityId: item.entityId,
+                    quantity: item.quantity,
+                    orderId: sub.orderId,
+                    performedBy: "marketplace",
+                });
+            }
+        }
+        // Reverse balance: debit the sale credit
+        if (sub.payoutAmount > 0) {
+            await payout.addLedgerEntry({
+                vendorId: sub.vendorId,
+                type: "refund_deduction",
+                amountCents: -sub.payoutAmount,
+                referenceType: "sub_order",
+                referenceId: sub.id,
+                description: `Cancelled sub-order ${sub.id.slice(0, 8)}`,
+            });
+        }
+    });
+    return { vendor, subOrder, commission, payout, dispute, return: returnSvc, review, rfq, contractPrice };
+}
+export function marketplacePlugin(options = {}) {
+    return defineCommercePlugin({
+        id: "marketplace",
+        version: "2.0.0",
+        schema: () => ({
+            vendors,
+            vendorEntities,
+            vendorSubOrders,
+            vendorPayouts,
+            vendorDocuments,
+            commissionRules,
+            vendorBalances,
+            disputes,
+            vendorReviews,
+            returnRequests,
+            rfqs,
+            rfqResponses,
+            contractPrices,
+        }),
+        hooks: () => buildHooks(options),
+        routes: (ctx) => {
+            const db = ctx.database.db;
+            const services = db ? createServices(db, options, ctx.services) : null;
+            if (!services)
+                return [];
+            return [
+                ...buildVendorRoutes(services, options),
+                ...buildVendorPortalRoutes(services),
+                ...buildSubOrderRoutes(services),
+                ...buildCommissionRoutes(services),
+                ...buildPayoutRoutes(services),
+                ...buildDisputesReturnsReviewsRoutes(services),
+                ...(options.b2b?.rfq || options.b2b?.contractPricing
+                    ? buildB2BRoutes(services, options)
+                    : []),
+            ];
+        },
+        mcpTools: (ctx) => {
+            const db = ctx.database.db;
+            if (!db)
+                return [];
+            const services = createServices(db, options, ctx.services);
+            return buildMCPTools(services, options);
+        },
+        analyticsModels: () => MARKETPLACE_ANALYTICS_MODELS,
+    });
+}

package/dist/mcp-tools.d.ts

@@ -0,0 +1,21 @@
+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;
+}
+export declare function buildMCPTools(services: MCPServices, _options: MarketplacePluginOptions): MCPTool[];
+export {};
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../src/mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,UAAU,WAAW;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CAC9B;AAMD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,wBAAwB,GAAG,OAAO,EAAE,CAyLlG"}

package/dist/mcp-tools.js

@@ -0,0 +1,183 @@
+function p(params) {
+    return (params ?? {});
+}
+export function buildMCPTools(services, _options) {
+    const tools = [
+        {
+            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) {
+                const rows = await services.vendor.list(p(params));
+                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) {
+                const { vendorId } = p(params);
+                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) {
+                const { vendorId } = p(params);
+                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) {
+                const args = p(params);
+                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) {
+                    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) {
+                const { vendorId, categorySlug, volumeCents } = p(params);
+                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) {
+                const rows = await rfqService.list(p(params));
+                return { content: [{ type: "text", text: JSON.stringify(rows, null, 2) }] };
+            },
+        });
+    }
+    return tools;
+}

package/dist/routes/b2b.d.ts

@@ -0,0 +1,9 @@
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+import type { RFQService } from "../services/rfq";
+import type { ContractPriceService } from "../services/contract-price";
+import type { MarketplacePluginOptions } from "../types";
+export declare function buildB2BRoutes(services: {
+    rfq?: RFQService | undefined;
+    contractPrice?: ContractPriceService | undefined;
+}, options: MarketplacePluginOptions): PluginRouteRegistration[];
+//# sourceMappingURL=b2b.d.ts.map

package/dist/routes/b2b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"b2b.d.ts","sourceRoot":"","sources":["../../src/routes/b2b.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAErE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAUzD,wBAAgB,cAAc,CAAC,QAAQ,EAAE;IACvC,GAAG,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IAC7B,aAAa,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAClD,EAAE,OAAO,EAAE,wBAAwB,GAAG,uBAAuB,EAAE,CAgK/D"}