address pr comments

Author: cbrady

.fernignore

@@ -13,10 +13,13 @@ src/events.test.ts
 src/events.ts
 src/index.ts
 src/logger.ts
-src/rules-engine.test.ts
 src/rules-engine.ts
 src/version.ts
 src/wasm/
 src/webhooks.ts
 src/wrapper.ts
+tests/unit/cache/local.test.ts
+tests/unit/datastream/datastream-client.test.ts
+tests/unit/datastream/websocket-client.test.ts
+tests/unit/rules-engine.test.ts
 tests/unit/webhooks.test.ts

build.js

@@ -12,11 +12,9 @@ const sharedConfig = {
   sourcemap: 'external',
   external: [
     // Keep dependencies external since this is a library
-    'url-join',
     'form-data',
-    'formdata-node', 
+    'formdata-node',
     'node-fetch',
-    'qs',
     'readable-stream'
   ],
   tsconfig: './tsconfig.json',

src/cache/redis.ts

@@ -20,7 +20,8 @@ export interface RedisOptions extends CacheOptions {
  * Requires the 'redis' package to be installed: npm install redis
  */
 export class RedisCacheProvider<T> implements CacheProvider<T> {
-  private client: any; // Redis client type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- redis client is dynamically imported
+  private client: any;
   private defaultTTL: number;
   private keyPrefix: string;
   private isConnected: boolean = false;
@@ -37,10 +38,11 @@ export class RedisCacheProvider<T> implements CacheProvider<T> {
   private async initRedisClient(options: RedisOptions): Promise<void> {
     try {
       // Dynamically import redis so it's only loaded if actually used
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dynamic import for optional dependency
       const redisModule = await import('redis' as any);
       const { createClient } = redisModule;
-      
-      let clientConfig: any = {};
+
+      let clientConfig: Record<string, unknown> = {};
 
       if (options.url) {
         clientConfig.url = options.url;

src/datastream/datastream-client.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'events';
 import * as Schematic from '../api/types';
 import { DatastreamWSClient } from './websocket-client';
-import { DataStreamResp, DataStreamReq, EntityType, MessageType } from './types';
+import { DataStreamResp, DataStreamReq, DataStreamError, EntityType, MessageType } from './types';
 import { RulesEngineClient } from '../rules-engine';
 import { Logger } from '../logger';
 
@@ -44,7 +44,6 @@ export interface DataStreamClientOptions {
 type PendingRequestHandler<T> = (value: T | null) => void;
 
 // Cache key constants
-const CACHE_KEY_PREFIX = 'schematic';
 const CACHE_KEY_PREFIX_COMPANY = 'company';
 const CACHE_KEY_PREFIX_USER = 'user';  
 const CACHE_KEY_PREFIX_FLAGS = 'flags';
@@ -796,7 +795,7 @@ export class DataStreamClient extends EventEmitter {
    * handleErrorMessage processes error messages
    */
   private async handleErrorMessage(message: DataStreamResp): Promise<void> {
-    const errorData = message.data as any;
+    const errorData = message.data as DataStreamError;
 
     if (errorData?.keys && errorData?.entity_type) {
       // Notify pending requests with null/error
@@ -1146,28 +1145,28 @@ export class DataStreamClient extends EventEmitter {
   }
 
   /**
-   * evaluateFlag evaluates a flag using the rules engine
+   * sanitizeForWasm removes null/undefined values from objects for WASM compatibility
    */
-  private sanitizeForWasm(obj: any): any {
+  private sanitizeForWasm<T>(obj: T): T {
     if (obj === null || obj === undefined) {
-      return null;
+      return null as T;
     }
-    
+
     if (Array.isArray(obj)) {
-      return obj.map(item => this.sanitizeForWasm(item)).filter(item => item !== null);
+      return obj.map(item => this.sanitizeForWasm(item)).filter(item => item !== null) as T;
     }
-    
+
     if (typeof obj === 'object') {
-      const sanitized: any = {};
+      const sanitized: Record<string, unknown> = {};
       for (const [key, value] of Object.entries(obj)) {
         const sanitizedValue = this.sanitizeForWasm(value);
         if (sanitizedValue !== null) {
           sanitized[key] = sanitizedValue;
         }
       }
-      return sanitized;
+      return sanitized as T;
     }
-    
+
     return obj;
   }
 

src/datastream/types.ts

@@ -39,7 +39,7 @@ export interface DataStreamBaseReq {
  * DataStreamResp represents a response message from the datastream
  */
 export interface DataStreamResp {
-  data: any; // JSON raw message equivalent
+  data: unknown;
   entity_type: string;
   message_type: string;
 }

src/datastream/websocket-client.ts

@@ -349,7 +349,7 @@ export class DatastreamWSClient extends EventEmitter {
   /**
    * connect establishes the WebSocket connection
    */
-  private connect(): Promise<any> {
+  private connect(): Promise<WebSocket> {
     return new Promise((resolve, reject) => {
       this.logger.debug(`Connecting to WebSocket: ${this.url}`);
 
@@ -472,7 +472,12 @@ export class DatastreamWSClient extends EventEmitter {
       return;
     }
 
-    
+    // Clear any existing pong timeout before setting a new one
+    if (this.pongTimeout) {
+      clearTimeout(this.pongTimeout);
+      this.pongTimeout = undefined;
+    }
+
     // Set pong timeout
     this.pongTimeout = setTimeout(() => {
       this.logger.warn('Pong timeout - closing connection');

src/rules-engine.ts

@@ -1,48 +1,43 @@
 import { RulesEngineJS } from './wasm/rulesengine.js';
+import type * as Schematic from './api/types';
+
+/** Result returned by the WASM rules engine (snake_case keys) */
+export interface WasmCheckFlagResult {
+    value: boolean;
+    reason: string;
+    rule_id?: string;
+    flag_id?: string;
+    flag_key?: string;
+    company_id?: string;
+    user_id?: string;
+    rule_type?: string;
+    err?: string;
+}
 
-/**
- * High-performance rules engine for flag evaluation and rule processing.
- * 
- * This engine provides significant performance improvements over traditional JavaScript
- * implementations by leveraging compiled Rust code running in WebAssembly.
- */
 export class RulesEngineClient {
     private wasmInstance: RulesEngineJS | null = null;
     private initialized = false;
 
     constructor() {}
 
-    /**
-     * Initialize the WASM rules engine.
-     * Must be called before using any other methods.
-     */
     async initialize(): Promise<void> {
         if (this.initialized) {
             return;
         }
 
         try {
-            // Initialize the WASM module
             this.wasmInstance = new RulesEngineJS();
             this.initialized = true;
         } catch (error) {
             throw new Error(`Failed to initialize WASM rules engine: ${error}`);
         }
     }
 
-    /**
-     * Check a feature flag using the WASM engine.
-     * 
-     * @param flag - The flag configuration object
-     * @param company - Optional company context
-     * @param user - Optional user context
-     * @returns Promise resolving to the flag check result
-     */
     async checkFlag(
-        flag: any,
-        company?: any,
-        user?: any
-    ): Promise<any> {
+        flag: Schematic.RulesengineFlag,
+        company?: Schematic.RulesengineCompany | null,
+        user?: Schematic.RulesengineUser | null
+    ): Promise<WasmCheckFlagResult> {
         this.ensureInitialized();
 
         try {

src/wrapper.ts

@@ -180,6 +180,7 @@ export class SchematicClient extends BaseClient {
                     flagKey: key,
                     value: flagValue ?? false,
                     reason: resp?.reason ?? "unknown",
+                    ruleId: resp?.ruleId,
                     companyId: resp?.companyId,
                     userId: resp?.userId,
                     flagId: resp?.flagId,

tests/unit/datastream/datastream-client.test.ts

@@ -166,10 +166,10 @@ describe('DataStreamClient', () => {
 
     // Simulate WebSocket events
     const onCalls = mockDatastreamWSClientInstance.on.mock.calls;
-    const connectedHandler = onCalls.find((call: any) => call[0] === 'connected')?.[1];
-    const disconnectedHandler = onCalls.find((call: any) => call[0] === 'disconnected')?.[1];
-    const readyHandler = onCalls.find((call: any) => call[0] === 'ready')?.[1];
-    const errorHandler = onCalls.find((call: any) => call[0] === 'error')?.[1];
+    const connectedHandler = onCalls.find((call: [string, Function]) => call[0] === 'connected')?.[1];
+    const disconnectedHandler = onCalls.find((call: [string, Function]) => call[0] === 'disconnected')?.[1];
+    const readyHandler = onCalls.find((call: [string, Function]) => call[0] === 'ready')?.[1];
+    const errorHandler = onCalls.find((call: [string, Function]) => call[0] === 'error')?.[1];
 
     if (connectedHandler) connectedHandler();
     if (disconnectedHandler) disconnectedHandler();
@@ -260,7 +260,7 @@ describe('DataStreamClient', () => {
 
     // Get the connection handler from the WebSocket client mock
     const onCalls = mockDatastreamWSClientInstance.on.mock.calls;
-    const connectedHandler = onCalls.find((call: any) => call[0] === 'connected')?.[1];
+    const connectedHandler = onCalls.find((call: [string, Function]) => call[0] === 'connected')?.[1];
 
     // Mock sendMessage to automatically trigger response
     mockDatastreamWSClientInstance.sendMessage.mockImplementation(async (message: any) => {
@@ -313,7 +313,7 @@ describe('DataStreamClient', () => {
 
     // Get the connection handler from the WebSocket client mock
     const onCalls = mockDatastreamWSClientInstance.on.mock.calls;
-    const connectedHandler = onCalls.find((call: any) => call[0] === 'connected')?.[1];
+    const connectedHandler = onCalls.find((call: [string, Function]) => call[0] === 'connected')?.[1];
 
     // Mock sendMessage to track requests and auto-respond
     mockDatastreamWSClientInstance.sendMessage.mockImplementation(async (message: any) => {