@unifiedcommerce/core 0.4.4 → 0.4.5

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;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,gCAmD3C"}

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

@@ -0,0 +1,48 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+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 result = await kernel.services.pricing.listPrices({
+            ...(entityId !== undefined ? { entityId } : {}),
+            ...(variantId !== undefined ? { variantId } : {}),
+            ...(currency !== undefined ? { currency } : {}),
+            ...(customerGroupId !== undefined ? { customerGroupId } : {}),
+        });
+        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 result = await kernel.services.pricing.createModifier(c.req.valid("json"), 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;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAG7F,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,gCAqF7C"}

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, listActivePromotionsRoute } 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 active promotions — requires auth
+    router.use("/active", requirePerm("promotions:read"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listActivePromotionsRoute, async (_c) => {
+        const actor = _c.get("actor");
+        const result = await kernel.services.promotions.listActive(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,gCAiE1C"}

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

@@ -0,0 +1,60 @@
+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) => {
+        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,
+            },
+        });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(suggestRoute, async (c) => {
+        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 });
+    });
+    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,gCAwC3C"}

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();
+        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"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: { deleted: true } });
+    });
+    return router;
+}

package/dist/interfaces/rest/schemas/admin-jobs.d.ts

@@ -0,0 +1,327 @@
+import { z } from "@hono/zod-openapi";
+export declare const listFailedJobsRoute: {
+    method: "get";
+    path: "/jobs/failed";
+    tags: string[];
+    summary: string;
+    request: {
+        query: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodArray<import("drizzle-zod").BuildSchema<"select", {
+                            id: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "id";
+                                tableName: "commerce_jobs";
+                                dataType: "string";
+                                columnType: "PgUUID";
+                                data: string;
+                                driverParam: string;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: true;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            organizationId: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "organization_id";
+                                tableName: "commerce_jobs";
+                                dataType: "string";
+                                columnType: "PgText";
+                                data: string;
+                                driverParam: string;
+                                notNull: true;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: [string, ...string[]];
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            queue: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "queue";
+                                tableName: "commerce_jobs";
+                                dataType: "string";
+                                columnType: "PgText";
+                                data: string;
+                                driverParam: string;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: [string, ...string[]];
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            taskSlug: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "task_slug";
+                                tableName: "commerce_jobs";
+                                dataType: "string";
+                                columnType: "PgText";
+                                data: string;
+                                driverParam: string;
+                                notNull: true;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: [string, ...string[]];
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            input: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "input";
+                                tableName: "commerce_jobs";
+                                dataType: "json";
+                                columnType: "PgJsonb";
+                                data: unknown;
+                                driverParam: unknown;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            output: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "output";
+                                tableName: "commerce_jobs";
+                                dataType: "json";
+                                columnType: "PgJsonb";
+                                data: unknown;
+                                driverParam: unknown;
+                                notNull: false;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            status: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "status";
+                                tableName: "commerce_jobs";
+                                dataType: "string";
+                                columnType: "PgText";
+                                data: "pending" | "processing" | "succeeded" | "failed";
+                                driverParam: string;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: ["pending", "processing", "succeeded", "failed"];
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            attempts: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "attempts";
+                                tableName: "commerce_jobs";
+                                dataType: "number";
+                                columnType: "PgInteger";
+                                data: number;
+                                driverParam: string | number;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "max_attempts";
+                                tableName: "commerce_jobs";
+                                dataType: "number";
+                                columnType: "PgInteger";
+                                data: number;
+                                driverParam: string | number;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            error: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "error";
+                                tableName: "commerce_jobs";
+                                dataType: "string";
+                                columnType: "PgText";
+                                data: string;
+                                driverParam: string;
+                                notNull: false;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: [string, ...string[]];
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            waitUntil: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "wait_until";
+                                tableName: "commerce_jobs";
+                                dataType: "date";
+                                columnType: "PgTimestamp";
+                                data: Date;
+                                driverParam: string;
+                                notNull: false;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            concurrencyKey: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "concurrency_key";
+                                tableName: "commerce_jobs";
+                                dataType: "string";
+                                columnType: "PgText";
+                                data: string;
+                                driverParam: string;
+                                notNull: false;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: [string, ...string[]];
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "created_at";
+                                tableName: "commerce_jobs";
+                                dataType: "date";
+                                columnType: "PgTimestamp";
+                                data: Date;
+                                driverParam: string;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "updated_at";
+                                tableName: "commerce_jobs";
+                                dataType: "date";
+                                columnType: "PgTimestamp";
+                                data: Date;
+                                driverParam: string;
+                                notNull: true;
+                                hasDefault: true;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            processingStartedAt: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "processing_started_at";
+                                tableName: "commerce_jobs";
+                                dataType: "date";
+                                columnType: "PgTimestamp";
+                                data: Date;
+                                driverParam: string;
+                                notNull: false;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                            completedAt: import("drizzle-orm/pg-core").PgColumn<{
+                                name: "completed_at";
+                                tableName: "commerce_jobs";
+                                dataType: "date";
+                                columnType: "PgTimestamp";
+                                data: Date;
+                                driverParam: string;
+                                notNull: false;
+                                hasDefault: false;
+                                isPrimaryKey: false;
+                                isAutoincrement: false;
+                                hasRuntimeDefault: false;
+                                enumValues: undefined;
+                                baseColumn: never;
+                                identity: undefined;
+                                generated: undefined;
+                            }, {}, {}>;
+                        }, undefined, undefined>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/jobs/failed";
+};
+export declare const retryJobRoute: {
+    method: "post";
+    path: "/jobs/{id}/retry";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodObject<{
+                            retried: z.ZodLiteral<true>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/jobs/:id/retry";
+};
+//# sourceMappingURL=admin-jobs.d.ts.map

package/dist/interfaces/rest/schemas/admin-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-jobs.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/schemas/admin-jobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAKnD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB9B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBxB,CAAC"}

package/dist/interfaces/rest/schemas/admin-jobs.js

@@ -0,0 +1,37 @@
+import { z, createRoute } from "@hono/zod-openapi";
+import { JobListResponse } from "./responses.js";
+// ─── Route Definitions ──────────────────────────────────────────────────────
+export const listFailedJobsRoute = createRoute({
+    method: "get",
+    path: "/jobs/failed",
+    tags: ["Admin Jobs"],
+    summary: "List failed jobs",
+    request: {
+        query: z.object({
+            limit: z.string().optional(),
+        }),
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: JobListResponse } },
+            description: "Failed jobs",
+        },
+    },
+});
+export const retryJobRoute = createRoute({
+    method: "post",
+    path: "/jobs/{id}/retry",
+    tags: ["Admin Jobs"],
+    summary: "Retry a failed job",
+    request: {
+        params: z.object({
+            id: z.string().min(1).openapi({ example: "job-uuid" }),
+        }),
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.object({ data: z.object({ retried: z.literal(true) }) }) } },
+            description: "Job retried",
+        },
+    },
+});