@voyantjs/promotions 0.28.3

package/README.md

@@ -0,0 +1,38 @@
+# @voyantjs/promotions
+
+Promotional offers for Voyant — auto-applied catalog discounts (badges, strikethrough prices), code-redeemed discounts at checkout, and audience- / market-scoped blanket discounts. Resolves issue #497.
+
+PR1 ships the schema + admin CRUD only. Catalog plane wiring lands in PR3, booking-engine integration in PR4. See `docs/architecture/promotions-architecture.md` for the full design.
+
+## Install
+
+```bash
+pnpm add @voyantjs/promotions
+```
+
+## Usage
+
+```typescript
+import { promotionsModule } from "@voyantjs/promotions"
+import { createApp } from "@voyantjs/hono"
+
+const app = createApp({
+  modules: [promotionsModule],
+  // ...
+})
+```
+
+## Exports
+
+| Entry | Description |
+| --- | --- |
+| `.` | Module export (`promotionsModule`, `promotionsHonoModule`) |
+| `./schema` | Drizzle tables (`promotionalOffers`, `promotionalOfferProducts`, `promotionalOfferRedemptions`) |
+| `./validation` | Zod schemas (insert / update / scope discriminator / conditions) |
+| `./routes` | Hono admin routes mounted at `/v1/admin/promotions/*` |
+| `./events` | `PROMOTION_CHANGED_EVENT` + payload types |
+| `./service` | `promotionsService` (CRUD + scope materialization) |
+
+## License
+
+Apache-2.0

package/dist/events.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Promotions domain events.
+ *
+ * Per docs/architecture/promotions-architecture.md §9.1.
+ *
+ * Emitted (after the service mutation commits) by every CRUD path that
+ * changes a field affecting projection or evaluation. Pure metadata-only
+ * edits (`description`, `metadata`) skip emission to avoid pointless
+ * reindex churn.
+ *
+ * The catalog bridge subscribes and dispatches per `affected.kind`:
+ *   - `products` → reindex the listed product IDs only.
+ *   - `all`      → reindex every owned product (used when the resolved
+ *                   product set would be too large to enumerate, or for
+ *                   `global`-scope offers).
+ *
+ * No `slices` variant: `IndexerService` (packages/catalog/src/services/
+ * indexer-service.ts:75) has `reindexEntity` (one entity, all slices) and
+ * `reindexEntityForSlice` (one entity, one slice) but no "reindex every
+ * product in this slice" helper. Slice-shaped scopes (`markets`,
+ * `audiences`) are resolved to product IDs at emission time, falling back
+ * to `all` when the resolved set would be unbounded.
+ */
+/** Stable string identifier for the event. */
+export declare const PROMOTION_CHANGED_EVENT: "promotion.changed";
+export type PromotionChangedSource = "created" | "updated" | "deleted" | "expired";
+export type PromotionChangedAffected = {
+    kind: "products";
+    productIds: string[];
+} | {
+    kind: "all";
+};
+export interface PromotionChangedEvent {
+    offerId: string;
+    source: PromotionChangedSource;
+    affected: PromotionChangedAffected;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,8CAA8C;AAC9C,eAAO,MAAM,uBAAuB,EAAG,mBAA4B,CAAA;AAEnE,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;AAElF,MAAM,MAAM,wBAAwB,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAA;AAEnG,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,sBAAsB,CAAA;IAC9B,QAAQ,EAAE,wBAAwB,CAAA;CACnC"}

package/dist/events.js

@@ -0,0 +1,25 @@
+/**
+ * Promotions domain events.
+ *
+ * Per docs/architecture/promotions-architecture.md §9.1.
+ *
+ * Emitted (after the service mutation commits) by every CRUD path that
+ * changes a field affecting projection or evaluation. Pure metadata-only
+ * edits (`description`, `metadata`) skip emission to avoid pointless
+ * reindex churn.
+ *
+ * The catalog bridge subscribes and dispatches per `affected.kind`:
+ *   - `products` → reindex the listed product IDs only.
+ *   - `all`      → reindex every owned product (used when the resolved
+ *                   product set would be too large to enumerate, or for
+ *                   `global`-scope offers).
+ *
+ * No `slices` variant: `IndexerService` (packages/catalog/src/services/
+ * indexer-service.ts:75) has `reindexEntity` (one entity, all slices) and
+ * `reindexEntityForSlice` (one entity, one slice) but no "reindex every
+ * product in this slice" helper. Slice-shaped scopes (`markets`,
+ * `audiences`) are resolved to product IDs at emission time, falling back
+ * to `all` when the resolved set would be unbounded.
+ */
+/** Stable string identifier for the event. */
+export const PROMOTION_CHANGED_EVENT = "promotion.changed";

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { Module } from "@voyantjs/core";
+import type { HonoModule } from "@voyantjs/hono/module";
+export type { PromotionsRoutes } from "./routes.js";
+export declare const promotionsModule: Module;
+export declare const promotionsHonoModule: HonoModule;
+export { PROMOTION_CHANGED_EVENT, type PromotionChangedAffected, type PromotionChangedEvent, type PromotionChangedSource, } from "./events.js";
+export { type NewPromotionalOffer, type NewPromotionalOfferProduct, type NewPromotionalOfferRedemption, type PromotionalOffer, type PromotionalOfferDiscountType, type PromotionalOfferProduct, type PromotionalOfferRedemption, promotionalOfferDiscountTypeEnum, promotionalOfferProducts, promotionalOfferRedemptions, promotionalOffers, } from "./schema.js";
+export { type OfferMutationRuntime, type PromotionsService, promotionsService, recomputeOfferLinks, resolveScopeProductIds, } from "./service.js";
+export { type InsertPromotionalOffer, type InsertPromotionalOfferInput, insertPromotionalOfferSchema, type PromotionalOfferConditions, type PromotionalOfferListQuery, type PromotionalOfferScope, type PromotionalOfferScopeKind, promotionalOfferConditionsSchema, promotionalOfferListQuerySchema, promotionalOfferScopeSchema, type UpdatePromotionalOffer, type UpdatePromotionalOfferInput, updatePromotionalOfferSchema, } from "./validation.js";
+export { BULK_REINDEX_SERVICE_KEY, type BulkReindexProductsInput, type BulkReindexProductsOutput, type BulkReindexProductsService, bulkReindexProductsWorkflow, promotionAffectedAllFilter, } from "./workflow-bulk-reindex.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAKvD,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,eAAO,MAAM,gBAAgB,EAAE,MAI9B,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,UAGlC,CAAA;AAED,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,GAC5B,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,6BAA6B,EAClC,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,gCAAgC,EAChC,wBAAwB,EACxB,2BAA2B,EAC3B,iBAAiB,GAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,4BAA4B,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,gCAAgC,EAChC,+BAA+B,EAC/B,2BAA2B,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,4BAA4B,GAC7B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,4BAA4B,CAAA"}

package/dist/index.js

@@ -0,0 +1,16 @@
+import { promotionsRoutes } from "./routes.js";
+import { bulkReindexProductsWorkflow, promotionAffectedAllFilter } from "./workflow-bulk-reindex.js";
+export const promotionsModule = {
+    name: "promotions",
+    workflows: [bulkReindexProductsWorkflow],
+    eventFilters: [promotionAffectedAllFilter],
+};
+export const promotionsHonoModule = {
+    module: promotionsModule,
+    adminRoutes: promotionsRoutes,
+};
+export { PROMOTION_CHANGED_EVENT, } from "./events.js";
+export { promotionalOfferDiscountTypeEnum, promotionalOfferProducts, promotionalOfferRedemptions, promotionalOffers, } from "./schema.js";
+export { promotionsService, recomputeOfferLinks, resolveScopeProductIds, } from "./service.js";
+export { insertPromotionalOfferSchema, promotionalOfferConditionsSchema, promotionalOfferListQuerySchema, promotionalOfferScopeSchema, updatePromotionalOfferSchema, } from "./validation.js";
+export { BULK_REINDEX_SERVICE_KEY, bulkReindexProductsWorkflow, promotionAffectedAllFilter, } from "./workflow-bulk-reindex.js";

package/dist/routes-shared.d.ts

@@ -0,0 +1,14 @@
+import type { EventBus } from "@voyantjs/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { Context } from "hono";
+export type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+        eventBus?: EventBus;
+    };
+};
+export declare function notFound(c: Context<Env>, message: string): Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">;
+//# sourceMappingURL=routes-shared.d.ts.map

package/dist/routes-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-shared.d.ts","sourceRoot":"","sources":["../src/routes-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,MAAM,GAAG,GAAG;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM;;gBAExD"}

package/dist/routes-shared.js

@@ -0,0 +1,3 @@
+export function notFound(c, message) {
+    return c.json({ error: message }, 404);
+}

package/dist/routes.d.ts

@@ -0,0 +1,345 @@
+/**
+ * Admin routes for promotions — mounted by the operator template at
+ * `/v1/admin/promotions/*` (staff-actor-gated by the parent app's
+ * middleware chain).
+ *
+ * PR1 ships CRUD only. Public storefront routes are exposed via the
+ * existing `/v1/public/products/:productId/offers` endpoints in
+ * `@voyantjs/storefront` once the storefront resolver is wired in PR4.
+ */
+import { type Env } from "./routes-shared.js";
+export declare const promotionsRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    slug: string;
+                    description: string | null;
+                    discountType: "percentage" | "fixed_amount";
+                    discountPercent: string | null;
+                    discountAmountCents: number | null;
+                    currency: string | null;
+                    scope: {
+                        kind: "global";
+                    } | {
+                        kind: "products";
+                        productIds: string[];
+                    } | {
+                        kind: "categories";
+                        categoryIds: string[];
+                    } | {
+                        kind: "destinations";
+                        destinationIds: string[];
+                    } | {
+                        kind: "markets";
+                        marketIds: string[];
+                    } | {
+                        kind: "audiences";
+                        audiences: ("staff" | "customer" | "partner" | "supplier")[];
+                    };
+                    conditions: {
+                        minPax?: number | undefined;
+                    };
+                    validFrom: string | null;
+                    validUntil: string | null;
+                    code: string | null;
+                    stackable: boolean;
+                    active: boolean;
+                    metadata: import("hono/utils/types").JSONValue;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+                total: number;
+                limit: number;
+                offset: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/": {
+        $post: {
+            input: {};
+            output: {
+                data: {
+                    active: boolean;
+                    code: string | null;
+                    metadata: import("hono/utils/types").JSONValue;
+                    id: string;
+                    description: string | null;
+                    name: string;
+                    slug: string;
+                    discountType: "percentage" | "fixed_amount";
+                    discountPercent: string | null;
+                    discountAmountCents: number | null;
+                    currency: string | null;
+                    scope: {
+                        kind: "global";
+                    } | {
+                        kind: "products";
+                        productIds: string[];
+                    } | {
+                        kind: "categories";
+                        categoryIds: string[];
+                    } | {
+                        kind: "destinations";
+                        destinationIds: string[];
+                    } | {
+                        kind: "markets";
+                        marketIds: string[];
+                    } | {
+                        kind: "audiences";
+                        audiences: ("staff" | "customer" | "partner" | "supplier")[];
+                    };
+                    conditions: {
+                        minPax?: number | undefined;
+                    };
+                    validFrom: string | null;
+                    validUntil: string | null;
+                    stackable: boolean;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    active: boolean;
+                    code: string | null;
+                    metadata: import("hono/utils/types").JSONValue;
+                    id: string;
+                    description: string | null;
+                    name: string;
+                    slug: string;
+                    discountType: "percentage" | "fixed_amount";
+                    discountPercent: string | null;
+                    discountAmountCents: number | null;
+                    currency: string | null;
+                    scope: {
+                        kind: "global";
+                    } | {
+                        kind: "products";
+                        productIds: string[];
+                    } | {
+                        kind: "categories";
+                        categoryIds: string[];
+                    } | {
+                        kind: "destinations";
+                        destinationIds: string[];
+                    } | {
+                        kind: "markets";
+                        marketIds: string[];
+                    } | {
+                        kind: "audiences";
+                        audiences: ("staff" | "customer" | "partner" | "supplier")[];
+                    };
+                    conditions: {
+                        minPax?: number | undefined;
+                    };
+                    validFrom: string | null;
+                    validUntil: string | null;
+                    stackable: boolean;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
+} & {
+    "/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    active: boolean;
+                    code: string | null;
+                    metadata: import("hono/utils/types").JSONValue;
+                    id: string;
+                    description: string | null;
+                    name: string;
+                    slug: string;
+                    discountType: "percentage" | "fixed_amount";
+                    discountPercent: string | null;
+                    discountAmountCents: number | null;
+                    currency: string | null;
+                    scope: {
+                        kind: "global";
+                    } | {
+                        kind: "products";
+                        productIds: string[];
+                    } | {
+                        kind: "categories";
+                        categoryIds: string[];
+                    } | {
+                        kind: "destinations";
+                        destinationIds: string[];
+                    } | {
+                        kind: "markets";
+                        marketIds: string[];
+                    } | {
+                        kind: "audiences";
+                        audiences: ("staff" | "customer" | "partner" | "supplier")[];
+                    };
+                    conditions: {
+                        minPax?: number | undefined;
+                    };
+                    validFrom: string | null;
+                    validUntil: string | null;
+                    stackable: boolean;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/:id/archive": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    active: boolean;
+                    code: string | null;
+                    metadata: import("hono/utils/types").JSONValue;
+                    id: string;
+                    description: string | null;
+                    name: string;
+                    slug: string;
+                    discountType: "percentage" | "fixed_amount";
+                    discountPercent: string | null;
+                    discountAmountCents: number | null;
+                    currency: string | null;
+                    scope: {
+                        kind: "global";
+                    } | {
+                        kind: "products";
+                        productIds: string[];
+                    } | {
+                        kind: "categories";
+                        categoryIds: string[];
+                    } | {
+                        kind: "destinations";
+                        destinationIds: string[];
+                    } | {
+                        kind: "markets";
+                        marketIds: string[];
+                    } | {
+                        kind: "audiences";
+                        audiences: ("staff" | "customer" | "partner" | "supplier")[];
+                    };
+                    conditions: {
+                        minPax?: number | undefined;
+                    };
+                    validFrom: string | null;
+                    validUntil: string | null;
+                    stackable: boolean;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 409;
+        };
+    };
+}, "/", "/:id">;
+export type PromotionsRoutes = typeof promotionsRoutes;
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,oBAAoB,CAAA;AAQvD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAgDzB,CAAA;AAEJ,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA"}

package/dist/routes.js

@@ -0,0 +1,55 @@
+/**
+ * Admin routes for promotions — mounted by the operator template at
+ * `/v1/admin/promotions/*` (staff-actor-gated by the parent app's
+ * middleware chain).
+ *
+ * PR1 ships CRUD only. Public storefront routes are exposed via the
+ * existing `/v1/public/products/:productId/offers` endpoints in
+ * `@voyantjs/storefront` once the storefront resolver is wired in PR4.
+ */
+import { parseJsonBody, parseQuery } from "@voyantjs/hono";
+import { Hono } from "hono";
+import { notFound } from "./routes-shared.js";
+import { promotionsService } from "./service.js";
+import { insertPromotionalOfferSchema, promotionalOfferListQuerySchema, updatePromotionalOfferSchema, } from "./validation.js";
+export const promotionsRoutes = new Hono()
+    .get("/", async (c) => {
+    const query = await parseQuery(c, promotionalOfferListQuerySchema);
+    return c.json(await promotionsService.listOffers(c.get("db"), query));
+})
+    .post("/", async (c) => c.json({
+    data: await promotionsService.createOffer(c.get("db"), await parseJsonBody(c, insertPromotionalOfferSchema), { eventBus: c.get("eventBus") }),
+}, 201))
+    .get("/:id", async (c) => {
+    const offer = await promotionsService.getOfferById(c.get("db"), c.req.param("id"));
+    return offer ? c.json({ data: offer }) : notFound(c, "Promotional offer not found");
+})
+    .patch("/:id", async (c) => {
+    const patch = await parseJsonBody(c, updatePromotionalOfferSchema);
+    const offer = await promotionsService.updateOffer(c.get("db"), c.req.param("id"), patch, {
+        eventBus: c.get("eventBus"),
+    });
+    return offer ? c.json({ data: offer }) : notFound(c, "Promotional offer not found");
+})
+    .post("/:id/archive", async (c) => {
+    const offer = await promotionsService.archiveOffer(c.get("db"), c.req.param("id"), {
+        eventBus: c.get("eventBus"),
+    });
+    return offer ? c.json({ data: offer }) : notFound(c, "Promotional offer not found");
+})
+    .delete("/:id", async (c) => {
+    try {
+        const result = await promotionsService.deleteOffer(c.get("db"), c.req.param("id"), {
+            eventBus: c.get("eventBus"),
+        });
+        return result ? c.json({ data: result }) : notFound(c, "Promotional offer not found");
+    }
+    catch (err) {
+        // `deleteOffer` throws when redemptions exist (the FK RESTRICT
+        // would otherwise surface a less helpful error). Translate to 409.
+        if (err instanceof Error && err.message.includes("redemption(s) exist")) {
+            return c.json({ error: err.message }, 409);
+        }
+        throw err;
+    }
+});