@porulle/core 0.6.0 → 0.8.0

package/dist/interfaces/rest/routes/checkout.js

@@ -14,6 +14,15 @@ export function checkoutRoutes(kernel) {
     router.openapi(checkoutRoute, async (c) => {
         const body = c.req.valid("json");
         const actor = c.get("actor");
+        // Idempotent replay: a re-submitted checkout (offline POS queue, network
+        // retry) returns the already-created order BEFORE the pipeline runs — no
+        // double payment authorization, no duplicate order.
+        if (body.idempotencyKey) {
+            const replay = await kernel.services.orders.getByIdempotencyKey(body.idempotencyKey, actor);
+            if (replay.ok && replay.value) {
+                return c.json({ data: replay.value }, 201);
+            }
+        }
         const checkoutData = {
             checkoutId: makeId(),
             cartId: body.cartId,
@@ -105,6 +114,9 @@ export function checkoutRoutes(kernel) {
                 // If both lookups fail, we still allow guest checkout (customerUuid remains undefined)
             }
             const orderPayload = {
+                ...(body.idempotencyKey !== undefined
+                    ? { idempotencyKey: body.idempotencyKey }
+                    : {}),
                 currency: processed.currency,
                 subtotal: processed.subtotal,
                 taxTotal: processed.taxTotal,
@@ -133,6 +145,11 @@ export function checkoutRoutes(kernel) {
                         quantity: lineItem.quantity,
                         unitPrice: lineItem.resolvedUnitPrice ?? 0,
                         totalPrice: lineItem.resolvedTotal ?? 0,
+                        // Per-line tax from product tax classes (issue #57)
+                        taxAmount: lineItem.taxAmount ?? 0,
+                        ...(lineItem.discountAmount !== undefined
+                            ? { discountAmount: lineItem.discountAmount }
+                            : {}),
                     };
                     return lineItem.variantId !== undefined
                         ? { ...payload, variantId: lineItem.variantId }

package/dist/interfaces/rest/routes/documents.d.ts

@@ -0,0 +1,10 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { Kernel } from "../../../runtime/kernel.js";
+import { type AppEnv } from "../utils.js";
+/**
+ * Order document rendering (issue #47). Mounted under /orders. Access
+ * control rides on OrderService.getById (orders:read, or orders:read:own
+ * for the order's customer), so no extra scope is needed here.
+ */
+export declare function documentRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=documents.d.ts.map

package/dist/interfaces/rest/routes/documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/documents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAOzD,OAAO,EAAE,KAAK,MAAM,EAAwC,MAAM,aAAa,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,gCA6C5C"}

package/dist/interfaces/rest/routes/documents.js

@@ -0,0 +1,40 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { emailInvoiceRoute, invoiceHtmlRoute, invoicePdfRoute, receiptHtmlRoute, } from "../schemas/documents.js";
+import { mapErrorToResponse, mapErrorToStatus } from "../utils.js";
+/**
+ * Order document rendering (issue #47). Mounted under /orders. Access
+ * control rides on OrderService.getById (orders:read, or orders:read:own
+ * for the order's customer), so no extra scope is needed here.
+ */
+export function documentRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.openapi(invoicePdfRoute, async (c) => {
+        const result = await kernel.services.documents.renderInvoicePdf(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.body(result.value.pdf.slice().buffer, 200, {
+            "content-type": "application/pdf",
+            "content-disposition": `inline; filename="invoice-${result.value.invoiceNumber}.pdf"`,
+        });
+    });
+    router.openapi(invoiceHtmlRoute, async (c) => {
+        const result = await kernel.services.documents.renderInvoiceHtml(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.html(result.value.html);
+    });
+    router.openapi(receiptHtmlRoute, async (c) => {
+        const result = await kernel.services.documents.renderReceiptHtml(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.html(result.value.html);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(emailInvoiceRoute, async (c) => {
+        const result = await kernel.services.documents.emailInvoice(c.req.param("id"), c.req.valid("json").to, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/orders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/orders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAiE,MAAM,aAAa,CAAC;AAEzG,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,gCA4FzC"}
+{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/orders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAiE,MAAM,aAAa,CAAC;AAGzG,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,gCAsQzC"}

package/dist/interfaces/rest/routes/orders.js

@@ -1,5 +1,5 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { changeOrderStatusRoute, listOrdersRoute, orderLookupRoute, getOrderRoute, getOrderFulfillmentsRoute } from "../schemas/orders.js";
+import { changeOrderStatusRoute, listOrdersRoute, orderLookupRoute, getOrderRoute, getOrderFulfillmentsRoute, createOrderRoute, refundOrderRoute, captureOrderRoute, createOrderFulfillmentRoute, addOrderLineItemRoute, updateOrderLineItemRoute, removeOrderLineItemRoute, refundOrderLinesRoute, undoOrderRefundRoute, listOrderRefundsRoute, refundCapStatusRoute, createOrderNoteRoute, listOrderNotesRoute, deleteOrderNoteRoute, orderTimelineRoute } from "../schemas/orders.js";
 import { isUUID, mapErrorToResponse, mapErrorToStatus, parsePagination } from "../utils.js";
 export function orderRoutes(kernel) {
     const router = new OpenAPIHono();
@@ -53,6 +53,113 @@ export function orderRoutes(kernel) {
             return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
         return c.json({ data: result.value });
     });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOrderRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.create(body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(refundOrderRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.refund(c.req.param("id"), c.get("actor"), body?.reason ?? "refunded", undefined, body?.amount !== undefined ? { amount: body.amount } : undefined);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // ── Notes + activity timeline (issue #56) ──────────────────────────
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOrderNoteRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.addNote(c.req.param("id"), body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listOrderNotesRoute, async (c) => {
+        const result = await kernel.services.orders.listNotes(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteOrderNoteRoute, async (c) => {
+        const result = await kernel.services.orders.deleteNote(c.req.param("id"), c.req.param("noteId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(orderTimelineRoute, async (c) => {
+        const result = await kernel.services.orders.timeline(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // ── Line-level refunds (issue #52) ─────────────────────────────────
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(refundCapStatusRoute, async (c) => {
+        const result = await kernel.services.orders.refundCapStatus(c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(refundOrderLinesRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.refundLines(c.req.param("id"), body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(undoOrderRefundRoute, async (c) => {
+        const result = await kernel.services.orders.undoRefund(c.req.param("id"), c.req.param("refundId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listOrderRefundsRoute, async (c) => {
+        const result = await kernel.services.orders.listRefunds(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(captureOrderRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.capture(c.req.param("id"), c.get("actor"), body?.amount !== undefined ? { amount: body.amount } : undefined);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(addOrderLineItemRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.addLineItem(c.req.param("id"), body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateOrderLineItemRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.updateOrderLineItem(c.req.param("id"), c.req.param("lineItemId"), body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(removeOrderLineItemRoute, async (c) => {
+        const result = await kernel.services.orders.removeLineItem(c.req.param("id"), c.req.param("lineItemId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
     // @ts-expect-error -- openapi() enforces strict response typing but our handler
     // returns union responses (200 | 400 | 404). The route definition documents the
     // contract; the handler returns dynamic status.
@@ -68,6 +175,20 @@ export function orderRoutes(kernel) {
         return c.json({ data: result.value });
     });
     // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOrderFulfillmentRoute, async (c) => {
+        const actor = c.get("actor");
+        const orderId = c.req.param("id");
+        // Verify the order exists and the actor has access before recording
+        const orderResult = await kernel.services.orders.getById(orderId, actor);
+        if (!orderResult.ok)
+            return c.json(mapErrorToResponse(orderResult.error), mapErrorToStatus(orderResult.error));
+        const body = c.req.valid("json");
+        const result = await kernel.services.fulfillment.createFulfillment({ ...body, orderId: orderResult.value.id }, actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
     router.openapi(getOrderFulfillmentsRoute, async (c) => {
         const orderId = c.req.param("id");
         const actor = c.get("actor");

package/dist/interfaces/rest/routes/pricing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCAoE3C"}
+{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCA+G3C"}

package/dist/interfaces/rest/routes/pricing.js

@@ -2,7 +2,7 @@ import { OpenAPIHono } from "@hono/zod-openapi";
 import { resolveOrgId } from "../../../auth/org.js";
 import { CommerceValidationError } from "../../../kernel/errors.js";
 import { CatalogRepository } from "../../../modules/catalog/repository/index.js";
-import { setBasePriceRoute, createModifierRoute, listPricesRoute } from "../schemas/pricing.js";
+import { setBasePriceRoute, createModifierRoute, listPricesRoute, listModifiersRoute, updateModifierRoute, deleteModifierRoute } from "../schemas/pricing.js";
 import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
 export function pricingRoutes(kernel) {
     const router = new OpenAPIHono();
@@ -37,6 +37,41 @@ export function pricingRoutes(kernel) {
         return c.json({ data: result.value });
     });
     router.use("/modifiers", requirePerm("pricing:manage"));
+    router.use("/modifiers/:id", requirePerm("pricing:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listModifiersRoute, async (c) => {
+        const actor = c.get("actor");
+        const entityId = c.req.query("entityId");
+        const currency = c.req.query("currency");
+        const active = c.req.query("active");
+        const result = await kernel.services.pricing.listModifiers({
+            ...(entityId !== undefined ? { entityId } : {}),
+            ...(currency !== undefined ? { currency } : {}),
+            ...(active === "true" ? { active: true } : {}),
+        }, actor);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateModifierRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.pricing.updateModifier(c.req.param("id"), c.req.valid("json"), actor);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteModifierRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.pricing.deleteModifier(c.req.param("id"), actor);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value });
+    });
     // @ts-expect-error -- openapi() enforces strict response typing but our handler
     // returns union responses (201 | 400 | 422). The route definition documents the
     // contract; the handler returns dynamic status.

package/dist/interfaces/rest/routes/settings.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { Kernel } from "../../../runtime/kernel.js";
+import { type AppEnv } from "../utils.js";
+export declare function settingsRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=settings.d.ts.map

package/dist/interfaces/rest/routes/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAOzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,gCAkD5C"}

package/dist/interfaces/rest/routes/settings.js

@@ -0,0 +1,50 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { KNOWN_GROUP_SCHEMAS, getAllSettingsRoute, getSettingsGroupRoute, patchSettingsGroupRoute, } from "../schemas/settings.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function settingsRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/", requirePerm("settings:manage"));
+    router.use("/:group", requirePerm("settings:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getAllSettingsRoute, async (c) => {
+        const result = await kernel.services.settings.getAll(c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getSettingsGroupRoute, async (c) => {
+        const result = await kernel.services.settings.getGroup(c.req.param("group"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(patchSettingsGroupRoute, async (c) => {
+        const group = c.req.param("group");
+        const body = c.req.valid("json");
+        // Known groups get typed validation; unknown groups accept any object.
+        const groupSchema = KNOWN_GROUP_SCHEMAS[group];
+        if (groupSchema) {
+            const parsed = groupSchema.safeParse(body);
+            if (!parsed.success) {
+                const isProd = process.env.NODE_ENV === "production";
+                return c.json({
+                    error: {
+                        code: "VALIDATION_FAILED",
+                        message: isProd
+                            ? "Invalid input."
+                            : parsed.error.issues
+                                .map((i) => `${i.path.join(".")}: ${i.message}`)
+                                .join("; "),
+                    },
+                }, 422);
+            }
+        }
+        const result = await kernel.services.settings.updateGroup(group, body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/shipping.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { Kernel } from "../../../runtime/kernel.js";
+import { type AppEnv } from "../utils.js";
+export declare function shippingRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=shipping.d.ts.map

package/dist/interfaces/rest/routes/shipping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipping.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/shipping.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAWzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,gCA6E5C"}

package/dist/interfaces/rest/routes/shipping.js

@@ -0,0 +1,68 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createShippingZoneRoute, listShippingZonesRoute, updateShippingZoneRoute, deleteShippingZoneRoute, createShippingRateRoute, listShippingRatesRoute, updateShippingRateRoute, deleteShippingRateRoute, } from "../schemas/shipping.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function shippingRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/zones", requirePerm("shipping:manage"));
+    router.use("/zones/:id", requirePerm("shipping:manage"));
+    router.use("/rates", requirePerm("shipping:manage"));
+    router.use("/rates/:id", requirePerm("shipping:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createShippingZoneRoute, async (c) => {
+        const result = await kernel.services.shipping.createZone(c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listShippingZonesRoute, async (c) => {
+        const result = await kernel.services.shipping.listZones(c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateShippingZoneRoute, async (c) => {
+        const result = await kernel.services.shipping.updateZone(c.req.param("id"), c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteShippingZoneRoute, async (c) => {
+        const result = await kernel.services.shipping.deleteZone(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createShippingRateRoute, async (c) => {
+        const result = await kernel.services.shipping.createRate(c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listShippingRatesRoute, async (c) => {
+        const zoneId = c.req.query("zoneId");
+        const result = await kernel.services.shipping.listRates(zoneId !== undefined ? { zoneId } : undefined, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateShippingRateRoute, async (c) => {
+        const result = await kernel.services.shipping.updateRate(c.req.param("id"), c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteShippingRateRoute, async (c) => {
+        const result = await kernel.services.shipping.deleteRate(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/tax.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { Kernel } from "../../../runtime/kernel.js";
+import { type AppEnv } from "../utils.js";
+export declare function taxRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=tax.d.ts.map

package/dist/interfaces/rest/routes/tax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tax.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/tax.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAWzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,gCA2EvC"}

package/dist/interfaces/rest/routes/tax.js

@@ -0,0 +1,68 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createTaxRateRoute, listTaxRatesRoute, updateTaxRateRoute, deleteTaxRateRoute, createTaxClassRoute, listTaxClassesRoute, updateTaxClassRoute, deleteTaxClassRoute, } from "../schemas/tax.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function taxRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/rates", requirePerm("tax:manage"));
+    router.use("/rates/:id", requirePerm("tax:manage"));
+    router.use("/classes", requirePerm("tax:manage"));
+    router.use("/classes/:id", requirePerm("tax:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createTaxRateRoute, async (c) => {
+        const result = await kernel.services.tax.createTaxRate(c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listTaxRatesRoute, async (c) => {
+        const result = await kernel.services.tax.listTaxRates(c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateTaxRateRoute, async (c) => {
+        const result = await kernel.services.tax.updateTaxRate(c.req.param("id"), c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteTaxRateRoute, async (c) => {
+        const result = await kernel.services.tax.deleteTaxRate(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // ── Product tax classes (issue #57) ───────────────────────────────
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createTaxClassRoute, async (c) => {
+        const result = await kernel.services.tax.createTaxClass(c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listTaxClassesRoute, async (c) => {
+        const result = await kernel.services.tax.listTaxClasses(c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateTaxClassRoute, async (c) => {
+        const result = await kernel.services.tax.updateTaxClass(c.req.param("id"), c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteTaxClassRoute, async (c) => {
+        const result = await kernel.services.tax.deleteTaxClass(c.req.param("id"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    return router;
+}