@open-mercato/core 0.6.1-develop.3260.1.dc719cac84 → 0.6.1-develop.3278.1.a4d26475e4

package/src/modules/customer_accounts/setup.ts

@@ -15,6 +15,76 @@ interface SeedScope {
   organizationId: string
 }
 
+type SchedulerServiceLike = {
+  register: (registration: {
+    id: string
+    name: string
+    description?: string
+    scopeType: 'system'
+    scheduleType: 'interval'
+    scheduleValue: string
+    timezone?: string
+    targetType: 'queue'
+    targetQueue: string
+    targetPayload?: Record<string, unknown>
+    sourceType: 'module'
+    sourceModule: string
+    isEnabled?: boolean
+  }) => Promise<void>
+}
+
+// Stable, deterministic UUIDs for the two domain-routing system schedules so
+// re-running setup re-upserts the same rows instead of creating duplicates.
+const DOMAIN_VERIFICATION_SCHEDULE_ID = '5e9ef5fc-1f4d-5b3d-8b58-8e1a5a4d1001'
+const DOMAIN_TLS_RETRY_SCHEDULE_ID = '5e9ef5fc-1f4d-5b3d-8b58-8e1a5a4d1002'
+
+function intervalSecondsFromEnv(envName: string, fallbackSeconds: number): string {
+  const parsed = Number.parseInt(process.env[envName] ?? '', 10)
+  const seconds = Number.isFinite(parsed) && parsed > 0 ? parsed : fallbackSeconds
+  return `${seconds}s`
+}
+
+async function registerDomainSchedules(
+  container: { hasRegistration?: (name: string) => boolean; resolve: (name: string) => unknown },
+): Promise<void> {
+  if (typeof container.hasRegistration !== 'function' || !container.hasRegistration('schedulerService')) {
+    return
+  }
+  const schedulerService = container.resolve('schedulerService') as SchedulerServiceLike
+
+  await schedulerService.register({
+    id: DOMAIN_VERIFICATION_SCHEDULE_ID,
+    name: 'Custom domain — DNS auto-verification',
+    description:
+      'Re-runs DNS verification for custom-domain mappings stuck in pending or dns_failed, and triggers TLS health checks on success.',
+    scopeType: 'system',
+    scheduleType: 'interval',
+    scheduleValue: intervalSecondsFromEnv('DOMAIN_AUTO_VERIFY_INTERVAL_SECONDS', 300),
+    timezone: 'UTC',
+    targetType: 'queue',
+    targetQueue: 'domain-verification',
+    sourceType: 'module',
+    sourceModule: 'customer_accounts',
+    isEnabled: true,
+  })
+
+  await schedulerService.register({
+    id: DOMAIN_TLS_RETRY_SCHEDULE_ID,
+    name: 'Custom domain — TLS retry',
+    description:
+      'Retries TLS certificate provisioning for verified or tls_failed custom-domain mappings, with batch cap and adaptive backoff on Let\'s Encrypt rate limits.',
+    scopeType: 'system',
+    scheduleType: 'interval',
+    scheduleValue: intervalSecondsFromEnv('DOMAIN_TLS_RETRY_INTERVAL_SECONDS', 1800),
+    timezone: 'UTC',
+    targetType: 'queue',
+    targetQueue: 'domain-tls-retry',
+    sourceType: 'module',
+    sourceModule: 'customer_accounts',
+    isEnabled: true,
+  })
+}
+
 const DEFAULT_ROLES = [
   {
     name: 'Portal Admin',
@@ -155,7 +225,7 @@ export const setup: ModuleSetupConfig = {
     await seedDefaultRoles(em, { tenantId, organizationId })
   },
 
-  async seedDefaults({ em, tenantId, organizationId }) {
+  async seedDefaults({ em, tenantId, organizationId, container }) {
     await seedDefaultRoles(em, { tenantId, organizationId })
     // Merge defaultCustomerRoleFeatures from all enabled modules
     try {
@@ -165,6 +235,16 @@ export const setup: ModuleSetupConfig = {
     } catch {
       // Modules may not be registered yet during initial setup
     }
+
+    // System-scoped schedules: register is idempotent, so re-running setup
+    // (or running it for additional tenants) just upserts the same two rows.
+    try {
+      await registerDomainSchedules(
+        container as { hasRegistration?: (name: string) => boolean; resolve: (name: string) => unknown },
+      )
+    } catch {
+      // Scheduler may not be installed in this deployment; ignore.
+    }
   },
 
   async seedExamples({ em, tenantId, organizationId }) {

package/src/modules/customer_accounts/subscribers/invalidateDomainCache.ts

@@ -0,0 +1,35 @@
+type CacheService = {
+  deleteByTags(tags: string[]): Promise<number>
+}
+
+export const metadata = {
+  event: 'customer_accounts.domain_mapping.*',
+  persistent: false,
+  id: 'customer_accounts:invalidate-domain-cache',
+}
+
+export default async function handle(
+  payload: unknown,
+  ctx: { resolve: <T = unknown>(name: string) => T },
+): Promise<void> {
+  const data = (payload ?? {}) as Record<string, unknown>
+  const hostname = typeof data.hostname === 'string' ? data.hostname : null
+  const organizationId = typeof data.organizationId === 'string' ? data.organizationId : null
+
+  let cache: CacheService | null = null
+  try {
+    cache = ctx.resolve<CacheService>('cache')
+  } catch {
+    return
+  }
+  if (!cache) return
+
+  const tags = ['domain_routing']
+  if (hostname) tags.push(`domain_routing:${hostname}`)
+  if (organizationId) tags.push(`domain_routing:org:${organizationId}`)
+  try {
+    await cache.deleteByTags(tags)
+  } catch {
+    // Best-effort cache invalidation. TTL is the backstop.
+  }
+}

package/src/modules/customer_accounts/subscribers/notifyDomainActivated.ts

@@ -0,0 +1,32 @@
+import type { EventBus } from '@open-mercato/events/types'
+
+export const metadata = {
+  event: 'customer_accounts.domain_mapping.activated',
+  persistent: true,
+  id: 'customer_accounts:notify-domain-activated',
+}
+
+export default async function handle(
+  payload: unknown,
+  ctx: { resolve: <T = unknown>(name: string) => T },
+): Promise<void> {
+  const data = (payload ?? {}) as Record<string, unknown>
+  const id = typeof data.id === 'string' ? data.id : null
+  const tenantId = typeof data.tenantId === 'string' ? data.tenantId : null
+  const organizationId = typeof data.organizationId === 'string' ? data.organizationId : null
+  const hostname = typeof data.hostname === 'string' ? data.hostname : ''
+  if (!id || !tenantId || !organizationId) return
+
+  try {
+    const eventBus = ctx.resolve<EventBus>('eventBus')
+    await eventBus.emitEvent('notifications.create', {
+      type: 'customer_accounts.domain_mapping.activated',
+      tenantId,
+      organizationId,
+      sourceEntityId: id,
+      data: { hostname },
+    })
+  } catch {
+    // Notifications module may be absent — best-effort.
+  }
+}

package/src/modules/customer_accounts/subscribers/notifyDomainDnsFailed.ts

@@ -0,0 +1,33 @@
+import type { EventBus } from '@open-mercato/events/types'
+
+export const metadata = {
+  event: 'customer_accounts.domain_mapping.dns_failed',
+  persistent: true,
+  id: 'customer_accounts:notify-domain-dns-failed',
+}
+
+export default async function handle(
+  payload: unknown,
+  ctx: { resolve: <T = unknown>(name: string) => T },
+): Promise<void> {
+  const data = (payload ?? {}) as Record<string, unknown>
+  const id = typeof data.id === 'string' ? data.id : null
+  const tenantId = typeof data.tenantId === 'string' ? data.tenantId : null
+  const organizationId = typeof data.organizationId === 'string' ? data.organizationId : null
+  const hostname = typeof data.hostname === 'string' ? data.hostname : ''
+  const reason = typeof data.reason === 'string' ? data.reason : ''
+  if (!id || !tenantId || !organizationId) return
+
+  try {
+    const eventBus = ctx.resolve<EventBus>('eventBus')
+    await eventBus.emitEvent('notifications.create', {
+      type: 'customer_accounts.domain_mapping.dns_failed',
+      tenantId,
+      organizationId,
+      sourceEntityId: id,
+      data: { hostname, reason },
+    })
+  } catch {
+    // Notifications module may be absent — best-effort.
+  }
+}

package/src/modules/customer_accounts/subscribers/notifyDomainTlsFailed.ts

@@ -0,0 +1,34 @@
+import type { EventBus } from '@open-mercato/events/types'
+
+export const metadata = {
+  event: 'customer_accounts.domain_mapping.tls_failed',
+  persistent: true,
+  id: 'customer_accounts:notify-domain-tls-failed',
+}
+
+export default async function handle(
+  payload: unknown,
+  ctx: { resolve: <T = unknown>(name: string) => T },
+): Promise<void> {
+  const data = (payload ?? {}) as Record<string, unknown>
+  const id = typeof data.id === 'string' ? data.id : null
+  const tenantId = typeof data.tenantId === 'string' ? data.tenantId : null
+  const organizationId = typeof data.organizationId === 'string' ? data.organizationId : null
+  const hostname = typeof data.hostname === 'string' ? data.hostname : ''
+  const reason = typeof data.reason === 'string' ? data.reason : ''
+  const retryCount = typeof data.retryCount === 'number' ? data.retryCount : 0
+  if (!id || !tenantId || !organizationId) return
+
+  try {
+    const eventBus = ctx.resolve<EventBus>('eventBus')
+    await eventBus.emitEvent('notifications.create', {
+      type: 'customer_accounts.domain_mapping.tls_failed',
+      tenantId,
+      organizationId,
+      sourceEntityId: id,
+      data: { hostname, reason, retryCount },
+    })
+  } catch {
+    // Notifications module may be absent — best-effort.
+  }
+}

package/src/modules/customer_accounts/subscribers/notifyDomainVerified.ts

@@ -0,0 +1,32 @@
+import type { EventBus } from '@open-mercato/events/types'
+
+export const metadata = {
+  event: 'customer_accounts.domain_mapping.verified',
+  persistent: true,
+  id: 'customer_accounts:notify-domain-verified',
+}
+
+export default async function handle(
+  payload: unknown,
+  ctx: { resolve: <T = unknown>(name: string) => T },
+): Promise<void> {
+  const data = (payload ?? {}) as Record<string, unknown>
+  const id = typeof data.id === 'string' ? data.id : null
+  const tenantId = typeof data.tenantId === 'string' ? data.tenantId : null
+  const organizationId = typeof data.organizationId === 'string' ? data.organizationId : null
+  const hostname = typeof data.hostname === 'string' ? data.hostname : ''
+  if (!id || !tenantId || !organizationId) return
+
+  try {
+    const eventBus = ctx.resolve<EventBus>('eventBus')
+    await eventBus.emitEvent('notifications.create', {
+      type: 'customer_accounts.domain_mapping.verified',
+      tenantId,
+      organizationId,
+      sourceEntityId: id,
+      data: { hostname },
+    })
+  } catch {
+    // Notifications module may be absent — best-effort.
+  }
+}

package/src/modules/customer_accounts/workers/domainTlsRetryWorker.ts

@@ -0,0 +1,84 @@
+import type { JobContext, QueuedJob, WorkerMeta } from '@open-mercato/queue'
+import type { DomainMappingService } from '@open-mercato/core/modules/customer_accounts/services/domainMappingService'
+
+export const metadata: WorkerMeta = {
+  queue: 'domain-tls-retry',
+  id: 'customer_accounts:domain-tls-retry',
+  concurrency: 1,
+}
+
+type HandlerContext = JobContext & {
+  resolve: <T = unknown>(name: string) => T
+}
+
+function parseInt32(value: string | undefined, fallback: number): number {
+  const parsed = Number.parseInt(value ?? '', 10)
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback
+  return parsed
+}
+
+function parseFloat01(value: string | undefined, fallback: number): number {
+  const parsed = Number.parseFloat(value ?? '')
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) return fallback
+  return parsed
+}
+
+// In-process adaptive-backoff state. Worker is concurrency=1, so a single
+// process owns this state. Surviving restarts is unnecessary because the
+// scheduler will simply re-evaluate on the next tick. See spec
+// "Phase 5 → Worker-level backoff" for the contract.
+let backoffMultiplier = 1
+let nextEligibleAt = 0
+
+const BACKOFF_CAP_HOURS = 6
+
+export default async function handle(_job: QueuedJob, ctx: HandlerContext): Promise<void> {
+  const baseIntervalSeconds = parseInt32(process.env.DOMAIN_TLS_RETRY_INTERVAL_SECONDS, 1800)
+  const batchSize = parseInt32(process.env.DOMAIN_TLS_RETRY_BATCH, 50)
+  const maxRetries = parseInt32(process.env.DOMAIN_TLS_MAX_RETRIES, 6)
+  const failureThreshold = parseFloat01(process.env.DOMAIN_TLS_RETRY_FAILURE_THRESHOLD, 0.8)
+  const capSeconds = BACKOFF_CAP_HOURS * 3600
+  const maxMultiplier = Math.max(1, Math.floor(capSeconds / baseIntervalSeconds))
+
+  if (Date.now() < nextEligibleAt) return
+
+  const service = ctx.resolve<DomainMappingService>('domainMappingService')
+  const candidates = await service.findPendingTls({ maxRetries, batchSize })
+  if (candidates.length === 0) {
+    backoffMultiplier = 1
+    nextEligibleAt = 0
+    return
+  }
+
+  let attempted = 0
+  let failed = 0
+  for (const mapping of candidates) {
+    attempted += 1
+    try {
+      const updated = await service.healthCheck(mapping.id)
+      if (updated.status !== 'active') failed += 1
+    } catch {
+      failed += 1
+    }
+  }
+
+  if (attempted === 0) return
+  const failureRate = failed / attempted
+
+  if (failureRate >= failureThreshold) {
+    backoffMultiplier = Math.min(backoffMultiplier * 2, maxMultiplier)
+    nextEligibleAt = Date.now() + backoffMultiplier * baseIntervalSeconds * 1000
+  } else {
+    backoffMultiplier = 1
+    nextEligibleAt = 0
+  }
+}
+
+// Test-only export so unit tests can reset state between runs.
+export const __testing__ = {
+  reset: () => {
+    backoffMultiplier = 1
+    nextEligibleAt = 0
+  },
+  getState: () => ({ backoffMultiplier, nextEligibleAt }),
+}

package/src/modules/customer_accounts/workers/domainVerificationWorker.ts

@@ -0,0 +1,45 @@
+import type { JobContext, QueuedJob, WorkerMeta } from '@open-mercato/queue'
+import type { DomainMappingService } from '@open-mercato/core/modules/customer_accounts/services/domainMappingService'
+
+export const metadata: WorkerMeta = {
+  queue: 'domain-verification',
+  id: 'customer_accounts:domain-verification',
+  concurrency: 1,
+}
+
+type HandlerContext = JobContext & {
+  resolve: <T = unknown>(name: string) => T
+}
+
+function parseSeconds(value: string | undefined, fallback: number): number {
+  const parsed = Number.parseInt(value ?? '', 10)
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback
+  return parsed
+}
+
+export default async function handle(_job: QueuedJob, ctx: HandlerContext): Promise<void> {
+  const service = ctx.resolve<DomainMappingService>('domainMappingService')
+
+  const intervalSeconds = parseSeconds(process.env.DOMAIN_AUTO_VERIFY_INTERVAL_SECONDS, 300)
+  const olderThanMs = intervalSeconds * 1000
+
+  const candidates = await service.findPendingVerification({ olderThanMs })
+  if (candidates.length === 0) return
+
+  for (const mapping of candidates) {
+    try {
+      const result = await service.verify(mapping.id)
+      if (result.domainMapping.status === 'verified') {
+        try {
+          await service.healthCheck(mapping.id)
+        } catch {
+          // healthCheck emits its own events on failure; swallow here so one
+          // bad domain doesn't poison the rest of the batch.
+        }
+      }
+    } catch {
+      // verify() emits dns_failed events on negative results. A thrown error
+      // here is unexpected (e.g. DB blip) — skip and let the next tick retry.
+    }
+  }
+}

package/src/modules/customers/api/companies/route.ts

@@ -14,7 +14,6 @@ import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import {
   applyEntityIdExclusion,
   applyEntityIdRestriction,
-  consumeAdvancedFilterState,
   findMatchingEntityIdsWithQueryEngine,
   findMatchingEntityIdsBySearchTokensAcrossSources,
   withScopedPayload,
@@ -27,7 +26,7 @@ import {
 import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
 import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
-import { mergeAdvancedFilters } from '@open-mercato/shared/lib/crud/advanced-filter-integration'
+import { consumeAdvancedFilterState, mergeAdvancedFilterTree } from '@open-mercato/shared/lib/crud/advanced-filter-integration'
 import {
   createCustomersCrudOpenApi,
   createPagedListResponseSchema,
@@ -119,8 +118,7 @@ const crud = makeCrudRoute({
       updatedAt: 'updated_at',
     },
     buildFilters: async (query, ctx) => {
-      const advancedQuery = { ...query }
-      const advancedFilterState = consumeAdvancedFilterState(query)
+      const advancedFilterTree = consumeAdvancedFilterState(query)
       const filters: Record<string, unknown> = { kind: { $eq: 'company' } }
       if (query.id) filters.id = { $eq: query.id }
       if (query.search) {
@@ -313,11 +311,8 @@ const crud = makeCrudRoute({
           console.warn('[customers.companies.list] custom field filter resolution failed; falling back to base filters', err)
         }
       }
-      if (ctx && advancedFilterState) {
-        const advancedFilters = mergeAdvancedFilters(
-          { ...filters },
-          advancedQuery as Record<string, unknown>,
-        )
+      if (ctx && advancedFilterTree) {
+        const advancedFilters = mergeAdvancedFilterTree({ ...filters }, advancedFilterTree)
         const matchedIds = await findMatchingEntityIdsWithQueryEngine({
           ctx,
           entityId: E.customers.customer_entity,

package/src/modules/customers/api/deals/route.ts

@@ -7,7 +7,6 @@ import { E } from '#generated/entities.ids.generated'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import {
   applyEntityIdRestriction,
-  consumeAdvancedFilterState,
   findMatchingEntityIdsWithQueryEngine,
   findMatchingEntityIdsBySearchTokensAcrossSources,
   parseScopedCommandInput,
@@ -20,7 +19,7 @@ import {
 } from '../openapi'
 import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
-import { mergeAdvancedFilters } from '@open-mercato/shared/lib/crud/advanced-filter-integration'
+import { consumeAdvancedFilterState, mergeAdvancedFilterTree } from '@open-mercato/shared/lib/crud/advanced-filter-integration'
 
 const rawBodySchema = z.object({}).passthrough()
 
@@ -133,8 +132,7 @@ const crud = makeCrudRoute<unknown, unknown, DealListQuery>({
     },
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     buildFilters: async (query: any, ctx) => {
-      const advancedQuery = { ...query }
-      const advancedFilterState = consumeAdvancedFilterState(query)
+      const advancedFilterTree = consumeAdvancedFilterState(query)
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const filters: Record<string, any> = {}
       if (query.search) {
@@ -182,11 +180,8 @@ const crud = makeCrudRoute<unknown, unknown, DealListQuery>({
       if (query.pipelineStageId) {
         filters.pipeline_stage_id = { $eq: query.pipelineStageId }
       }
-      if (ctx && advancedFilterState) {
-        const advancedFilters = mergeAdvancedFilters(
-          { ...filters },
-          advancedQuery as Record<string, unknown>,
-        )
+      if (ctx && advancedFilterTree) {
+        const advancedFilters = mergeAdvancedFilterTree({ ...filters }, advancedFilterTree)
         const matchedIds = await findMatchingEntityIdsWithQueryEngine({
           ctx,
           entityId: E.customers.customer_deal,

package/src/modules/customers/api/people/route.ts

@@ -14,7 +14,6 @@ import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import {
   applyEntityIdExclusion,
   applyEntityIdRestriction,
-  consumeAdvancedFilterState,
   findMatchingEntityIdsWithQueryEngine,
   findMatchingEntityIdsBySearchTokensAcrossSources,
   withScopedPayload,
@@ -23,7 +22,7 @@ import { buildCustomFieldFiltersFromQuery, extractAllCustomFieldEntries, splitCu
 import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
 import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
-import { mergeAdvancedFilters } from '@open-mercato/shared/lib/crud/advanced-filter-integration'
+import { consumeAdvancedFilterState, mergeAdvancedFilterTree } from '@open-mercato/shared/lib/crud/advanced-filter-integration'
 import {
   createCustomersCrudOpenApi,
   createPagedListResponseSchema,
@@ -112,8 +111,7 @@ const crud = makeCrudRoute({
       updatedAt: 'updated_at',
     },
     buildFilters: async (query, ctx) => {
-      const advancedQuery = { ...query }
-      const advancedFilterState = consumeAdvancedFilterState(query)
+      const advancedFilterTree = consumeAdvancedFilterState(query)
       const filters: Record<string, unknown> = { kind: { $eq: 'person' } }
       if (query.id) filters.id = { $eq: query.id }
       if (query.search) {
@@ -304,11 +302,8 @@ const crud = makeCrudRoute({
           console.warn('[customers.people.list] custom field filter resolution failed; falling back to base filters', err)
         }
       }
-      if (ctx && advancedFilterState) {
-        const advancedFilters = mergeAdvancedFilters(
-          { ...filters },
-          advancedQuery as Record<string, unknown>,
-        )
+      if (ctx && advancedFilterTree) {
+        const advancedFilters = mergeAdvancedFilterTree({ ...filters }, advancedFilterTree)
         const matchedIds = await findMatchingEntityIdsWithQueryEngine({
           ctx,
           entityId: E.customers.customer_entity,

package/src/modules/customers/api/utils.ts

@@ -6,7 +6,6 @@ import type { EntityId } from '@open-mercato/shared/modules/entities'
 import type { QueryCustomFieldSource, QueryJoinEdge, QueryEngine } from '@open-mercato/shared/lib/query/types'
 import { resolveSearchConfig } from '@open-mercato/shared/lib/search/config'
 import { tokenizeText } from '@open-mercato/shared/lib/search/tokenize'
-import { deserializeAdvancedFilter } from '@open-mercato/shared/lib/query/advanced-filter'
 import { SortDir } from '@open-mercato/shared/lib/query/types'
 
 const { withScopedPayload, parseScopedCommandInput } = createScopedApiHelpers({
@@ -278,19 +277,6 @@ export function applyEntityIdExclusion(
   }
 }
 
-export function consumeAdvancedFilterState(query: Record<string, unknown>) {
-  const state = deserializeAdvancedFilter(query)
-  if (!state) return null
-
-  for (const key of Object.keys(query)) {
-    if (key.startsWith('filter[')) {
-      delete query[key]
-    }
-  }
-
-  return state
-}
-
 export async function findMatchingEntityIdsWithQueryEngine({
   ctx,
   entityId,