@voyant-travel/commerce 0.1.0

package/dist/pricing/service-option-rules.d.ts

@@ -0,0 +1,321 @@
+import type { EventBus } from "@voyant-travel/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type PricingRuleChangeSource } from "./events.js";
+/**
+ * Optional runtime context for pricing-rule mutations. When `eventBus`
+ * is wired the service emits `pricing.rule.changed` after a successful
+ * mutation so the catalog bridge can reindex the affected product.
+ *
+ * Keeping it optional preserves back-compat with existing callers that
+ * don't care about the catalog plane (e.g. data-import scripts).
+ */
+export interface RuleMutationRuntime {
+    eventBus?: EventBus;
+    source?: PricingRuleChangeSource;
+}
+import type { CreateOptionPriceRuleInput, CreateOptionStartTimeRuleInput, CreateOptionUnitPriceRuleInput, CreateOptionUnitTierInput, OptionPriceRuleListQuery, OptionStartTimeRuleListQuery, OptionUnitPriceRuleListQuery, OptionUnitTierListQuery, UpdateOptionPriceRuleInput, UpdateOptionStartTimeRuleInput, UpdateOptionUnitPriceRuleInput, UpdateOptionUnitTierInput } from "./service-shared.js";
+export declare function listOptionPriceRules(db: PostgresJsDatabase, query: OptionPriceRuleListQuery): Promise<{
+    data: {
+        id: string;
+        productId: string;
+        optionId: string;
+        priceCatalogId: string;
+        priceScheduleId: string | null;
+        cancellationPolicyId: string | null;
+        code: string | null;
+        name: string;
+        description: string | null;
+        pricingMode: "on_request" | "per_person" | "per_booking" | "starting_from" | "free";
+        baseSellAmountCents: number | null;
+        baseCostAmountCents: number | null;
+        minPerBooking: number | null;
+        maxPerBooking: number | null;
+        allPricingCategories: boolean;
+        isDefault: boolean;
+        active: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getOptionPriceRuleById(db: PostgresJsDatabase, id: string): Promise<{
+    id: string;
+    productId: string;
+    optionId: string;
+    priceCatalogId: string;
+    priceScheduleId: string | null;
+    cancellationPolicyId: string | null;
+    code: string | null;
+    name: string;
+    description: string | null;
+    pricingMode: "on_request" | "per_person" | "per_booking" | "starting_from" | "free";
+    baseSellAmountCents: number | null;
+    baseCostAmountCents: number | null;
+    minPerBooking: number | null;
+    maxPerBooking: number | null;
+    allPricingCategories: boolean;
+    isDefault: boolean;
+    active: boolean;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function createOptionPriceRule(db: PostgresJsDatabase, data: CreateOptionPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
+    id: string;
+    code: string | null;
+    active: boolean;
+    metadata: Record<string, unknown> | null;
+    description: string | null;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDefault: boolean;
+    notes: string | null;
+    priceCatalogId: string;
+    productId: string;
+    optionId: string;
+    priceScheduleId: string | null;
+    cancellationPolicyId: string | null;
+    pricingMode: "on_request" | "per_person" | "per_booking" | "starting_from" | "free";
+    baseSellAmountCents: number | null;
+    baseCostAmountCents: number | null;
+    minPerBooking: number | null;
+    maxPerBooking: number | null;
+    allPricingCategories: boolean;
+} | null>;
+export declare function updateOptionPriceRule(db: PostgresJsDatabase, id: string, data: UpdateOptionPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
+    id: string;
+    productId: string;
+    optionId: string;
+    priceCatalogId: string;
+    priceScheduleId: string | null;
+    cancellationPolicyId: string | null;
+    code: string | null;
+    name: string;
+    description: string | null;
+    pricingMode: "on_request" | "per_person" | "per_booking" | "starting_from" | "free";
+    baseSellAmountCents: number | null;
+    baseCostAmountCents: number | null;
+    minPerBooking: number | null;
+    maxPerBooking: number | null;
+    allPricingCategories: boolean;
+    isDefault: boolean;
+    active: boolean;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function deleteOptionPriceRule(db: PostgresJsDatabase, id: string, runtime?: RuleMutationRuntime): Promise<{
+    id: string;
+} | null>;
+export declare function listOptionUnitPriceRules(db: PostgresJsDatabase, query: OptionUnitPriceRuleListQuery): Promise<{
+    data: {
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        unitId: string;
+        pricingCategoryId: string | null;
+        pricingMode: "on_request" | "per_person" | "per_booking" | "free" | "per_unit" | "included";
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getOptionUnitPriceRuleById(db: PostgresJsDatabase, id: string): Promise<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    unitId: string;
+    pricingCategoryId: string | null;
+    pricingMode: "on_request" | "per_person" | "per_booking" | "free" | "per_unit" | "included";
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    minQuantity: number | null;
+    maxQuantity: number | null;
+    active: boolean;
+    sortOrder: number;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function createOptionUnitPriceRule(db: PostgresJsDatabase, data: CreateOptionUnitPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
+    id: string;
+    active: boolean;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+    sortOrder: number;
+    notes: string | null;
+    optionId: string;
+    pricingMode: "on_request" | "per_person" | "per_booking" | "free" | "per_unit" | "included";
+    optionPriceRuleId: string;
+    unitId: string;
+    pricingCategoryId: string | null;
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    minQuantity: number | null;
+    maxQuantity: number | null;
+} | null>;
+export declare function updateOptionUnitPriceRule(db: PostgresJsDatabase, id: string, data: UpdateOptionUnitPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    unitId: string;
+    pricingCategoryId: string | null;
+    pricingMode: "on_request" | "per_person" | "per_booking" | "free" | "per_unit" | "included";
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    minQuantity: number | null;
+    maxQuantity: number | null;
+    active: boolean;
+    sortOrder: number;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function deleteOptionUnitPriceRule(db: PostgresJsDatabase, id: string, runtime?: RuleMutationRuntime): Promise<{
+    id: string;
+} | null>;
+export declare function listOptionStartTimeRules(db: PostgresJsDatabase, query: OptionStartTimeRuleListQuery): Promise<{
+    data: {
+        id: string;
+        optionPriceRuleId: string;
+        optionId: string;
+        startTimeId: string;
+        ruleMode: "adjustment" | "override" | "included" | "excluded";
+        adjustmentType: "fixed" | "percentage" | null;
+        sellAdjustmentCents: number | null;
+        costAdjustmentCents: number | null;
+        adjustmentBasisPoints: number | null;
+        active: boolean;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getOptionStartTimeRuleById(db: PostgresJsDatabase, id: string): Promise<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    startTimeId: string;
+    ruleMode: "adjustment" | "override" | "included" | "excluded";
+    adjustmentType: "fixed" | "percentage" | null;
+    sellAdjustmentCents: number | null;
+    costAdjustmentCents: number | null;
+    adjustmentBasisPoints: number | null;
+    active: boolean;
+    notes: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function createOptionStartTimeRule(db: PostgresJsDatabase, data: CreateOptionStartTimeRuleInput): Promise<{
+    id: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    notes: string | null;
+    optionId: string;
+    optionPriceRuleId: string;
+    startTimeId: string;
+    ruleMode: "adjustment" | "override" | "included" | "excluded";
+    adjustmentType: "fixed" | "percentage" | null;
+    sellAdjustmentCents: number | null;
+    adjustmentBasisPoints: number | null;
+    costAdjustmentCents: number | null;
+} | null>;
+export declare function updateOptionStartTimeRule(db: PostgresJsDatabase, id: string, data: UpdateOptionStartTimeRuleInput): Promise<{
+    id: string;
+    optionPriceRuleId: string;
+    optionId: string;
+    startTimeId: string;
+    ruleMode: "adjustment" | "override" | "included" | "excluded";
+    adjustmentType: "fixed" | "percentage" | null;
+    sellAdjustmentCents: number | null;
+    costAdjustmentCents: number | null;
+    adjustmentBasisPoints: number | null;
+    active: boolean;
+    notes: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function deleteOptionStartTimeRule(db: PostgresJsDatabase, id: string): Promise<{
+    id: string;
+} | null>;
+export declare function listOptionUnitTiers(db: PostgresJsDatabase, query: OptionUnitTierListQuery): Promise<{
+    data: {
+        id: string;
+        optionUnitPriceRuleId: string;
+        minQuantity: number;
+        maxQuantity: number | null;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        active: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getOptionUnitTierById(db: PostgresJsDatabase, id: string): Promise<{
+    id: string;
+    optionUnitPriceRuleId: string;
+    minQuantity: number;
+    maxQuantity: number | null;
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    active: boolean;
+    sortOrder: number;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function createOptionUnitTier(db: PostgresJsDatabase, data: CreateOptionUnitTierInput): Promise<{
+    id: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    sortOrder: number;
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    minQuantity: number;
+    maxQuantity: number | null;
+    optionUnitPriceRuleId: string;
+} | null>;
+export declare function updateOptionUnitTier(db: PostgresJsDatabase, id: string, data: UpdateOptionUnitTierInput): Promise<{
+    id: string;
+    optionUnitPriceRuleId: string;
+    minQuantity: number;
+    maxQuantity: number | null;
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    active: boolean;
+    sortOrder: number;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function deleteOptionUnitTier(db: PostgresJsDatabase, id: string): Promise<{
+    id: string;
+} | null>;
+//# sourceMappingURL=service-option-rules.d.ts.map

package/dist/pricing/service-option-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-option-rules.d.ts","sourceRoot":"","sources":["../../src/pricing/service-option-rules.ts"],"names":[],"mappings":"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"}

package/dist/pricing/service-option-rules.js

@@ -0,0 +1,340 @@
+import { RequestValidationError } from "@voyant-travel/hono";
+import { and, asc, desc, eq, sql } from "drizzle-orm";
+import { PRICING_RULE_CHANGED_EVENT, } from "./events.js";
+import { optionPriceRules, optionStartTimeRules, optionUnitPriceRules, optionUnitTiers, } from "./schema.js";
+async function emitRuleChanged(eventBus, payload) {
+    if (!eventBus)
+        return;
+    await eventBus.emit(PRICING_RULE_CHANGED_EVENT, payload, {
+        category: "domain",
+        source: "service",
+    });
+}
+// A `per_booking` rule produces a single flat amount for the whole booking;
+// per-unit prices implicitly assume a per-unit (or per-person) multiplier.
+// The two are contradictory — see #482.
+const PER_BOOKING_REJECTS_UNIT_PRICES_MESSAGE = "Rules with pricingMode = 'per_booking' cannot carry per-unit prices. " +
+    "Use pricingMode = 'per_person' or 'starting_from' for unit-priced rules, " +
+    "or remove the unit prices to keep this rule a flat per-booking amount.";
+import { paginate } from "./service-shared.js";
+export async function listOptionPriceRules(db, query) {
+    const conditions = [];
+    if (query.productId)
+        conditions.push(eq(optionPriceRules.productId, query.productId));
+    if (query.optionId)
+        conditions.push(eq(optionPriceRules.optionId, query.optionId));
+    if (query.priceCatalogId)
+        conditions.push(eq(optionPriceRules.priceCatalogId, query.priceCatalogId));
+    if (query.priceScheduleId)
+        conditions.push(eq(optionPriceRules.priceScheduleId, query.priceScheduleId));
+    if (query.cancellationPolicyId) {
+        conditions.push(eq(optionPriceRules.cancellationPolicyId, query.cancellationPolicyId));
+    }
+    if (query.pricingMode)
+        conditions.push(eq(optionPriceRules.pricingMode, query.pricingMode));
+    if (query.active !== undefined)
+        conditions.push(eq(optionPriceRules.active, query.active));
+    const where = conditions.length ? and(...conditions) : undefined;
+    return paginate(db
+        .select()
+        .from(optionPriceRules)
+        .where(where)
+        .limit(query.limit)
+        .offset(query.offset)
+        .orderBy(desc(optionPriceRules.updatedAt)), db.select({ count: sql `count(*)::int` }).from(optionPriceRules).where(where), query.limit, query.offset);
+}
+export async function getOptionPriceRuleById(db, id) {
+    const [row] = await db.select().from(optionPriceRules).where(eq(optionPriceRules.id, id)).limit(1);
+    return row ?? null;
+}
+export async function createOptionPriceRule(db, data, runtime = {}) {
+    const [row] = await db.insert(optionPriceRules).values(data).returning();
+    if (!row)
+        return null;
+    await emitRuleChanged(runtime.eventBus, {
+        productId: row.productId,
+        ruleId: row.id,
+        kind: "option-rule",
+        source: runtime.source ?? "created",
+    });
+    return row;
+}
+export async function updateOptionPriceRule(db, id, data, runtime = {}) {
+    if (data.pricingMode === "per_booking") {
+        const [countRow] = await db
+            .select({ count: sql `count(*)::int` })
+            .from(optionUnitPriceRules)
+            .where(eq(optionUnitPriceRules.optionPriceRuleId, id));
+        const unitPriceCount = countRow?.count ?? 0;
+        if (unitPriceCount > 0) {
+            throw new RequestValidationError(PER_BOOKING_REJECTS_UNIT_PRICES_MESSAGE, {
+                ruleId: id,
+                unitPriceCount,
+            });
+        }
+    }
+    // Snapshot the pre-update productId so reassignment (rule moves
+    // between products) reindexes the *previous* product too. Without
+    // this, the projection on the old product keeps a stale MIN that
+    // includes a rule it no longer owns.
+    const [pre] = await db
+        .select({ productId: optionPriceRules.productId })
+        .from(optionPriceRules)
+        .where(eq(optionPriceRules.id, id))
+        .limit(1);
+    const [row] = await db
+        .update(optionPriceRules)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(optionPriceRules.id, id))
+        .returning();
+    if (!row)
+        return null;
+    await emitRuleChanged(runtime.eventBus, {
+        productId: row.productId,
+        ruleId: row.id,
+        kind: "option-rule",
+        source: runtime.source ?? "updated",
+    });
+    if (pre && pre.productId !== row.productId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: pre.productId,
+            ruleId: row.id,
+            kind: "option-rule",
+            source: runtime.source ?? "updated",
+        });
+    }
+    return row;
+}
+export async function deleteOptionPriceRule(db, id, runtime = {}) {
+    // Snapshot before deletion so the event payload carries productId —
+    // can't read it back from the deleted row.
+    const [snapshot] = await db
+        .select({ productId: optionPriceRules.productId })
+        .from(optionPriceRules)
+        .where(eq(optionPriceRules.id, id))
+        .limit(1);
+    const [row] = await db
+        .delete(optionPriceRules)
+        .where(eq(optionPriceRules.id, id))
+        .returning({ id: optionPriceRules.id });
+    if (!row)
+        return null;
+    if (snapshot) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: snapshot.productId,
+            ruleId: row.id,
+            kind: "option-rule",
+            source: runtime.source ?? "deleted",
+        });
+    }
+    return row;
+}
+export async function listOptionUnitPriceRules(db, query) {
+    const conditions = [];
+    if (query.optionPriceRuleId) {
+        conditions.push(eq(optionUnitPriceRules.optionPriceRuleId, query.optionPriceRuleId));
+    }
+    if (query.optionId)
+        conditions.push(eq(optionUnitPriceRules.optionId, query.optionId));
+    if (query.unitId)
+        conditions.push(eq(optionUnitPriceRules.unitId, query.unitId));
+    if (query.pricingCategoryId) {
+        conditions.push(eq(optionUnitPriceRules.pricingCategoryId, query.pricingCategoryId));
+    }
+    if (query.active !== undefined)
+        conditions.push(eq(optionUnitPriceRules.active, query.active));
+    const where = conditions.length ? and(...conditions) : undefined;
+    return paginate(db
+        .select()
+        .from(optionUnitPriceRules)
+        .where(where)
+        .limit(query.limit)
+        .offset(query.offset)
+        .orderBy(asc(optionUnitPriceRules.sortOrder), asc(optionUnitPriceRules.createdAt)), db.select({ count: sql `count(*)::int` }).from(optionUnitPriceRules).where(where), query.limit, query.offset);
+}
+export async function getOptionUnitPriceRuleById(db, id) {
+    const [row] = await db
+        .select()
+        .from(optionUnitPriceRules)
+        .where(eq(optionUnitPriceRules.id, id))
+        .limit(1);
+    return row ?? null;
+}
+/**
+ * Look up the productId on an option-unit-rule's parent rule. Used by
+ * the mutation paths to populate the `pricing.rule.changed` payload —
+ * unit rules don't carry productId directly, so we walk through their
+ * parent every time. One small extra query per mutation; pricing
+ * mutations aren't on a hot path so the cost is negligible.
+ */
+async function getProductIdForUnitRule(db, unitRuleId) {
+    const [row] = await db
+        .select({ productId: optionPriceRules.productId })
+        .from(optionUnitPriceRules)
+        .innerJoin(optionPriceRules, eq(optionPriceRules.id, optionUnitPriceRules.optionPriceRuleId))
+        .where(eq(optionUnitPriceRules.id, unitRuleId))
+        .limit(1);
+    return row?.productId ?? null;
+}
+export async function createOptionUnitPriceRule(db, data, runtime = {}) {
+    const [parent] = await db
+        .select({ pricingMode: optionPriceRules.pricingMode, productId: optionPriceRules.productId })
+        .from(optionPriceRules)
+        .where(eq(optionPriceRules.id, data.optionPriceRuleId))
+        .limit(1);
+    if (parent?.pricingMode === "per_booking") {
+        throw new RequestValidationError(PER_BOOKING_REJECTS_UNIT_PRICES_MESSAGE, {
+            ruleId: data.optionPriceRuleId,
+        });
+    }
+    const [row] = await db.insert(optionUnitPriceRules).values(data).returning();
+    if (!row)
+        return null;
+    if (parent) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: parent.productId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "created",
+        });
+    }
+    return row;
+}
+export async function updateOptionUnitPriceRule(db, id, data, runtime = {}) {
+    // Snapshot the pre-update parent's productId. If the update reassigns
+    // `optionPriceRuleId` to a parent rule under a different product, the
+    // *previous* product also loses this unit-rule from its MIN
+    // candidate set and needs reindexing. Without this snapshot the old
+    // product's `priceFromAmountCents` stays stale.
+    const prevProductId = await getProductIdForUnitRule(db, id);
+    const [row] = await db
+        .update(optionUnitPriceRules)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(optionUnitPriceRules.id, id))
+        .returning();
+    if (!row)
+        return null;
+    const nextProductId = await getProductIdForUnitRule(db, row.id);
+    if (nextProductId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: nextProductId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "updated",
+        });
+    }
+    if (prevProductId && prevProductId !== nextProductId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: prevProductId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "updated",
+        });
+    }
+    return row;
+}
+export async function deleteOptionUnitPriceRule(db, id, runtime = {}) {
+    // Snapshot productId before deletion — the row is gone after.
+    const productId = await getProductIdForUnitRule(db, id);
+    const [row] = await db
+        .delete(optionUnitPriceRules)
+        .where(eq(optionUnitPriceRules.id, id))
+        .returning({ id: optionUnitPriceRules.id });
+    if (!row)
+        return null;
+    if (productId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "deleted",
+        });
+    }
+    return row;
+}
+export async function listOptionStartTimeRules(db, query) {
+    const conditions = [];
+    if (query.optionPriceRuleId) {
+        conditions.push(eq(optionStartTimeRules.optionPriceRuleId, query.optionPriceRuleId));
+    }
+    if (query.optionId)
+        conditions.push(eq(optionStartTimeRules.optionId, query.optionId));
+    if (query.startTimeId)
+        conditions.push(eq(optionStartTimeRules.startTimeId, query.startTimeId));
+    if (query.active !== undefined)
+        conditions.push(eq(optionStartTimeRules.active, query.active));
+    const where = conditions.length ? and(...conditions) : undefined;
+    return paginate(db
+        .select()
+        .from(optionStartTimeRules)
+        .where(where)
+        .limit(query.limit)
+        .offset(query.offset)
+        .orderBy(asc(optionStartTimeRules.createdAt)), db.select({ count: sql `count(*)::int` }).from(optionStartTimeRules).where(where), query.limit, query.offset);
+}
+export async function getOptionStartTimeRuleById(db, id) {
+    const [row] = await db
+        .select()
+        .from(optionStartTimeRules)
+        .where(eq(optionStartTimeRules.id, id))
+        .limit(1);
+    return row ?? null;
+}
+export async function createOptionStartTimeRule(db, data) {
+    const [row] = await db.insert(optionStartTimeRules).values(data).returning();
+    return row ?? null;
+}
+export async function updateOptionStartTimeRule(db, id, data) {
+    const [row] = await db
+        .update(optionStartTimeRules)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(optionStartTimeRules.id, id))
+        .returning();
+    return row ?? null;
+}
+export async function deleteOptionStartTimeRule(db, id) {
+    const [row] = await db
+        .delete(optionStartTimeRules)
+        .where(eq(optionStartTimeRules.id, id))
+        .returning({ id: optionStartTimeRules.id });
+    return row ?? null;
+}
+export async function listOptionUnitTiers(db, query) {
+    const conditions = [];
+    if (query.optionUnitPriceRuleId) {
+        conditions.push(eq(optionUnitTiers.optionUnitPriceRuleId, query.optionUnitPriceRuleId));
+    }
+    if (query.active !== undefined)
+        conditions.push(eq(optionUnitTiers.active, query.active));
+    const where = conditions.length ? and(...conditions) : undefined;
+    return paginate(db
+        .select()
+        .from(optionUnitTiers)
+        .where(where)
+        .limit(query.limit)
+        .offset(query.offset)
+        .orderBy(asc(optionUnitTiers.sortOrder), asc(optionUnitTiers.minQuantity)), db.select({ count: sql `count(*)::int` }).from(optionUnitTiers).where(where), query.limit, query.offset);
+}
+export async function getOptionUnitTierById(db, id) {
+    const [row] = await db.select().from(optionUnitTiers).where(eq(optionUnitTiers.id, id)).limit(1);
+    return row ?? null;
+}
+export async function createOptionUnitTier(db, data) {
+    const [row] = await db.insert(optionUnitTiers).values(data).returning();
+    return row ?? null;
+}
+export async function updateOptionUnitTier(db, id, data) {
+    const [row] = await db
+        .update(optionUnitTiers)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(optionUnitTiers.id, id))
+        .returning();
+    return row ?? null;
+}
+export async function deleteOptionUnitTier(db, id) {
+    const [row] = await db
+        .delete(optionUnitTiers)
+        .where(eq(optionUnitTiers.id, id))
+        .returning({ id: optionUnitTiers.id });
+    return row ?? null;
+}