@porulle/core 0.1.0

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

@@ -0,0 +1,74 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { inventoryAdjustRoute, inventoryReserveRoute, inventoryReleaseRoute, createWarehouseRoute, inventoryCheckRoute, listWarehousesRoute, listInventoryLevelsRoute, } from "../schemas/inventory.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function inventoryRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // Inventory levels listing requires inventory:read
+    router.use("/levels", requirePerm("inventory:read"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listInventoryLevelsRoute, async (c) => {
+        const actor = c.get("actor");
+        const warehouseId = c.req.query("warehouseId");
+        const entityId = c.req.query("entityId");
+        const result = await kernel.services.inventory.listLevels({
+            ...(warehouseId ? { warehouseId } : {}),
+            ...(entityId ? { entityId } : {}),
+        }, 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(inventoryCheckRoute, async (c) => {
+        const entityIds = (c.req.query("entityIds") ?? "")
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+        const result = await kernel.services.inventory.checkMultiple(entityIds, 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(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.js";
+import { type AppEnv } from "../utils.js";
+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,4BAA4B,CAAC;AAGzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,gCAgFzC"}

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

@@ -0,0 +1,66 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { attachMediaRoute, getMediaRoute, deleteMediaRoute } from "../schemas/media.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+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 actor = c.get("actor");
+        const result = signed
+            ? await kernel.services.media.getSignedUrl(c.req.param("id"), undefined, actor)
+            : await kernel.services.media.getUrl(c.req.param("id"), actor);
+        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"), actor);
+        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, c.get("actor"));
+        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.js";
+import { type AppEnv } from "../utils.js";
+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,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAiE,MAAM,aAAa,CAAC;AAEzG,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,gCAwEzC"}

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

@@ -0,0 +1,64 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { changeOrderStatusRoute, listOrdersRoute, getOrderRoute, getOrderFulfillmentsRoute } from "../schemas/orders.js";
+import { isUUID, mapErrorToResponse, mapErrorToStatus, parsePagination } from "../utils.js";
+export function orderRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listOrdersRoute, async (c) => {
+        const pagination = parsePagination(c.req.query());
+        const status = c.req.query("status");
+        const result = await kernel.services.orders.list({
+            page: pagination.page,
+            limit: pagination.limit,
+            ...(status !== undefined ? { status } : {}),
+        }, c.get("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(getOrderRoute, async (c) => {
+        const idOrNumber = c.req.param("idOrNumber");
+        const result = isUUID(idOrNumber)
+            ? await kernel.services.orders.getById(idOrNumber, c.get("actor"))
+            : await kernel.services.orders.getByNumber(idOrNumber, 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.
+    router.openapi(changeOrderStatusRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.changeStatus({
+            orderId: c.req.param("id"),
+            newStatus: body.status,
+            ...(body.reason !== undefined ? { reason: body.reason } : {}),
+        }, 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(getOrderFulfillmentsRoute, async (c) => {
+        const orderId = c.req.param("id");
+        const actor = c.get("actor");
+        // Verify the order exists and the actor has access before returning fulfillments
+        const orderResult = isUUID(orderId)
+            ? await kernel.services.orders.getById(orderId, actor)
+            : await kernel.services.orders.getByNumber(orderId, actor);
+        if (!orderResult.ok)
+            return c.json(mapErrorToResponse(orderResult.error), mapErrorToStatus(orderResult.error));
+        const result = await kernel.services.fulfillment.getByOrderId(orderResult.value.id);
+        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/payments.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 paymentRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=payments.d.ts.map

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

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

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

@@ -0,0 +1,45 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { mapErrorToResponse, mapErrorToStatus } from "../utils.js";
+import { processedWebhookEvents } from "../../../modules/webhooks/schema.js";
+export function paymentRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.post("/webhook", async (c) => {
+        const result = await kernel.services.payments.verifyWebhook(c.req.raw);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        const event = result.value;
+        const db = kernel.database.db;
+        // Atomic idempotency: INSERT ... ON CONFLICT DO NOTHING ... RETURNING
+        // If the row already exists, RETURNING yields zero rows → duplicate.
+        // If the row is new, RETURNING yields one row → process the event.
+        // No TOCTOU race: the UNIQUE constraint on event_id is the single source of truth.
+        const [inserted] = await db
+            .insert(processedWebhookEvents)
+            .values({
+            eventId: event.id,
+            provider: "stripe",
+            eventType: event.type,
+        })
+            .onConflictDoNothing()
+            .returning({ id: processedWebhookEvents.id });
+        if (!inserted) {
+            // Row already existed — this is a duplicate delivery
+            return c.json({ data: { received: true, duplicate: true } });
+        }
+        // Process the event (first time only)
+        if (event.type === "payment_intent.succeeded") {
+            const data = event.data;
+            const metadata = data?.metadata;
+            if (typeof metadata?.orderId === "string") {
+                await kernel.services.orders.changeStatus({
+                    orderId: metadata.orderId,
+                    newStatus: "confirmed",
+                    reason: "stripe_webhook_payment_intent_succeeded",
+                }, null);
+            }
+        }
+        return c.json({ data: { received: true } });
+    });
+    return router;
+}

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

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

@@ -0,0 +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"}

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

@@ -0,0 +1,61 @@
+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 { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function pricingRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/prices", requirePerm("pricing:manage"));
+    // @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.
+    router.openapi(setBasePriceRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.pricing.setBasePrice(c.req.valid("json"), 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(listPricesRoute, async (c) => {
+        const entityId = c.req.query("entityId");
+        const variantId = c.req.query("variantId");
+        const currency = c.req.query("currency");
+        const customerGroupId = c.req.query("customerGroupId");
+        const actor = c.get("actor");
+        const result = await kernel.services.pricing.listPrices({
+            ...(entityId !== undefined ? { entityId } : {}),
+            ...(variantId !== undefined ? { variantId } : {}),
+            ...(currency !== undefined ? { currency } : {}),
+            ...(customerGroupId !== undefined ? { customerGroupId } : {}),
+        }, actor);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value });
+    });
+    router.use("/modifiers", requirePerm("pricing:manage"));
+    // @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.
+    router.openapi(createModifierRoute, async (c) => {
+        const actor = c.get("actor");
+        const input = c.req.valid("json");
+        if (input.entityId) {
+            const catalogRepo = new CatalogRepository(kernel.database.db);
+            const orgId = resolveOrgId(actor);
+            const entity = await catalogRepo.findEntityById(input.entityId);
+            if (!entity || entity.organizationId !== orgId) {
+                return c.json(mapErrorToResponse(new CommerceValidationError("entityId does not belong to this organization.")), 422);
+            }
+        }
+        const result = await kernel.services.pricing.createModifier(input, 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/promotions.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 promotionRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=promotions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promotions.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/promotions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAGzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAG7F,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,gCAuF7C"}

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

@@ -0,0 +1,76 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { rateLimiter } from "hono-rate-limiter";
+import { createPromotionRoute, validatePromotionRoute, deactivatePromotionRoute, listPromotionsRoute } from "../schemas/promotions.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+import { resolveOrgId } from "../../../auth/org.js";
+export function promotionRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // Rate limit promo code validation — prevents brute-force code enumeration
+    router.use("/validate", rateLimiter({
+        windowMs: 60 * 1000,
+        limit: 10,
+        keyGenerator: (c) => {
+            // Node.js Request has a socket property; Hono types it as unknown.
+            const socket = c.req.raw.socket;
+            return socket?.remoteAddress ?? "unknown";
+        },
+    }));
+    router.use("/", requirePerm("promotions:manage"));
+    // @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.
+    router.openapi(createPromotionRoute, async (c) => {
+        const body = c.req.valid("json");
+        const actor = c.get("actor");
+        const result = await kernel.services.promotions.create(body, actor);
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value }, 201);
+    });
+    // List promotions — supports ?status= filter (active/inactive/expired/scheduled)
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listPromotionsRoute, async (c) => {
+        const actor = c.get("actor");
+        const status = c.req.query("status");
+        const result = await kernel.services.promotions.list(status ? { status } : undefined, 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.
+    router.openapi(validatePromotionRoute, async (c) => {
+        const payload = c.req.valid("json");
+        const actor = c.get("actor");
+        const orgId = resolveOrgId(actor);
+        const result = await kernel.services.promotions.validate(payload.code, {
+            orgId,
+            currency: payload.currency,
+            subtotal: payload.subtotal,
+            lineItems: payload.lineItems,
+            ...(payload.customerId !== undefined ? { customerId: payload.customerId } : {}),
+            ...(payload.customerGroupIds !== undefined ? { customerGroupIds: payload.customerGroupIds } : {}),
+        });
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value });
+    });
+    router.use("/:id/deactivate", requirePerm("promotions:manage"));
+    // @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.
+    router.openapi(deactivatePromotionRoute, async (c) => {
+        const actor = c.get("actor");
+        const orgId = resolveOrgId(actor);
+        const result = await kernel.services.promotions.deactivate(orgId, c.req.param("id"));
+        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/search.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 searchRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/search.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,EAAwC,MAAM,aAAa,CAAC;AAEhF,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,gCA2E1C"}

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

@@ -0,0 +1,72 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { searchRoute, suggestRoute } from "../schemas/search.js";
+import { mapErrorToResponse, mapErrorToStatus } from "../utils.js";
+export function searchRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(searchRoute, async (c) => {
+        try {
+            const q = c.req.query("q") ?? "";
+            const type = c.req.query("type");
+            const category = c.req.query("category");
+            const brand = c.req.query("brand");
+            const status = c.req.query("status");
+            const page = Number.parseInt(c.req.query("page") ?? "1", 10);
+            const limit = Number.parseInt(c.req.query("limit") ?? "20", 10);
+            const facets = (c.req.query("facets") ?? "")
+                .split(",")
+                .map((facet) => facet.trim())
+                .filter(Boolean);
+            const result = await kernel.services.search.query({
+                query: q,
+                page,
+                limit,
+                filters: {
+                    ...(type ? { type } : {}),
+                    ...(category ? { category } : {}),
+                    ...(brand ? { brand } : {}),
+                    ...(status ? { status } : {}),
+                },
+                ...(facets.length > 0 ? { facets } : {}),
+            }, { 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.hits,
+                meta: {
+                    total: result.value.total,
+                    page: result.value.page,
+                    limit: result.value.limit,
+                    facets: result.value.facets,
+                },
+            });
+        }
+        catch (error) {
+            console.error("[search] Route handler failed:", error instanceof Error ? error.message : error);
+            return c.json({ data: [], meta: { total: 0, page: 1, limit: 20, facets: {} } });
+        }
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(suggestRoute, async (c) => {
+        try {
+            const prefix = c.req.query("prefix") ?? "";
+            const type = c.req.query("type");
+            const limit = Number.parseInt(c.req.query("limit") ?? "10", 10);
+            const result = await kernel.services.search.suggest({
+                prefix,
+                ...(type ? { type } : {}),
+                limit,
+            }, { 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 });
+        }
+        catch (error) {
+            console.error("[search] Suggest route failed:", error instanceof Error ? error.message : error);
+            return c.json({ data: [] });
+        }
+    });
+    return router;
+}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/webhooks.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,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCA2C3C"}

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

@@ -0,0 +1,39 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createWebhookEndpointRoute, listWebhookEndpointsRoute, deleteWebhookEndpointRoute } from "../schemas/webhooks.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function webhookRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/*", requirePerm("webhooks:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createWebhookEndpointRoute, async (c) => {
+        const body = c.req.valid("json");
+        // Generate a default secret if none provided (Zod schema marks it optional for API convenience)
+        if (!body.secret) {
+            body.secret = `whsec_${crypto.randomUUID().replace(/-/g, "")}`;
+        }
+        const actor = c.get("actor");
+        const result = await kernel.services.webhooks.createEndpoint(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(listWebhookEndpointsRoute, async (c) => {
+        const result = await kernel.services.webhooks.listEndpoints(c.get("actor"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        const sanitized = result.value.map(({ secret: _secret, ...rest }) => rest);
+        return c.json({ data: sanitized });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(deleteWebhookEndpointRoute, async (c) => {
+        const result = await kernel.services.webhooks.deleteEndpoint(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 } });
+    });
+    return router;
+}