@open-mercato/core 0.6.6-develop.6133.1.f01540250e → 0.6.6-develop.6140.1.d3fbb77495

package/src/modules/directory/api/tenants/tenant-cf-filter.ts

@@ -0,0 +1,97 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { FilterQuery } from '@mikro-orm/core'
+import type { EntityId } from '@open-mercato/shared/modules/entities'
+import { CustomFieldDef, CustomFieldValue } from '@open-mercato/core/modules/entities/data/entities'
+
+export type CustomFieldFilterEntry = readonly [string, unknown]
+
+type ValueColumn = 'valueText' | 'valueMultiline' | 'valueInt' | 'valueFloat' | 'valueBool'
+
+const valueColumnForKind = (kind: string | null | undefined): ValueColumn => {
+  switch (kind) {
+    case 'integer':
+      return 'valueInt'
+    case 'float':
+      return 'valueFloat'
+    case 'boolean':
+      return 'valueBool'
+    case 'multiline':
+      return 'valueMultiline'
+    default:
+      return 'valueText'
+  }
+}
+
+const expectedValuesFor = (condition: unknown): unknown[] => {
+  if (condition && typeof condition === 'object' && !Array.isArray(condition)) {
+    const maybeIn = (condition as { $in?: unknown[] }).$in
+    if (Array.isArray(maybeIn)) return maybeIn
+  }
+  return [condition]
+}
+
+const intersect = (current: Set<string> | null, next: Set<string>): Set<string> => {
+  if (current === null) return next
+  const result = new Set<string>()
+  for (const id of next) {
+    if (current.has(id)) result.add(id)
+  }
+  return result
+}
+
+/**
+ * Resolve the bounded set of record ids that satisfy the given custom-field
+ * filters by querying the custom-field value store directly, instead of loading
+ * every entity row and matching the values in memory. Filters are combined with
+ * AND semantics. Returns an empty set when any filter matches nothing.
+ */
+export async function resolveRecordIdsForCustomFieldFilters(opts: {
+  em: EntityManager
+  entityId: EntityId
+  tenantId: string | null
+  filters: CustomFieldFilterEntry[]
+}): Promise<Set<string>> {
+  const { em, entityId, tenantId, filters } = opts
+  if (!filters.length) return new Set<string>()
+
+  const keys = Array.from(new Set(filters.map(([key]) => key)))
+  const tenantScope: Record<string, unknown> = tenantId
+    ? { tenantId: { $in: [tenantId, null] } }
+    : { tenantId: null }
+
+  const defs = await em.find(CustomFieldDef, {
+    entityId: String(entityId),
+    key: { $in: keys },
+    isActive: true,
+    deletedAt: null,
+    ...tenantScope,
+  } as FilterQuery<CustomFieldDef>)
+  const kindByKey = new Map<string, string>()
+  for (const def of defs) {
+    if (!kindByKey.has(def.key)) kindByKey.set(def.key, def.kind)
+  }
+
+  let matched: Set<string> | null = null
+  for (const [key, condition] of filters) {
+    const column = valueColumnForKind(kindByKey.get(key))
+    const expectedValues = expectedValuesFor(condition).filter((value) => value !== undefined && value !== null)
+    if (!expectedValues.length) return new Set<string>()
+
+    const rows = await em.find(
+      CustomFieldValue,
+      {
+        entityId: String(entityId),
+        fieldKey: key,
+        deletedAt: null,
+        [column]: { $in: expectedValues },
+        ...tenantScope,
+      } as FilterQuery<CustomFieldValue>,
+      { fields: ['recordId'] },
+    )
+    const ids = new Set<string>(rows.map((row) => String(row.recordId)))
+    matched = intersect(matched, ids)
+    if (matched.size === 0) return matched
+  }
+
+  return matched ?? new Set<string>()
+}

package/src/modules/feature_toggles/components/FeatureToggleDetailsCard.tsx

@@ -7,30 +7,32 @@ type FeatureToggleDetailsCardProps = {
 }
 
 function DefaultValueDisplay({ featureToggleItem }: { featureToggleItem?: FeatureToggle }) {
+  const t = useT()
 
-  if (!featureToggleItem?.defaultValue) {
+  const defaultValue = featureToggleItem?.defaultValue
+  if (defaultValue === null || defaultValue === undefined) {
     return <p className="text-base text-muted-foreground">-</p>
   }
 
-  switch (featureToggleItem.type) {
+  switch (featureToggleItem?.type) {
     case 'boolean':
       return (
         <p className="text-base font-semibold text-foreground">
-          {featureToggleItem.defaultValue ? useT()('feature_toggles.values.true', 'True') : useT()('feature_toggles.values.false', 'False')}
+          {defaultValue ? t('feature_toggles.values.true', 'True') : t('feature_toggles.values.false', 'False')}
         </p>
       )
 
     case 'string':
       return (
         <p className="text-base font-semibold text-foreground">
-          {featureToggleItem.defaultValue}
+          {defaultValue}
         </p>
       )
 
     case 'number':
       return (
         <p className="text-base font-semibold text-foreground">
-          {featureToggleItem.defaultValue}
+          {defaultValue}
         </p>
       )
 
@@ -38,9 +40,9 @@ function DefaultValueDisplay({ featureToggleItem }: { featureToggleItem?: Featur
       return (
         <div className="text-base font-semibold text-foreground">
           <pre className="bg-muted/30 p-2 rounded text-sm font-mono overflow-x-auto whitespace-pre-wrap">
-            {typeof featureToggleItem.defaultValue === 'object'
-              ? JSON.stringify(featureToggleItem.defaultValue, null, 2)
-              : featureToggleItem.defaultValue}
+            {typeof defaultValue === 'object'
+              ? JSON.stringify(defaultValue, null, 2)
+              : defaultValue}
           </pre>
         </div>
       )

package/src/modules/integrations/api/[id]/health/route.ts

@@ -4,6 +4,11 @@ import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getIntegration } from '@open-mercato/shared/modules/integrations/types'
 import type { IntegrationHealthService } from '../../../lib/health-service'
+import {
+  resolveUserFeatures,
+  runIntegrationMutationGuardAfterSuccess,
+  runIntegrationMutationGuards,
+} from '../../guards'
 
 const idParamsSchema = z.object({ id: z.string().min(1) })
 
@@ -37,6 +42,25 @@ export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }
   }
 
   const container = await createRequestContainer()
+  const guardResult = await runIntegrationMutationGuards(
+    container,
+    {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+      userId: auth.sub ?? '',
+      resourceKind: 'integrations.integration',
+      resourceId: integration.id,
+      operation: 'update',
+      requestMethod: req.method,
+      requestHeaders: req.headers,
+      mutationPayload: { integrationId: integration.id },
+    },
+    resolveUserFeatures(auth),
+  )
+  if (!guardResult.ok) {
+    return NextResponse.json(guardResult.errorBody ?? { error: 'Operation blocked by guard' }, { status: guardResult.errorStatus ?? 422 })
+  }
+
   const healthService = container.resolve('integrationHealthService') as IntegrationHealthService
 
   const result = await healthService.runHealthCheck(
@@ -44,6 +68,17 @@ export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }
     { organizationId: auth.orgId as string, tenantId: auth.tenantId },
   )
 
+  await runIntegrationMutationGuardAfterSuccess(guardResult.afterSuccessCallbacks, {
+    tenantId: auth.tenantId,
+    organizationId: auth.orgId,
+    userId: auth.sub ?? '',
+    resourceKind: 'integrations.integration',
+    resourceId: integration.id,
+    operation: 'update',
+    requestMethod: req.method,
+    requestHeaders: req.headers,
+  })
+
   return NextResponse.json({
     status: result.status,
     message: result.message ?? null,

package/src/modules/notifications/api/unread-count/route.ts

@@ -29,10 +29,12 @@ export async function GET(req: Request) {
   const cacheKey = cache && userId ? buildUnreadCountCacheKey(userId) : null
 
   if (cache && cacheKey) {
-    const cached = await runWithCacheTenant(scope.tenantId, () => cache.get(cacheKey))
-    if (typeof cached === 'number') {
-      return Response.json({ unreadCount: cached })
-    }
+    try {
+      const cached = await runWithCacheTenant(scope.tenantId, () => cache.get(cacheKey))
+      if (typeof cached === 'number') {
+        return Response.json({ unreadCount: cached })
+      }
+    } catch {}
   }
 
   const count = await em.count(Notification, {