@porulle/core 0.1.0

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

@@ -0,0 +1,269 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { listEntitiesRoute, getEntityRoute, getEntityAttributesRoute, listCategoriesRoute, listBrandsRoute, deleteEntityRoute, deleteCategoryRoute, deleteBrandRoute, removeEntityFromCategoryRoute, removeEntityFromBrandRoute, publishEntityRoute, archiveEntityRoute, discontinueEntityRoute, addEntityToCategoryRoute, addEntityToBrandRoute, createEntityRoute, updateEntityRoute, setEntityAttributesRoute, createCategoryRoute, updateCategoryRoute, createBrandRoute, updateBrandRoute, createOptionTypeRoute, createOptionValueRoute, createVariantRoute, generateVariantsRoute, } from "../schemas/catalog.js";
+import { mapErrorToResponse, mapErrorToStatus, parseInclude, parsePagination, parseSort, } from "../utils.js";
+export function catalogRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listEntitiesRoute, async (c) => {
+        try {
+            const include = parseInclude(c.req.query("include"));
+            const pagination = parsePagination(c.req.query());
+            const filter = {};
+            const type = c.req.query("type");
+            const status = c.req.query("status");
+            const category = c.req.query("category");
+            const brand = c.req.query("brand");
+            if (type)
+                filter.type = type;
+            if (status)
+                filter.status = status;
+            if (category)
+                filter.category = category;
+            if (brand)
+                filter.brand = brand;
+            const payload = {
+                filter,
+                pagination,
+            };
+            const sort = parseSort(c.req.query("sort"));
+            if (sort)
+                payload.sort = sort;
+            const result = await kernel.services.catalog.list(payload, c.get("actor"));
+            if (!result.ok) {
+                return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+            }
+            let withIncludes = result.value.items;
+            if (include.size > 0) {
+                const includeOptions = {
+                    includeAttributes: include.has("attributes"),
+                    includeVariants: include.has("variants"),
+                    includeOptionTypes: include.has("optionTypes"),
+                    includeCategories: include.has("categories"),
+                    includeBrands: include.has("brands"),
+                    includeMedia: include.has("media"),
+                    includeInventory: include.has("inventory"),
+                    includePricing: include.has("pricing"),
+                };
+                const hydrated = await Promise.all(result.value.items.map(async (item) => {
+                    const full = await kernel.services.catalog.getById(item.id, includeOptions);
+                    return full.ok ? full.value : item;
+                }));
+                withIncludes = hydrated;
+            }
+            return c.json({
+                data: withIncludes,
+                meta: {
+                    pagination: result.value.pagination,
+                },
+            });
+        }
+        catch (error) {
+            console.error("[catalog] List failed:", error instanceof Error ? error.message : error);
+            return c.json(mapErrorToResponse(error), mapErrorToStatus(error));
+        }
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getEntityRoute, async (c) => {
+        try {
+            const idOrSlug = c.req.param("idOrSlug");
+            const include = parseInclude(c.req.query("include"));
+            const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(idOrSlug);
+            const includeOptions = {
+                includeAttributes: include.has("attributes"),
+                includeVariants: include.has("variants"),
+                includeOptionTypes: include.has("optionTypes"),
+                includeCategories: include.has("categories"),
+                includeBrands: include.has("brands"),
+                includeMedia: include.has("media"),
+                includeInventory: include.has("inventory"),
+                includePricing: include.has("pricing"),
+            };
+            const actor = c.get("actor");
+            const result = isUUID
+                ? await kernel.services.catalog.getById(idOrSlug, includeOptions, actor)
+                : await kernel.services.catalog.getBySlug(idOrSlug, includeOptions, actor);
+            if (!result.ok) {
+                return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+            }
+            return c.json({ data: result.value });
+        }
+        catch (error) {
+            console.error("[catalog] Get entity failed:", error instanceof Error ? error.message : error);
+            return c.json(mapErrorToResponse(error), mapErrorToStatus(error));
+        }
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.create(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(updateEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.update(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(deleteEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.delete(c.req.param("id"), c.get("actor"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: { deleted: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(publishEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.publish(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(archiveEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.archive(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(discontinueEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.discontinue(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(setEntityAttributesRoute, async (c) => {
+        const result = await kernel.services.catalog.setAttributes(c.req.param("id"), c.req.param("locale"), c.req.valid("json"), // Zod-validated; Hono returns Record<string, unknown>
+        c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { updated: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getEntityAttributesRoute, async (c) => {
+        const result = await kernel.services.catalog.getAttributes(c.req.param("id"), c.req.param("locale"));
+        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(listCategoriesRoute, async (c) => {
+        const result = await kernel.services.catalog.listCategories({ actor: c.get("actor"), tx: null, requestId: "" });
+        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(createCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.createCategory(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(updateCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.updateCategory(c.req.param("categoryId"), 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(deleteCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.deleteCategory(c.req.param("categoryId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { deleted: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(addEntityToCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.addToCategory(c.req.param("id"), c.req.param("categoryId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { linked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(removeEntityFromCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.removeFromCategory(c.req.param("id"), c.req.param("categoryId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { unlinked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listBrandsRoute, async (c) => {
+        const result = await kernel.services.catalog.listBrands({ actor: c.get("actor"), tx: null, requestId: "" });
+        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(createBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.createBrand(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(updateBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.updateBrand(c.req.param("brandId"), 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(deleteBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.deleteBrand(c.req.param("brandId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { deleted: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(addEntityToBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.addToBrand(c.req.param("id"), c.req.param("brandId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { linked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(removeEntityFromBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.removeFromBrand(c.req.param("id"), c.req.param("brandId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { unlinked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOptionTypeRoute, async (c) => {
+        const result = await kernel.services.catalog.createOptionType({ ...c.req.valid("json"), entityId: 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 }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOptionValueRoute, async (c) => {
+        const result = await kernel.services.catalog.createOptionValue({ ...c.req.valid("json"), optionTypeId: c.req.param("optionTypeId") }, 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(createVariantRoute, async (c) => {
+        const result = await kernel.services.catalog.createVariant({ ...c.req.valid("json"), entityId: 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 }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(generateVariantsRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.catalog.generateVariants(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);
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/checkout.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 checkoutRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=checkout.d.ts.map

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

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

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

@@ -0,0 +1,220 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { checkoutRoute } from "../schemas/checkout.js";
+import { applyPromotionCodes, authorizePayment, calculateShipping, calculateTax, checkInventoryAvailability, completeCheckout, recordAnalyticsEvent, resolveCurrentPrices, validateCartNotEmpty, validatePaymentMethod, } from "../../../hooks/checkout.js";
+import { runAfterHooks, runBeforeHooks } from "../../../kernel/hooks/executor.js";
+import { createHookContext } from "../../../kernel/hooks/create-context.js";
+import { mapErrorToResponse, mapErrorToStatus } from "../utils.js";
+import { isCommerceError } from "../../../kernel/errors.js";
+import { makeId } from "../../../utils/id.js";
+export function checkoutRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi() enforces strict response typing but our handler
+    // returns union responses (201 | 400 | 422). The route definition documents the
+    // contract; the defaultHook handles Zod validation; the handler returns dynamic status.
+    router.openapi(checkoutRoute, async (c) => {
+        const body = c.req.valid("json");
+        const actor = c.get("actor");
+        const checkoutData = {
+            checkoutId: makeId(),
+            cartId: body.cartId,
+            currency: body.currency ?? "USD",
+            paymentMethodId: body.paymentMethodId,
+            lineItems: [],
+            subtotal: 0,
+            discountTotal: 0,
+            taxTotal: 0,
+            shippingTotal: 0,
+            total: 0,
+            ...(body.customerId !== undefined ? { customerId: body.customerId } : {}),
+            ...(body.customerGroupIds !== undefined
+                ? { customerGroupIds: body.customerGroupIds }
+                : {}),
+            ...(body.promotionCodes !== undefined
+                ? { promotionCodes: body.promotionCodes }
+                : {}),
+            ...(body.shippingAddress != null
+                ? {
+                    shippingAddress: {
+                        line1: body.shippingAddress.line1,
+                        city: body.shippingAddress.city,
+                        postalCode: body.shippingAddress.postalCode,
+                        country: body.shippingAddress.country,
+                        ...(body.shippingAddress.line2 != null ? { line2: body.shippingAddress.line2 } : {}),
+                        ...(body.shippingAddress.state != null ? { state: body.shippingAddress.state } : {}),
+                    },
+                }
+                : {}),
+        };
+        // ── Phase 1: Validate & Calculate (inside DB transaction — fast SQL only) ──
+        const validationHooks = [
+            validateCartNotEmpty,
+            resolveCurrentPrices,
+            checkInventoryAvailability,
+            applyPromotionCodes,
+            calculateTax,
+            calculateShipping,
+            ...kernel.hooks.resolve("checkout.beforePayment"),
+            validatePaymentMethod,
+        ];
+        // ── Phase 2: Payment Authorization (outside transaction — external API call) ──
+        const paymentHooks = [
+            authorizePayment,
+            ...kernel.hooks.resolve("checkout.beforeCreate"),
+        ];
+        const afterHooks = [
+            completeCheckout,
+            recordAnalyticsEvent,
+            ...kernel.hooks.resolve("checkout.afterCreate"),
+        ];
+        const context = createHookContext({
+            actor,
+            logger: kernel.logger,
+            services: kernel.services,
+            context: { moduleName: "checkout" },
+            origin: "rest",
+            database: { db: kernel.database.db },
+        });
+        try {
+            // Phase 1: DB transaction for validation — releases connection immediately after
+            const validated = await kernel.database.transaction(async (_tx) => {
+                context.tx = _tx;
+                return runBeforeHooks(validationHooks, checkoutData, "create", context);
+            });
+            // Phase 2: Payment authorization — NO DB connection held while calling Stripe/etc.
+            // If Stripe takes 5s, the DB connection pool is not affected.
+            context.tx = null;
+            const processed = await runBeforeHooks(paymentHooks, validated, "create", context);
+            // Resolve customer profile UUID from customerId (may be a profile UUID or a Better Auth user_id)
+            let customerUuid = undefined;
+            if (processed.customerId) {
+                const uuidRe = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+                if (uuidRe.test(processed.customerId)) {
+                    // Looks like a profile UUID — try direct lookup (no auto-create)
+                    const byIdResult = await kernel.services.customers.getById(processed.customerId, actor);
+                    if (byIdResult.ok) {
+                        customerUuid = byIdResult.value.id;
+                    }
+                }
+                if (!customerUuid) {
+                    // Fall back to user_id lookup (auto-creates customer profile if needed)
+                    const byUserIdResult = await kernel.services.customers.getByUserId(processed.customerId, actor);
+                    if (byUserIdResult.ok) {
+                        customerUuid = byUserIdResult.value.id;
+                    }
+                }
+                // If both lookups fail, we still allow guest checkout (customerUuid remains undefined)
+            }
+            const orderPayload = {
+                currency: processed.currency,
+                subtotal: processed.subtotal,
+                taxTotal: processed.taxTotal,
+                shippingTotal: processed.shippingTotal,
+                discountTotal: processed.discountTotal,
+                grandTotal: processed.total,
+                paymentIntentId: processed.paymentIntentId,
+                paymentMethodId: processed.paymentMethodId,
+                metadata: {
+                    // H2 fix: Merge hook-injected metadata (e.g., BNPL fee) before core fields
+                    ...(typeof processed.metadata === "object" && processed.metadata !== null
+                        ? processed.metadata
+                        : {}),
+                    cartId: processed.cartId,
+                    paymentIntentId: processed.paymentIntentId,
+                    checkoutId: processed.checkoutId,
+                    promotionCodes: processed.promotionCodes,
+                    appliedPromotions: processed.appliedPromotions,
+                    shippingAddress: processed.shippingAddress,
+                },
+                lineItems: processed.lineItems.map((lineItem) => {
+                    const payload = {
+                        entityId: lineItem.entityId,
+                        entityType: lineItem.entityType ?? "product",
+                        title: lineItem.title ?? lineItem.entityId,
+                        quantity: lineItem.quantity,
+                        unitPrice: lineItem.resolvedUnitPrice ?? 0,
+                        totalPrice: lineItem.resolvedTotal ?? 0,
+                    };
+                    return lineItem.variantId !== undefined
+                        ? { ...payload, variantId: lineItem.variantId }
+                        : payload;
+                }),
+                ...(customerUuid !== undefined
+                    ? { customerId: customerUuid }
+                    : {}),
+            };
+            const order = await kernel.services.orders.create(orderPayload, actor);
+            if (!order.ok) {
+                return c.json(mapErrorToResponse(order.error), mapErrorToStatus(order.error));
+            }
+            if (order.ok && (processed.appliedPromotions?.length ?? 0) > 0) {
+                await kernel.services.promotions.recordUsage({
+                    promotions: processed.appliedPromotions ?? [],
+                    orderId: order.value.id,
+                    ...(customerUuid !== undefined
+                        ? { customerId: customerUuid }
+                        : {}),
+                });
+            }
+            if (order.ok) {
+                await kernel.services.tax.reportTransaction({
+                    transactionId: order.value.id,
+                    transactionDate: new Date(),
+                    currency: processed.currency,
+                    amount: processed.subtotal -
+                        processed.discountTotal +
+                        processed.shippingTotal,
+                    shipping: processed.shippingTotal,
+                    salesTax: processed.taxTotal,
+                    lineItems: processed.lineItems.map((lineItem, index) => ({
+                        id: lineItem.id ?? `${order.value.id}-${index + 1}`,
+                        entityId: lineItem.entityId,
+                        description: lineItem.title ?? lineItem.entityId,
+                        quantity: lineItem.quantity,
+                        unitPrice: lineItem.resolvedUnitPrice ?? 0,
+                        ...(lineItem.discountAmount !== undefined
+                            ? { discount: lineItem.discountAmount }
+                            : {}),
+                    })),
+                    ...(customerUuid !== undefined
+                        ? { customerId: customerUuid }
+                        : {}),
+                    ...(processed.shippingAddress !== undefined
+                        ? { toAddress: processed.shippingAddress }
+                        : {}),
+                });
+            }
+            // Stash paymentMethodId for completeCheckout compensation chain
+            context.context.paymentMethodId = processed.paymentMethodId;
+            const afterReport = await runAfterHooks(afterHooks, null, order.value, "create", context);
+            await kernel.services.cart.markAsCheckedOut(body.cartId, actor);
+            return c.json({
+                data: {
+                    ...order.value,
+                    // Stripe Elements requires clientSecret to collect card details on the frontend
+                    ...(processed.paymentClientSecret
+                        ? { paymentClientSecret: processed.paymentClientSecret }
+                        : {}),
+                },
+                meta: afterReport.hasErrors
+                    ? { hookErrors: afterReport.errors }
+                    : undefined,
+            }, 201);
+        }
+        catch (error) {
+            // Always log the real error — hidden errors in checkout are unacceptable
+            const realMessage = error instanceof Error ? error.message : String(error);
+            const realStack = error instanceof Error ? error.stack : undefined;
+            console.error("[checkout] Pipeline failed:", { message: realMessage, stack: realStack, code: error?.code });
+            const message = isCommerceError(error)
+                ? error.message
+                : realMessage;
+            return c.json({
+                error: {
+                    code: "CHECKOUT_FAILED",
+                    message,
+                },
+            }, 422);
+        }
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/customers.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 customerRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=customers.d.ts.map

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

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

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

@@ -0,0 +1,78 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { listCustomersRoute, getCustomerRoute, updateCustomerRoute, getCustomerOrdersRoute, getCustomerAddressesRoute, } from "../schemas/customers.js";
+import { mapErrorToResponse, mapErrorToStatus, parsePagination, requirePerm } from "../utils.js";
+export function customerRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // All customer admin routes require authentication + customers:read
+    router.use("/*", requirePerm("customers:read"));
+    router.use("/", requirePerm("customers:read"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listCustomersRoute, async (c) => {
+        const actor = c.get("actor");
+        const { page, limit } = parsePagination(c.req.query());
+        const result = await kernel.services.customers.list(actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        const all = result.value;
+        const total = all.length;
+        const start = (page - 1) * limit;
+        const paged = all.slice(start, start + limit);
+        return c.json({
+            data: paged,
+            meta: {
+                pagination: { page, limit, total, totalPages: Math.ceil(total / limit) },
+            },
+        });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getCustomerRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const actor = c.get("actor");
+        const result = await kernel.services.customers.getById(id, actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // PATCH requires customers:update (checked in handler since middleware can't distinguish methods)
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateCustomerRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const body = c.req.valid("json");
+        const actor = c.get("actor");
+        // Strip undefined values — exactOptionalPropertyTypes requires omission, not undefined
+        const updates = {};
+        for (const [k, v] of Object.entries(body)) {
+            if (v !== undefined)
+                updates[k] = v;
+        }
+        const result = await kernel.services.customers.update(id, updates, 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(getCustomerOrdersRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const actor = c.get("actor");
+        const { page, limit } = parsePagination(c.req.query());
+        const status = c.req.query("status") || undefined;
+        const result = await kernel.services.orders.listByCustomer(id, { page, limit, ...(status ? { status } : {}) }, actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value.items, meta: { pagination: result.value.pagination } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getCustomerAddressesRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const actor = c.get("actor");
+        // Get customer first, then use their userId for address lookup
+        const customerResult = await kernel.services.customers.getById(id, actor);
+        if (!customerResult.ok)
+            return c.json(mapErrorToResponse(customerResult.error), mapErrorToStatus(customerResult.error));
+        const addressResult = await kernel.services.customers.getAddresses(customerResult.value.userId, actor);
+        if (!addressResult.ok)
+            return c.json(mapErrorToResponse(addressResult.error), mapErrorToStatus(addressResult.error));
+        return c.json({ data: addressResult.value });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/inventory.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 inventoryRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=inventory.d.ts.map

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

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