@open-mercato/core 0.6.4-develop.4110.1.836aafde58 → 0.6.4-develop.4121.1.0d7f20d229

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

@@ -131,29 +131,56 @@ export function getSelectedTenantFromRequest(
   return parseSelectedTenantCookie(header)
 }
 
-async function collectWithDescendants(em: EntityManager, tenantId: string, ids: string[]): Promise<Set<string>> {
-  if (!ids.length) return new Set()
-  const unique = Array.from(new Set(
+function normalizeOrganizationIds(ids: string[]): string[] {
+  return Array.from(new Set(
     ids.map((value) => normalizeOrganizationId(value)).filter((value): value is string => {
       if (!value) return false
       if (isAllOrganizationsSelection(value)) return false
       return true
     })
   ))
-  if (!unique.length) return new Set()
+}
+
+// Map each organization id to itself plus its persisted descendant ids. Only
+// orgs that exist for the tenant and are not soft-deleted are included, so an
+// unknown/inaccessible id simply has no entry (matching the per-id query that
+// returned an empty set for it).
+type OrgDescendantMap = Map<string, string[]>
+
+// Issue #2228 — single round-trip for org-scope resolution. Instead of issuing
+// one `organizations` SELECT per `collectWithDescendants` call (up to 3-4
+// sequential queries per request: accessible set, fallback set, selected set),
+// gather every candidate id up front and fetch their descendant expansions in
+// one `em.find(Organization, { id: $in })`. Expansion then happens in-memory.
+async function loadOrgDescendantMap(em: EntityManager, tenantId: string, ids: string[]): Promise<OrgDescendantMap> {
+  const unique = normalizeOrganizationIds(ids)
+  if (!unique.length) return new Map()
   const filter: FilterQuery<Organization> = {
     tenant: tenantId,
     id: { $in: unique },
     deletedAt: null,
   }
   const orgs = await em.find(Organization, filter)
-  const set = new Set<string>()
+  const map: OrgDescendantMap = new Map()
   for (const org of orgs) {
     const id = String(org.id)
-    set.add(id)
+    const expansion = [id]
     if (Array.isArray(org.descendantIds)) {
-      for (const desc of org.descendantIds) set.add(String(desc))
+      for (const desc of org.descendantIds) expansion.push(String(desc))
     }
+    map.set(id, expansion)
+  }
+  return map
+}
+
+function expandWithDescendants(map: OrgDescendantMap, ids: string[]): Set<string> {
+  const set = new Set<string>()
+  for (const value of ids) {
+    const id = normalizeOrganizationId(value)
+    if (!id || isAllOrganizationsSelection(id)) continue
+    const expansion = map.get(id)
+    if (!expansion) continue
+    for (const entry of expansion) set.add(entry)
   }
   return set
 }
@@ -214,14 +241,18 @@ export async function resolveOrganizationScope({
 
   const accountOrgId = actorTenantId && actorTenantId === tenantId ? normalizeOrganizationId(auth.orgId) : null
   const fallbackOrgId = accountOrgId ?? null
-  let fallbackSet: Set<string> | null = null
-  const loadFallbackSet = async (): Promise<Set<string> | null> => {
-    if (!fallbackOrgId) return null
-    if (!fallbackSet) {
-      fallbackSet = await collectWithDescendants(em, tenantId, [fallbackOrgId])
-    }
-    return fallbackSet
-  }
+
+  // Every id that could be expanded below — accessible set, fallback (account)
+  // org, and the requested selection — is known up front, so fetch them all in
+  // a single `organizations` query and expand from the in-memory map.
+  const candidateIds = [
+    ...(accessibleList ?? []),
+    ...(fallbackOrgId ? [fallbackOrgId] : []),
+    ...(normalizedSelectedId ? [normalizedSelectedId] : []),
+  ]
+  const orgDescendants = await loadOrgDescendantMap(em, tenantId, candidateIds)
+  const loadFallbackSet = (): Set<string> | null =>
+    fallbackOrgId ? expandWithDescendants(orgDescendants, [fallbackOrgId]) : null
 
   let allowedSet: Set<string> | null = null
   if (accessibleList === null) {
@@ -229,11 +260,11 @@ export async function resolveOrganizationScope({
   } else if (accessibleList.length === 0) {
     allowedSet = new Set()
   } else {
-    allowedSet = await collectWithDescendants(em, tenantId, accessibleList)
+    allowedSet = expandWithDescendants(orgDescendants, accessibleList)
   }
 
   if (allowedSet && allowedSet.size === 0 && fallbackOrgId) {
-    const computed = await loadFallbackSet()
+    const computed = loadFallbackSet()
     if (computed && computed.size > 0) {
       allowedSet = computed
     }
@@ -256,17 +287,17 @@ export async function resolveOrganizationScope({
 
   let filterSet: Set<string> | null = null
   if (effectiveSelected) {
-    filterSet = await collectWithDescendants(em, tenantId, [effectiveSelected])
+    filterSet = expandWithDescendants(orgDescendants, [effectiveSelected])
   } else if (allowedSet !== null) {
     filterSet = allowedSet
   } else if (widenToAllOrgs) {
     filterSet = null
   } else if (auth.orgId) {
-    filterSet = await loadFallbackSet()
+    filterSet = loadFallbackSet()
   }
 
   if ((!filterSet || filterSet.size === 0) && fallbackOrgId && !widenToAllOrgs) {
-    const computed = await loadFallbackSet()
+    const computed = loadFallbackSet()
     if (computed && computed.size > 0) {
       filterSet = computed
       if (!effectiveSelected) {

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