@open-mercato/core 0.6.3-develop.3857.1.da89d7530c → 0.6.3-develop.3881.1.0b590ac4eb

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

@@ -427,37 +427,39 @@ const crud = makeCrudRoute({
         tenantId: ctx.auth?.tenantId ?? null,
         organizationId: ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null,
       }
-      const entities = await findWithDecryption(
-        em,
-        CustomerEntity,
-        {
-          id: { $in: ids },
-          deletedAt: null,
-          kind: 'person',
-        } as FilterQuery<CustomerEntity>,
-        undefined,
-        decryptionScope,
-      )
-      const entitiesById = new Map<string, CustomerEntity>()
-      for (const entity of entities) {
-        entitiesById.set(entity.id, entity)
-      }
-
-      const where: Record<string, unknown> = {
+      const profileWhere: Record<string, unknown> = {
         entity: { $in: ids },
         tenantId: ctx.auth?.tenantId ?? null,
       }
       if (ctx.selectedOrganizationId) {
-        where.organizationId = ctx.selectedOrganizationId
+        profileWhere.organizationId = ctx.selectedOrganizationId
       }
 
-      const profiles = await findWithDecryption(
-        em,
-        CustomerPersonProfile,
-        where as FilterQuery<CustomerPersonProfile>,
-        { populate: ['entity', 'company'] },
-        decryptionScope,
-      )
+      const [entities, profiles] = await Promise.all([
+        findWithDecryption(
+          em,
+          CustomerEntity,
+          {
+            id: { $in: ids },
+            deletedAt: null,
+            kind: 'person',
+          } as FilterQuery<CustomerEntity>,
+          undefined,
+          decryptionScope,
+        ),
+        findWithDecryption(
+          em,
+          CustomerPersonProfile,
+          profileWhere as FilterQuery<CustomerPersonProfile>,
+          { populate: ['entity', 'company'] },
+          decryptionScope,
+        ),
+      ])
+
+      const entitiesById = new Map<string, CustomerEntity>()
+      for (const entity of entities) {
+        entitiesById.set(entity.id, entity)
+      }
 
       const profilesByEntityId = new Map<string, CustomerPersonProfile>()
       for (const profile of profiles) {

package/src/modules/directory/subscribers/invalidateOrgScopeCache.ts

@@ -0,0 +1,39 @@
+// Invalidate the OrganizationScope cache when an organization mutates.
+//
+// resolveOrganizationScopeForRequest caches its result with a short TTL
+// (default 60s, OM_ORG_SCOPE_CACHE_TTL_MS). When an organization is
+// created/updated/deleted, the cached scope for users of the affected
+// tenant may be stale (visibility set or descendant tree changed). We
+// drop every cache entry tagged for that tenant; the TTL is the backstop
+// for races where the event fires after a request reads the cache.
+
+type CacheService = {
+  deleteByTags(tags: string[]): Promise<number>
+}
+
+export const metadata = {
+  event: 'directory.organization.*',
+  persistent: false,
+  id: 'directory:invalidate-org-scope-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 tenantId = typeof data.tenantId === 'string' ? data.tenantId : null
+  if (!tenantId) return
+  let cache: CacheService | null = null
+  try {
+    cache = ctx.resolve<CacheService>('cache')
+  } catch {
+    return
+  }
+  if (!cache) return
+  try {
+    await cache.deleteByTags([`org-scope:tenant:${tenantId}`])
+  } catch {
+    // best-effort; TTL is the backstop.
+  }
+}

package/src/modules/directory/utils/organizationScope.ts

@@ -5,6 +5,7 @@ import { Organization } from '@open-mercato/core/modules/directory/data/entities
 import { isAllOrganizationsSelection } from '@open-mercato/core/modules/directory/constants'
 import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
 import type { AuthContext } from '@open-mercato/shared/lib/auth/server'
+import type { CacheStrategy } from '@open-mercato/cache'
 import { parseSelectedOrganizationCookie, parseSelectedTenantCookie } from './scopeCookies'
 
 export { parseSelectedOrganizationCookie, parseSelectedTenantCookie }
@@ -16,6 +17,90 @@ export type OrganizationScope = {
   tenantId: string | null
 }
 
+// Phase 4 — short-TTL cache for resolveOrganizationScopeForRequest.
+// OrganizationScope is a pure function of (userId, tenantId, selectedOrgId,
+// requestedTenant) between membership changes; caching it bypasses 1
+// SELECT on `organizations` per CRUD request. TTL is short (60s default)
+// to keep staleness bounded for membership/visibility changes. Tag-based
+// invalidation kicks the cache when user_organizations or organizations
+// mutate (wired via invalidateOrganizationScopeCacheFor).
+const ORG_SCOPE_CACHE_KEY_PREFIX = 'org-scope'
+// Phase 4 default-off until the same readiness probe (`GET /api/customers/people`)
+// stays green with the cache layer engaged. Set `OM_ORG_SCOPE_CACHE_TTL_MS=60000`
+// (or any positive integer) to opt in once cross-request safety is re-verified.
+const ORG_SCOPE_DEFAULT_TTL_MS = 0
+
+function resolveOrgScopeTtlMs(): number {
+  const raw = process.env.OM_ORG_SCOPE_CACHE_TTL_MS
+  if (raw === undefined) return ORG_SCOPE_DEFAULT_TTL_MS
+  const parsed = Number(raw)
+  if (!Number.isFinite(parsed) || parsed < 0) return ORG_SCOPE_DEFAULT_TTL_MS
+  return parsed
+}
+
+function buildOrgScopeCacheKey(parts: {
+  userId: string
+  effectiveTenantId: string
+  selectedOrgId: string | null
+  requestedTenantId: string | null
+}): string {
+  const selected = parts.selectedOrgId ?? 'none'
+  const requested = parts.requestedTenantId ?? 'none'
+  return `${ORG_SCOPE_CACHE_KEY_PREFIX}:${parts.userId}:${parts.effectiveTenantId}:${selected}:${requested}`
+}
+
+function buildOrgScopeCacheTags(parts: { userId: string; effectiveTenantId: string }): string[] {
+  return [
+    `${ORG_SCOPE_CACHE_KEY_PREFIX}:user:${parts.userId}`,
+    `${ORG_SCOPE_CACHE_KEY_PREFIX}:tenant:${parts.effectiveTenantId}`,
+  ]
+}
+
+function isValidCachedScope(value: unknown): value is OrganizationScope {
+  if (typeof value !== 'object' || value === null) return false
+  const record = value as Partial<OrganizationScope>
+  const idOk = (v: unknown) => v === null || typeof v === 'string'
+  const arrOk = (v: unknown) => v === null || (Array.isArray(v) && v.every((entry) => typeof entry === 'string'))
+  return idOk(record.selectedId) && idOk(record.tenantId) && arrOk(record.filterIds) && arrOk(record.allowedIds)
+}
+
+function resolveCacheFromContainer(container: AwilixContainer | null | undefined): CacheStrategy | null {
+  if (!container) return null
+  try {
+    const c = container.resolve('cache') as CacheStrategy | undefined
+    if (c && typeof c.get === 'function' && typeof c.set === 'function') return c
+  } catch {
+    return null
+  }
+  return null
+}
+
+export async function invalidateOrganizationScopeCacheForUser(
+  container: AwilixContainer,
+  userId: string,
+): Promise<void> {
+  const cache = resolveCacheFromContainer(container)
+  if (!cache?.deleteByTags) return
+  try {
+    await cache.deleteByTags([`${ORG_SCOPE_CACHE_KEY_PREFIX}:user:${userId}`])
+  } catch (err) {
+    console.warn('[org-scope:cache] invalidate user failed', err)
+  }
+}
+
+export async function invalidateOrganizationScopeCacheForTenant(
+  container: AwilixContainer,
+  tenantId: string,
+): Promise<void> {
+  const cache = resolveCacheFromContainer(container)
+  if (!cache?.deleteByTags) return
+  try {
+    await cache.deleteByTags([`${ORG_SCOPE_CACHE_KEY_PREFIX}:tenant:${tenantId}`])
+  } catch (err) {
+    console.warn('[org-scope:cache] invalidate tenant failed', err)
+  }
+}
+
 function normalizeOrganizationId(value: unknown): string | null {
   if (typeof value !== 'string') return null
   const trimmed = value.trim()
@@ -270,6 +355,31 @@ export async function resolveOrganizationScopeForRequest({
   }
 
   const rawSelected = selectedId !== undefined ? selectedId : (request ? getSelectedOrganizationFromRequest(request) : null)
+  const normalizedSelectedId = typeof rawSelected === 'string' && rawSelected.trim().length > 0
+    ? rawSelected.trim()
+    : null
+
+  const userId = typeof auth.sub === 'string' && auth.sub.length > 0 ? auth.sub : null
+  const ttlMs = resolveOrgScopeTtlMs()
+  const cache = ttlMs > 0 ? resolveCacheFromContainer(container) : null
+  const cacheKey = userId
+    ? buildOrgScopeCacheKey({
+        userId,
+        effectiveTenantId,
+        selectedOrgId: normalizedSelectedId,
+        requestedTenantId: requestedTenantId ?? null,
+      })
+    : null
+
+  if (cache && cacheKey && typeof cache.get === 'function') {
+    try {
+      const cached = await cache.get(cacheKey)
+      if (isValidCachedScope(cached)) return cached
+    } catch (err) {
+      console.warn('[org-scope:cache] read failed', err)
+    }
+  }
+
   const baseScope = await resolveOrganizationScope({
     em,
     rbac,
@@ -278,6 +388,17 @@ export async function resolveOrganizationScopeForRequest({
     tenantId: effectiveTenantId,
   })
 
+  if (cache && cacheKey && userId && typeof cache.set === 'function') {
+    try {
+      await cache.set(cacheKey, baseScope, {
+        ttl: ttlMs,
+        tags: buildOrgScopeCacheTags({ userId, effectiveTenantId }),
+      })
+    } catch (err) {
+      console.warn('[org-scope:cache] write failed', err)
+    }
+  }
+
   return baseScope
 }
 

package/src/modules/workflows/backend/definitions/[id]/page.tsx

@@ -10,6 +10,7 @@ import { Button } from '@open-mercato/ui/primitives/button'
 import { Alert, AlertDescription } from '@open-mercato/ui/primitives/alert'
 import { apiFetch } from '@open-mercato/ui/backend/utils/api'
 import { readJsonSafe } from '@open-mercato/ui/backend/utils/serverErrors'
+import { formatWorkflowValidationError } from '../../../lib/format-validation-error'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
@@ -94,8 +95,8 @@ export default function EditWorkflowDefinitionPage() {
           body: JSON.stringify(payload),
         })
         if (!response.ok) {
-          const errorBody = await readJsonSafe<{ error?: string }>(response, null)
-          throw new Error(errorBody?.error || t('workflows.errors.updateFailed'))
+          const errorBody = await readJsonSafe<{ error?: string; details?: Array<{ path?: Array<string | number>; message?: string }> }>(response, null)
+          throw new Error(formatWorkflowValidationError(errorBody, t('workflows.errors.updateFailed')))
         }
         return response
       },

package/src/modules/workflows/backend/definitions/create/page.tsx

@@ -5,6 +5,7 @@ import { useRouter } from 'next/navigation'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { CrudForm } from '@open-mercato/ui/backend/CrudForm'
 import { apiFetch } from '@open-mercato/ui/backend/utils/api'
+import { readJsonSafe } from '@open-mercato/ui/backend/utils/serverErrors'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import {
   workflowDefinitionFormSchema,
@@ -18,6 +19,7 @@ import { StepsEditor } from '../../../components/StepsEditor'
 import { TransitionsEditor } from '../../../components/TransitionsEditor'
 import { Alert, AlertDescription, AlertTitle } from '@open-mercato/ui/primitives/alert'
 import { Zap } from 'lucide-react'
+import { formatWorkflowValidationError } from '../../../lib/format-validation-error'
 
 export default function CreateWorkflowDefinitionPage() {
   const router = useRouter()
@@ -33,8 +35,8 @@ export default function CreateWorkflowDefinitionPage() {
     })
 
     if (!response.ok) {
-      const error = await response.json()
-      throw new Error(error.error || t('workflows.errors.createFailed'))
+      const errorBody = await readJsonSafe<{ error?: string; details?: Array<{ path?: Array<string | number>; message?: string }> }>(response, null)
+      throw new Error(formatWorkflowValidationError(errorBody, t('workflows.errors.createFailed')))
     }
 
     router.push('/backend/definitions')

package/src/modules/workflows/backend/definitions/visual-editor/page.tsx

@@ -989,7 +989,7 @@ export default function VisualEditorPage() {
               <p className="mb-3 text-xs text-muted-foreground">{t('workflows.visualEditor.tapToAdd')}</p>
 
               <div className="flex gap-2 overflow-x-auto pb-1">
-                {(['start', 'userTask', 'automated', 'waitForSignal', 'subWorkflow', 'end'] as const).map((nodeType) => {
+                {(['start', 'userTask', 'automated', 'waitForSignal', 'waitForTimer', 'subWorkflow', 'end'] as const).map((nodeType) => {
                   const Icon = NODE_TYPE_ICONS[nodeType]
                   return (
                     <button
@@ -1078,6 +1078,21 @@ export default function VisualEditorPage() {
                   <div className="mt-0.5 text-xs text-muted-foreground">{NODE_TYPE_LABELS.waitForSignal.description}</div>
                 </button>
 
+                {/* WAIT_FOR_TIMER Step */}
+                <button
+                  onClick={() => handleAddNode('waitForTimer')}
+                  className="group relative w-full cursor-pointer rounded-xl border-2 border-border bg-background px-4 py-3 text-left transition-all hover:border-muted-foreground/30 hover:shadow-md"
+                >
+                  <div className={`absolute right-2 top-2 ${NODE_TYPE_COLORS.waitForTimer} opacity-60 transition-opacity group-hover:opacity-100`}>
+                    {(() => {
+                      const Icon = NODE_TYPE_ICONS.waitForTimer
+                      return <Icon className="h-4 w-4" />
+                    })()}
+                  </div>
+                  <div className="text-sm font-semibold text-foreground">{NODE_TYPE_LABELS.waitForTimer.title}</div>
+                  <div className="mt-0.5 text-xs text-muted-foreground">{NODE_TYPE_LABELS.waitForTimer.description}</div>
+                </button>
+
                 {/* SUB_WORKFLOW Step */}
                 <button
                   onClick={() => handleAddNode('subWorkflow')}
@@ -1182,6 +1197,7 @@ function getDefaultLabel(nodeType: string): string {
     automated: 'New Automated Task',
     decision: 'Decision Point',
     waitForSignal: 'Wait for Signal',
+    waitForTimer: 'Wait for Timer',
   }
   return labels[nodeType] || 'New Step'
 }
@@ -1194,6 +1210,7 @@ function getDefaultBadge(nodeType: string): string {
     automated: 'Automated',
     decision: 'Decision',
     waitForSignal: 'Wait for Signal',
+    waitForTimer: 'Wait for Timer',
   }
   return badges[nodeType] || 'Task'
 }

package/src/modules/workflows/components/ActivitiesEditor.tsx

@@ -273,6 +273,45 @@ export function ActivitiesEditor({ value = [], onChange, error }: ActivitiesEdit
                 </div>
               </div>
 
+              {activity.activityType === 'WAIT' && (
+                <div className="space-y-3">
+                  <div>
+                    <Label htmlFor={`activity-${index}-duration`} className="text-xs">
+                      {t('workflows.activities.waitDuration')}
+                    </Label>
+                    <Input
+                      id={`activity-${index}-duration`}
+                      value={activity.config?.duration || ''}
+                      onChange={(e) => updateActivity(index, 'config', { ...activity.config, duration: e.target.value, until: undefined })}
+                      placeholder={t('workflows.activities.waitDurationPlaceholder')}
+                      disabled={!!activity.config?.until}
+                      className="mt-1"
+                    />
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {t('workflows.activities.waitDurationDescription')}
+                    </p>
+                  </div>
+                  <div className="text-xs text-center text-muted-foreground">{t('workflows.activities.waitOr')}</div>
+                  <div>
+                    <Label htmlFor={`activity-${index}-until`} className="text-xs">
+                      {t('workflows.activities.waitUntil')}
+                    </Label>
+                    <Input
+                      id={`activity-${index}-until`}
+                      type="datetime-local"
+                      value={activity.config?.until ? activity.config.until.slice(0, 16) : ''}
+                      onChange={(e) => updateActivity(index, 'config', { ...activity.config, until: e.target.value ? new Date(e.target.value).toISOString() : undefined, duration: undefined })}
+                      disabled={!!activity.config?.duration}
+                      className="mt-1"
+                    />
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {t('workflows.activities.waitUntilDescription')}
+                    </p>
+                  </div>
+                </div>
+              )}
+
+              {activity.activityType !== 'WAIT' && (
               <div>
                 <Label htmlFor={`activity-${index}-config`} className="text-xs">
                   {t('workflows.activities.config')} (JSON)
@@ -293,6 +332,7 @@ export function ActivitiesEditor({ value = [], onChange, error }: ActivitiesEdit
                   className="mt-1 font-mono text-xs"
                 />
               </div>
+              )}
             </div>
           </div>
         ))}