@porulle/plugin-marketplace 0.64.0 → 0.65.1

package/src/services/sub-order.ts

@@ -1,4 +1,5 @@
 import { eq, and, desc } from "@porulle/core/drizzle";
+import { CommerceInvalidTransitionError, CommerceNotFoundError } from "@porulle/core";
 import { vendorSubOrders } from "../schema.js";
 import type { Db, SubOrderStatus } from "../types.js";
 import { SUB_ORDER_TRANSITIONS } from "../types.js";
@@ -19,12 +20,6 @@ export class SubOrderService {
     return sub ?? null;
   }
 
-  async listByOrder(orderId: string) {
-    return this.db.select().from(vendorSubOrders)
-      .where(eq(vendorSubOrders.orderId, orderId))
-      .orderBy(desc(vendorSubOrders.createdAt));
-  }
-
   async listByVendor(vendorId: string, filters?: { status?: string }) {
     const conditions = [eq(vendorSubOrders.vendorId, vendorId)];
     if (filters?.status) conditions.push(eq(vendorSubOrders.status, filters.status));
@@ -49,13 +44,21 @@ export class SubOrderService {
   private assertTransition(current: SubOrderStatus, next: SubOrderStatus) {
     const allowed = SUB_ORDER_TRANSITIONS[current];
     if (!allowed?.includes(next)) {
-      throw new Error(`Cannot transition sub-order from "${current}" to "${next}".`);
+      throw new CommerceInvalidTransitionError(
+        `Cannot transition sub-order from "${current}" to "${next}".`,
+      );
     }
   }
 
+  private requireSubOrder(id: string) {
+    return this.getById(id).then((sub) => {
+      if (!sub) throw new CommerceNotFoundError("Sub-order not found.");
+      return sub;
+    });
+  }
+
   async confirm(id: string) {
-    const sub = await this.getById(id);
-    if (!sub) throw new Error("Sub-order not found.");
+    const sub = await this.requireSubOrder(id);
     this.assertTransition(sub.status as SubOrderStatus, "confirmed");
 
     const [updated] = await this.db.update(vendorSubOrders).set({
@@ -67,8 +70,7 @@ export class SubOrderService {
   }
 
   async process(id: string) {
-    const sub = await this.getById(id);
-    if (!sub) throw new Error("Sub-order not found.");
+    const sub = await this.requireSubOrder(id);
     this.assertTransition(sub.status as SubOrderStatus, "processing");
 
     const [updated] = await this.db.update(vendorSubOrders).set({
@@ -79,8 +81,7 @@ export class SubOrderService {
   }
 
   async ship(id: string, data: { trackingNumber: string; carrier: string }) {
-    const sub = await this.getById(id);
-    if (!sub) throw new Error("Sub-order not found.");
+    const sub = await this.requireSubOrder(id);
     this.assertTransition(sub.status as SubOrderStatus, "shipped");
 
     const [updated] = await this.db.update(vendorSubOrders).set({
@@ -94,8 +95,7 @@ export class SubOrderService {
   }
 
   async deliver(id: string) {
-    const sub = await this.getById(id);
-    if (!sub) throw new Error("Sub-order not found.");
+    const sub = await this.requireSubOrder(id);
     this.assertTransition(sub.status as SubOrderStatus, "delivered");
 
     const [updated] = await this.db.update(vendorSubOrders).set({
@@ -107,8 +107,7 @@ export class SubOrderService {
   }
 
   async cancel(id: string, reason?: string) {
-    const sub = await this.getById(id);
-    if (!sub) throw new Error("Sub-order not found.");
+    const sub = await this.requireSubOrder(id);
     this.assertTransition(sub.status as SubOrderStatus, "cancelled");
 
     const [updated] = await this.db.update(vendorSubOrders).set({
@@ -118,7 +117,6 @@ export class SubOrderService {
       updatedAt: new Date(),
     }).where(eq(vendorSubOrders.id, id)).returning();
 
-    // Trigger side effects: release inventory + reverse ledger
     if (this.onCancel && sub) {
       await this.onCancel(sub);
     }

package/src/types.ts

@@ -99,34 +99,12 @@ export type RFQResponseStatus = "submitted" | "shortlisted" | "accepted" | "reje
 
 export interface MarketplacePluginOptions {
   defaultCommissionRateBps?: number;
-
-  vendorApprovalMode?: VendorApprovalMode;
-  requiredDocuments?: DocumentType[];
-
-  defaultPayoutSchedule?: PayoutSchedule;
   defaultPayoutMinimumCents?: number;
-  defaultHoldbackDays?: number;
-
   vendorResponseDeadlineDays?: number;
-  autoEscalateOnMissedDeadline?: boolean;
-
-  returnWindowDays?: number;
-  autoApproveReturnsOnVendorTimeout?: boolean;
-  vendorReturnResponseDays?: number;
-
-  requireVerifiedPurchase?: boolean;
   reviewModerationEnabled?: boolean;
 
   b2b?: {
     rfq?: boolean;
-    contractPricing?: boolean;
-  };
-
-  performanceThresholds?: {
-    minRating?: number;
-    maxDefectRatePercent?: number;
-    maxLateShipmentRatePercent?: number;
-    maxCancellationRatePercent?: number;
   };
 }
 
@@ -156,9 +134,3 @@ export interface RouteContext {
   json(data: unknown, status?: number): Response;
   get(key: string): unknown;
 }
-
-// ─── Error helper ────────────────────────────────────────────────────────────
-
-export function errorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : "Internal server error";
-}

package/dist/schemas/payouts.d.ts

@@ -1,375 +0,0 @@
-import { z } from "@hono/zod-openapi";
-export declare const RunPayoutCycleBodySchema: z.ZodObject<{
-    vendorIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-    force: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const runPayoutCycleRoute: {
-    method: "post";
-    path: "/api/marketplace/payouts/run";
-    tags: string[];
-    summary: string;
-    request: {
-        body: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        vendorIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-                        force: z.ZodOptional<z.ZodBoolean>;
-                    }, z.core.$strip>;
-                };
-            };
-            required: true;
-        };
-    };
-    responses: {
-        401: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Authentication required.";
-        };
-        403: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Insufficient permissions.";
-        };
-        404: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Not found.";
-        };
-        422: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Validation error.";
-        };
-        500: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Server error.";
-        };
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        data: z.ZodAny;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-    };
-} & {
-    getRoutingPath(): "/api/marketplace/payouts/run";
-};
-export declare const listPayoutsRoute: {
-    method: "get";
-    path: "/api/marketplace/payouts";
-    tags: string[];
-    summary: string;
-    request: {
-        query: z.ZodObject<{
-            vendorId: z.ZodOptional<z.ZodString>;
-            status: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    };
-    responses: {
-        401: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Authentication required.";
-        };
-        403: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Insufficient permissions.";
-        };
-        404: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Not found.";
-        };
-        422: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Validation error.";
-        };
-        500: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Server error.";
-        };
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        data: z.ZodAny;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-    };
-} & {
-    getRoutingPath(): "/api/marketplace/payouts";
-};
-export declare const retryPayoutRoute: {
-    method: "post";
-    path: "/api/marketplace/payouts/{id}/retry";
-    tags: string[];
-    summary: string;
-    request: {
-        params: z.ZodObject<{
-            id: z.ZodUUID;
-        }, z.core.$strip>;
-    };
-    responses: {
-        401: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Authentication required.";
-        };
-        403: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Insufficient permissions.";
-        };
-        404: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Not found.";
-        };
-        422: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Validation error.";
-        };
-        500: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Server error.";
-        };
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        data: z.ZodAny;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-    };
-} & {
-    getRoutingPath(): "/api/marketplace/payouts/:id/retry";
-};
-export declare const getPayoutRoute: {
-    method: "get";
-    path: "/api/marketplace/payouts/{id}";
-    tags: string[];
-    summary: string;
-    request: {
-        params: z.ZodObject<{
-            id: z.ZodUUID;
-        }, z.core.$strip>;
-    };
-    responses: {
-        401: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Authentication required.";
-        };
-        403: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Insufficient permissions.";
-        };
-        404: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Not found.";
-        };
-        422: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Validation error.";
-        };
-        500: {
-            readonly content: {
-                readonly "application/json": {
-                    readonly schema: z.ZodObject<{
-                        error: z.ZodObject<{
-                            code: z.ZodString;
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            readonly description: "Server error.";
-        };
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        data: z.ZodAny;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-    };
-} & {
-    getRoutingPath(): "/api/marketplace/payouts/:id";
-};
-//# sourceMappingURL=payouts.d.ts.map

package/dist/schemas/payouts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payouts.d.ts","sourceRoot":"","sources":["../../src/schemas/payouts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAqBnD,eAAO,MAAM,wBAAwB;;;iBAGF,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAY9B,CAAC;AAIH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe3B,CAAC;AAIH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAY3B,CAAC;AAIH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYzB,CAAC"}

package/dist/schemas/payouts.js

@@ -1,78 +0,0 @@
-import { z, createRoute } from "@hono/zod-openapi";
-const ErrorSchema = z.object({
-    error: z.object({
-        code: z.string(),
-        message: z.string(),
-    }),
-});
-const errorResponses = {
-    401: { content: { "application/json": { schema: ErrorSchema } }, description: "Authentication required." },
-    403: { content: { "application/json": { schema: ErrorSchema } }, description: "Insufficient permissions." },
-    404: { content: { "application/json": { schema: ErrorSchema } }, description: "Not found." },
-    422: { content: { "application/json": { schema: ErrorSchema } }, description: "Validation error." },
-    500: { content: { "application/json": { schema: ErrorSchema } }, description: "Server error." },
-};
-const PayoutResponseSchema = z.object({ data: z.any() });
-// ─── Run Payout Cycle ────────────────────────────────────────────────────────
-export const RunPayoutCycleBodySchema = z.object({
-    vendorIds: z.array(z.uuid()).optional().openapi({ description: "Limit payout run to specific vendors" }),
-    force: z.boolean().optional().openapi({ description: "Force payout even if below minimum threshold" }),
-}).openapi("RunPayoutCycleRequest");
-export const runPayoutCycleRoute = createRoute({
-    method: "post",
-    path: "/api/marketplace/payouts/run",
-    tags: ["Marketplace - Payouts"],
-    summary: "Run a payout cycle",
-    request: {
-        body: { content: { "application/json": { schema: RunPayoutCycleBodySchema } }, required: true },
-    },
-    responses: {
-        200: { content: { "application/json": { schema: PayoutResponseSchema } }, description: "Payout cycle completed." },
-        ...errorResponses,
-    },
-});
-// ─── List Payouts ───────────────────────────────────────────────────────────
-export const listPayoutsRoute = createRoute({
-    method: "get",
-    path: "/api/marketplace/payouts",
-    tags: ["Marketplace - Payouts"],
-    summary: "List payouts",
-    request: {
-        query: z.object({
-            vendorId: z.string().optional(),
-            status: z.string().optional(),
-        }),
-    },
-    responses: {
-        200: { content: { "application/json": { schema: PayoutResponseSchema } }, description: "Success" },
-        ...errorResponses,
-    },
-});
-// ─── Retry Payout ───────────────────────────────────────────────────────────
-export const retryPayoutRoute = createRoute({
-    method: "post",
-    path: "/api/marketplace/payouts/{id}/retry",
-    tags: ["Marketplace - Payouts"],
-    summary: "Retry a failed payout",
-    request: {
-        params: z.object({ id: z.uuid() }),
-    },
-    responses: {
-        200: { content: { "application/json": { schema: PayoutResponseSchema } }, description: "Payout retried." },
-        ...errorResponses,
-    },
-});
-// ─── Get Payout ─────────────────────────────────────────────────────────────
-export const getPayoutRoute = createRoute({
-    method: "get",
-    path: "/api/marketplace/payouts/{id}",
-    tags: ["Marketplace - Payouts"],
-    summary: "Get payout by ID",
-    request: {
-        params: z.object({ id: z.uuid() }),
-    },
-    responses: {
-        200: { content: { "application/json": { schema: PayoutResponseSchema } }, description: "Success" },
-        ...errorResponses,
-    },
-});

package/dist/services/contract-price.d.ts

@@ -1,64 +0,0 @@
-import type { Db } from "../types.js";
-export declare class ContractPriceService {
-    private db;
-    constructor(db: Db);
-    create(data: {
-        vendorId: string;
-        buyerId: string;
-        entityId: string;
-        variantId?: string;
-        priceCents: number;
-        minQuantity?: number;
-        currency?: string;
-        validFrom?: Date | undefined;
-        validUntil?: Date | undefined;
-    }): Promise<{
-        id: string;
-        createdAt: Date;
-        vendorId: string;
-        entityId: string;
-        variantId: string | null;
-        currency: string;
-        minQuantity: number;
-        validFrom: Date | null;
-        validUntil: Date | null;
-        buyerId: string;
-        priceCents: number;
-    } | undefined>;
-    update(id: string, data: Record<string, unknown>): Promise<{
-        id: string;
-        vendorId: string;
-        buyerId: string;
-        entityId: string;
-        variantId: string | null;
-        priceCents: number;
-        minQuantity: number;
-        currency: string;
-        validFrom: Date | null;
-        validUntil: Date | null;
-        createdAt: Date;
-    } | null>;
-    delete(id: string): Promise<void>;
-    list(filters?: {
-        vendorId?: string;
-        buyerId?: string;
-    }): Promise<{
-        id: string;
-        vendorId: string;
-        buyerId: string;
-        entityId: string;
-        variantId: string | null;
-        priceCents: number;
-        minQuantity: number;
-        currency: string;
-        validFrom: Date | null;
-        validUntil: Date | null;
-        createdAt: Date;
-    }[]>;
-    /**
-     * Resolve the best contract price for a buyer+vendor+entity+quantity.
-     * Returns null if no matching contract exists.
-     */
-    resolvePrice(vendorId: string, buyerId: string, entityId: string, variantId: string | null, quantity: number): Promise<number | null>;
-}
-//# sourceMappingURL=contract-price.d.ts.map

package/dist/services/contract-price.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-price.d.ts","sourceRoot":"","sources":["../../src/services/contract-price.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,qBAAa,oBAAoB;IACnB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,IAAI,EAAE;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;QAC7B,UAAU,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;KAC/B;;;;;;;;;;;;;IAKK,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;IAMhD,MAAM,CAAC,EAAE,EAAE,MAAM;IAIjB,IAAI,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;IAW5D;;;OAGG;IACG,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CA0B1B"}