@open-mercato/shared 0.7.1-develop.7149.1.7efa6e1612 → 0.7.1-develop.7150.1.c1941e0c22

package/src/lib/crud/factory.ts

@@ -1100,6 +1100,49 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
   const indexerConfig = opts.indexer as CrudIndexerConfig | undefined
   const eventsConfig = opts.events as CrudEventsConfig | undefined
 
+  // Command-backed verbs (`actions.*`) never reach the built-in `markOrmEntityChange` calls
+  // below — the handler owns the mark and the command bus owns the flush. Hand the route's
+  // declared `indexer:` to the data engine for the duration of the command so a handler that
+  // marks `events:` only still writes the projection the route promised, using the handler's
+  // own entity and identifiers. Without this the declaration reaches no code at all (#5741).
+  const withRouteIndexerDeclaration = async <TResult>(
+    ctx: CrudCtx,
+    operation: CrudEventAction,
+    commandId: string,
+    run: () => Promise<TResult>,
+  ): Promise<TResult> => {
+    if (!indexerConfig || !ormCfg.entity) return run()
+    let de: DataEngine | null = null
+    try {
+      de = ctx.container.resolve('dataEngine') as DataEngine
+    } catch {
+      de = null
+    }
+    if (!de || typeof de.setDefaultIndexerConfig !== 'function') return run()
+    de.setDefaultIndexerConfig({ indexer: indexerConfig, entityClass: ormCfg.entity })
+    try {
+      const result = await run()
+      if (de.hasIndexedDefaultEntityClass?.() === false) {
+        // The one genuinely undiagnosable case: a handler that marks no side effect at all,
+        // so neither the route nor the command maintains the projection. One line per dropped
+        // write — far narrower than warning at construction time, though not literally false-
+        // positive-free: the flag tracks the route's own entity class, so a handler that
+        // discharges the projection through a different class (marking a parent aggregate with
+        // its own explicit `indexer:`) would also be warned about. No route in this repository
+        // does that today; widen the flag to "any indexer discharged" if one ever needs to.
+        logger.warn('CRUD route declares an indexer that its command handler did not discharge; the query index was not updated for this write', {
+          resourceKind,
+          operation,
+          commandId,
+          entityType: indexerConfig.entityType,
+        })
+      }
+      return result
+    } finally {
+      de.setDefaultIndexerConfig(null)
+    }
+  }
+
   const inferFieldValue = (item: Record<string, unknown>, keys: string[]): string | null => {
     for (const key of keys) {
       const value = item[key]
@@ -2286,7 +2329,9 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
           context: { cacheAliases: resourceTargets },
         }
         const metadataToSend = mergeCommandMetadata(baseMetadata, userMetadata)
-        const { result, logEntry } = await commandBus.execute(action.commandId, { input, ctx, metadata: metadataToSend })
+        const { result, logEntry } = await withRouteIndexerDeclaration(ctx, 'created', action.commandId, () =>
+          commandBus.execute(action.commandId, { input, ctx, metadata: metadataToSend }),
+        )
 
         // Sync after-event (*.created) — command path
         if (createLifecycleCmd.afterEventId && ctx.auth.tenantId) {
@@ -2337,9 +2382,11 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
             requestHeaders: request.headers,
           })
         }
-        // Note: side effects (events + indexing) are already flushed by CommandBus.execute()
-        // via flushCrudSideEffects(). Calling markCommandResultForIndexing here would cause
-        // duplicate event emissions.
+        // Note: side effects are already flushed by CommandBus.execute() via
+        // flushCrudSideEffects(). Re-marking the result here would emit a duplicate domain
+        // event, so the route does not. The route's `indexer:` declaration still reaches
+        // that flush: withRouteIndexerDeclaration() hands it to the data engine as the
+        // default for marks the handler makes without one (#5741).
         return response
       }
 
@@ -2612,7 +2659,9 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
         }
         if (candidateId) baseMetadata.resourceId = candidateId
         const metadataToSend = mergeCommandMetadata(baseMetadata, userMetadata)
-        const { result, logEntry } = await commandBus.execute(action.commandId, { input, ctx, metadata: metadataToSend })
+        const { result, logEntry } = await withRouteIndexerDeclaration(ctx, 'updated', action.commandId, () =>
+          commandBus.execute(action.commandId, { input, ctx, metadata: metadataToSend }),
+        )
         const payload = action.response ? action.response({ result, logEntry, ctx }) : result
         let resolvedPayload = await Promise.resolve(payload)
         if (interceptorRequestPayload && resolvedPayload && typeof resolvedPayload === 'object' && !Array.isArray(resolvedPayload)) {
@@ -2659,9 +2708,11 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
           }
         }
 
-        // Note: side effects (events + indexing) are already flushed by CommandBus.execute()
-        // via flushCrudSideEffects(). Calling markCommandResultForIndexing here would cause
-        // duplicate event emissions.
+        // Note: side effects are already flushed by CommandBus.execute() via
+        // flushCrudSideEffects(). Re-marking the result here would emit a duplicate domain
+        // event, so the route does not. The route's `indexer:` declaration still reaches
+        // that flush: withRouteIndexerDeclaration() hands it to the data engine as the
+        // default for marks the handler makes without one (#5741).
         return response
       }
 
@@ -2945,7 +2996,9 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
         }
         if (candidateId) baseMetadata.resourceId = candidateId
         const metadataToSend = mergeCommandMetadata(baseMetadata, userMetadata)
-        const { result, logEntry } = await commandBus.execute(action.commandId, { input, ctx, metadata: metadataToSend })
+        const { result, logEntry } = await withRouteIndexerDeclaration(ctx, 'deleted', action.commandId, () =>
+          commandBus.execute(action.commandId, { input, ctx, metadata: metadataToSend }),
+        )
         const payload = action.response ? action.response({ result, logEntry, ctx }) : result
         let resolvedPayload = await Promise.resolve(payload)
         if (interceptorRequestPayload && resolvedPayload && typeof resolvedPayload === 'object' && !Array.isArray(resolvedPayload)) {
@@ -2991,9 +3044,11 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
           }
         }
 
-        // Note: side effects (events + indexing) are already flushed by CommandBus.execute()
-        // via flushCrudSideEffects(). Calling markCommandResultForIndexing here would cause
-        // duplicate event emissions.
+        // Note: side effects are already flushed by CommandBus.execute() via
+        // flushCrudSideEffects(). Re-marking the result here would emit a duplicate domain
+        // event, so the route does not. The route's `indexer:` declaration still reaches
+        // that flush: withRouteIndexerDeclaration() hands it to the data engine as the
+        // default for marks the handler makes without one (#5741).
         return response
       }
 

package/src/lib/crud/types.ts

@@ -24,6 +24,29 @@ export type CrudEventsConfig<TEntity = unknown> = {
   buildPayload?(ctx: CrudEmitContext<TEntity>): unknown
 }
 
+/**
+ * Declares that a CRUD write maintains the `query_index` projection for `entityType`.
+ *
+ * On `makeCrudRoute`'s built-in write path (`create` / `update` / `del`) the route emits the
+ * projection event itself. On the command path (`actions.*`) the command handler owns the
+ * side-effect mark and the command bus owns the flush, so the route's declaration is applied
+ * to the handler's mark: a handler that calls `emitCrudSideEffects({ events })` without an
+ * `indexer` still indexes the record under this `entityType`, and one that passes its own
+ * `indexer` keeps it. A handler that marks no side effect at all indexes nothing — the route
+ * logs a warning naming the command when that happens.
+ *
+ * Two limits of that hand-down are worth knowing before you rely on it:
+ *
+ * - It is scoped to one `CommandBus.execute()`, and the declaration lives on the request's
+ *   `DataEngine` instance. That is sound because `createRequestContainer()` registers
+ *   `dataEngine` per request; re-registering it as a transient would leave the command marking
+ *   on a different instance than the route declared on, so nothing is indexed and every write
+ *   logs the warning.
+ * - `CommandBus.undo()` runs outside any route, so no declaration is active there. An undo
+ *   handler that must maintain the projection MUST pass its own `indexer` to
+ *   `emitCrudUndoSideEffects` — otherwise undoing a delete restores the row in the database and
+ *   leaves it missing from `query_index` until the next full rebuild.
+ */
 export type CrudIndexerConfig<TEntity = unknown> = {
   entityType: string
   buildUpsertPayload?(ctx: CrudEmitContext<TEntity>): unknown

package/src/lib/data/__tests__/engine.default-indexer.test.ts

@@ -0,0 +1,188 @@
+import type { AwilixContainer } from 'awilix'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { DefaultDataEngine } from '../engine'
+import type { CrudEventsConfig, CrudIndexerConfig } from '../../crud/types'
+
+// A command-backed CRUD route (`makeCrudRoute` + `actions.*`) cannot mark its own side effect:
+// the handler owns the mark and the command bus owns the flush. The route therefore hands its
+// declared `indexer:` to the engine for the duration of the command, and the engine applies it
+// to marks the handler makes without one — otherwise the declaration reaches no code at all and
+// the projection is never written (#5741). The entity-class gate is what keeps a handler's
+// sibling-entity marks from being indexed under the route's entityType.
+
+class RouteEntity {
+  constructor(public id: string) {}
+}
+
+class SiblingEntity {
+  constructor(public id: string) {}
+}
+
+const EVENTS: CrudEventsConfig<unknown> = { module: 'customers', entity: 'tag', persistent: false }
+const ROUTE_INDEXER: CrudIndexerConfig<unknown> = { entityType: 'customers:customer_tag' }
+const HANDLER_INDEXER: CrudIndexerConfig<unknown> = { entityType: 'customers:handler_owned' }
+const IDENTIFIERS = { id: 'rec-1', organizationId: 'org-1', tenantId: 'tenant-1' }
+
+function buildEngine() {
+  const emitEvent = jest.fn().mockResolvedValue(undefined)
+  const container = {
+    resolve: (token: string) => {
+      if (token === 'eventBus') return { emitEvent }
+      throw new Error(`unexpected resolve(${token})`)
+    },
+  } as unknown as AwilixContainer
+  const engine = new DefaultDataEngine({} as EntityManager, container)
+  const indexPayloads = (eventName: string) =>
+    emitEvent.mock.calls.filter(([name]) => name === eventName).map(([, payload]) => payload as Record<string, unknown>)
+  return { engine, emitEvent, indexPayloads }
+}
+
+describe('DefaultDataEngine route-declared indexer default', () => {
+  let warnSpy: jest.SpyInstance
+  beforeAll(() => { warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined) })
+  afterAll(() => { warnSpy.mockRestore() })
+
+  it('indexes an events-only mark under the route-declared entityType', async () => {
+    const { engine, indexPayloads } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    // What every command handler on the two affected core routes does: mark `events:` only.
+    engine.markOrmEntityChange({ action: 'created', entity: new RouteEntity('rec-1'), events: EVENTS, identifiers: IDENTIFIERS })
+    await engine.flushOrmEntityChanges()
+
+    const upserts = indexPayloads('query_index.upsert_one')
+    expect(upserts).toHaveLength(1)
+    expect(upserts[0]).toMatchObject({ entityType: 'customers:customer_tag', recordId: 'rec-1', crudAction: 'created' })
+    expect(engine.hasIndexedDefaultEntityClass()).toBe(true)
+  })
+
+  it('emits the delete projection for an events-only delete mark', async () => {
+    const { engine, indexPayloads } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    engine.markOrmEntityChange({ action: 'deleted', entity: new RouteEntity('rec-1'), events: EVENTS, identifiers: IDENTIFIERS })
+    await engine.flushOrmEntityChanges()
+
+    expect(indexPayloads('query_index.delete_one')).toHaveLength(1)
+    expect(indexPayloads('query_index.upsert_one')).toHaveLength(0)
+  })
+
+  it('leaves a handler-supplied indexer untouched — explicit wins over the default', async () => {
+    const { engine, indexPayloads } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    engine.markOrmEntityChange({
+      action: 'updated',
+      entity: new RouteEntity('rec-1'),
+      events: EVENTS,
+      indexer: HANDLER_INDEXER,
+      identifiers: IDENTIFIERS,
+    })
+    await engine.flushOrmEntityChanges()
+
+    const upserts = indexPayloads('query_index.upsert_one')
+    expect(upserts).toHaveLength(1)
+    expect(upserts[0]).toMatchObject({ entityType: 'customers:handler_owned' })
+  })
+
+  it('does not apply the default to a mark for a different entity class', async () => {
+    const { engine, emitEvent } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    // A tag command also marks its tag *assignments*; indexing those as `customer_tag` would
+    // write a projection row for the wrong record.
+    engine.markOrmEntityChange({ action: 'updated', entity: new SiblingEntity('assignment-1'), identifiers: { ...IDENTIFIERS, id: 'assignment-1' } })
+    await engine.flushOrmEntityChanges()
+
+    expect(emitEvent.mock.calls.map(([name]) => name)).not.toContain('query_index.upsert_one')
+    expect(engine.hasIndexedDefaultEntityClass()).toBe(false)
+  })
+
+  it('reports an undischarged declaration when the handler marks nothing at all', async () => {
+    const { engine, emitEvent } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    await engine.flushOrmEntityChanges()
+
+    expect(emitEvent).not.toHaveBeenCalled()
+    expect(engine.hasIndexedDefaultEntityClass()).toBe(false)
+  })
+
+  it('stops applying the declaration once it is cleared', async () => {
+    const { engine, emitEvent } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+    engine.setDefaultIndexerConfig(null)
+
+    engine.markOrmEntityChange({ action: 'created', entity: new RouteEntity('rec-1'), events: EVENTS, identifiers: IDENTIFIERS })
+    await engine.flushOrmEntityChanges()
+
+    expect(emitEvent.mock.calls.map(([name]) => name)).not.toContain('query_index.upsert_one')
+    expect(engine.hasIndexedDefaultEntityClass()).toBe(false)
+  })
+
+  it('keeps a handler indexer when a later events-only mark hits the same key', async () => {
+    const { engine, indexPayloads } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    // Same (action, id, organizationId, tenantId) key twice. The merge branch must not let the
+    // route default overwrite the config the first mark installed — that would silently drop the
+    // handler's own `buildUpsertPayload` and invert the "explicit always wins" rule.
+    engine.markOrmEntityChange({
+      action: 'updated',
+      entity: new RouteEntity('rec-1'),
+      events: EVENTS,
+      indexer: HANDLER_INDEXER,
+      identifiers: IDENTIFIERS,
+    })
+    engine.markOrmEntityChange({ action: 'updated', entity: new RouteEntity('rec-1'), events: EVENTS, identifiers: IDENTIFIERS })
+    await engine.flushOrmEntityChanges()
+
+    const upserts = indexPayloads('query_index.upsert_one')
+    expect(upserts).toHaveLength(1)
+    expect(upserts[0]).toMatchObject({ entityType: 'customers:handler_owned' })
+  })
+
+  it('still applies the default when the first mark on a key carried no indexer', async () => {
+    const { engine, indexPayloads } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    engine.markOrmEntityChange({ action: 'updated', entity: new RouteEntity('rec-1'), events: EVENTS, identifiers: IDENTIFIERS })
+    engine.markOrmEntityChange({ action: 'updated', entity: new RouteEntity('rec-1'), events: EVENTS, identifiers: IDENTIFIERS })
+    await engine.flushOrmEntityChanges()
+
+    const upserts = indexPayloads('query_index.upsert_one')
+    expect(upserts).toHaveLength(1)
+    expect(upserts[0]).toMatchObject({ entityType: 'customers:customer_tag' })
+  })
+
+  it('ignores a non-constructor entityClass instead of throwing on the write path', async () => {
+    const { engine, emitEvent } = buildEngine()
+    // `OrmEntityConfig.entity` is `any` and this repo treats `EntitySchema` instances — plain
+    // objects, not constructors — as a first-class entity shape. `instanceof` against one throws,
+    // and it would throw inside `markOrmEntityChange`, outside the flush's best-effort catch.
+    const entitySchemaLike = { name: 'RouteEntity', meta: {} } as unknown as new (...args: never[]) => unknown
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: entitySchemaLike })
+
+    expect(() => engine.markOrmEntityChange({
+      action: 'created',
+      entity: new RouteEntity('rec-1'),
+      events: EVENTS,
+      identifiers: IDENTIFIERS,
+    })).not.toThrow()
+    await engine.flushOrmEntityChanges()
+
+    expect(emitEvent.mock.calls.map(([name]) => name)).not.toContain('query_index.upsert_one')
+    expect(engine.hasIndexedDefaultEntityClass()).toBe(false)
+  })
+
+  it('honours a bulk-import skipReindex suppression over the declaration', async () => {
+    const { engine, emitEvent } = buildEngine()
+    engine.setDefaultIndexerConfig({ indexer: ROUTE_INDEXER, entityClass: RouteEntity })
+
+    engine.markOrmEntityChange({ action: 'created', entity: new RouteEntity('rec-1'), events: EVENTS, identifiers: IDENTIFIERS })
+    await engine.flushOrmEntityChanges({ skipReindex: true })
+
+    expect(emitEvent.mock.calls.map(([name]) => name)).not.toContain('query_index.upsert_one')
+    expect(engine.hasIndexedDefaultEntityClass()).toBe(false)
+  })
+})

package/src/lib/data/engine.ts

@@ -64,6 +64,19 @@ type QueuedCrudSideEffect = {
   indexer?: CrudIndexerConfig<unknown>
 }
 
+/**
+ * A `makeCrudRoute` route-level `indexer:` declaration, handed to the data engine for the
+ * duration of one command-bus write. Command handlers own the side-effect mark on the
+ * `actions.*` path, and most of them mark `events:` only — without this the route's
+ * declaration would reach no code at all. `entityClass` scopes the default to the route's
+ * own ORM entity so a handler that also marks a sibling entity in the same request (a tag
+ * assignment alongside a tag, say) is never indexed under the route's `entityType`.
+ */
+export type DefaultCrudIndexerConfig = {
+  indexer: CrudIndexerConfig<unknown>
+  entityClass: abstract new (...args: never[]) => object
+}
+
 export interface DataEngine {
   setCustomFields(opts: {
     entityId: string
@@ -149,6 +162,20 @@ export interface DataEngine {
    * is responsible for rebuilding the `query_index` afterwards.
    */
   flushOrmEntityChanges(suppress?: BulkImportSuppression): Promise<void>
+
+  /**
+   * Declare the indexer a CRUD route configured, for marks made during one command-bus
+   * write that do not carry an indexer of their own. Pass `null` to clear it. Optional so
+   * third-party `DataEngine` implementations stay valid; callers invoke it with `?.`.
+   */
+  setDefaultIndexerConfig?(config: DefaultCrudIndexerConfig | null): void
+
+  /**
+   * Whether any side effect drained since the current default was declared carried an
+   * indexer for that default's entity class — false means the declared query-index
+   * obligation was discharged by nobody. Optional for the same reason as the setter.
+   */
+  hasIndexedDefaultEntityClass?(): boolean
 }
 
 export const SYSTEM_ENTITY_RECORDS_BLOCKED_CODE = 'system_entity_records_blocked'
@@ -188,8 +215,43 @@ export function assertCustomEntityStorageEntityId(em: EntityManager, entityId: s
 
 export class DefaultDataEngine implements DataEngine {
   private pendingSideEffects = new Map<string, QueuedCrudSideEffect>()
+  private defaultIndexer: DefaultCrudIndexerConfig | null = null
+  private indexedDefaultEntityClass = false
   constructor(private em: EntityManager, private container: AwilixContainer) {}
 
+  /**
+   * Per-command state, deliberately held on the engine instance rather than threaded through
+   * `CommandRuntimeContext` the way the bulk-import flags are. That is sound only because
+   * `createRequestContainer()` registers `dataEngine` per request (`lib/di/container.ts`), so
+   * one engine instance never spans two requests, and no `makeCrudRoute` verb runs two commands
+   * concurrently against it. An application that re-registers `dataEngine` as a transient would
+   * break both assumptions: the command would mark on a different instance than the route
+   * declared on, so nothing is indexed and every write logs the undischarged-declaration warning.
+   */
+  setDefaultIndexerConfig(config: DefaultCrudIndexerConfig | null): void {
+    this.defaultIndexer = config
+    this.indexedDefaultEntityClass = false
+  }
+
+  hasIndexedDefaultEntityClass(): boolean {
+    return this.indexedDefaultEntityClass
+  }
+
+  private matchesDefaultEntityClass(entity: unknown): boolean {
+    const declared = this.defaultIndexer?.entityClass
+    // `OrmEntityConfig.entity` is `any` and this repository treats `EntitySchema` instances as a
+    // first-class entity shape (`lib/bootstrap/types.ts`). An `EntitySchema` is an object rather
+    // than a constructor, so `instanceof` against it throws — and it would throw inside
+    // `markOrmEntityChange`, outside the best-effort try/catch that guards the flush, turning
+    // every write on such a route into a 500.
+    if (typeof declared !== 'function') return false
+    return entity instanceof declared
+  }
+
+  private resolveDefaultIndexer(entity: unknown): CrudIndexerConfig<unknown> | undefined {
+    return this.matchesDefaultEntityClass(entity) ? this.defaultIndexer?.indexer : undefined
+  }
+
   async setCustomFields(opts: Parameters<DataEngine['setCustomFields']>[0]): Promise<void> {
     const { entityId, recordId, organizationId = null, tenantId = null, values } = opts
     const sanitizedValues = await sanitizeCustomFieldHtmlRichTextValuesServer(this.em, {
@@ -728,6 +790,10 @@ export class DefaultDataEngine implements DataEngine {
     const { entity, identifiers } = opts
     if (!entity) return
     if (!identifiers?.id) return
+    // A command handler that marks `events:` only still discharges the route's declared
+    // query-index obligation — the route hands its `indexer:` down as the default so the
+    // handler's own entity and identifiers (the accurate ones) drive the projection write.
+    const indexer = opts.indexer ?? this.resolveDefaultIndexer(entity)
     const key = this.buildSideEffectKey(opts.action, identifiers)
     const existing = this.pendingSideEffects.get(key)
     if (existing) {
@@ -740,7 +806,11 @@ export class DefaultDataEngine implements DataEngine {
       existing.syncOrigin = opts.syncOrigin ?? null
       existing.actorUserId = opts.actorUserId ?? null
       if (opts.events) existing.events = opts.events as CrudEventsConfig<unknown>
+      // Explicit always wins, on the merge branch too: a second `events:`-only mark on the same
+      // key must not let the route default overwrite the `indexer:` an earlier mark installed,
+      // which would silently drop that handler's own `buildUpsertPayload`.
       if (opts.indexer) existing.indexer = opts.indexer as CrudIndexerConfig<unknown>
+      else if (!existing.indexer && indexer) existing.indexer = indexer
       this.pendingSideEffects.set(key, existing)
       return
     }
@@ -756,7 +826,7 @@ export class DefaultDataEngine implements DataEngine {
       actorUserId: opts.actorUserId ?? null,
     }
     if (opts.events) entry.events = opts.events as CrudEventsConfig<unknown>
-    if (opts.indexer) entry.indexer = opts.indexer as CrudIndexerConfig<unknown>
+    if (indexer) entry.indexer = indexer
     this.pendingSideEffects.set(key, entry)
   }
 
@@ -765,6 +835,9 @@ export class DefaultDataEngine implements DataEngine {
     const entries = Array.from(this.pendingSideEffects.values())
     this.pendingSideEffects.clear()
     for (const entry of entries) {
+      if (entry.indexer && !suppress?.skipReindex && this.matchesDefaultEntityClass(entry.entity)) {
+        this.indexedDefaultEntityClass = true
+      }
       try {
         await this.emitOrmEntityEvent({
           action: entry.action,