@omnixal/openclaw-nats-plugin 0.2.16 → 0.2.17

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/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;