@voyantjs/promotions 0.28.3

package/dist/validation.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Validation schemas for the promotions module.
+ *
+ * Per docs/architecture/promotions-architecture.md §3.2 (scope), §4.1 (offer
+ * fields), §11 (currency rules), §12.1 (conditions schema).
+ *
+ * The scope discriminated union is the source of truth for what an offer
+ * applies to; the materialized `promotional_offer_products` link table (§4.2)
+ * is rebuilt from it on every create / update.
+ */
+import { z } from "zod";
+export declare const promotionalOfferScopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"global">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"products">;
+    productIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"categories">;
+    categoryIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"destinations">;
+    destinationIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"markets">;
+    marketIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"audiences">;
+    audiences: z.ZodArray<z.ZodEnum<{
+        staff: "staff";
+        customer: "customer";
+        partner: "partner";
+        supplier: "supplier";
+    }>>;
+}, z.core.$strip>], "kind">;
+export type PromotionalOfferScope = z.infer<typeof promotionalOfferScopeSchema>;
+export type PromotionalOfferScopeKind = PromotionalOfferScope["kind"];
+export declare const promotionalOfferConditionsSchema: z.ZodObject<{
+    minPax: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PromotionalOfferConditions = z.infer<typeof promotionalOfferConditionsSchema>;
+export declare const insertPromotionalOfferSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    discountType: z.ZodEnum<{
+        percentage: "percentage";
+        fixed_amount: "fixed_amount";
+    }>;
+    discountPercent: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    discountAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    currency: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"global">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"products">;
+        productIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"categories">;
+        categoryIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"destinations">;
+        destinationIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"markets">;
+        marketIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"audiences">;
+        audiences: z.ZodArray<z.ZodEnum<{
+            staff: "staff";
+            customer: "customer";
+            partner: "partner";
+            supplier: "supplier";
+        }>>;
+    }, z.core.$strip>], "kind">;
+    conditions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        minPax: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    validFrom: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    validUntil: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stackable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    active: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const updatePromotionalOfferSchema: z.ZodObject<{
+    discountType: z.ZodOptional<z.ZodEnum<{
+        percentage: "percentage";
+        fixed_amount: "fixed_amount";
+    }>>;
+    scope: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"global">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"products">;
+        productIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"categories">;
+        categoryIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"destinations">;
+        destinationIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"markets">;
+        marketIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"audiences">;
+        audiences: z.ZodArray<z.ZodEnum<{
+            staff: "staff";
+            customer: "customer";
+            partner: "partner";
+            supplier: "supplier";
+        }>>;
+    }, z.core.$strip>], "kind">>;
+    name: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    discountPercent: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    discountAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    currency: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    conditions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        minPax: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    validFrom: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    validUntil: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stackable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    active: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const promotionalOfferListQuerySchema: z.ZodObject<{
+    active: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodTransform<boolean, "true" | "false">>>;
+    code: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export type InsertPromotionalOfferInput = z.input<typeof insertPromotionalOfferSchema>;
+export type InsertPromotionalOffer = z.infer<typeof insertPromotionalOfferSchema>;
+export type UpdatePromotionalOfferInput = z.input<typeof updatePromotionalOfferSchema>;
+export type UpdatePromotionalOffer = z.infer<typeof updatePromotionalOfferSchema>;
+export type PromotionalOfferListQuery = z.infer<typeof promotionalOfferListQuerySchema>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;2BAsBtC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC/E,MAAM,MAAM,yBAAyB,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAA;AAOrE,eAAO,MAAM,gCAAgC;;iBAK3C,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAqFzF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAmD,CAAA;AAE5F,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQxC,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;iBAQ1C,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACtF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACjF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACtF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACjF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA"}

package/dist/validation.js

@@ -0,0 +1,134 @@
+/**
+ * Validation schemas for the promotions module.
+ *
+ * Per docs/architecture/promotions-architecture.md §3.2 (scope), §4.1 (offer
+ * fields), §11 (currency rules), §12.1 (conditions schema).
+ *
+ * The scope discriminated union is the source of truth for what an offer
+ * applies to; the materialized `promotional_offer_products` link table (§4.2)
+ * is rebuilt from it on every create / update.
+ */
+import { z } from "zod";
+// ---------- Scope discriminated union (§3.2) ----------
+//
+// Audience literal inlined to avoid a back-edge from @voyantjs/promotions to
+// @voyantjs/catalog (where Visibility lives). A unit test pins the literal
+// set against catalog's Visibility export.
+const audienceLiteral = z.enum(["staff", "customer", "partner", "supplier"]);
+export const promotionalOfferScopeSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("global") }),
+    z.object({
+        kind: z.literal("products"),
+        productIds: z.array(z.string().min(1)).min(1),
+    }),
+    z.object({
+        kind: z.literal("categories"),
+        categoryIds: z.array(z.string().min(1)).min(1),
+    }),
+    z.object({
+        kind: z.literal("destinations"),
+        destinationIds: z.array(z.string().min(1)).min(1),
+    }),
+    z.object({
+        kind: z.literal("markets"),
+        marketIds: z.array(z.string().min(1)).min(1),
+    }),
+    z.object({
+        kind: z.literal("audiences"),
+        audiences: z.array(audienceLiteral).min(1),
+    }),
+]);
+// ---------- Conditions (§12.1) ----------
+//
+// Typed JSONB validated by Zod. Date validity stays on the offer header
+// (`validFrom` / `validUntil`) — not duplicated in `conditions` for v1.
+export const promotionalOfferConditionsSchema = z.object({
+    /** Minimum total travelers. Catalog-plane evaluation surfaces this as a
+     *  conditional offer when pax is unknown; checkout treats below-minimum
+     *  as a hard exclusion. */
+    minPax: z.number().int().positive().optional(),
+});
+// ---------- Discount type / value cross-field rule (§11) ----------
+//
+// `percentage` requires `discountPercent`; `fixed_amount` requires
+// `discountAmountCents` + `currency`. The other-flavor fields must be
+// null/undefined to prevent operator confusion.
+const discountTypeEnum = z.enum(["percentage", "fixed_amount"]);
+const baseOfferShape = {
+    name: z.string().min(1).max(200),
+    slug: z
+        .string()
+        .min(1)
+        .max(200)
+        .regex(/^[a-z0-9-]+$/, "slug must be lowercase alphanumeric with hyphens"),
+    description: z.string().nullable().optional(),
+    discountType: discountTypeEnum,
+    discountPercent: z.number().positive().max(100).nullable().optional(),
+    discountAmountCents: z.number().int().positive().nullable().optional(),
+    currency: z
+        .string()
+        .length(3)
+        .regex(/^[A-Z]{3}$/, "currency must be a 3-letter ISO 4217 code")
+        .nullable()
+        .optional(),
+    scope: promotionalOfferScopeSchema,
+    conditions: promotionalOfferConditionsSchema.optional().default({}),
+    validFrom: z.coerce.date().nullable().optional(),
+    validUntil: z.coerce.date().nullable().optional(),
+    /** Stored lowercase. Provided in any case at the API; lowercased before insert. */
+    code: z
+        .string()
+        .min(1)
+        .max(80)
+        .regex(/^[A-Za-z0-9_-]+$/, "code must be alphanumeric (with - or _)")
+        .nullable()
+        .optional(),
+    stackable: z.boolean().optional().default(false),
+    active: z.boolean().optional().default(true),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+};
+function applyDiscountTypeRules(schema) {
+    return schema
+        .refine((value) => {
+        if (value.discountType !== "percentage")
+            return true;
+        return (value.discountPercent != null &&
+            value.discountAmountCents == null &&
+            value.currency == null);
+    }, {
+        message: "percentage offers require `discountPercent` and must not set `discountAmountCents` or `currency`",
+        path: ["discountType"],
+    })
+        .refine((value) => {
+        if (value.discountType !== "fixed_amount")
+            return true;
+        return (value.discountAmountCents != null &&
+            value.currency != null &&
+            value.discountPercent == null);
+    }, {
+        message: "fixed_amount offers require `discountAmountCents` and `currency` and must not set `discountPercent`",
+        path: ["discountType"],
+    })
+        .refine((value) => {
+        if (value.validFrom == null || value.validUntil == null)
+            return true;
+        return value.validFrom < value.validUntil;
+    }, { message: "`validFrom` must be earlier than `validUntil`", path: ["validFrom"] });
+}
+export const insertPromotionalOfferSchema = applyDiscountTypeRules(z.object(baseOfferShape));
+export const updatePromotionalOfferSchema = applyDiscountTypeRules(z.object({
+    ...baseOfferShape,
+    discountType: discountTypeEnum.optional(),
+    scope: promotionalOfferScopeSchema.optional(),
+    name: baseOfferShape.name.optional(),
+    slug: baseOfferShape.slug.optional(),
+}));
+export const promotionalOfferListQuerySchema = z.object({
+    active: z
+        .union([z.literal("true"), z.literal("false")])
+        .transform((v) => v === "true")
+        .optional(),
+    code: z.string().min(1).max(80).optional(),
+    limit: z.coerce.number().int().positive().max(200).optional().default(50),
+    offset: z.coerce.number().int().nonnegative().optional().default(0),
+});

package/dist/workflow-bulk-reindex.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bulk-reindex workflow + event filter for `affected.kind === "all"`.
+ *
+ * The `promotion.changed` payload's `affected` is a discriminated union:
+ *   - `{ kind: "products", productIds }` — small, bounded set; the catalog
+ *     bridge reindexes inline on the in-process EventBus subscriber.
+ *   - `{ kind: "all" }` — every owned product (global / market / audience-
+ *     scoped offers). Inline enumeration would burn the request handler's
+ *     CPU budget on a sizeable catalog, so this branch routes through a
+ *     workflow that breaks the work into one step per product. The
+ *     orchestrator schedules them in parallel so each individual step stays
+ *     inside Worker CPU limits.
+ *
+ * The workflow body delegates catalog access to a service the operator
+ * template registers under `BULK_REINDEX_SERVICE_KEY`. The promotions
+ * package stays catalog-agnostic: it knows nothing about Typesense / index
+ * slices / document builders. The seam is the same one used elsewhere in
+ * the codebase for cross-module behavior (workflow → ctx.services.resolve).
+ */
+import { type PromotionChangedSource } from "./events.js";
+/**
+ * Service-container key the operator template registers a concrete
+ * implementation against. Kept stable + exported so consumers don't have
+ * to repeat the magic string.
+ */
+export declare const BULK_REINDEX_SERVICE_KEY: "promotions:bulk-reindex-products";
+/**
+ * Contract the operator template implements. The workflow body resolves
+ * this from `ctx.services` and calls into it from steps.
+ *
+ * Two methods so the workflow can split enumeration from per-product
+ * reindex — that's what makes the parallel-step pattern viable on edge
+ * runtime. A single `reindexAllProducts()` would have to do everything in
+ * one step, which is what we're trying to avoid.
+ */
+export interface BulkReindexProductsService {
+    listAllProductIds(): Promise<string[]>;
+    reindexProduct(productId: string): Promise<void>;
+}
+export interface BulkReindexProductsInput {
+    /** The offer that triggered the reindex (for logging / correlation). */
+    offerId: string;
+    source: PromotionChangedSource;
+}
+export interface BulkReindexProductsOutput {
+    reindexed: number;
+}
+export declare const bulkReindexProductsWorkflow: import("@voyantjs/workflows").WorkflowDefinition<BulkReindexProductsInput, BulkReindexProductsOutput>;
+/**
+ * Routes `promotion.changed` envelopes whose `affected.kind === "all"` into
+ * the workflow above. Other shapes (`{ kind: "products", productIds }`) fall
+ * through to the in-process catalog-bridge subscriber.
+ */
+export declare const promotionAffectedAllFilter: import("@voyantjs/workflows/events").EventFilterRuntimeEntry;
+//# sourceMappingURL=workflow-bulk-reindex.d.ts.map

package/dist/workflow-bulk-reindex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-bulk-reindex.d.ts","sourceRoot":"","sources":["../src/workflow-bulk-reindex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EAA2B,KAAK,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAElF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,EAAG,kCAA2C,CAAA;AAEnF;;;;;;;;GAQG;AACH,MAAM,WAAW,0BAA0B;IACzC,iBAAiB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACtC,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjD;AAED,MAAM,WAAW,wBAAwB;IACvC,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,sBAAsB,CAAA;CAC/B;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAA;CAClB;AAKD,eAAO,MAAM,2BAA2B,uGAuBtC,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,8DAYtC,CAAA"}

package/dist/workflow-bulk-reindex.js

@@ -0,0 +1,58 @@
+/**
+ * Bulk-reindex workflow + event filter for `affected.kind === "all"`.
+ *
+ * The `promotion.changed` payload's `affected` is a discriminated union:
+ *   - `{ kind: "products", productIds }` — small, bounded set; the catalog
+ *     bridge reindexes inline on the in-process EventBus subscriber.
+ *   - `{ kind: "all" }` — every owned product (global / market / audience-
+ *     scoped offers). Inline enumeration would burn the request handler's
+ *     CPU budget on a sizeable catalog, so this branch routes through a
+ *     workflow that breaks the work into one step per product. The
+ *     orchestrator schedules them in parallel so each individual step stays
+ *     inside Worker CPU limits.
+ *
+ * The workflow body delegates catalog access to a service the operator
+ * template registers under `BULK_REINDEX_SERVICE_KEY`. The promotions
+ * package stays catalog-agnostic: it knows nothing about Typesense / index
+ * slices / document builders. The seam is the same one used elsewhere in
+ * the codebase for cross-module behavior (workflow → ctx.services.resolve).
+ */
+import { trigger, workflow } from "@voyantjs/workflows";
+import { PROMOTION_CHANGED_EVENT } from "./events.js";
+/**
+ * Service-container key the operator template registers a concrete
+ * implementation against. Kept stable + exported so consumers don't have
+ * to repeat the magic string.
+ */
+export const BULK_REINDEX_SERVICE_KEY = "promotions:bulk-reindex-products";
+/** Cap on concurrent per-product reindex steps to avoid hammering the index. */
+const REINDEX_CONCURRENCY = 8;
+export const bulkReindexProductsWorkflow = workflow({
+    id: "promotions.reindex-all-products",
+    defaultRuntime: "edge",
+    async run(_input, ctx) {
+        const svc = ctx.services.resolve(BULK_REINDEX_SERVICE_KEY);
+        const ids = await ctx.step("list-product-ids", async () => svc.listAllProductIds());
+        if (ids.length === 0)
+            return { reindexed: 0 };
+        await ctx.parallel(ids, async (productId) => ctx.step(`reindex:${productId}`, async () => {
+            await svc.reindexProduct(productId);
+        }), { concurrency: REINDEX_CONCURRENCY });
+        return { reindexed: ids.length };
+    },
+});
+/**
+ * Routes `promotion.changed` envelopes whose `affected.kind === "all"` into
+ * the workflow above. Other shapes (`{ kind: "products", productIds }`) fall
+ * through to the in-process catalog-bridge subscriber.
+ */
+export const promotionAffectedAllFilter = trigger.on(PROMOTION_CHANGED_EVENT, {
+    target: bulkReindexProductsWorkflow,
+    where: { eq: [{ path: "data.affected.kind" }, { lit: "all" }] },
+    input: {
+        object: {
+            offerId: { path: "data.offerId" },
+            source: { path: "data.source" },
+        },
+    },
+});

package/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "@voyantjs/promotions",
+  "version": "0.28.3",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./schema": "./src/schema.ts",
+    "./validation": "./src/validation.ts",
+    "./routes": "./src/routes.ts",
+    "./events": "./src/events.ts",
+    "./service": "./src/service.ts",
+    "./service-catalog-plane-promotions": "./src/service-catalog-plane-promotions.ts",
+    "./service-boundary-scheduler": "./src/service-boundary-scheduler.ts",
+    "./service-catalog-evaluator": "./src/service-catalog-evaluator.ts",
+    "./service-booking-confirmed": "./src/service-booking-confirmed.ts",
+    "./service-storefront": "./src/service-storefront.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "@voyantjs/catalog": "workspace:*",
+    "@voyantjs/core": "workspace:*",
+    "@voyantjs/db": "workspace:*",
+    "@voyantjs/hono": "workspace:*",
+    "@voyantjs/products": "workspace:*",
+    "@voyantjs/storefront": "workspace:*",
+    "@voyantjs/workflows": "workspace:*",
+    "drizzle-orm": "^0.45.2",
+    "hono": "^4.12.10",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@voyantjs/voyant-test-utils": "workspace:*",
+    "@voyantjs/voyant-typescript-config": "workspace:*",
+    "typescript": "^6.0.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "./schema": {
+        "types": "./dist/schema.d.ts",
+        "import": "./dist/schema.js",
+        "default": "./dist/schema.js"
+      },
+      "./validation": {
+        "types": "./dist/validation.d.ts",
+        "import": "./dist/validation.js",
+        "default": "./dist/validation.js"
+      },
+      "./routes": {
+        "types": "./dist/routes.d.ts",
+        "import": "./dist/routes.js",
+        "default": "./dist/routes.js"
+      },
+      "./events": {
+        "types": "./dist/events.d.ts",
+        "import": "./dist/events.js",
+        "default": "./dist/events.js"
+      },
+      "./service": {
+        "types": "./dist/service.d.ts",
+        "import": "./dist/service.js",
+        "default": "./dist/service.js"
+      },
+      "./service-catalog-plane-promotions": {
+        "types": "./dist/service-catalog-plane-promotions.d.ts",
+        "import": "./dist/service-catalog-plane-promotions.js",
+        "default": "./dist/service-catalog-plane-promotions.js"
+      },
+      "./service-boundary-scheduler": {
+        "types": "./dist/service-boundary-scheduler.d.ts",
+        "import": "./dist/service-boundary-scheduler.js",
+        "default": "./dist/service-boundary-scheduler.js"
+      },
+      "./service-catalog-evaluator": {
+        "types": "./dist/service-catalog-evaluator.d.ts",
+        "import": "./dist/service-catalog-evaluator.js",
+        "default": "./dist/service-catalog-evaluator.js"
+      },
+      "./service-booking-confirmed": {
+        "types": "./dist/service-booking-confirmed.d.ts",
+        "import": "./dist/service-booking-confirmed.js",
+        "default": "./dist/service-booking-confirmed.js"
+      },
+      "./service-storefront": {
+        "types": "./dist/service-storefront.d.ts",
+        "import": "./dist/service-storefront.js",
+        "default": "./dist/service-storefront.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/promotions"
+  },
+  "voyant": {
+    "schema": "./schema",
+    "requiresSchemas": [
+      "@voyantjs/db"
+    ]
+  }
+}