@open-mercato/core 0.7.1-develop.7154.1.981330c924 → 0.7.1-develop.7171.1.9b31dbba45

package/src/modules/wms/lib/invalidateInventoryEnricherCache.ts

@@ -0,0 +1,71 @@
+// Drop the cached WMS inventory enrichment for a tenant after a write that
+// changed the data it was derived from.
+//
+// The three WMS inventory enrichers cache their cross-module reads read-through
+// with a short TTL (see `enricherCacheTags.ts`). Every write surface that moves
+// balances, reservations, movements, profiles, warehouses or the sales-order
+// warehouse assignment drops the matching tags here, so a user sees the new
+// stock on the next request rather than after the TTL.
+//
+// The cache service prefixes tags with the *current* cache tenant, which is an
+// AsyncLocalStorage value set on the request path. A subscriber or command side
+// effect running outside that scope would otherwise write its invalidation
+// against the `tenant:global:` prefix and silently miss every entry the request
+// path stored. `runWithCacheTenant` re-enters the right scope, mirroring
+// `directory/subscribers/invalidateOrgScopeCache.ts`.
+
+import { runWithCacheTenant } from '@open-mercato/cache'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import {
+  WMS_INVENTORY_CACHE_TAG,
+  WMS_WAREHOUSE_CACHE_TAG,
+} from './enricherCacheTags'
+
+const logger = createLogger('wms').child({ component: 'enricher-cache' })
+
+type CacheService = {
+  deleteByTags(tags: string[]): Promise<number>
+}
+
+export type EnricherCacheScope = 'inventory' | 'warehouse' | 'all'
+
+type Resolver = { resolve: <T = unknown>(name: string) => T }
+
+function resolveCache(container: Resolver | null | undefined): CacheService | null {
+  if (!container?.resolve) return null
+  for (const name of ['cache', 'cacheService']) {
+    try {
+      const candidate = container.resolve<CacheService>(name)
+      if (candidate && typeof candidate.deleteByTags === 'function') return candidate
+    } catch {
+      // try the next registration name
+    }
+  }
+  return null
+}
+
+function tagsForScope(scope: EnricherCacheScope): string[] {
+  if (scope === 'inventory') return [WMS_INVENTORY_CACHE_TAG]
+  if (scope === 'warehouse') return [WMS_WAREHOUSE_CACHE_TAG]
+  return [WMS_INVENTORY_CACHE_TAG, WMS_WAREHOUSE_CACHE_TAG]
+}
+
+/**
+ * Best-effort tag invalidation. A failure is logged and swallowed: an
+ * invalidation that throws must never fail the write that triggered it, and the
+ * enricher TTL bounds how long a missed drop can serve stale data.
+ */
+export async function invalidateWmsInventoryEnricherCache(
+  container: Resolver | null | undefined,
+  tenantId: string | null | undefined,
+  scope: EnricherCacheScope = 'all',
+): Promise<void> {
+  if (!tenantId) return
+  const cache = resolveCache(container)
+  if (!cache) return
+  try {
+    await runWithCacheTenant(tenantId, () => cache.deleteByTags(tagsForScope(scope)))
+  } catch (err) {
+    logger.warn('Failed to invalidate WMS inventory enricher cache', { tenantId, scope, err })
+  }
+}

package/src/modules/wms/lib/inventoryEnricherCacheSubscriber.ts

@@ -0,0 +1,30 @@
+// Shared handler behind the WMS inventory enricher-cache invalidation
+// subscribers. Each subscriber file binds it to one event pattern, because
+// `metadata.event` takes a single pattern and the matcher is single-segment —
+// `wms.*` does NOT match `wms.inventory_balance.created`, so every event family
+// the enrichers read from is registered explicitly.
+//
+// It lives here rather than under `subscribers/` because the module generator
+// scans that directory recursively and treats every file it finds as a
+// subscriber.
+
+import {
+  invalidateWmsInventoryEnricherCache,
+  type EnricherCacheScope,
+} from './invalidateInventoryEnricherCache'
+
+type SubscriberContext = {
+  resolve: <T = unknown>(name: string) => T
+  tenantId?: string | null
+}
+
+export function createInventoryEnricherCacheHandler(scope: EnricherCacheScope) {
+  return async function handle(payload: unknown, ctx: SubscriberContext): Promise<void> {
+    const data = (payload ?? {}) as Record<string, unknown>
+    const tenantId =
+      typeof data.tenantId === 'string' && data.tenantId.length > 0
+        ? data.tenantId
+        : ctx.tenantId ?? null
+    await invalidateWmsInventoryEnricherCache(ctx, tenantId, scope)
+  }
+}

package/src/modules/wms/subscribers/invalidate-enricher-cache-balance.ts

@@ -0,0 +1,9 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+export const metadata = {
+  event: 'wms.inventory_balance.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-balance',
+}
+
+export default createInventoryEnricherCacheHandler('inventory')

package/src/modules/wms/subscribers/invalidate-enricher-cache-inventory.ts

@@ -0,0 +1,9 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+export const metadata = {
+  event: 'wms.inventory.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-inventory',
+}
+
+export default createInventoryEnricherCacheHandler('inventory')

package/src/modules/wms/subscribers/invalidate-enricher-cache-movement.ts

@@ -0,0 +1,9 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+export const metadata = {
+  event: 'wms.inventory_movement.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-movement',
+}
+
+export default createInventoryEnricherCacheHandler('inventory')

package/src/modules/wms/subscribers/invalidate-enricher-cache-profile.ts

@@ -0,0 +1,9 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+export const metadata = {
+  event: 'wms.inventory_profile.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-profile',
+}
+
+export default createInventoryEnricherCacheHandler('inventory')

package/src/modules/wms/subscribers/invalidate-enricher-cache-reservation.ts

@@ -0,0 +1,9 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+export const metadata = {
+  event: 'wms.inventory_reservation.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-reservation',
+}
+
+export default createInventoryEnricherCacheHandler('inventory')

package/src/modules/wms/subscribers/invalidate-enricher-cache-sales-line.ts

@@ -0,0 +1,14 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+// The sales module declares `sales.line.*` in its event registry and documents
+// it publicly, but no write surface emits it today — line writes ride the order
+// commands' `sales.order.*`. Registering the pattern anyway costs one ephemeral
+// subscription and means that wiring those events later cannot silently
+// reintroduce the staleness `invalidate-enricher-cache-sales-order.ts` closes.
+export const metadata = {
+  event: 'sales.line.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-sales-line',
+}
+
+export default createInventoryEnricherCacheHandler('warehouse')

package/src/modules/wms/subscribers/invalidate-enricher-cache-sales-order.ts

@@ -0,0 +1,18 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+// `wms.sales-order-inventory` reads the order's lines, and both the required
+// quantity behind `reservationSummary.status` and the variant list behind
+// `stockSummary` come from them. Order lines are written inside the sales order
+// commands, which emit `sales.order.*` — not a WMS event — so without this the
+// enrichment would stay stale for the whole TTL after a line edit.
+//
+// Scope `warehouse` rather than `inventory`: `wms:warehouse` is declared by the
+// sales-order enricher alone, so this drops exactly its entries and leaves the
+// two catalog enrichers' caches intact.
+export const metadata = {
+  event: 'sales.order.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-sales-order',
+}
+
+export default createInventoryEnricherCacheHandler('warehouse')

package/src/modules/wms/subscribers/invalidate-enricher-cache-variant.ts

@@ -0,0 +1,9 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+export const metadata = {
+  event: 'catalog.variant.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-variant',
+}
+
+export default createInventoryEnricherCacheHandler('inventory')

package/src/modules/wms/subscribers/invalidate-enricher-cache-warehouse.ts

@@ -0,0 +1,9 @@
+import { createInventoryEnricherCacheHandler } from '../lib/inventoryEnricherCacheSubscriber'
+
+export const metadata = {
+  event: 'wms.warehouse.*',
+  persistent: false,
+  id: 'wms:invalidate-enricher-cache-warehouse',
+}
+
+export default createInventoryEnricherCacheHandler('warehouse')