@open-mercato/core 0.6.4-develop.4106.1.12c205a613 → 0.6.4-develop.4113.1.5e87922616

package/dist/modules/planner/components/availabilityRulesEditorState.js

@@ -0,0 +1,8 @@
+function resolveRuleSetSelectValue(ruleSets, selectedRulesetId) {
+  if (!selectedRulesetId) return void 0;
+  return ruleSets.some((ruleSet) => ruleSet.id === selectedRulesetId) ? selectedRulesetId : void 0;
+}
+export {
+  resolveRuleSetSelectValue
+};
+//# sourceMappingURL=availabilityRulesEditorState.js.map

package/dist/modules/planner/components/availabilityRulesEditorState.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/planner/components/availabilityRulesEditorState.ts"],
+  "sourcesContent": ["export type AvailabilityRuleSetOption = {\n  id: string\n}\n\nexport function resolveRuleSetSelectValue(\n  ruleSets: AvailabilityRuleSetOption[],\n  selectedRulesetId: string | null | undefined,\n): string | undefined {\n  if (!selectedRulesetId) return undefined\n  return ruleSets.some((ruleSet) => ruleSet.id === selectedRulesetId) ? selectedRulesetId : undefined\n}\n"],
+  "mappings": "AAIO,SAAS,0BACd,UACA,mBACoB;AACpB,MAAI,CAAC,kBAAmB,QAAO;AAC/B,SAAO,SAAS,KAAK,CAAC,YAAY,QAAQ,OAAO,iBAAiB,IAAI,oBAAoB;AAC5F;",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/core",
-  "version": "0.6.4-develop.4106.1.12c205a613",
+  "version": "0.6.4-develop.4113.1.5e87922616",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -243,16 +243,16 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@open-mercato/ai-assistant": "0.6.4-develop.4106.1.12c205a613",
-    "@open-mercato/shared": "0.6.4-develop.4106.1.12c205a613",
-    "@open-mercato/ui": "0.6.4-develop.4106.1.12c205a613",
+    "@open-mercato/ai-assistant": "0.6.4-develop.4113.1.5e87922616",
+    "@open-mercato/shared": "0.6.4-develop.4113.1.5e87922616",
+    "@open-mercato/ui": "0.6.4-develop.4113.1.5e87922616",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@open-mercato/ai-assistant": "0.6.4-develop.4106.1.12c205a613",
-    "@open-mercato/shared": "0.6.4-develop.4106.1.12c205a613",
-    "@open-mercato/ui": "0.6.4-develop.4106.1.12c205a613",
+    "@open-mercato/ai-assistant": "0.6.4-develop.4113.1.5e87922616",
+    "@open-mercato/shared": "0.6.4-develop.4113.1.5e87922616",
+    "@open-mercato/ui": "0.6.4-develop.4113.1.5e87922616",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.1",

package/src/modules/currencies/services/rateFetchingService.ts

@@ -13,6 +13,13 @@ export interface FetchOptions {
   forceUpdate?: boolean
 }
 
+const exchangeRateKey = (
+  fromCurrencyCode: string,
+  toCurrencyCode: string,
+  date: Date,
+  source: string
+): string => `${fromCurrencyCode}|${toCurrencyCode}|${date.getTime()}|${source}`
+
 export class RateFetchingService {
   private providers: Map<string, RateProvider>
 
@@ -103,25 +110,47 @@ export class RateFetchingService {
     rates: RateProviderResult[],
     scope: { tenantId: string; organizationId: string }
   ): Promise<number> {
+    if (rates.length === 0) return 0
+
     let stored = 0
 
     await this.em.transactional(async (em) => {
+      // Prefetch every existing rate that could match this batch in a single query,
+      // then index by composite key so the per-rate loop never hits the database.
+      const fromCurrencyCodes = Array.from(new Set(rates.map((rate) => rate.fromCurrencyCode)))
+      const toCurrencyCodes = Array.from(new Set(rates.map((rate) => rate.toCurrencyCode)))
+      const sources = Array.from(new Set(rates.map((rate) => rate.source)))
+      const dates = Array.from(new Set(rates.map((rate) => rate.date.getTime()))).map(
+        (time) => new Date(time)
+      )
+
+      const existingRates = await em.find(ExchangeRate, {
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+        fromCurrencyCode: { $in: fromCurrencyCodes },
+        toCurrencyCode: { $in: toCurrencyCodes },
+        date: { $in: dates },
+        source: { $in: sources },
+      })
+
+      const existingByKey = new Map<string, ExchangeRate>()
+      for (const existing of existingRates) {
+        existingByKey.set(
+          exchangeRateKey(existing.fromCurrencyCode, existing.toCurrencyCode, existing.date, existing.source),
+          existing
+        )
+      }
+
+      const now = new Date()
       for (const rate of rates) {
-        // Check if rate already exists
-        const existing = await em.findOne(ExchangeRate, {
-          organizationId: scope.organizationId,
-          tenantId: scope.tenantId,
-          fromCurrencyCode: rate.fromCurrencyCode,
-          toCurrencyCode: rate.toCurrencyCode,
-          date: rate.date,
-          source: rate.source,
-        })
+        const key = exchangeRateKey(rate.fromCurrencyCode, rate.toCurrencyCode, rate.date, rate.source)
+        const existing = existingByKey.get(key)
 
         if (existing) {
           // Update existing rate
           existing.rate = rate.rate
           existing.type = rate.type ?? null
-          existing.updatedAt = new Date()
+          existing.updatedAt = now
           em.persist(existing)
         } else {
           // Create new rate
@@ -135,15 +164,17 @@ export class RateFetchingService {
             source: rate.source,
             type: rate.type ?? null,
             isActive: true,
-            createdAt: new Date(),
-            updatedAt: new Date(),
+            createdAt: now,
+            updatedAt: now,
           })
           em.persist(newRate)
+          // Track so duplicate keys within the same batch update in memory instead of double-inserting.
+          existingByKey.set(key, newRate)
         }
 
         stored++
       }
-      
+
       // Flush all changes at once
       await em.flush()
     })

package/src/modules/entities/api/definitions.batch.ts

@@ -65,6 +65,20 @@ export async function POST(req: Request) {
 
   await em.begin()
   try {
+    // Prefetch every existing definition for this entity in a single query, then index
+    // by key so the per-definition loop resolves create/update without round trips.
+    const defByKey = new Map<string, any>()
+    const keys = definitions.map((d) => d.key)
+    if (keys.length > 0) {
+      const existingDefs = await em.find(CustomFieldDef, {
+        entityId,
+        key: { $in: keys },
+        organizationId: auth.orgId ?? null,
+        tenantId: auth.tenantId ?? null,
+      })
+      for (const existing of existingDefs) defByKey.set(existing.key, existing)
+    }
+
     for (const [idx, d] of definitions.entries()) {
       const where: any = {
         entityId,
@@ -72,8 +86,11 @@ export async function POST(req: Request) {
         organizationId: auth.orgId ?? null,
         tenantId: auth.tenantId ?? null,
       }
-      let def = await em.findOne(CustomFieldDef, where)
-      if (!def) def = em.create(CustomFieldDef, { ...where, createdAt: new Date() })
+      let def = defByKey.get(d.key)
+      if (!def) {
+        def = em.create(CustomFieldDef, { ...where, createdAt: new Date() })
+        defByKey.set(d.key, def)
+      }
       def.kind = d.kind
 
       const inCfg = (d as any).configJson ?? {}

package/src/modules/entities/lib/field-definitions.ts

@@ -73,15 +73,28 @@ export async function ensureCustomFieldDefinitions(
   let updated = 0
   let unchanged = 0
 
+  // Prefetch every existing definition the batch could touch in a single query,
+  // then index by composite key so the nested loop never issues per-field lookups.
+  const entityIds = Array.from(new Set(sets.map((set) => set.entity)))
+  const fieldKeys = Array.from(new Set(sets.flatMap((set) => set.fields.map((field) => field.key))))
+  const existingByKey = new Map<string, CustomFieldDef>()
+  if (entityIds.length > 0 && fieldKeys.length > 0) {
+    const existingDefs = await em.find(CustomFieldDef, {
+      entityId: { $in: entityIds },
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      key: { $in: fieldKeys },
+    })
+    for (const def of existingDefs) {
+      existingByKey.set(`${def.entityId}|${def.key}`, def)
+    }
+  }
+
+  let dirty = false
+
   for (const set of sets) {
     for (const field of set.fields) {
-      const where = {
-        entityId: set.entity,
-        organizationId: scope.organizationId,
-        tenantId: scope.tenantId,
-        key: field.key,
-      }
-      const existing = await em.findOne(CustomFieldDef, where)
+      const existing = existingByKey.get(`${set.entity}|${field.key}`) ?? null
       const configJson: Record<string, unknown> = {}
 
       for (const key of CONFIG_PASSTHROUGH_KEYS) {
@@ -91,19 +104,21 @@ export async function ensureCustomFieldDefinitions(
 
       if (!existing) {
         if (!scope.dryRun) {
-          await em.persist(
-            em.create(CustomFieldDef, {
-              entityId: set.entity,
-              organizationId: scope.organizationId,
-              tenantId: scope.tenantId,
-              key: field.key,
-              kind: field.kind,
-              configJson,
-              isActive: true,
-              createdAt: new Date(),
-              updatedAt: new Date(),
-            })
-          ).flush()
+          const createdDef = em.create(CustomFieldDef, {
+            entityId: set.entity,
+            organizationId: scope.organizationId,
+            tenantId: scope.tenantId,
+            key: field.key,
+            kind: field.kind,
+            configJson,
+            isActive: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          })
+          em.persist(createdDef)
+          // Track so duplicate (entity, key) pairs within the batch update in memory instead of double-inserting.
+          existingByKey.set(`${set.entity}|${field.key}`, createdDef)
+          dirty = true
         }
         created++
         continue
@@ -127,11 +142,17 @@ export async function ensureCustomFieldDefinitions(
         existing.isActive = true
         existing.updatedAt = new Date()
         if (existing.deletedAt) existing.deletedAt = null
-        await em.flush()
+        em.persist(existing)
+        dirty = true
       }
       updated++
     }
   }
 
+  if (dirty) {
+    // Single flush for the whole batch instead of one round trip per field.
+    await em.flush()
+  }
+
   return { created, updated, unchanged }
 }

package/src/modules/perspectives/services/perspectiveService.ts

@@ -339,15 +339,23 @@ export async function saveRolePerspectives(
 
   const results: ResolvedRolePerspective[] = []
 
-  for (const roleId of input.roleIds) {
-    let record = await em.findOne(RolePerspective, {
-      roleId,
+  // Prefetch every matching role perspective in a single query, then index by role id
+  // so the loop resolves create/update without a lookup per role.
+  const recordByRole = new Map<string, RolePerspective>()
+  if (input.roleIds.length) {
+    const existingRecords = await em.find(RolePerspective, {
+      roleId: { $in: input.roleIds },
       tableId,
       tenantId,
       organizationId,
       name: input.name,
       deletedAt: null,
     })
+    for (const existing of existingRecords) recordByRole.set(existing.roleId, existing)
+  }
+
+  for (const roleId of input.roleIds) {
+    let record = recordByRole.get(roleId) ?? null
     if (!record) {
       record = em.create(RolePerspective, {
         roleId,
@@ -361,6 +369,7 @@ export async function saveRolePerspectives(
         updatedAt: now,
       })
       em.persist(record)
+      recordByRole.set(roleId, record)
     } else {
       record.settingsJson = input.settings
       record.updatedAt = now

package/src/modules/planner/components/AvailabilityRulesEditor.tsx

@@ -30,6 +30,7 @@ import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import { parseAvailabilityRuleWindow } from '@open-mercato/core/modules/planner/lib/availabilitySchedule'
 import { CrudForm, type CrudField } from '@open-mercato/ui/backend/CrudForm'
 import { Calendar, Clock, List, PencilLine, Plus, Trash2 } from 'lucide-react'
+import { resolveRuleSetSelectValue } from './availabilityRulesEditorState'
 
 type AvailabilityRepeat = 'once' | 'daily' | 'weekly'
 type AvailabilitySubjectType = 'member' | 'resource' | 'ruleset'
@@ -398,6 +399,7 @@ export function AvailabilityRulesEditor({
   const [createRuleSetOpen, setCreateRuleSetOpen] = React.useState(false)
   const [isWeeklyAutoSaving, setIsWeeklyAutoSaving] = React.useState(false)
   const [customOverridesEnabled, setCustomOverridesEnabled] = React.useState(false)
+  const [selectedRulesetId, setSelectedRulesetId] = React.useState<string | null>(rulesetId ?? null)
   const autoSaveTimerRef = React.useRef<number | null>(null)
   const lastSavedWeeklyKeyRef = React.useRef<string | null>(null)
   const weeklySaveStateRef = React.useRef({ inFlight: false, queued: false })
@@ -409,7 +411,12 @@ export function AvailabilityRulesEditor({
   >(null)
   const timezoneOptions = React.useMemo(() => getTimezoneOptions(), [])
 
-  const usingRuleSet = Boolean(rulesetId) && availabilityRules.length === 0 && !customOverridesEnabled
+  React.useEffect(() => {
+    setSelectedRulesetId(rulesetId ?? null)
+  }, [rulesetId])
+
+  const effectiveRulesetId = selectedRulesetId
+  const usingRuleSet = Boolean(effectiveRulesetId) && availabilityRules.length === 0 && !customOverridesEnabled
   const activeRules = usingRuleSet ? rulesetRules : availabilityRules
   const scheduleRules = React.useMemo(() => {
     const dateBlockers = new Set<string>()
@@ -547,7 +554,7 @@ export function AvailabilityRulesEditor({
   }, [labelPrefix, subjectId, subjectType, t])
 
   const refreshRuleSetRules = React.useCallback(async () => {
-    if (!rulesetId) {
+    if (!effectiveRulesetId) {
       setRulesetRules([])
       return
     }
@@ -556,7 +563,7 @@ export function AvailabilityRulesEditor({
         page: '1',
         pageSize: '100',
         subjectType: 'ruleset',
-        subjectIds: rulesetId,
+        subjectIds: effectiveRulesetId,
       })
       const call = await apiCall<{ items?: AvailabilityRule[] }>(`/api/planner/availability?${params.toString()}`)
       const items = Array.isArray(call.result?.items) ? call.result.items : []
@@ -564,7 +571,7 @@ export function AvailabilityRulesEditor({
     } catch {
       setRulesetRules([])
     }
-  }, [rulesetId])
+  }, [effectiveRulesetId])
 
   const refreshRuleSets = React.useCallback(async () => {
     if (!onRulesetChange) return
@@ -653,10 +660,10 @@ export function AvailabilityRulesEditor({
 
   React.useEffect(() => {
     if (timezoneDirty) return
-    if (!usingRuleSet || !rulesetId) return
-    const ruleset = ruleSets.find((entry) => entry.id === rulesetId)
+    if (!usingRuleSet || !effectiveRulesetId) return
+    const ruleset = ruleSets.find((entry) => entry.id === effectiveRulesetId)
     if (ruleset?.timezone) setTimezone(ruleset.timezone)
-  }, [rulesetId, ruleSets, timezoneDirty, usingRuleSet])
+  }, [effectiveRulesetId, ruleSets, timezoneDirty, usingRuleSet])
 
   React.useEffect(() => {
     if (availabilityRules.length > 0) {
@@ -665,10 +672,10 @@ export function AvailabilityRulesEditor({
   }, [availabilityRules.length])
 
   React.useEffect(() => {
-    if (!rulesetId) {
+    if (!effectiveRulesetId) {
       setCustomOverridesEnabled(false)
     }
-  }, [rulesetId])
+  }, [effectiveRulesetId])
 
   const refreshBookedEvents = React.useCallback(async () => {
     if (!loadBookedEvents) return
@@ -764,7 +771,7 @@ export function AvailabilityRulesEditor({
   const saveWeeklyHours = React.useCallback(async (options?: { silentSuccess?: boolean; skipRefresh?: boolean }) => {
     if (isReadOnly) return
     const subjectForRules: AvailabilitySubjectType = usingRuleSet ? 'ruleset' : subjectType
-    const subjectIdForRules = usingRuleSet ? (rulesetId ?? '') : subjectId
+    const subjectIdForRules = usingRuleSet ? (effectiveRulesetId ?? '') : subjectId
     if (!subjectIdForRules) return
     if (weeklyHasErrors) return
 
@@ -802,7 +809,7 @@ export function AvailabilityRulesEditor({
     listLabels.saveWeeklySuccess,
     refreshAvailability,
     refreshRuleSetRules,
-    rulesetId,
+    effectiveRulesetId,
     subjectId,
     subjectType,
     timezone,
@@ -856,7 +863,7 @@ export function AvailabilityRulesEditor({
     if (isReadOnly) return
     if (timezoneSaveInFlightRef.current) return
     const trimmedTimezone = nextTimezone.trim() || 'UTC'
-    const rulesetTimezoneId = subjectType === 'ruleset' ? subjectId : rulesetId
+    const rulesetTimezoneId = subjectType === 'ruleset' ? subjectId : effectiveRulesetId
     const rulesToUpdate = activeRules.filter((rule) => rule.timezone !== trimmedTimezone)
     if (!rulesToUpdate.length && !rulesetTimezoneId) {
       setTimezoneDirty(false)
@@ -895,7 +902,7 @@ export function AvailabilityRulesEditor({
     listLabels.timezoneSaveError,
     refreshAvailability,
     refreshRuleSetRules,
-    rulesetId,
+    effectiveRulesetId,
     subjectId,
     subjectType,
     isReadOnly,
@@ -927,7 +934,7 @@ export function AvailabilityRulesEditor({
 
   const handleCustomize = React.useCallback(async () => {
     if (isReadOnly) return
-    if (!rulesetId) return
+    if (!effectiveRulesetId) return
     try {
       const creations = rulesetRules.map((rule) => createCrud('planner/availability', {
         subjectType,
@@ -945,11 +952,11 @@ export function AvailabilityRulesEditor({
       const message = error instanceof Error ? error.message : listLabels.saveWeeklyError
       flash(message, 'error')
     }
-  }, [listLabels.saveWeeklyError, refreshAvailability, rulesetId, rulesetRules, subjectId, subjectType, isReadOnly])
+  }, [effectiveRulesetId, listLabels.saveWeeklyError, refreshAvailability, rulesetRules, subjectId, subjectType, isReadOnly])
 
   const handleResetToRuleSet = React.useCallback(async () => {
     if (isReadOnly) return
-    if (!rulesetId) return
+    if (!effectiveRulesetId) return
     try {
       await Promise.all(
         availabilityRules.map((rule) => deleteCrud('planner/availability', rule.id, { errorMessage: listLabels.saveWeeklyError })),
@@ -960,12 +967,12 @@ export function AvailabilityRulesEditor({
       const message = error instanceof Error ? error.message : listLabels.saveWeeklyError
       flash(message, 'error')
     }
-  }, [availabilityRules, listLabels.saveWeeklyError, refreshAvailability, rulesetId, isReadOnly])
+  }, [availabilityRules, effectiveRulesetId, listLabels.saveWeeklyError, refreshAvailability, isReadOnly])
 
   const handleRuleSetChange = React.useCallback(async (nextId: string | null) => {
     if (isReadOnly) return
     if (!onRulesetChange) return
-    if (availabilityRules.length > 0 && nextId !== rulesetId) {
+    if (availabilityRules.length > 0 && nextId !== effectiveRulesetId) {
       const confirmed = await confirm({
         title: listLabels.ruleSetConfirm,
         variant: 'default',
@@ -975,17 +982,23 @@ export function AvailabilityRulesEditor({
         availabilityRules.map((rule) => deleteCrud('planner/availability', rule.id, { errorMessage: listLabels.saveWeeklyError })),
       )
     }
+    setSelectedRulesetId(nextId)
     setCustomOverridesEnabled(false)
-    await onRulesetChange(nextId)
-    await refreshAvailability()
+    try {
+      await onRulesetChange(nextId)
+      await refreshAvailability()
+    } catch (error) {
+      setSelectedRulesetId(effectiveRulesetId)
+      throw error
+    }
   }, [
     availabilityRules,
     confirm,
+    effectiveRulesetId,
     listLabels.ruleSetConfirm,
     listLabels.saveWeeklyError,
     onRulesetChange,
     refreshAvailability,
-    rulesetId,
     isReadOnly,
   ])
 
@@ -1058,6 +1071,7 @@ export function AvailabilityRulesEditor({
     }
     await refreshRuleSets()
     if (onRulesetChange) {
+      setSelectedRulesetId(id)
       await onRulesetChange(id)
       await refreshAvailability()
     }
@@ -1155,7 +1169,7 @@ export function AvailabilityRulesEditor({
     if (isReadOnly) return
     if (editorUnavailable && !canManageUnavailability) return
     const subjectForRules: AvailabilitySubjectType = usingRuleSet ? 'ruleset' : subjectType
-    const subjectIdForRules = usingRuleSet ? (rulesetId ?? '') : subjectId
+    const subjectIdForRules = usingRuleSet ? (effectiveRulesetId ?? '') : subjectId
     if (!subjectIdForRules) return
     if (!editorUnavailable && editorWindowErrors.some(Boolean)) return
     const validWindows = editorWindows
@@ -1235,7 +1249,7 @@ export function AvailabilityRulesEditor({
     refreshAvailability,
     refreshRuleSetRules,
     reasonEntriesById,
-    rulesetId,
+    effectiveRulesetId,
     subjectId,
     subjectType,
     timezone,
@@ -1316,7 +1330,7 @@ export function AvailabilityRulesEditor({
                 <span className="text-xs text-muted-foreground">{listLabels.ruleSetLoading}</span>
               ) : (
                 <Select
-                  value={rulesetId || undefined}
+                  value={resolveRuleSetSelectValue(ruleSets, effectiveRulesetId)}
                   onValueChange={(value) => {
                     void handleRuleSetChange(value ? value : null)
                   }}
@@ -1338,12 +1352,12 @@ export function AvailabilityRulesEditor({
                 <Plus className="size-4 mr-2" aria-hidden />
                 {listLabels.ruleSetCreateLabel}
               </Button>
-              {rulesetId && usingRuleSet ? (
+              {effectiveRulesetId && usingRuleSet ? (
                 <Button type="button" variant="outline" size="sm" onClick={handleCustomize} disabled={isReadOnly}>
                   {listLabels.ruleSetCustomize}
                 </Button>
               ) : null}
-              {rulesetId && !usingRuleSet ? (
+              {effectiveRulesetId && !usingRuleSet ? (
                 <Button type="button" variant="ghost" size="sm" onClick={handleResetToRuleSet} disabled={isReadOnly}>
                   {listLabels.ruleSetReset}
                 </Button>

package/src/modules/planner/components/availabilityRulesEditorState.ts

@@ -0,0 +1,11 @@
+export type AvailabilityRuleSetOption = {
+  id: string
+}
+
+export function resolveRuleSetSelectValue(
+  ruleSets: AvailabilityRuleSetOption[],
+  selectedRulesetId: string | null | undefined,
+): string | undefined {
+  if (!selectedRulesetId) return undefined
+  return ruleSets.some((ruleSet) => ruleSet.id === selectedRulesetId) ? selectedRulesetId : undefined
+}