@omnixal/openclaw-nats-plugin 0.2.15 → 0.2.17

package/sidecar/src/route-filter/route-filter.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@onebun/core';
+import { RouteFilterService } from './route-filter.service';
+
+@Module({
+  services: [RouteFilterService],
+  exports: [RouteFilterService],
+})
+export class RouteFilterModule {}

package/sidecar/src/route-filter/route-filter.service.ts

@@ -0,0 +1,61 @@
+import { Service, BaseService } from '@onebun/core';
+import type { FilterExpression, FilterCondition } from './filter-expression';
+
+@Service()
+export class RouteFilterService extends BaseService {
+  evaluate(payload: unknown, filter: FilterExpression | null): boolean {
+    if (!filter || !filter.conditions || filter.conditions.length === 0) return true;
+    const results = filter.conditions.map(c => this.evalCondition(payload, c));
+    return filter.logic === 'or' ? results.some(Boolean) : results.every(Boolean);
+  }
+
+  private resolveField(obj: unknown, path: string): { found: boolean; value: unknown } {
+    const parts = path.split('.');
+    let current: unknown = obj;
+    for (const part of parts) {
+      if (current === null || current === undefined) return { found: false, value: undefined };
+      if (typeof current === 'object') {
+        if (!(part in (current as Record<string, unknown>))) return { found: false, value: undefined };
+        current = (current as Record<string, unknown>)[part];
+      } else {
+        return { found: false, value: undefined };
+      }
+    }
+    return { found: true, value: current };
+  }
+
+  private evalCondition(payload: unknown, cond: FilterCondition): boolean {
+    const { found, value } = this.resolveField(payload, cond.field);
+
+    if (cond.op === 'exists') {
+      return cond.value ? found : !found;
+    }
+
+    if (!found) return false;
+
+    switch (cond.op) {
+      case 'eq':
+        return value === cond.value;
+      case 'neq':
+        return value !== cond.value;
+      case 'gt':
+        return typeof value === 'number' && typeof cond.value === 'number' && value > cond.value;
+      case 'gte':
+        return typeof value === 'number' && typeof cond.value === 'number' && value >= cond.value;
+      case 'lt':
+        return typeof value === 'number' && typeof cond.value === 'number' && value < cond.value;
+      case 'lte':
+        return typeof value === 'number' && typeof cond.value === 'number' && value <= cond.value;
+      case 'in':
+        return Array.isArray(cond.value) && cond.value.includes(value);
+      case 'nin':
+        return Array.isArray(cond.value) && !cond.value.includes(value);
+      case 'contains':
+        if (typeof value === 'string' && typeof cond.value === 'string') return value.includes(cond.value);
+        if (Array.isArray(value)) return value.includes(cond.value);
+        return false;
+      default:
+        return false;
+    }
+  }
+}

package/sidecar/src/router/router.controller.ts

@@ -37,10 +37,14 @@ export class RouterController extends BaseController {
     const routes = await this.routerService.listRoutes();
     const result = routes.map(r => ({
       id: r.id,
+      name: r.name,
       pattern: r.pattern,
       target: r.target,
       priority: r.priority,
       enabled: r.enabled,
+      filter: r.filter ?? null,
+      filterDropCount: r.filterDropCount ?? 0,
+      customPayload: r.customPayload ?? null,
       lastDeliveredAt: r.lastDeliveredAt?.toISOString() ?? null,
       lastEventSubject: r.lastEventSubject ?? null,
       deliveryCount: r.deliveryCount ?? 0,
@@ -66,10 +70,14 @@ export class RouterController extends BaseController {
     if (!isValidAgentSubject(body.pattern)) {
       return this.error('pattern must start with "agent.events." followed by at least one token and must not end with "."', 400, 400);
     }
+    const name = body.name ?? body.pattern;
     const { route, created } = await this.routerService.subscribe(
+      name,
       body.pattern,
       body.target ?? 'main',
       body.priority ?? 5,
+      body.filter ?? null,
+      body.payload,
     );
     return this.success({ ...route, created });
   }
@@ -79,7 +87,12 @@ export class RouterController extends BaseController {
     @Param('id') id: string,
     @Body(updateRouteBodySchema) body: UpdateRouteBody,
   ): Promise<OneBunResponse> {
-    const updated = await this.routerService.updateById(id, body);
+    const { payload: customPayload, filter, ...rest } = body;
+    const updated = await this.routerService.updateById(id, {
+      ...rest,
+      ...(customPayload !== undefined ? { customPayload } : {}),
+      ...(filter !== undefined ? { filter: filter as any } : {}),
+    });
     if (!updated) {
       return this.error('Route not found', 404, 404);
     }

package/sidecar/src/router/router.repository.ts

@@ -36,11 +36,14 @@ export class RouterRepository extends BaseService {
       .insert(eventRoutes)
       .values(route)
       .onConflictDoUpdate({
-        target: eventRoutes.pattern,
+        target: eventRoutes.name,
         set: {
+          pattern: sql`excluded.pattern`,
           target: sql`excluded.target`,
           priority: sql`excluded.priority`,
           enabled: sql`excluded.enabled`,
+          filter: sql`excluded.filter`,
+          customPayload: sql`excluded.custom_payload`,
         },
       })
       .returning();
@@ -49,7 +52,7 @@ export class RouterRepository extends BaseService {
     return { route: result, created };
   }
 
-  async updateById(id: string, fields: Partial<Pick<DbEventRoute, 'target' | 'priority' | 'enabled'>>): Promise<DbEventRoute | null> {
+  async updateById(id: string, fields: Partial<Pick<DbEventRoute, 'target' | 'priority' | 'enabled' | 'customPayload' | 'filter'>>): Promise<DbEventRoute | null> {
     const [result] = await this.db.update(eventRoutes)
       .set(fields)
       .where(eq(eventRoutes.id, id))
@@ -68,13 +71,21 @@ export class RouterRepository extends BaseService {
       .where(eq(eventRoutes.id, routeId));
   }
 
+  async incrementFilterDropCount(routeId: string): Promise<void> {
+    await this.db.update(eventRoutes)
+      .set({
+        filterDropCount: sql`${eventRoutes.filterDropCount} + 1`,
+      })
+      .where(eq(eventRoutes.id, routeId));
+  }
+
   async deleteById(id: string): Promise<boolean> {
     const result = await this.db.delete(eventRoutes).where(eq(eventRoutes.id, id)).returning();
     return result.length > 0;
   }
 
-  async deleteByPattern(pattern: string): Promise<boolean> {
-    const result = await this.db.delete(eventRoutes).where(eq(eventRoutes.pattern, pattern)).returning();
+  async deleteByName(name: string): Promise<boolean> {
+    const result = await this.db.delete(eventRoutes).where(eq(eventRoutes.name, name)).returning();
     return result.length > 0;
   }
 

package/sidecar/src/router/router.service.ts

@@ -1,6 +1,7 @@
 import { Service, BaseService } from '@onebun/core';
 import { RouterRepository } from './router.repository';
 import type { DbEventRoute } from '../db/schema';
+import type { FilterExpression } from '../route-filter/filter-expression';
 import { ulid } from 'ulid';
 
 @Service()
@@ -40,21 +41,27 @@ export class RouterService extends BaseService {
   }
 
   async subscribe(
+    name: string,
     pattern: string,
     target: string = 'main',
     priority: number = 5,
+    filter?: FilterExpression | null,
+    customPayload?: unknown,
   ): Promise<{ route: DbEventRoute; created: boolean }> {
     return this.repo.upsert({
       id: ulid(),
+      name,
       pattern,
       target,
       enabled: true,
       priority,
+      filter: filter ?? null,
+      customPayload: customPayload ?? null,
       createdAt: new Date(),
     });
   }
 
-  async updateById(id: string, fields: { target?: string; priority?: number; enabled?: boolean }): Promise<DbEventRoute | null> {
+  async updateById(id: string, fields: { target?: string; priority?: number; enabled?: boolean; customPayload?: unknown; filter?: FilterExpression | null }): Promise<DbEventRoute | null> {
     return this.repo.updateById(id, fields);
   }
 
@@ -62,8 +69,12 @@ export class RouterService extends BaseService {
     await this.repo.recordDelivery(routeId, subject, lagMs);
   }
 
-  async unsubscribe(pattern: string): Promise<boolean> {
-    return this.repo.deleteByPattern(pattern);
+  async incrementFilterDropCount(routeId: string): Promise<void> {
+    await this.repo.incrementFilterDropCount(routeId);
+  }
+
+  async unsubscribeByName(name: string): Promise<boolean> {
+    return this.repo.deleteByName(name);
   }
 
   async deleteById(id: string): Promise<boolean> {

package/sidecar/src/scheduler/scheduler.controller.ts

@@ -124,7 +124,7 @@ export class SchedulerController extends BaseController {
 
   // ── Queue Handlers ────────────────────────────────────────────────
 
-  @Subscribe('scheduler.fire.*', { group: 'scheduler-handler' })
+  @Subscribe('scheduler.fire.*', { group: 'scheduler-cron-handler' })
   async handleFire(message: Message<unknown>): Promise<void> {
     const jobName = message.pattern?.split('.').pop();
     if (jobName) {
@@ -132,7 +132,7 @@ export class SchedulerController extends BaseController {
     }
   }
 
-  @Subscribe('scheduler.timer.*', { group: 'scheduler-handler' })
+  @Subscribe('scheduler.timer.*', { group: 'scheduler-timer-handler' })
   async handleTimerFire(message: Message<unknown>): Promise<void> {
     const timerName = message.pattern?.split('.').pop();
     if (timerName) {

package/sidecar/src/validation/schemas.ts

@@ -18,10 +18,24 @@ export const markDeliveredBodySchema = type({
 
 export type MarkDeliveredBody = typeof markDeliveredBodySchema.infer;
 
+export const filterConditionSchema = type({
+  field: 'string',
+  op: "'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'exists'",
+  value: 'unknown',
+});
+
+export const filterExpressionSchema = type({
+  logic: "'and' | 'or'",
+  conditions: filterConditionSchema.array(),
+});
+
 export const createRouteBodySchema = type({
   pattern: 'string',
+  'name?': 'string',
   'target?': 'string',
   'priority?': 'number',
+  'payload?': 'unknown',
+  'filter?': filterExpressionSchema,
 });
 
 export type CreateRouteBody = typeof createRouteBodySchema.infer;
@@ -40,6 +54,8 @@ export const updateRouteBodySchema = type({
   'target?': 'string',
   'priority?': 'number',
   'enabled?': 'boolean',
+  'payload?': 'unknown',
+  'filter?': 'unknown',
 });
 
 export type UpdateRouteBody = typeof updateRouteBodySchema.infer;