@open-mercato/core 0.6.7-develop.6706.1.b3a4c759bb → 0.6.7-develop.6725.1.07a748cfc2

package/src/modules/feature_toggles/components/hooks/useFeatureFlagString.ts

@@ -2,9 +2,16 @@
 
 import { useQuery } from '@tanstack/react-query'
 import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { FEATURE_FLAG_STALE_TIME_MS } from './staleTime'
 
 export type UseFeatureFlagStringOptions = {
     id: string
+    /**
+     * Value used while the check is in flight and whenever the toggle cannot be
+     * resolved (undefined toggle, type mismatch, network or permission failure).
+     * Defaults to `null`.
+     */
+    defaultValue?: string | null
 }
 
 export type UseFeatureFlagStringResult = {
@@ -21,6 +28,7 @@ type Result<T> = {
 }
 
 export function useFeatureFlagString(options: UseFeatureFlagStringOptions): UseFeatureFlagStringResult {
+    const defaultValue = options.defaultValue ?? null
     const query = useQuery({
         queryKey: ['featureToggles', 'check', 'string', options?.id],
         queryFn: async () => {
@@ -37,9 +45,10 @@ export function useFeatureFlagString(options: UseFeatureFlagStringOptions): UseF
             return result
         },
         enabled: !!options.id,
+        staleTime: FEATURE_FLAG_STALE_TIME_MS,
     })
 
-    const value = query.data?.ok ? query.data.value : null
+    const value = query.data?.ok ? query.data.value : defaultValue
     const isLoading = query.isLoading
 
     return {

package/src/modules/inbox_ops/api/proposals/route.ts

@@ -4,6 +4,8 @@ import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import type { FilterQuery } from '@mikro-orm/postgresql'
 import { findAndCountWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
+import { findEntityIdsBySearchTokens, type SearchTokenDatabase } from '@open-mercato/shared/lib/search/tokenLookup'
+import { E } from '#generated/entities.ids.generated'
 import { InboxProposal, InboxEmail, InboxProposalAction, InboxDiscrepancy, type InboxProposalCategory } from '../../data/entities'
 import { proposalListQuerySchema } from '../../data/validators'
 import { resolveRequestContext, UnauthorizedError } from '../routeHelpers'
@@ -47,7 +49,24 @@ export async function GET(req: Request) {
       }
     }
     if (query.search) {
-      where.summary = { $ilike: `%${escapeLikePattern(query.search)}%` }
+      // `summary` is covered by the inbox_ops encryption map, so an ILIKE alone
+      // compares the pattern against ciphertext and matches nothing once
+      // encryption is on. Union it with the token index, which stores hashes of
+      // the plaintext. Issue #2990.
+      const searchOr: FilterQuery<InboxProposal>[] = [
+        { summary: { $ilike: `%${escapeLikePattern(query.search)}%` } },
+      ]
+      const tokenMatch = await findEntityIdsBySearchTokens({
+        db: ctx.em.getKysely<SearchTokenDatabase>(),
+        entityType: E.inbox_ops.inbox_proposal,
+        query: query.search,
+        fields: ['summary'],
+        scope: { tenantId: ctx.tenantId, organizationId: ctx.organizationId },
+      })
+      if (tokenMatch.matched && tokenMatch.ids.length) {
+        searchOr.push({ id: { $in: tokenMatch.ids } })
+      }
+      where.$or = searchOr
     }
 
     const offset = (query.page - 1) * query.pageSize

package/src/modules/inbox_ops/subscribers/search-reindex-proposal-created.ts

@@ -0,0 +1,39 @@
+export const metadata = {
+  event: 'inbox_ops.proposal.created',
+  persistent: false,
+  id: 'inbox_ops:query-index-reindex-proposal-created',
+}
+
+type Payload = {
+  proposalId?: string
+  tenantId?: string | null
+  organizationId?: string | null
+}
+
+type EventBus = { emitEvent: (name: string, body: unknown, options?: unknown) => Promise<void> }
+type HandlerContext = { resolve: <T = unknown>(name: string) => T }
+
+export default async function handle(payload: Payload, ctx: HandlerContext): Promise<void> {
+  const recordId = typeof payload.proposalId === 'string' ? payload.proposalId : null
+  const tenantId = typeof payload.tenantId === 'string' ? payload.tenantId : null
+  if (!recordId || !tenantId) return
+
+  let eventBus: EventBus | null = null
+  try {
+    eventBus = ctx.resolve<EventBus>('eventBus')
+  } catch {
+    return
+  }
+
+  await eventBus.emitEvent('query_index.upsert_one', {
+    entityType: 'inbox_ops:inbox_proposal',
+    recordId,
+    organizationId: payload.organizationId ?? null,
+    tenantId,
+    crudAction: 'created',
+    coverageBaseDelta: 1,
+  }, {
+    tenantId,
+    organizationId: payload.organizationId ?? null,
+  }).catch(() => undefined)
+}

package/src/modules/integrations/widgets/injection/external-ids/widget.client.tsx

@@ -87,8 +87,3 @@ export default function ExternalIdsWidget({ data }: InjectionWidgetComponentProp
   )
 }
 
-ExternalIdsWidget.metadata = {
-  id: 'integrations.injection.external-ids',
-  title: 'External IDs',
-  features: ['integrations.view'],
-}

package/src/modules/integrations/widgets/injection/external-ids/widget.ts

@@ -0,0 +1,13 @@
+import type { InjectionWidgetModule } from '@open-mercato/shared/modules/widgets/injection'
+import ExternalIdsWidget from './widget.client'
+
+const widget: InjectionWidgetModule = {
+  metadata: {
+    id: 'integrations.injection.external-ids',
+    title: 'External IDs',
+    features: ['integrations.view'],
+  },
+  Widget: ExternalIdsWidget,
+}
+
+export default widget

package/src/modules/messages/lib/searchLookup.ts

@@ -1,10 +1,9 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
-import { type Kysely, sql } from 'kysely'
-import { resolveSearchConfig } from '@open-mercato/shared/lib/search/config'
-import { tokenizeText } from '@open-mercato/shared/lib/search/tokenize'
+import type { Kysely } from 'kysely'
+import { findEntityIdsBySearchTokensCompat, type SearchTokenDatabase } from '@open-mercato/shared/lib/search/tokenLookup'
 
-function getDb(em: EntityManager): Kysely<any> {
-  return em.getKysely<any>()
+function getDb(em: EntityManager): Kysely<SearchTokenDatabase> {
+  return em.getKysely<SearchTokenDatabase>()
 }
 
 export async function findMessageIdsBySearchTokens({
@@ -20,33 +19,11 @@ export async function findMessageIdsBySearchTokens({
   organizationId: string | null
   fields?: string[]
 }): Promise<string[] | null> {
-  const trimmed = query.trim()
-  if (!trimmed) return null
-
-  const tokens = tokenizeText(trimmed, resolveSearchConfig())
-  if (!tokens.hashes.length) return []
-
-  const db = getDb(em) as any
-  let searchQuery = db
-    .selectFrom('search_tokens')
-    .select('entity_id')
-    .where('entity_type', '=', 'messages:message')
-    .where('field', 'in', fields)
-    .where('token_hash', 'in', tokens.hashes)
-    .where(sql<boolean>`tenant_id is not distinct from ${tenantId}`)
-
-  if (organizationId) {
-    searchQuery = searchQuery.where('organization_id', '=', organizationId)
-  } else {
-    searchQuery = searchQuery.where(sql<boolean>`organization_id is not distinct from ${null}`)
-  }
-
-  const rows = await searchQuery
-    .groupBy('entity_id')
-    .having(sql<boolean>`count(distinct token_hash) >= ${tokens.hashes.length}`)
-    .execute()
-
-  return rows
-    .map((row: { entity_id?: unknown }) => (typeof row.entity_id === 'string' ? row.entity_id : null))
-    .filter((id: string | null): id is string => typeof id === 'string' && id.length > 0)
+  return findEntityIdsBySearchTokensCompat({
+    db: getDb(em),
+    entityType: 'messages:message',
+    query,
+    fields,
+    scope: { tenantId, organizationId },
+  })
 }

package/src/modules/query_index/api/openapi.ts

@@ -37,13 +37,25 @@ export const queryIndexJobSchema = z.object({
 
 export const queryIndexStatusItemSchema = z.object({
   entityId: z.string(),
+  /** Human label. Code-defined entities have no label registry, so this mirrors `entityId`. */
   label: z.string(),
   baseCount: z.number().int().nonnegative().nullable(),
   indexCount: z.number().int().nonnegative().nullable(),
   vectorCount: z.number().int().nonnegative().nullable().optional(),
+  /** The entity declares `buildSource`, i.e. it is configured for vector search. */
   vectorEnabled: z.boolean().optional(),
+  /** Additive: vector indexing can actually run (auto-indexing on, provider reachable, tenant opted in). */
+  vectorIndexingActive: z.boolean().optional(),
+  fulltextCount: z.number().int().nonnegative().nullable().optional(),
+  fulltextEnabled: z.boolean().optional(),
+  /** Additive: the entity has active custom field definitions in the current scope. */
+  hasCustomFields: z.boolean().optional(),
+  /** Aggregate health: query index in sync AND, when vector-configured, vector coverage complete. */
   ok: z.boolean(),
+  /** Additive: query index alone is in sync with the base table, independent of vector/fulltext. */
+  queryIndexOk: z.boolean().optional(),
   job: queryIndexJobSchema,
+  refreshedAt: z.string().datetime().nullable().optional(),
 })
 
 export const queryIndexErrorLogSchema = z.object({