@voyantjs/pricing 0.77.1 → 0.77.4

package/dist/service-catalog-plane-pricing.d.ts

@@ -1,6 +1,6 @@
 /**
  * Projection extension that aggregates a "price from" amount across the
- * product's configured default-rule prices and contributes
+ * product's future bookable rate-plan prices and contributes
  * `priceFromAmountCents`, `priceFromCurrency`, and `hasPricing` to the
  * product search document.
  *
@@ -17,28 +17,24 @@
  * Scope intentionally narrow:
  *   - **No schedule-aware rule resolution.** Only `is_default = true`
  *     rules contribute. Seasonal / promo rules with schedules don't
- *     surface here — they'd require per-slice resolution against a
- *     moving "now" date and are deferred to a follow-up.
+ *     surface here; they require per-slice rule evaluation beyond the
+ *     future-departure presence check below.
  *   - **No per-departure overrides.** Same reason.
  *   - **Currency consistency.** Only rules whose catalog currency matches
  *     the product's `sellCurrency` (or whose catalog currency is null
- *     and therefore inherits the product's) are MIN'd together. This
- *     prevents emitting a misleading "from $50" when one of the rules
- *     is actually €50.
+ *     and therefore inherits the product's) are MIN'd together.
  *
- * Document churn: this projection is `now()`-independent — it reads
- * static configured prices, not date-dependent rule windows. Same
- * product reindexed an hour later produces the same fields.
+ * Document churn: this projection is `now()`-dependent because it only
+ * considers future bookable departures. A product can move to "unpriced"
+ * once its final departure starts unless a row-level fallback remains.
  */
 import type { AnyDrizzleDb } from "@voyantjs/db";
 import type { ProductProjectionExtension } from "@voyantjs/products/service-catalog-plane";
 interface PricingProjectionOptions {
     /**
-     * Resolve the product's `sellAmountCents` + `sellCurrency` so the
-     * projection can MIN the product-row default into the candidate set
-     * and filter rules by matching currency. Templates inject this — the
-     * default reads the products table via raw SQL, but tests can stub
-     * with a known shape without standing up the products schema.
+     * Resolve the product's row-level `sellAmountCents` + `sellCurrency`.
+     * Templates use the default raw-SQL loader; tests can stub it without
+     * standing up the products schema.
      *
      * Returns `null` for both fields when the product doesn't exist.
      */
@@ -46,35 +42,51 @@ interface PricingProjectionOptions {
         sellAmountCents: number | null;
         sellCurrency: string | null;
     }>;
+    /**
+     * Resolve future bookable rate-plan prices for the product. Tests can
+     * stub this without standing up availability/product option tables.
+     */
+    loadRatePlanPricing?: (db: AnyDrizzleDb, productId: string, productCurrency: string) => Promise<RatePlanPricing>;
 }
 interface PricingAggregate {
     priceFromAmountCents: number | null;
     priceFromCurrency: string | null;
     hasPricing: boolean;
 }
+interface RatePlanPricing {
+    roomPrices: number[];
+    basePrices: number[];
+}
 /**
- * Pure aggregation kernel — given the product-row pricing and the rule
- * candidate set, produce the projection fields. Exposed via `__test__`
- * for unit coverage that doesn't need a real DB.
- *
- * `productPrice` is the row's `sellAmountCents` (`null` when unset).
- * `currency` is the row's `sellCurrency` (used as the projected
- * currency; rule prices fed in here are pre-filtered to match).
- * `ruleCandidates` is every active default rule's `baseSellAmountCents`
- * AND every active default rule's per-unit `sellAmountCents`, with
- * nulls already filtered out.
+ * Pure aggregation kernel. Room prices take precedence over base/unit
+ * prices, which take precedence over the product-row fallback. Non-
+ * positive values are treated as absent so stale `0` caches don't block
+ * nullish fallbacks in catalog consumers.
  */
-declare function aggregatePricing(productPrice: number | null, currency: string | null, ruleCandidates: ReadonlyArray<number>): PricingAggregate;
+declare function aggregatePricing(productPrice: number | null, currency: string | null, roomPrices: ReadonlyArray<number>, basePrices: ReadonlyArray<number>): PricingAggregate;
 /**
  * Construct the pricing projection extension.
  *
- * Pass `loadProductPricing` in tests to stub the products-row fetch;
- * production uses the default raw-SQL implementation.
+ * Pass loaders in tests to stub DB reads; production uses raw SQL against
+ * the deployed schema.
  */
 export declare function createProductPricingProjectionExtension(options?: PricingProjectionOptions): ProductProjectionExtension;
+/**
+ * Resolve the same "from price" value emitted by the pricing projection.
+ * Promotion projection wiring uses this so strikethrough base prices
+ * follow the same rate-plan-first fallback chain.
+ */
+export declare function loadProductPriceFrom(db: AnyDrizzleDb, productId: string): Promise<{
+    amountCents: number | null;
+    currency: string | null;
+}>;
+declare function firstPositiveMin(values: ReadonlyArray<number>): number | null;
+declare function isMissingCatalogPricingDependencyError(error: unknown): boolean;
 export declare const __test__: {
     aggregatePricing: typeof aggregatePricing;
     EMPTY_AGGREGATE: PricingAggregate;
+    firstPositiveMin: typeof firstPositiveMin;
+    isMissingCatalogPricingDependencyError: typeof isMissingCatalogPricingDependencyError;
 };
 export {};
 //# sourceMappingURL=service-catalog-plane-pricing.d.ts.map

package/dist/service-catalog-plane-pricing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-catalog-plane-pricing.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane-pricing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,KAAK,EAEV,0BAA0B,EAC3B,MAAM,0CAA0C,CAAA;AAMjD,UAAU,wBAAwB;IAChC;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,CACnB,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;CAC9E;AAED,UAAU,gBAAgB;IACxB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,UAAU,EAAE,OAAO,CAAA;CACpB;AAQD;;;;;;;;;;;GAWG;AACH,iBAAS,gBAAgB,CACvB,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,GACpC,gBAAgB,CAqBlB;AAED;;;;;GAKG;AACH,wBAAgB,uCAAuC,CACrD,OAAO,GAAE,wBAA6B,GACrC,0BAA0B,CA4B5B;AA6GD,eAAO,MAAM,QAAQ;;;CAGpB,CAAA"}
+{"version":3,"file":"service-catalog-plane-pricing.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane-pricing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,KAAK,EAEV,0BAA0B,EAC3B,MAAM,0CAA0C,CAAA;AAGjD,UAAU,wBAAwB;IAChC;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,CACnB,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;IAE7E;;;OAGG;IACH,mBAAmB,CAAC,EAAE,CACpB,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,KACpB,OAAO,CAAC,eAAe,CAAC,CAAA;CAC9B;AAED,UAAU,gBAAgB;IACxB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,UAAU,eAAe;IACvB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAQD;;;;;GAKG;AACH,iBAAS,gBAAgB,CACvB,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,EACjC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,GAChC,gBAAgB,CAYlB;AAED;;;;;GAKG;AACH,wBAAgB,uCAAuC,CACrD,OAAO,GAAE,wBAA6B,GACrC,0BAA0B,CA2B5B;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAclE;AAuLD,iBAAS,gBAAgB,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAOtE;AAYD,iBAAS,sCAAsC,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAWvE;AAWD,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAA"}

package/dist/service-catalog-plane-pricing.js

@@ -1,6 +1,6 @@
 /**
  * Projection extension that aggregates a "price from" amount across the
- * product's configured default-rule prices and contributes
+ * product's future bookable rate-plan prices and contributes
  * `priceFromAmountCents`, `priceFromCurrency`, and `hasPricing` to the
  * product search document.
  *
@@ -17,55 +17,34 @@
  * Scope intentionally narrow:
  *   - **No schedule-aware rule resolution.** Only `is_default = true`
  *     rules contribute. Seasonal / promo rules with schedules don't
- *     surface here — they'd require per-slice resolution against a
- *     moving "now" date and are deferred to a follow-up.
+ *     surface here; they require per-slice rule evaluation beyond the
+ *     future-departure presence check below.
  *   - **No per-departure overrides.** Same reason.
  *   - **Currency consistency.** Only rules whose catalog currency matches
  *     the product's `sellCurrency` (or whose catalog currency is null
- *     and therefore inherits the product's) are MIN'd together. This
- *     prevents emitting a misleading "from $50" when one of the rules
- *     is actually €50.
+ *     and therefore inherits the product's) are MIN'd together.
  *
- * Document churn: this projection is `now()`-independent — it reads
- * static configured prices, not date-dependent rule windows. Same
- * product reindexed an hour later produces the same fields.
+ * Document churn: this projection is `now()`-dependent because it only
+ * considers future bookable departures. A product can move to "unpriced"
+ * once its final departure starts unless a row-level fallback remains.
  */
-import { and, eq, isNull, or, sql } from "drizzle-orm";
-import { priceCatalogs } from "./schema-catalogs.js";
-import { optionPriceRules, optionUnitPriceRules } from "./schema-option-rules.js";
+import { sql } from "drizzle-orm";
 const EMPTY_AGGREGATE = {
     priceFromAmountCents: null,
     priceFromCurrency: null,
     hasPricing: false,
 };
 /**
- * Pure aggregation kernel — given the product-row pricing and the rule
- * candidate set, produce the projection fields. Exposed via `__test__`
- * for unit coverage that doesn't need a real DB.
- *
- * `productPrice` is the row's `sellAmountCents` (`null` when unset).
- * `currency` is the row's `sellCurrency` (used as the projected
- * currency; rule prices fed in here are pre-filtered to match).
- * `ruleCandidates` is every active default rule's `baseSellAmountCents`
- * AND every active default rule's per-unit `sellAmountCents`, with
- * nulls already filtered out.
+ * Pure aggregation kernel. Room prices take precedence over base/unit
+ * prices, which take precedence over the product-row fallback. Non-
+ * positive values are treated as absent so stale `0` caches don't block
+ * nullish fallbacks in catalog consumers.
  */
-function aggregatePricing(productPrice, currency, ruleCandidates) {
-    const candidates = [];
-    if (productPrice !== null)
-        candidates.push(productPrice);
-    for (const c of ruleCandidates)
-        candidates.push(c);
-    if (candidates.length === 0) {
+function aggregatePricing(productPrice, currency, roomPrices, basePrices) {
+    const min = firstPositiveMin(roomPrices) ?? firstPositiveMin(basePrices) ?? positive(productPrice);
+    if (min === null) {
         return { ...EMPTY_AGGREGATE, priceFromCurrency: currency };
     }
-    // MIN with a sentinel; faster than spread+Math.min for large arrays
-    // and avoids the Math.min stack-arg limit edge case.
-    let min = candidates[0];
-    for (const c of candidates) {
-        if (c < min)
-            min = c;
-    }
     return {
         priceFromAmountCents: min,
         priceFromCurrency: currency,
@@ -75,86 +54,180 @@ function aggregatePricing(productPrice, currency, ruleCandidates) {
 /**
  * Construct the pricing projection extension.
  *
- * Pass `loadProductPricing` in tests to stub the products-row fetch;
- * production uses the default raw-SQL implementation.
+ * Pass loaders in tests to stub DB reads; production uses raw SQL against
+ * the deployed schema.
  */
 export function createProductPricingProjectionExtension(options = {}) {
     const loadProductPricing = options.loadProductPricing ?? defaultLoadProductPricing;
+    const loadRatePlanPricing = options.loadRatePlanPricing ?? defaultLoadRatePlanPricing;
     return {
         name: "products:pricing",
         async project(db, productId, _slice) {
             const product = await loadProductPricing(db, productId);
             const currency = product.sellCurrency;
             // Without a product row currency we can't safely filter rules by
-            // matching currency — emit only the (null) row pricing. This case
-            // is rare in practice (every product has sellCurrency set in the
-            // operator UI) but keeps the projection failure-isolated.
+            // matching currency. Emit only the positive row-level fallback.
             if (!currency) {
-                const out = aggregatePricing(product.sellAmountCents, null, []);
+                const out = aggregatePricing(product.sellAmountCents, null, [], []);
                 return toProjectionMap(out);
             }
-            const [flatPrices, unitPrices] = await Promise.all([
-                fetchFlatRulePrices(db, productId, currency),
-                fetchUnitRulePrices(db, productId, currency),
-            ]);
-            const candidates = [...flatPrices, ...unitPrices];
-            const out = aggregatePricing(product.sellAmountCents, currency, candidates);
+            const ratePlans = await loadRatePlanPricing(db, productId, currency);
+            const out = aggregatePricing(product.sellAmountCents, currency, ratePlans.roomPrices, ratePlans.basePrices);
             return toProjectionMap(out);
         },
     };
 }
 /**
- * Read `optionPriceRules.baseSellAmountCents` for the product's active
- * default rules whose catalog currency matches the product currency
- * (or whose catalog has a NULL currency, meaning "inherit product").
- *
- * Filtering on the `(productId, active=true, isDefault=true)` subset
- * keeps the candidate set small even for products with hundreds of
- * seasonal rules.
+ * Resolve the same "from price" value emitted by the pricing projection.
+ * Promotion projection wiring uses this so strikethrough base prices
+ * follow the same rate-plan-first fallback chain.
  */
-async function fetchFlatRulePrices(db, productId, productCurrency) {
-    const rows = await db
-        .select({ price: optionPriceRules.baseSellAmountCents })
-        .from(optionPriceRules)
-        .innerJoin(priceCatalogs, eq(priceCatalogs.id, optionPriceRules.priceCatalogId))
-        .where(and(eq(optionPriceRules.productId, productId), eq(optionPriceRules.active, true), eq(optionPriceRules.isDefault, true), eq(priceCatalogs.active, true), or(eq(priceCatalogs.currencyCode, productCurrency), isNull(priceCatalogs.currencyCode))));
-    const out = [];
-    for (const row of rows) {
-        if (row.price !== null)
-            out.push(row.price);
+export async function loadProductPriceFrom(db, productId) {
+    const product = await defaultLoadProductPricing(db, productId);
+    const currency = product.sellCurrency;
+    if (!currency) {
+        return { amountCents: positive(product.sellAmountCents), currency: null };
     }
-    return out;
+    const ratePlans = await defaultLoadRatePlanPricing(db, productId, currency);
+    const amountCents = firstPositiveMin(ratePlans.roomPrices) ??
+        firstPositiveMin(ratePlans.basePrices) ??
+        positive(product.sellAmountCents);
+    return { amountCents, currency };
 }
 /**
- * Read `optionUnitPriceRules.sellAmountCents` for active per-unit tiers
- * whose parent rule is one of the product's active default rules in a
- * matching-currency catalog. Used for products priced per occupancy
- * (e.g. cabins at "single $X / double $Y / triple $Z") where the parent
- * rule's `baseSellAmountCents` is null and the actual prices live on
- * the unit tiers.
+ * Read positive prices from active default rules that have at least one
+ * future bookable departure. Room prices are separated from base/unit
+ * fallbacks so per-room pricing wins even when the product row contains
+ * a stale zero or stale manual price.
  */
-async function fetchUnitRulePrices(db, productId, productCurrency) {
-    const rows = await db
-        .select({ price: optionUnitPriceRules.sellAmountCents })
-        .from(optionUnitPriceRules)
-        .innerJoin(optionPriceRules, eq(optionPriceRules.id, optionUnitPriceRules.optionPriceRuleId))
-        .innerJoin(priceCatalogs, eq(priceCatalogs.id, optionPriceRules.priceCatalogId))
-        .where(and(eq(optionPriceRules.productId, productId), eq(optionPriceRules.active, true), eq(optionPriceRules.isDefault, true), eq(optionUnitPriceRules.active, true), eq(priceCatalogs.active, true), or(eq(priceCatalogs.currencyCode, productCurrency), isNull(priceCatalogs.currencyCode))));
-    const out = [];
-    for (const row of rows) {
-        if (row.price !== null)
-            out.push(row.price);
+async function defaultLoadRatePlanPricing(db, productId, productCurrency) {
+    try {
+        const [roomPrice, basePrice] = await Promise.all([
+            fetchBookableRoomPrice(db, productId, productCurrency),
+            fetchBookableBasePrice(db, productId, productCurrency),
+        ]);
+        return {
+            roomPrices: roomPrice == null ? [] : [roomPrice],
+            basePrices: basePrice == null ? [] : [basePrice],
+        };
+    }
+    catch (error) {
+        // Slim test fixtures may omit availability_slots/product_options/
+        // option_units. Keep reindex failure-isolated and fall back to the
+        // product row only for those expected schema gaps.
+        if (isMissingCatalogPricingDependencyError(error)) {
+            return { roomPrices: [], basePrices: [] };
+        }
+        throw error;
     }
-    return out;
+}
+async function fetchBookableRoomPrice(db, productId, productCurrency) {
+    const rows = await executeRows(db, sql `
+    WITH active_rules AS (
+      SELECT opr.id
+      FROM option_price_rules opr
+      INNER JOIN price_catalogs pc ON pc.id = opr.price_catalog_id
+      WHERE opr.product_id = ${productId}
+        AND opr.active = true
+        AND opr.is_default = true
+        AND pc.active = true
+        AND (pc.currency_code = ${productCurrency} OR pc.currency_code IS NULL)
+        AND EXISTS (
+          SELECT 1
+          FROM product_options po
+          WHERE po.id = opr.option_id
+            AND po.product_id = opr.product_id
+            AND po.status = 'active'
+        )
+        AND EXISTS (
+          SELECT 1
+          FROM availability_slots slot
+          WHERE slot.product_id = opr.product_id
+            AND slot.starts_at >= NOW()
+            AND slot.status::text IN ('open', 'planned', 'confirmed')
+            AND (slot.option_id IS NULL OR slot.option_id = opr.option_id)
+        )
+    ),
+    candidates AS (
+      SELECT COALESCE(tier.sell_amount_cents, unit_rule.sell_amount_cents) AS price
+      FROM active_rules rule
+      INNER JOIN option_unit_price_rules unit_rule
+        ON unit_rule.option_price_rule_id = rule.id
+      INNER JOIN option_units unit
+        ON unit.id = unit_rule.unit_id
+      LEFT JOIN option_unit_tiers tier
+        ON tier.option_unit_price_rule_id = unit_rule.id
+       AND tier.active = true
+      WHERE unit_rule.active = true
+        AND unit.unit_type = 'room'
+    )
+    SELECT MIN(price)::int AS price
+    FROM candidates
+    WHERE price > 0
+  `);
+    return readNullableInt(rows[0], "price");
+}
+async function fetchBookableBasePrice(db, productId, productCurrency) {
+    const rows = await executeRows(db, sql `
+    WITH active_rules AS (
+      SELECT opr.id, opr.base_sell_amount_cents
+      FROM option_price_rules opr
+      INNER JOIN price_catalogs pc ON pc.id = opr.price_catalog_id
+      WHERE opr.product_id = ${productId}
+        AND opr.active = true
+        AND opr.is_default = true
+        AND pc.active = true
+        AND (pc.currency_code = ${productCurrency} OR pc.currency_code IS NULL)
+        AND EXISTS (
+          SELECT 1
+          FROM product_options po
+          WHERE po.id = opr.option_id
+            AND po.product_id = opr.product_id
+            AND po.status = 'active'
+        )
+        AND EXISTS (
+          SELECT 1
+          FROM availability_slots slot
+          WHERE slot.product_id = opr.product_id
+            AND slot.starts_at >= NOW()
+            AND slot.status::text IN ('open', 'planned', 'confirmed')
+            AND (slot.option_id IS NULL OR slot.option_id = opr.option_id)
+        )
+    ),
+    candidates AS (
+      SELECT base_sell_amount_cents AS price
+      FROM active_rules
+      UNION ALL
+      SELECT COALESCE(tier.sell_amount_cents, unit_rule.sell_amount_cents) AS price
+      FROM active_rules rule
+      INNER JOIN option_unit_price_rules unit_rule
+        ON unit_rule.option_price_rule_id = rule.id
+      INNER JOIN option_units unit
+        ON unit.id = unit_rule.unit_id
+      LEFT JOIN option_unit_tiers tier
+        ON tier.option_unit_price_rule_id = unit_rule.id
+       AND tier.active = true
+      WHERE unit_rule.active = true
+        AND unit.unit_type <> 'room'
+    )
+    SELECT MIN(price)::int AS price
+    FROM candidates
+    WHERE price > 0
+  `);
+    return readNullableInt(rows[0], "price");
+}
+async function executeRows(db, query) {
+    // biome-ignore lint/suspicious/noExplicitAny: #1141 supports multiple drizzle driver result shapes
+    const result = await db.execute(query);
+    return Array.isArray(result) ? result : (result?.rows ?? []);
 }
 /**
  * Default loader reads the products row via raw SQL so we don't pull
- * the products schema into this file (would create a circular import
- * via the typed schema). The columns we read are stable enough that a
- * rename would break far more than this.
+ * the products schema into this file. The columns we read are stable
+ * enough that a rename would break far more than this.
  */
 async function defaultLoadProductPricing(db, productId) {
-    // biome-ignore lint/suspicious/noExplicitAny: drizzle's typed sql is overkill for two-column read
+    // biome-ignore lint/suspicious/noExplicitAny: #1141 keeps cross-package product lookup driver-agnostic
     const dbAny = db;
     const result = await dbAny.execute(sql `SELECT sell_amount_cents, sell_currency FROM products WHERE id = ${productId} LIMIT 1`);
     // postgres-js returns rows as an array-like; node-postgres returns `{ rows: [...] }`.
@@ -167,6 +240,39 @@ async function defaultLoadProductPricing(db, productId) {
         sellCurrency: first.sell_currency,
     };
 }
+function positive(value) {
+    return typeof value === "number" && value > 0 ? value : null;
+}
+function firstPositiveMin(values) {
+    let min = null;
+    for (const value of values) {
+        if (value <= 0)
+            continue;
+        if (min === null || value < min)
+            min = value;
+    }
+    return min;
+}
+function readNullableInt(row, key) {
+    const value = row?.[key];
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function isMissingCatalogPricingDependencyError(error) {
+    const err = error;
+    const code = typeof err?.code === "string" ? err.code : null;
+    if (code === "42P01" || code === "42703")
+        return true;
+    const message = typeof err?.message === "string" ? err.message.toLowerCase() : "";
+    return ((message.includes("relation") && message.includes("does not exist")) ||
+        message.includes("no such table") ||
+        message.includes("no such column"));
+}
 function toProjectionMap(a) {
     return new Map([
         ["priceFromAmountCents", a.priceFromAmountCents],
@@ -174,8 +280,10 @@ function toProjectionMap(a) {
         ["hasPricing", a.hasPricing],
     ]);
 }
-// Internal exports for unit tests — kept off the public surface.
+// Internal exports for unit tests - kept off the public surface.
 export const __test__ = {
     aggregatePricing,
     EMPTY_AGGREGATE,
+    firstPositiveMin,
+    isMissingCatalogPricingDependencyError,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/pricing",
-  "version": "0.77.1",
+  "version": "0.77.4",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -45,16 +45,16 @@
     "hono": "^4.12.10",
     "rrule": "^2.8.1",
     "zod": "^4.3.6",
-    "@voyantjs/availability": "0.77.1",
-    "@voyantjs/core": "0.77.1",
-    "@voyantjs/db": "0.77.1",
-    "@voyantjs/hono": "0.77.1",
-    "@voyantjs/products": "0.77.1"
+    "@voyantjs/availability": "0.77.4",
+    "@voyantjs/core": "0.77.4",
+    "@voyantjs/db": "0.77.4",
+    "@voyantjs/hono": "0.77.4",
+    "@voyantjs/products": "0.77.4"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
-    "@voyantjs/extras": "0.77.1",
-    "@voyantjs/facilities": "0.77.1",
+    "@voyantjs/extras": "0.77.4",
+    "@voyantjs/facilities": "0.77.4",
     "@voyantjs/voyant-typescript-config": "0.1.0"
   },
   "files": [