@unifiedcommerce/plugin-marketplace 0.0.1

package/dist/schemas/commission.d.ts

@@ -0,0 +1,532 @@
+import { z } from "@hono/zod-openapi";
+export declare const CreateCommissionRuleBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        vendor_tier: "vendor_tier";
+        category: "category";
+        volume_tier: "volume_tier";
+        promotional: "promotional";
+    }>;
+    rateBps: z.ZodNumber;
+    categorySlug: z.ZodOptional<z.ZodString>;
+    vendorId: z.ZodOptional<z.ZodUUID>;
+    vendorTier: z.ZodOptional<z.ZodString>;
+    minVolumeCents: z.ZodOptional<z.ZodNumber>;
+    maxVolumeCents: z.ZodOptional<z.ZodNumber>;
+    validFrom: z.ZodOptional<z.ZodString>;
+    validUntil: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const createCommissionRuleRoute: {
+    method: "post";
+    path: "/api/marketplace/commission-rules";
+    tags: string[];
+    summary: string;
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        name: z.ZodString;
+                        type: z.ZodEnum<{
+                            vendor_tier: "vendor_tier";
+                            category: "category";
+                            volume_tier: "volume_tier";
+                            promotional: "promotional";
+                        }>;
+                        rateBps: z.ZodNumber;
+                        categorySlug: z.ZodOptional<z.ZodString>;
+                        vendorId: z.ZodOptional<z.ZodUUID>;
+                        vendorTier: z.ZodOptional<z.ZodString>;
+                        minVolumeCents: z.ZodOptional<z.ZodNumber>;
+                        maxVolumeCents: z.ZodOptional<z.ZodNumber>;
+                        validFrom: z.ZodOptional<z.ZodString>;
+                        validUntil: z.ZodOptional<z.ZodString>;
+                        priority: z.ZodOptional<z.ZodNumber>;
+                    }, 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.";
+        };
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodAny;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/api/marketplace/commission-rules";
+};
+export declare const UpdateCommissionRuleBodySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    rateBps: z.ZodOptional<z.ZodNumber>;
+    categorySlug: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    vendorTier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    minVolumeCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxVolumeCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateCommissionRuleRoute: {
+    method: "patch";
+    path: "/api/marketplace/commission-rules/{id}";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodUUID;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        name: z.ZodOptional<z.ZodString>;
+                        rateBps: z.ZodOptional<z.ZodNumber>;
+                        categorySlug: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        vendorTier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        minVolumeCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        maxVolumeCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        priority: z.ZodOptional<z.ZodNumber>;
+                        isActive: 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/commission-rules/:id";
+};
+export declare const PreviewCommissionBodySchema: z.ZodObject<{
+    vendorId: z.ZodUUID;
+    categorySlug: z.ZodOptional<z.ZodString>;
+    volumeCents: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const previewCommissionRoute: {
+    method: "post";
+    path: "/api/marketplace/commission-rules/preview";
+    tags: string[];
+    summary: string;
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        vendorId: z.ZodUUID;
+                        categorySlug: z.ZodOptional<z.ZodString>;
+                        volumeCents: z.ZodOptional<z.ZodNumber>;
+                    }, 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/commission-rules/preview";
+};
+export declare const listCommissionRulesRoute: {
+    method: "get";
+    path: "/api/marketplace/commission-rules";
+    tags: string[];
+    summary: string;
+    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/commission-rules";
+};
+export declare const deleteCommissionRuleRoute: {
+    method: "delete";
+    path: "/api/marketplace/commission-rules/{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/commission-rules/:id";
+};
+//# sourceMappingURL=commission.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commission.d.ts","sourceRoot":"","sources":["../../src/schemas/commission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAqBnD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;iBAYF,CAAC;AAE1C,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYpC,CAAC;AAIH,eAAO,MAAM,8BAA8B;;;;;;;;;;;iBAWF,CAAC;AAE1C,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAapC,CAAC;AAIH,eAAO,MAAM,2BAA2B;;;;iBAIF,CAAC;AAEvC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYjC,CAAC;AAIH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASnC,CAAC;AAIH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYpC,CAAC"}

package/dist/schemas/commission.js

@@ -0,0 +1,113 @@
+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 CommissionResponseSchema = z.object({ data: z.any() });
+// ─── Create Commission Rule ──────────────────────────────────────────────────
+export const CreateCommissionRuleBodySchema = z.object({
+    name: z.string().min(1).openapi({ example: "Electronics Category Rate" }),
+    type: z.enum(["category", "volume_tier", "vendor_tier", "promotional"]).openapi({ example: "category" }),
+    rateBps: z.number().int().min(0).max(10000).openapi({ example: 1500, description: "Basis points (100 = 1%)" }),
+    categorySlug: z.string().optional(),
+    vendorId: z.uuid().optional(),
+    vendorTier: z.string().optional(),
+    minVolumeCents: z.number().int().optional(),
+    maxVolumeCents: z.number().int().optional(),
+    validFrom: z.string().optional().openapi({ example: "2026-01-01T00:00:00Z", description: "ISO 8601 date string" }),
+    validUntil: z.string().optional().openapi({ example: "2026-12-31T23:59:59Z", description: "ISO 8601 date string" }),
+    priority: z.number().int().optional(),
+}).openapi("CreateCommissionRuleRequest");
+export const createCommissionRuleRoute = createRoute({
+    method: "post",
+    path: "/api/marketplace/commission-rules",
+    tags: ["Marketplace - Commission"],
+    summary: "Create a commission rule",
+    request: {
+        body: { content: { "application/json": { schema: CreateCommissionRuleBodySchema } }, required: true },
+    },
+    responses: {
+        201: { content: { "application/json": { schema: CommissionResponseSchema } }, description: "Commission rule created." },
+        ...errorResponses,
+    },
+});
+// ─── Update Commission Rule ──────────────────────────────────────────────────
+export const UpdateCommissionRuleBodySchema = z.object({
+    name: z.string().min(1).optional(),
+    rateBps: z.number().int().min(0).max(10000).optional(),
+    categorySlug: z.string().nullable().optional(),
+    vendorTier: z.string().nullable().optional(),
+    minVolumeCents: z.number().int().nullable().optional(),
+    maxVolumeCents: z.number().int().nullable().optional(),
+    validFrom: z.string().nullable().optional().openapi({ description: "ISO 8601 date string or null to clear" }),
+    validUntil: z.string().nullable().optional().openapi({ description: "ISO 8601 date string or null to clear" }),
+    priority: z.number().int().optional(),
+    isActive: z.boolean().optional(),
+}).openapi("UpdateCommissionRuleRequest");
+export const updateCommissionRuleRoute = createRoute({
+    method: "patch",
+    path: "/api/marketplace/commission-rules/{id}",
+    tags: ["Marketplace - Commission"],
+    summary: "Update a commission rule",
+    request: {
+        params: z.object({ id: z.uuid() }),
+        body: { content: { "application/json": { schema: UpdateCommissionRuleBodySchema } }, required: true },
+    },
+    responses: {
+        200: { content: { "application/json": { schema: CommissionResponseSchema } }, description: "Commission rule updated." },
+        ...errorResponses,
+    },
+});
+// ─── Preview Commission Rate ─────────────────────────────────────────────────
+export const PreviewCommissionBodySchema = z.object({
+    vendorId: z.uuid().openapi({ example: "d4e5f6a7-b8c9-0d1e-2f3a-4b5c6d7e8f9a" }),
+    categorySlug: z.string().optional(),
+    volumeCents: z.number().int().optional().openapi({ example: 100000, description: "Order volume in cents" }),
+}).openapi("PreviewCommissionRequest");
+export const previewCommissionRoute = createRoute({
+    method: "post",
+    path: "/api/marketplace/commission-rules/preview",
+    tags: ["Marketplace - Commission"],
+    summary: "Preview the commission rate for a vendor",
+    request: {
+        body: { content: { "application/json": { schema: PreviewCommissionBodySchema } }, required: true },
+    },
+    responses: {
+        200: { content: { "application/json": { schema: CommissionResponseSchema } }, description: "Commission rate preview." },
+        ...errorResponses,
+    },
+});
+// ─── List Commission Rules ──────────────────────────────────────────────────
+export const listCommissionRulesRoute = createRoute({
+    method: "get",
+    path: "/api/marketplace/commission-rules",
+    tags: ["Marketplace - Commission"],
+    summary: "List all commission rules",
+    responses: {
+        200: { content: { "application/json": { schema: CommissionResponseSchema } }, description: "Success" },
+        ...errorResponses,
+    },
+});
+// ─── Delete Commission Rule ─────────────────────────────────────────────────
+export const deleteCommissionRuleRoute = createRoute({
+    method: "delete",
+    path: "/api/marketplace/commission-rules/{id}",
+    tags: ["Marketplace - Commission"],
+    summary: "Delete a commission rule",
+    request: {
+        params: z.object({ id: z.uuid() }),
+    },
+    responses: {
+        200: { content: { "application/json": { schema: CommissionResponseSchema } }, description: "Commission rule deleted." },
+        ...errorResponses,
+    },
+});