@unifiedcommerce/core 0.0.1

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

@@ -0,0 +1,256 @@
+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";
+import { mapErrorToResponse, mapErrorToStatus, parseInclude, parsePagination, parseSort, } from "../utils";
+export function catalogRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listEntitiesRoute, async (c) => {
+        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,
+            },
+        });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getEntityRoute, async (c) => {
+        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 });
+    });
+    // @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"));
+        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"));
+        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"));
+        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"));
+        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"));
+        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";
+import { type AppEnv } from "../utils";
+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,yBAAyB,CAAC;AAmBtD,OAAO,EAAE,KAAK,MAAM,EAAwC,MAAM,UAAU,CAAC;AAK7E,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,gCAiQ5C"}

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

@@ -0,0 +1,216 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { checkoutRoute } from "../schemas/checkout";
+import { applyPromotionCodes, authorizePayment, calculateShipping, calculateTax, checkInventoryAvailability, completeCheckout, recordAnalyticsEvent, resolveCurrentPrices, validateCartNotEmpty, validatePaymentMethod, } from "../../../hooks/checkout";
+import { runAfterHooks, runBeforeHooks } from "../../../kernel/hooks/executor";
+import { createHookContext } from "../../../kernel/hooks/create-context";
+import { mapErrorToResponse, mapErrorToStatus } from "../utils";
+import { isCommerceError } from "../../../kernel/errors";
+import { makeId } from "../../../utils/id";
+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",
+            kernel: kernel,
+        });
+        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) {
+            const message = isCommerceError(error)
+                ? error.message
+                : "Checkout failed.";
+            return c.json({
+                error: {
+                    code: "CHECKOUT_FAILED",
+                    message,
+                },
+            }, 422);
+        }
+    });
+    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";
+import { type AppEnv } from "../utils";
+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,yBAAyB,CAAC;AAStD,OAAO,EAAE,KAAK,MAAM,EAAwC,MAAM,UAAU,CAAC;AAE7E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,gCAyD7C"}

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

@@ -0,0 +1,59 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { inventoryAdjustRoute, inventoryReserveRoute, inventoryReleaseRoute, createWarehouseRoute, inventoryCheckRoute, listWarehousesRoute, } from "../schemas/inventory";
+import { mapErrorToResponse, mapErrorToStatus } from "../utils";
+export function inventoryRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(inventoryCheckRoute, async (c) => {
+        const entityIds = (c.req.query("entityIds") ?? "")
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+        const result = await kernel.services.inventory.checkMultiple(entityIds);
+        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(inventoryAdjustRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.inventory.adjust(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(inventoryReserveRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.inventory.reserve(body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { reserved: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(inventoryReleaseRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.inventory.release(body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { released: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createWarehouseRoute, async (c) => {
+        const body = c.req.valid("json");
+        const actor = c.get("actor");
+        const result = await kernel.services.inventory.createWarehouse(body, 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(listWarehousesRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.inventory.listWarehouses(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/media.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/media.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAGtD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,UAAU,CAAC;AAE1F,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,gCA+EzC"}

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

@@ -0,0 +1,65 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { attachMediaRoute, getMediaRoute, deleteMediaRoute } from "../schemas/media";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils";
+export function mediaRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // Upload requires authentication + media:write permission
+    router.use("/upload", requirePerm("media:write"));
+    router.post("/upload", async (c) => {
+        const body = await c.req.parseBody();
+        const file = body.file;
+        if (!file) {
+            return c.json({ error: { code: "VALIDATION_FAILED", message: "file is required" } }, 422);
+        }
+        const buffer = await file.arrayBuffer();
+        const actor = c.get("actor");
+        const result = await kernel.services.media.upload({
+            filename: file.name,
+            contentType: file.type,
+            data: buffer,
+            alt: String(body.alt ?? ""),
+        }, actor);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value }, 201);
+    });
+    router.openapi(getMediaRoute, async (c) => {
+        const signed = c.req.query("signed") === "true";
+        // Signed URLs require authentication
+        if (signed && !c.get("actor")) {
+            return c.json({ error: { code: "UNAUTHORIZED", message: "Authentication required for signed URLs." } }, 401);
+        }
+        const result = signed
+            ? await kernel.services.media.getSignedUrl(c.req.param("id"))
+            : await kernel.services.media.getUrl(c.req.param("id"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.redirect(result.value, 302);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteMediaRoute, async (c) => {
+        const actor = c.get("actor");
+        if (!actor || (!actor.permissions.includes("media:write") && !actor.permissions.includes("*:*"))) {
+            return c.json({ error: { code: "FORBIDDEN", message: "media:write permission required." } }, 403);
+        }
+        const result = await kernel.services.media.delete(c.req.param("id"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: { deleted: true } });
+    });
+    // Attach requires media:write
+    router.use("/attach", requirePerm("media:write"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(attachMediaRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.media.attachToEntity(body);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: { attached: true } }, 201);
+    });
+    return router;
+}

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

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

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

@@ -0,0 +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,yBAAyB,CAAC;AAEtD,OAAO,EAAE,KAAK,MAAM,EAAiE,MAAM,UAAU,CAAC;AAEtG,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,gCAwEzC"}