@voyantjs/promotions 0.28.3

package/dist/service-storefront.js

@@ -0,0 +1,146 @@
+/**
+ * Storefront resolvers — populate the previously-empty
+ * `/v1/public/products/:productId/offers` and `/v1/public/offers/:slug`
+ * endpoints in `@voyantjs/storefront` with real data.
+ *
+ * Wire via:
+ *
+ *   const storefrontModule = createStorefrontHonoModule({
+ *     offers: createPromotionsStorefrontResolvers(),
+ *   })
+ *
+ * Per docs/architecture/promotions-architecture.md §8.
+ *
+ * V1 limitations:
+ *   - Storefront calls don't carry an audience / market in the request
+ *     context, so the resolver only filters by `products` + `global`
+ *     scopes (the catalog plane handles audience-scoped projection).
+ *     `markets` and `audiences` scoped offers don't appear in this
+ *     listing endpoint.
+ *   - Locale-aware offer names: the schema doesn't store translations
+ *     yet (single-locale offer names per §12.1); `locale` is accepted
+ *     but ignored. A `promotional_offer_translations` table mirrors
+ *     `destinations_translations` if/when needed.
+ *   - `applicableDepartureIds`: always empty per §12.7 — departure-
+ *     scoped offers aren't modelled in v1.
+ *   - Only auto-applied offers (no code) appear in `listApplicableOffers`;
+ *     code-gated offers are still queryable via `getOfferBySlug`.
+ */
+import { and, eq, inArray, isNull, lte, or, sql } from "drizzle-orm";
+import { promotionalOfferProducts, promotionalOffers } from "./schema.js";
+export function createPromotionsStorefrontResolvers() {
+    return {
+        async listApplicableOffers(input) {
+            const db = resolveDb(input);
+            if (!db)
+                return [];
+            const now = new Date();
+            // Active + currently-valid + auto-applied (no code) offers.
+            const baseRows = await db
+                .select()
+                .from(promotionalOffers)
+                .where(and(eq(promotionalOffers.active, true), isNull(promotionalOffers.code), or(isNull(promotionalOffers.validFrom), lte(promotionalOffers.validFrom, now)), or(isNull(promotionalOffers.validUntil), sql `${promotionalOffers.validUntil} >= ${now}`)));
+            if (baseRows.length === 0)
+                return [];
+            // Restrict to offers that match the product: either `global` scope
+            // (always matches) OR a product-shaped scope whose materialized
+            // link table contains this product.
+            const productLinkRows = await db
+                .select({ offerId: promotionalOfferProducts.offerId })
+                .from(promotionalOfferProducts)
+                .where(and(eq(promotionalOfferProducts.productId, input.productId), inArray(promotionalOfferProducts.offerId, baseRows.map((r) => r.id))));
+            const offersMatchingProduct = new Set(productLinkRows.map((r) => r.offerId));
+            const productLinkLookups = await loadApplicableProductIds(db, baseRows.map((r) => r.id));
+            const out = [];
+            for (const offer of baseRows) {
+                if (!matchesProduct(offer.scope, offersMatchingProduct.has(offer.id)))
+                    continue;
+                out.push(toStorefrontDto(offer, productLinkLookups.get(offer.id) ?? []));
+            }
+            return out;
+        },
+        async getOfferBySlug(input) {
+            const db = resolveDb(input);
+            if (!db)
+                return null;
+            const rows = await db
+                .select()
+                .from(promotionalOffers)
+                .where(and(eq(promotionalOffers.slug, input.slug), eq(promotionalOffers.active, true)))
+                .limit(1);
+            const offer = rows[0];
+            if (!offer)
+                return null;
+            const links = await loadApplicableProductIds(db, [offer.id]);
+            return toStorefrontDto(offer, links.get(offer.id) ?? []);
+        },
+    };
+}
+function resolveDb(input) {
+    return input.db ?? undefined;
+}
+function matchesProduct(scope, inLinkTable) {
+    switch (scope.kind) {
+        case "global":
+            return true;
+        case "products":
+        case "categories":
+        case "destinations":
+            return inLinkTable;
+        // markets / audiences scopes don't render via this endpoint in v1
+        // (no audience / market in the request context). They're still
+        // honored by the catalog projection (PR3) when products are indexed.
+        case "markets":
+        case "audiences":
+            return false;
+    }
+}
+async function loadApplicableProductIds(db, offerIds) {
+    if (offerIds.length === 0)
+        return new Map();
+    const rows = await db
+        .select({
+        offerId: promotionalOfferProducts.offerId,
+        productId: promotionalOfferProducts.productId,
+    })
+        .from(promotionalOfferProducts)
+        .where(inArray(promotionalOfferProducts.offerId, offerIds));
+    const out = new Map();
+    for (const row of rows) {
+        const list = out.get(row.offerId) ?? [];
+        list.push(row.productId);
+        out.set(row.offerId, list);
+    }
+    return out;
+}
+function toStorefrontDto(offer, applicableProductIds) {
+    return {
+        id: offer.id,
+        name: offer.name,
+        slug: offer.slug,
+        description: offer.description,
+        discountType: offer.discountType,
+        // The DTO carries `discountValue` as a string for both flavors.
+        // Percentage offers store the percent ("20"); fixed_amount offers
+        // store the cents amount as a string ("500" for $5.00).
+        discountValue: offer.discountType === "percentage"
+            ? (offer.discountPercent ?? "0")
+            : String(offer.discountAmountCents ?? 0),
+        currency: offer.currency,
+        applicableProductIds,
+        // V1: departure-scoped offers aren't modelled (per §12.7).
+        applicableDepartureIds: [],
+        validFrom: offer.validFrom?.toISOString() ?? null,
+        validTo: offer.validUntil?.toISOString() ?? null,
+        minTravelers: typeof offer.conditions === "object" && offer.conditions != null
+            ? (offer.conditions.minPax ?? null)
+            : null,
+        // V1: no merchandising images on offers (per §2 non-goals).
+        imageMobileUrl: null,
+        imageDesktopUrl: null,
+        stackable: offer.stackable,
+        createdAt: offer.createdAt.toISOString(),
+        updatedAt: offer.updatedAt.toISOString(),
+    };
+}
+export const __test__ = { matchesProduct, toStorefrontDto };

package/dist/service.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Promotions service — CRUD over `promotional_offers` plus link-table
+ * materialization for product-shaped scopes.
+ *
+ * Per docs/architecture/promotions-architecture.md §13 (PR1 scope):
+ *   - listOffers / getOfferById / createOffer / updateOffer / archiveOffer / deleteOffer
+ *   - recomputeOfferLinks (rebuilds `promotional_offer_products` from current scope)
+ *   - emit `promotion.changed` (when an `eventBus` is supplied via the runtime arg)
+ *
+ * The evaluator (PR2) and catalog-plane / booking-engine / scheduler wiring
+ * (PR3 + PR4 + PR3.boundary) are NOT in this PR.
+ *
+ * Cross-module reads:
+ *   - `categories` scope expands via `product_category_products` (in @voyantjs/products)
+ *   - `destinations` scope expands via `product_destinations` (in @voyantjs/products)
+ */
+import type { EventBus } from "@voyantjs/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type PromotionChangedSource } from "./events.js";
+import { type PromotionalOffer } from "./schema.js";
+import type { InsertPromotionalOffer, PromotionalOfferListQuery, PromotionalOfferScope, UpdatePromotionalOffer } from "./validation.js";
+export interface OfferMutationRuntime {
+    /**
+     * Optional event bus. When wired, every CRUD path emits
+     * `promotion.changed` so the catalog bridge reindexes affected products.
+     * Per docs/architecture/promotions-architecture.md §9.1.
+     */
+    eventBus?: EventBus;
+    /**
+     * Override the emission `source`. `createOffer` / `deleteOffer` default
+     * to `"created"` / `"deleted"`; `updateOffer` / `archiveOffer` default
+     * to `"updated"`. The boundary scheduler (PR3) overrides with
+     * `"expired"` for `validUntil` crossings.
+     */
+    source?: PromotionChangedSource;
+}
+/**
+ * Expand an offer's scope to the product set it covers. Used by
+ * `recomputeOfferLinks` and by the event emitter to populate
+ * `affected.productIds`.
+ *
+ * Returns `null` for slice-shaped scopes (`global`, `markets`, `audiences`)
+ * to signal that the link table should be empty AND that the event payload
+ * should fall back to `affected: { kind: "all" }` — these scopes can match
+ * an unbounded product set and we don't enumerate them at write time
+ * (per §9.1's resolution rules).
+ */
+export declare function resolveScopeProductIds(db: PostgresJsDatabase, scope: PromotionalOfferScope): Promise<string[] | null>;
+/**
+ * Rebuild the `promotional_offer_products` rows for an offer from its
+ * current scope. Idempotent: deletes any prior rows, inserts the
+ * freshly-resolved set. Slice-shaped scopes leave the table empty.
+ */
+export declare function recomputeOfferLinks(db: PostgresJsDatabase, offerId: string, scope: PromotionalOfferScope): Promise<{
+    productIds: string[] | null;
+}>;
+declare function listOffers(db: PostgresJsDatabase, query: PromotionalOfferListQuery): Promise<{
+    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: Date | null;
+        validUntil: Date | null;
+        code: string | null;
+        stackable: boolean;
+        active: boolean;
+        metadata: unknown;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+declare function getOfferById(db: PostgresJsDatabase, id: string): Promise<PromotionalOffer | null>;
+declare function createOffer(db: PostgresJsDatabase, input: InsertPromotionalOffer, runtime?: OfferMutationRuntime): Promise<PromotionalOffer>;
+declare function updateOffer(db: PostgresJsDatabase, id: string, patch: UpdatePromotionalOffer, runtime?: OfferMutationRuntime): Promise<PromotionalOffer | null>;
+declare function archiveOffer(db: PostgresJsDatabase, id: string, runtime?: OfferMutationRuntime): Promise<PromotionalOffer | null>;
+declare function deleteOffer(db: PostgresJsDatabase, id: string, runtime?: OfferMutationRuntime): Promise<{
+    id: string;
+} | null>;
+export declare const promotionsService: {
+    listOffers: typeof listOffers;
+    getOfferById: typeof getOfferById;
+    createOffer: typeof createOffer;
+    updateOffer: typeof updateOffer;
+    archiveOffer: typeof archiveOffer;
+    deleteOffer: typeof deleteOffer;
+    recomputeOfferLinks: typeof recomputeOfferLinks;
+    resolveScopeProductIds: typeof resolveScopeProductIds;
+};
+export type PromotionsService = typeof promotionsService;
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAG9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAIL,KAAK,sBAAsB,EAC5B,MAAM,aAAa,CAAA;AACpB,OAAO,EAEL,KAAK,gBAAgB,EAItB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,iBAAiB,CAAA;AAExB,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,sBAAsB,CAAA;CAChC;AAUD;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAyB1B;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,kBAAkB,EACtB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CAAE,CAAC,CAS1C;AA8ED,iBAAe,UAAU,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBjF;AAED,iBAAe,YAAY,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAOhG;AAED,iBAAe,WAAW,CACxB,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,sBAAsB,EAC7B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAa3B;AAED,iBAAe,WAAW,CACxB,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,sBAAsB,EAC7B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAsClC;AAED,iBAAe,YAAY,CACzB,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAgBlC;AAED,iBAAe,WAAW,CACxB,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAiChC;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;CAS7B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA"}

package/dist/service.js

@@ -0,0 +1,296 @@
+/**
+ * Promotions service — CRUD over `promotional_offers` plus link-table
+ * materialization for product-shaped scopes.
+ *
+ * Per docs/architecture/promotions-architecture.md §13 (PR1 scope):
+ *   - listOffers / getOfferById / createOffer / updateOffer / archiveOffer / deleteOffer
+ *   - recomputeOfferLinks (rebuilds `promotional_offer_products` from current scope)
+ *   - emit `promotion.changed` (when an `eventBus` is supplied via the runtime arg)
+ *
+ * The evaluator (PR2) and catalog-plane / booking-engine / scheduler wiring
+ * (PR3 + PR4 + PR3.boundary) are NOT in this PR.
+ *
+ * Cross-module reads:
+ *   - `categories` scope expands via `product_category_products` (in @voyantjs/products)
+ *   - `destinations` scope expands via `product_destinations` (in @voyantjs/products)
+ */
+import { productCategoryProducts, productDestinations } from "@voyantjs/products/schema";
+import { and, count, desc, eq, inArray, sql } from "drizzle-orm";
+import { PROMOTION_CHANGED_EVENT, } from "./events.js";
+import { promotionalOfferProducts, promotionalOfferRedemptions, promotionalOffers, } from "./schema.js";
+/** Fields whose change does NOT affect projection or evaluation — safe to skip emit. */
+const NON_PROJECTION_FIELDS = new Set(["description", "metadata"]);
+function shouldEmitForUpdate(patch) {
+    const keys = Object.keys(patch);
+    return keys.some((key) => !NON_PROJECTION_FIELDS.has(key));
+}
+/**
+ * Expand an offer's scope to the product set it covers. Used by
+ * `recomputeOfferLinks` and by the event emitter to populate
+ * `affected.productIds`.
+ *
+ * Returns `null` for slice-shaped scopes (`global`, `markets`, `audiences`)
+ * to signal that the link table should be empty AND that the event payload
+ * should fall back to `affected: { kind: "all" }` — these scopes can match
+ * an unbounded product set and we don't enumerate them at write time
+ * (per §9.1's resolution rules).
+ */
+export async function resolveScopeProductIds(db, scope) {
+    switch (scope.kind) {
+        case "products":
+            return [...new Set(scope.productIds)];
+        case "categories": {
+            if (scope.categoryIds.length === 0)
+                return [];
+            const rows = await db
+                .selectDistinct({ productId: productCategoryProducts.productId })
+                .from(productCategoryProducts)
+                .where(inArray(productCategoryProducts.categoryId, scope.categoryIds));
+            return rows.map((r) => r.productId);
+        }
+        case "destinations": {
+            if (scope.destinationIds.length === 0)
+                return [];
+            const rows = await db
+                .selectDistinct({ productId: productDestinations.productId })
+                .from(productDestinations)
+                .where(inArray(productDestinations.destinationId, scope.destinationIds));
+            return rows.map((r) => r.productId);
+        }
+        case "global":
+        case "markets":
+        case "audiences":
+            return null;
+    }
+}
+/**
+ * Rebuild the `promotional_offer_products` rows for an offer from its
+ * current scope. Idempotent: deletes any prior rows, inserts the
+ * freshly-resolved set. Slice-shaped scopes leave the table empty.
+ */
+export async function recomputeOfferLinks(db, offerId, scope) {
+    const productIds = await resolveScopeProductIds(db, scope);
+    await db.delete(promotionalOfferProducts).where(eq(promotionalOfferProducts.offerId, offerId));
+    if (productIds && productIds.length > 0) {
+        await db
+            .insert(promotionalOfferProducts)
+            .values(productIds.map((productId) => ({ offerId, productId })));
+    }
+    return { productIds };
+}
+function toAffected(productIds) {
+    if (productIds === null)
+        return { kind: "all" };
+    return { kind: "products", productIds };
+}
+function unionAffectedProductIds(previousProductIds, nextProductIds) {
+    if (previousProductIds === null || nextProductIds === null)
+        return null;
+    return [...new Set([...previousProductIds, ...nextProductIds])];
+}
+async function emitChange(runtime, payload) {
+    const eventBus = runtime.eventBus;
+    if (!eventBus)
+        return;
+    await eventBus.emit(PROMOTION_CHANGED_EVENT, payload, {
+        category: "domain",
+        source: "service",
+    });
+}
+function normalizeCode(code) {
+    if (code == null)
+        return null;
+    return code.toLowerCase();
+}
+function toRowValues(input) {
+    return {
+        name: input.name,
+        slug: input.slug,
+        description: input.description ?? null,
+        discountType: input.discountType,
+        discountPercent: input.discountPercent != null ? String(input.discountPercent) : null,
+        discountAmountCents: input.discountAmountCents ?? null,
+        currency: input.currency ?? null,
+        scope: input.scope,
+        conditions: input.conditions ?? {},
+        validFrom: input.validFrom ?? null,
+        validUntil: input.validUntil ?? null,
+        code: normalizeCode(input.code),
+        stackable: input.stackable ?? false,
+        active: input.active ?? true,
+        metadata: input.metadata ?? null,
+    };
+}
+function toUpdateValues(patch) {
+    const out = {
+        updatedAt: new Date(),
+    };
+    if (patch.name !== undefined)
+        out.name = patch.name;
+    if (patch.slug !== undefined)
+        out.slug = patch.slug;
+    if (patch.description !== undefined)
+        out.description = patch.description ?? null;
+    if (patch.discountType !== undefined)
+        out.discountType = patch.discountType;
+    if (patch.discountPercent !== undefined) {
+        out.discountPercent = patch.discountPercent != null ? String(patch.discountPercent) : null;
+    }
+    if (patch.discountAmountCents !== undefined) {
+        out.discountAmountCents = patch.discountAmountCents ?? null;
+    }
+    if (patch.currency !== undefined)
+        out.currency = patch.currency ?? null;
+    if (patch.scope !== undefined)
+        out.scope = patch.scope;
+    if (patch.conditions !== undefined)
+        out.conditions = patch.conditions;
+    if (patch.validFrom !== undefined)
+        out.validFrom = patch.validFrom ?? null;
+    if (patch.validUntil !== undefined)
+        out.validUntil = patch.validUntil ?? null;
+    if (patch.code !== undefined)
+        out.code = normalizeCode(patch.code);
+    if (patch.stackable !== undefined)
+        out.stackable = patch.stackable;
+    if (patch.active !== undefined)
+        out.active = patch.active;
+    if (patch.metadata !== undefined)
+        out.metadata = patch.metadata ?? null;
+    return out;
+}
+async function listOffers(db, query) {
+    const where = [];
+    if (query.active !== undefined)
+        where.push(eq(promotionalOffers.active, query.active));
+    if (query.code !== undefined)
+        where.push(eq(promotionalOffers.code, query.code.toLowerCase()));
+    const filter = where.length > 0 ? and(...where) : undefined;
+    const limit = query.limit ?? 50;
+    const offset = query.offset ?? 0;
+    const [totalRow] = await db
+        .select({ total: count() })
+        .from(promotionalOffers)
+        .where(filter ?? sql `true`);
+    const total = totalRow?.total ?? 0;
+    const data = await db
+        .select()
+        .from(promotionalOffers)
+        .where(filter ?? sql `true`)
+        .orderBy(desc(promotionalOffers.createdAt))
+        .limit(limit)
+        .offset(offset);
+    return { data, total, limit, offset };
+}
+async function getOfferById(db, id) {
+    const [row] = await db
+        .select()
+        .from(promotionalOffers)
+        .where(eq(promotionalOffers.id, id))
+        .limit(1);
+    return row ?? null;
+}
+async function createOffer(db, input, runtime = {}) {
+    const [row] = await db.insert(promotionalOffers).values(toRowValues(input)).returning();
+    if (!row)
+        throw new Error("createOffer: insert returned no row");
+    const { productIds } = await recomputeOfferLinks(db, row.id, input.scope);
+    await emitChange(runtime, {
+        offerId: row.id,
+        source: runtime.source ?? "created",
+        affected: toAffected(productIds),
+    });
+    return row;
+}
+async function updateOffer(db, id, patch, runtime = {}) {
+    const updateValues = toUpdateValues(patch);
+    const previousScope = patch.scope !== undefined && shouldEmitForUpdate(patch)
+        ? (await getOfferById(db, id))?.scope
+        : null;
+    if (patch.scope !== undefined && previousScope === undefined)
+        return null;
+    const [row] = await db
+        .update(promotionalOffers)
+        .set(updateValues)
+        .where(eq(promotionalOffers.id, id))
+        .returning();
+    if (!row)
+        return null;
+    // Re-materialize links if the scope changed. The link table reflects
+    // the current scope at all times, so any scope edit (including a
+    // category-id list edit) requires a rebuild.
+    let productIds;
+    if (patch.scope !== undefined) {
+        productIds = (await recomputeOfferLinks(db, id, patch.scope)).productIds;
+    }
+    else {
+        productIds = await resolveScopeProductIds(db, row.scope);
+    }
+    if (shouldEmitForUpdate(patch)) {
+        const affectedProductIds = patch.scope !== undefined && previousScope
+            ? unionAffectedProductIds(await resolveScopeProductIds(db, previousScope), productIds)
+            : productIds;
+        await emitChange(runtime, {
+            offerId: row.id,
+            source: runtime.source ?? "updated",
+            affected: toAffected(affectedProductIds),
+        });
+    }
+    return row;
+}
+async function archiveOffer(db, id, runtime = {}) {
+    const [row] = await db
+        .update(promotionalOffers)
+        .set({ active: false, updatedAt: new Date() })
+        .where(eq(promotionalOffers.id, id))
+        .returning();
+    if (!row)
+        return null;
+    const productIds = await resolveScopeProductIds(db, row.scope);
+    await emitChange(runtime, {
+        offerId: row.id,
+        source: runtime.source ?? "updated",
+        affected: toAffected(productIds),
+    });
+    return row;
+}
+async function deleteOffer(db, id, runtime = {}) {
+    // Check redemptions FIRST so the caller gets a clearer error than the raw
+    // FK-violation that the RESTRICT would surface from the delete attempt.
+    const [redemptionCountRow] = await db
+        .select({ total: count() })
+        .from(promotionalOfferRedemptions)
+        .where(eq(promotionalOfferRedemptions.offerId, id));
+    const redemptionCount = redemptionCountRow?.total ?? 0;
+    if (redemptionCount > 0) {
+        throw new Error(`cannot delete offer ${id}: ${redemptionCount} redemption(s) exist; archive (set active = false) instead`);
+    }
+    // Capture the resolved product set BEFORE delete so we can emit the
+    // affected list after CASCADE wipes `promotional_offer_products`.
+    const existing = await getOfferById(db, id);
+    if (!existing)
+        return null;
+    const productIds = await resolveScopeProductIds(db, existing.scope);
+    const [deleted] = await db
+        .delete(promotionalOffers)
+        .where(eq(promotionalOffers.id, id))
+        .returning({ id: promotionalOffers.id });
+    if (!deleted)
+        return null;
+    await emitChange(runtime, {
+        offerId: deleted.id,
+        source: runtime.source ?? "deleted",
+        affected: toAffected(productIds),
+    });
+    return deleted;
+}
+export const promotionsService = {
+    listOffers,
+    getOfferById,
+    createOffer,
+    updateOffer,
+    archiveOffer,
+    deleteOffer,
+    recomputeOfferLinks,
+    resolveScopeProductIds,
+};