@unifiedcommerce/core 0.0.1

package/src/modules/pricing/schema.ts

@@ -0,0 +1,71 @@
+import { index, integer, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema";
+import { sellableEntities, variants } from "../catalog/schema";
+
+export const prices = pgTable(
+  "prices",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "cascade" }),
+    entityId: uuid("entity_id")
+      .references(() => sellableEntities.id, { onDelete: "cascade" })
+      .notNull(),
+    variantId: uuid("variant_id").references(() => variants.id, { onDelete: "cascade" }),
+    currency: text("currency").notNull(),
+    amount: integer("amount").notNull(),
+    customerGroupId: text("customer_group_id"),
+    minQuantity: integer("min_quantity"),
+    maxQuantity: integer("max_quantity"),
+    validFrom: timestamp("valid_from", { withTimezone: true }),
+    validUntil: timestamp("valid_until", { withTimezone: true }),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    entityVariantCurrencyIdx: index("idx_prices_entity_variant_currency").on(
+      table.entityId,
+      table.variantId,
+      table.currency,
+    ),
+    customerGroupIdx: index("idx_prices_customer_group").on(table.customerGroupId),
+    quantityIdx: index("idx_prices_quantity").on(table.minQuantity, table.maxQuantity),
+    validityIdx: index("idx_prices_validity").on(table.validFrom, table.validUntil),
+    orgIdx: index("idx_prices_org").on(table.organizationId),
+  }),
+);
+
+export const priceModifiers = pgTable(
+  "price_modifiers",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    type: text("type", {
+      enum: ["percentage_discount", "fixed_discount", "markup", "override"],
+    }).notNull(),
+    value: integer("value").notNull(),
+    priority: integer("priority").notNull().default(100),
+    entityId: uuid("entity_id").references(() => sellableEntities.id, { onDelete: "cascade" }),
+    variantId: uuid("variant_id").references(() => variants.id, { onDelete: "cascade" }),
+    customerGroupId: text("customer_group_id"),
+    currency: text("currency").default("USD"),
+    minQuantity: integer("min_quantity"),
+    maxQuantity: integer("max_quantity"),
+    conditions: jsonb("conditions").$type<Record<string, unknown>>().default({}),
+    validFrom: timestamp("valid_from", { withTimezone: true }),
+    validUntil: timestamp("valid_until", { withTimezone: true }),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    entityVariantIdx: index("idx_price_modifiers_entity_variant").on(table.entityId, table.variantId),
+    priorityIdx: index("idx_price_modifiers_priority").on(table.priority),
+    orgIdx: index("idx_price_modifiers_org").on(table.organizationId),
+  }),
+);

package/src/modules/pricing/schemas.ts

@@ -0,0 +1,38 @@
+import { z } from "@hono/zod-openapi";
+
+// ─── Zod Body Schemas (single source of truth) ─────────────────────────────
+
+export const SetBasePriceBodySchema = z.object({
+  entityId: z.string().openapi({ example: "product-uuid" }),
+  variantId: z.string().optional().openapi({ example: "variant-uuid" }),
+  currency: z.string().length(3).openapi({ example: "USD" }),
+  amount: z.number().openapi({ example: 29.99 }),
+  customerGroupId: z.string().optional(),
+  minQuantity: z.number().int().optional(),
+  maxQuantity: z.number().int().optional(),
+  validFrom: z.coerce.date().optional(),
+  validUntil: z.coerce.date().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("SetBasePriceRequest");
+
+export const CreateModifierBodySchema = z.object({
+  name: z.string().openapi({ example: "Summer Sale" }),
+  type: z.enum(["percentage_discount", "fixed_discount", "markup", "override"]).openapi({ example: "percentage_discount" }),
+  value: z.number().openapi({ example: 10 }),
+  priority: z.number().int().optional(),
+  entityId: z.string().optional(),
+  variantId: z.string().optional(),
+  customerGroupId: z.string().optional(),
+  currency: z.string().length(3).optional().openapi({ example: "USD" }),
+  minQuantity: z.number().int().optional(),
+  maxQuantity: z.number().int().optional(),
+  conditions: z.record(z.string(), z.unknown()).optional(),
+  validFrom: z.coerce.date().optional(),
+  validUntil: z.coerce.date().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateModifierRequest");
+
+// ─── Derived Input Types ────────────────────────────────────────────────────
+
+export type SetBasePriceInput = z.infer<typeof SetBasePriceBodySchema>;
+export type CreatePriceModifierInput = z.infer<typeof CreateModifierBodySchema>;

package/src/modules/pricing/service.ts

@@ -0,0 +1,494 @@
+import { resolveOrgId } from "../../auth/org";
+import type { Actor } from "../../auth/types";
+import {
+  CommerceNotFoundError,
+  CommerceValidationError,
+} from "../../kernel/errors";
+import { Err, Ok, type Result } from "../../kernel/result";
+import type { TxContext } from "../../kernel/database/tx-context";
+import type {
+  PricingRepository,
+  Price,
+  PriceModifier,
+  PriceInsert,
+  PriceModifierInsert,
+} from "./repository";
+import type { CatalogRepository } from "../catalog/repository";
+
+// Re-export PriceModifierType from schema for external use
+export type PriceModifierType =
+  | "percentage_discount"
+  | "fixed_discount"
+  | "markup"
+  | "override";
+
+interface PricingServiceDeps {
+  repository: PricingRepository;
+  catalogRepository: CatalogRepository;
+}
+
+export interface PriceResolutionContext {
+  entityId: string;
+  variantId?: string;
+  currency: string;
+  quantity: number;
+  customerId?: string;
+  customerGroupIds?: string[];
+  timestamp?: Date;
+}
+
+export interface PriceBreakdownStep {
+  label: string;
+  amountBefore: number;
+  delta: number;
+  amountAfter: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ResolvedPrice {
+  baseAmount: number;
+  finalAmount: number;
+  currency: string;
+  appliedModifiers: Array<{
+    id: string;
+    name: string;
+    type: PriceModifierType;
+    delta: number;
+    value: number;
+    priority: number;
+  }>;
+  breakdown: PriceBreakdownStep[];
+  basePriceId: string;
+}
+
+export type { SetBasePriceInput, CreatePriceModifierInput } from "./schemas";
+import type { SetBasePriceInput, CreatePriceModifierInput } from "./schemas";
+
+function matchesQuantity(
+  min: number | null | undefined,
+  max: number | null | undefined,
+  quantity: number,
+): boolean {
+  if (min != null && quantity < min) return false;
+  if (max != null && quantity > max) return false;
+  return true;
+}
+
+function matchesWindow(
+  validFrom: Date | null | undefined,
+  validUntil: Date | null | undefined,
+  timestamp: Date,
+): boolean {
+  if (validFrom && timestamp < validFrom) return false;
+  if (validUntil && timestamp > validUntil) return false;
+  return true;
+}
+
+function durationScore(
+  validFrom: Date | null | undefined,
+  validUntil: Date | null | undefined,
+): number {
+  if (validFrom && validUntil)
+    return validUntil.getTime() - validFrom.getTime();
+  if (validFrom || validUntil) return Number.MAX_SAFE_INTEGER - 1;
+  return Number.MAX_SAFE_INTEGER;
+}
+
+function quantityRangeWidth(
+  min: number | null | undefined,
+  max: number | null | undefined,
+): number {
+  if (min != null && max != null) return Math.max(0, max - min);
+  if (min != null || max != null) return Number.MAX_SAFE_INTEGER - 1;
+  return Number.MAX_SAFE_INTEGER;
+}
+
+function compareBasePriceSpecificity(
+  a: Price,
+  b: Price,
+  context: PriceResolutionContext,
+): number {
+  const aVariant =
+    context.variantId !== undefined && a.variantId === context.variantId
+      ? 1
+      : 0;
+  const bVariant =
+    context.variantId !== undefined && b.variantId === context.variantId
+      ? 1
+      : 0;
+  if (aVariant !== bVariant) return bVariant - aVariant;
+
+  const hasGroupA = a.customerGroupId ? 1 : 0;
+  const hasGroupB = b.customerGroupId ? 1 : 0;
+  if (hasGroupA !== hasGroupB) return hasGroupB - hasGroupA;
+
+  const aRange = quantityRangeWidth(a.minQuantity, a.maxQuantity);
+  const bRange = quantityRangeWidth(b.minQuantity, b.maxQuantity);
+  if (aRange !== bRange) return aRange - bRange;
+
+  const aDuration = durationScore(a.validFrom, a.validUntil);
+  const bDuration = durationScore(b.validFrom, b.validUntil);
+  if (aDuration !== bDuration) return aDuration - bDuration;
+
+  return b.createdAt.getTime() - a.createdAt.getTime();
+}
+
+function resolveModifierDelta(
+  type: PriceModifierType,
+  value: number,
+  amountBefore: number,
+): number {
+  switch (type) {
+    case "percentage_discount":
+      return -Math.round((amountBefore * value) / 100);
+    case "fixed_discount":
+      return -value;
+    case "markup":
+      return value;
+    case "override":
+      return value - amountBefore;
+    default:
+      return 0;
+  }
+}
+
+function toGroupSet(context: PriceResolutionContext): Set<string> {
+  return new Set(context.customerGroupIds ?? []);
+}
+
+function normalizeCurrency(currency: string): string {
+  return currency.trim().toUpperCase();
+}
+
+export class PricingService {
+  private readonly repo: PricingRepository;
+  private readonly catalogRepo: CatalogRepository;
+
+  constructor(private deps: PricingServiceDeps) {
+    this.repo = deps.repository;
+    this.catalogRepo = deps.catalogRepository;
+  }
+
+  async setBasePrice(
+    input: SetBasePriceInput,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Price>> {
+    if (input.amount < 0) {
+      return Err(
+        new CommerceValidationError("Base price amount cannot be negative."),
+      );
+    }
+
+    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx);
+    if (!entity) {
+      return Err(
+        new CommerceNotFoundError("Entity not found for price assignment."),
+      );
+    }
+
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+
+    const priceData: PriceInsert = {
+      organizationId: orgId,
+      entityId: input.entityId,
+      currency: normalizeCurrency(input.currency),
+      amount: input.amount,
+      metadata: input.metadata ?? {},
+      variantId: input.variantId ?? null,
+      customerGroupId: input.customerGroupId ?? null,
+      minQuantity: input.minQuantity ?? null,
+      maxQuantity: input.maxQuantity ?? null,
+      validFrom: input.validFrom ?? null,
+      validUntil: input.validUntil ?? null,
+    };
+
+    const record = await this.repo.createPrice(priceData, ctx);
+    return Ok(record);
+  }
+
+  async createModifier(
+    input: CreatePriceModifierInput,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<PriceModifier>> {
+    if (!input.name) {
+      return Err(new CommerceValidationError("Modifier name is required."));
+    }
+
+    // Validate modifier type
+    const validTypes: PriceModifierType[] = [
+      "percentage_discount",
+      "fixed_discount",
+      "markup",
+      "override",
+    ];
+    if (!validTypes.includes(input.type)) {
+      return Err(
+        new CommerceValidationError(
+          `Invalid modifier type "${input.type}". Must be one of: ${validTypes.join(", ")}`,
+        ),
+      );
+    }
+
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+
+    const modifierData: PriceModifierInsert = {
+      organizationId: orgId,
+      name: input.name,
+      type: input.type,
+      value: input.value,
+      priority: input.priority ?? 100,
+      conditions: input.conditions ?? {},
+      metadata: input.metadata ?? {},
+      entityId: input.entityId ?? null,
+      variantId: input.variantId ?? null,
+      customerGroupId: input.customerGroupId ?? null,
+      currency: input.currency ? normalizeCurrency(input.currency) : null,
+      minQuantity: input.minQuantity ?? null,
+      maxQuantity: input.maxQuantity ?? null,
+      validFrom: input.validFrom ?? null,
+      validUntil: input.validUntil ?? null,
+    };
+
+    const modifier = await this.repo.createModifier(modifierData, ctx);
+    return Ok(modifier);
+  }
+
+  async listPrices(
+    filter?: {
+      entityId?: string;
+      variantId?: string;
+      currency?: string;
+      customerGroupId?: string;
+    },
+    ctx?: TxContext,
+  ): Promise<Result<{ prices: Price[]; modifiers: PriceModifier[] }>> {
+    // Get all prices for the entity if specified, or filter after retrieval
+    let prices: Price[] = [];
+    if (filter?.entityId) {
+      prices = await this.repo.findPricesByEntityId(filter.entityId, ctx);
+    }
+    // Note: For full list without entityId, we'd need a findAll method
+    // For now, entityId is typically required for practical use
+
+    // Apply additional filters
+    if (filter?.variantId !== undefined) {
+      prices = prices.filter((p) => p.variantId === filter.variantId);
+    }
+    if (filter?.currency !== undefined) {
+      const normalizedCurrency = normalizeCurrency(filter.currency);
+      prices = prices.filter((p) => p.currency === normalizedCurrency);
+    }
+    if (filter?.customerGroupId !== undefined) {
+      prices = prices.filter(
+        (p) => p.customerGroupId === filter.customerGroupId,
+      );
+    }
+
+    // Get modifiers for the entity
+    let modifiers: PriceModifier[] = [];
+    if (filter?.entityId) {
+      modifiers = await this.repo.findModifiersByEntityId(filter.entityId, ctx);
+    }
+
+    // Apply additional filters
+    if (filter?.variantId !== undefined) {
+      modifiers = modifiers.filter((m) => m.variantId === filter.variantId);
+    }
+    if (filter?.currency !== undefined) {
+      const normalizedCurrency = normalizeCurrency(filter.currency);
+      modifiers = modifiers.filter(
+        (m) => m.currency === null || m.currency === normalizedCurrency,
+      );
+    }
+    if (filter?.customerGroupId !== undefined) {
+      modifiers = modifiers.filter(
+        (m) =>
+          m.customerGroupId === null ||
+          m.customerGroupId === filter.customerGroupId,
+      );
+    }
+
+    return Ok({ prices, modifiers });
+  }
+
+  async resolve(
+    input: PriceResolutionContext,
+    ctx?: TxContext,
+  ): Promise<Result<ResolvedPrice>> {
+    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx);
+    if (!entity) {
+      return Err(
+        new CommerceNotFoundError(`Entity ${input.entityId} not found.`),
+      );
+    }
+
+    if (input.quantity <= 0) {
+      return Err(
+        new CommerceValidationError(
+          "Quantity must be greater than zero for price resolution.",
+        ),
+      );
+    }
+
+    const timestamp = input.timestamp ?? new Date();
+    const currency = normalizeCurrency(input.currency);
+    const groupSet = toGroupSet(input);
+
+    // Get matching prices from repository
+    const allPrices = await this.repo.findPricesByEntityId(input.entityId, ctx);
+
+    const matchingPrices = allPrices.filter((price) => {
+      if (input.variantId !== undefined) {
+        if (price.variantId !== null && price.variantId !== input.variantId)
+          return false;
+      } else if (price.variantId !== null) {
+        return false;
+      }
+      if (price.currency !== currency) return false;
+      if (
+        !matchesQuantity(price.minQuantity, price.maxQuantity, input.quantity)
+      )
+        return false;
+      if (!matchesWindow(price.validFrom, price.validUntil, timestamp))
+        return false;
+      if (
+        price.customerGroupId !== null &&
+        !groupSet.has(price.customerGroupId)
+      )
+        return false;
+      return true;
+    });
+
+    if (matchingPrices.length === 0) {
+      const metadataPrice =
+        typeof entity.metadata?.basePrice === "number"
+          ? Math.round(entity.metadata.basePrice)
+          : undefined;
+      if (metadataPrice === undefined) {
+        return Err(
+          new CommerceNotFoundError(
+            `No base price configured for ${entity.slug} (${currency}).`,
+          ),
+        );
+      }
+      const fallback: ResolvedPrice = {
+        baseAmount: metadataPrice,
+        finalAmount: metadataPrice,
+        currency,
+        basePriceId: "metadata:basePrice",
+        appliedModifiers: [],
+        breakdown: [
+          {
+            label: "Base price (entity metadata)",
+            amountBefore: metadataPrice,
+            delta: 0,
+            amountAfter: metadataPrice,
+          },
+        ],
+      };
+      return Ok(fallback);
+    }
+
+    const selectedBase = [...matchingPrices].sort((a, b) =>
+      compareBasePriceSpecificity(a, b, input),
+    )[0];
+    if (!selectedBase) {
+      return Err(
+        new CommerceNotFoundError("No matching base price could be selected."),
+      );
+    }
+
+    let runningAmount = selectedBase.amount;
+    const breakdown: PriceBreakdownStep[] = [
+      {
+        label: "Base price",
+        amountBefore: selectedBase.amount,
+        delta: 0,
+        amountAfter: selectedBase.amount,
+        metadata: {
+          priceId: selectedBase.id,
+          customerGroupId: selectedBase.customerGroupId,
+          minQuantity: selectedBase.minQuantity,
+          maxQuantity: selectedBase.maxQuantity,
+        },
+      },
+    ];
+
+    const appliedModifiers: ResolvedPrice["appliedModifiers"] = [];
+
+    // Get matching modifiers (includes both entity-specific and global)
+    const firstGroupId = groupSet.size > 0 ? [...groupSet][0] : undefined;
+    const activeModifiers = await this.repo.findActiveModifiers(
+      input.entityId,
+      input.variantId,
+      firstGroupId,
+      currency,
+      input.quantity,
+      ctx,
+    );
+
+    // Additional filtering for multiple customer groups and conditions
+    const modifiers = activeModifiers
+      .filter((modifier) => {
+        // Re-check customer group for multi-group support
+        if (
+          modifier.customerGroupId !== null &&
+          !groupSet.has(modifier.customerGroupId)
+        )
+          return false;
+
+        const conditions = modifier.conditions as Record<
+          string,
+          unknown
+        > | null;
+        const minSubtotal = conditions?.minSubtotal;
+        if (typeof minSubtotal === "number" && runningAmount < minSubtotal)
+          return false;
+
+        return true;
+      })
+      .sort((a, b) => a.priority - b.priority);
+
+    for (const modifier of modifiers) {
+      const amountBefore = runningAmount;
+      const rawDelta = resolveModifierDelta(
+        modifier.type as PriceModifierType,
+        modifier.value,
+        amountBefore,
+      );
+      const delta = Math.max(-amountBefore, rawDelta);
+      runningAmount = Math.max(0, amountBefore + delta);
+
+      appliedModifiers.push({
+        id: modifier.id,
+        name: modifier.name,
+        type: modifier.type as PriceModifierType,
+        delta,
+        value: modifier.value,
+        priority: modifier.priority,
+      });
+
+      breakdown.push({
+        label: `Modifier: ${modifier.name}`,
+        amountBefore,
+        delta,
+        amountAfter: runningAmount,
+        metadata: {
+          type: modifier.type,
+          priority: modifier.priority,
+        },
+      });
+    }
+
+    return Ok({
+      baseAmount: selectedBase.amount,
+      finalAmount: runningAmount,
+      currency,
+      basePriceId: selectedBase.id,
+      appliedModifiers,
+      breakdown,
+    });
+  }
+}