@usageflow/core 0.4.2 → 0.4.3

package/src/base.ts

@@ -318,7 +318,7 @@ export abstract class UsageFlowAPI {
     public guessLedgerId(
         request: UsageFlowRequest,
         overrideUrl?: string,
-    ): { ledgerId: string, hasLimit: boolean } {
+    ): { ledgerId: string, hasLimit: boolean, responseTrackingField?: string } {
         const method = request.method;
         const url = overrideUrl || this.getRoutePattern(request);
         const configs = this.apiConfigs;
@@ -331,23 +331,25 @@ export abstract class UsageFlowAPI {
             const fieldName = config.identityFieldName!;
             const location = config.identityFieldLocation;
             const hasLimit = config.hasRateLimit || false;
+            const isResponseTrackingEnabled = config.isResponseTrackingEnabled;
+            const responseTrackingField = isResponseTrackingEnabled ? config.responseTrackingField : undefined;
 
             if (method === config.method && url === config.url) {
 
                 switch (location) {
                     case "path_params":
                         if (request.params?.[fieldName]) {
-                            return { ledgerId: `${method} ${url} ${request.params[fieldName]}`, hasLimit };
+                            return { ledgerId: `${method} ${url} ${request.params[fieldName]}`, hasLimit, responseTrackingField };
                         }
                         break;
                     case "query_params":
                         if (request.query?.[fieldName]) {
-                            return { ledgerId: `${method} ${url} ${request.query[fieldName]}`, hasLimit };
+                            return { ledgerId: `${method} ${url} ${request.query[fieldName]}`, hasLimit, responseTrackingField };
                         }
                         break;
                     case "body":
                         if (request.body?.[fieldName]) {
-                            return { ledgerId: `${method} ${url} ${request.body[fieldName]}`, hasLimit };
+                            return { ledgerId: `${method} ${url} ${request.body[fieldName]}`, hasLimit, responseTrackingField };
                         }
                         break;
                     case "bearer_token":
@@ -359,7 +361,7 @@ export abstract class UsageFlowAPI {
                         if (token) {
                             const claims = this.decodeJwtUnverified(token);
                             if (claims?.[fieldName]) {
-                                return { ledgerId: `${method} ${url} ${claims[fieldName]}`, hasLimit };
+                                return { ledgerId: `${method} ${url} ${claims[fieldName]}`, hasLimit, responseTrackingField };
                             }
                         }
                         break;
@@ -367,7 +369,7 @@ export abstract class UsageFlowAPI {
                     case "headers": {
                         const headerValue = this.getHeaderValue(request.headers, fieldName);
                         if (headerValue) {
-                            return { ledgerId: `${method} ${url} ${headerValue}`, hasLimit };
+                            return { ledgerId: `${method} ${url} ${headerValue}`, hasLimit, responseTrackingField };
                         }
                         break;
                     }
@@ -381,7 +383,7 @@ export abstract class UsageFlowAPI {
                             if (cookieValue) {
                                 const claims = this.decodeJwtUnverified(cookieValue);
                                 if (claims?.[claim]) {
-                                    return { ledgerId: `${method} ${url} ${claims[claim]}`, hasLimit };
+                                    return { ledgerId: `${method} ${url} ${claims[claim]}`, hasLimit, responseTrackingField };
                                 }
                             }
                             break;
@@ -398,7 +400,7 @@ export abstract class UsageFlowAPI {
                         }
 
                         if (cookieValue) {
-                            return { ledgerId: `${method} ${url} ${cookieValue}`, hasLimit };
+                            return { ledgerId: `${method} ${url} ${cookieValue}`, hasLimit, responseTrackingField };
                         }
                         break;
                     }
@@ -406,7 +408,7 @@ export abstract class UsageFlowAPI {
             }
         }
 
-        return { ledgerId: `${method} ${url}`, hasLimit: false };
+        return { ledgerId: `${method} ${url}`, hasLimit: false, responseTrackingField: undefined };
     }
 
     private async fetchApiPolicies(): Promise<void> {
@@ -476,6 +478,7 @@ export abstract class UsageFlowAPI {
         payload: RequestForAllocation,
         metadata: RequestMetadata,
         hasLimit: boolean,
+        responseTrackingField?: string,
     ): Promise<void> {
         if (this.socketManager && this.socketManager.isConnected()) {
             try {
@@ -508,6 +511,7 @@ export abstract class UsageFlowAPI {
                     });
                     request.usageflow!.eventId = payload.allocationId;
                     request.usageflow!.metadata = metadata;
+                    request.usageflow!.responseTrackingField = responseTrackingField;
                 }
             } catch (error: any) {
                 console.error(
@@ -684,6 +688,109 @@ export abstract class UsageFlowAPI {
         return path.split('.').reduce((acc, part) => acc?.[part], object);
     }
 
+    /**
+     * Extract a value from an object using a dot-notation path
+     * Supports nested paths like "data.amount" or "result.items[0].count"
+     * Supports wildcard array notation like "items[*].id" to iterate over arrays
+     * @param obj - The object to extract the value from
+     * @param path - The dot-notation path to the value (e.g., "data.amount" or "items[*].id")
+     * @returns The value at the path, or undefined if not found. For wildcard arrays, returns an array of values.
+     */
+    public getValueByPath(obj: any, path: string): any {
+        if (!obj || !path) {
+            return undefined;
+        }
+
+        // Parse path into segments, preserving [*] as a special marker
+        const segments: Array<string | '*'> = [];
+        let currentSegment = '';
+        let i = 0;
+
+        while (i < path.length) {
+            if (path[i] === '[' && i + 1 < path.length && path[i + 1] === '*') {
+                // Found [*]
+                if (currentSegment) {
+                    segments.push(currentSegment);
+                    currentSegment = '';
+                }
+                segments.push('*');
+                i += 3; // Skip '[', '*', ']'
+            } else if (path[i] === '[') {
+                // Found indexed array access like [0]
+                if (currentSegment) {
+                    segments.push(currentSegment);
+                    currentSegment = '';
+                }
+                // Extract the index
+                let index = '';
+                i++; // Skip '['
+                while (i < path.length && path[i] !== ']') {
+                    index += path[i];
+                    i++;
+                }
+                if (index) {
+                    segments.push(index);
+                }
+                i++; // Skip ']'
+            } else if (path[i] === '.') {
+                if (currentSegment) {
+                    segments.push(currentSegment);
+                    currentSegment = '';
+                }
+                i++;
+            } else {
+                currentSegment += path[i];
+                i++;
+            }
+        }
+
+        if (currentSegment) {
+            segments.push(currentSegment);
+        }
+
+        // Recursive helper function to process segments
+        const processSegments = (currentObj: any, segs: Array<string | '*'>, segIndex: number): any => {
+            if (currentObj === null || currentObj === undefined) {
+                return undefined;
+            }
+
+            // If we've processed all segments, return the current value
+            if (segIndex >= segs.length) {
+                return currentObj;
+            }
+
+            const segment = segs[segIndex];
+
+            // Handle wildcard array iteration
+            if (segment === '*') {
+                if (!Array.isArray(currentObj)) {
+                    return undefined;
+                }
+
+                // If this is the last segment, return the first element of the array
+                if (segIndex === segs.length - 1) {
+                    return currentObj.length > 0 ? currentObj[0] : undefined;
+                }
+
+                // Otherwise, iterate over the array and return the first valid result
+                for (const item of currentObj) {
+                    const result = processSegments(item, segs, segIndex + 1);
+                    if (result !== undefined) {
+                        return result;
+                    }
+                }
+
+                return undefined;
+            }
+
+            // Handle regular property access
+            const nextObj = currentObj[segment];
+            return processSegments(nextObj, segs, segIndex + 1);
+        };
+
+        return processSegments(obj, segments, 0);
+    }
+
     /**
      * Parse and extract a specific cookie value from the Cookie header
      * @param headers The request headers object
@@ -753,4 +860,110 @@ export abstract class UsageFlowAPI {
             claim: pickMatch[1],
         };
     }
+
+    public getResponseBody(response: Response): any {
+        if (response.body) {
+            return response.body;
+        }
+        return null;
+    }
+
+    /**
+     * Extract schema from a JavaScript object/array
+     * Recursively processes objects, arrays, and primitives to build a schema structure
+     * @param obj - The object to extract schema from
+     * @param path - The current path in the object hierarchy (for nested objects)
+     * @returns Schema object with type information and paths
+     */
+    public extractSchema(obj: any, path: string = ''): any {
+        // Handle null
+        if (obj === null || obj === undefined) {
+            return 'null';
+        }
+
+        // Handle arrays
+        if (Array.isArray(obj)) {
+            if (obj.length === 0) {
+                return 'array';
+            }
+            // Get schema of first element as representative
+            return {
+                type: 'array',
+                items: this.extractSchema(obj[0], path),
+            };
+        }
+
+        // Handle objects
+        if (typeof obj === 'object' && obj !== null) {
+            const schema: Record<string, any> = {};
+            for (const [key, value] of Object.entries(obj)) {
+                const fieldPath = path ? `${path}.${key}` : key;
+
+                if (value === null || value === undefined) {
+                    schema[key] = {
+                        type: 'null',
+                        path: fieldPath,
+                    };
+                } else if (typeof value === 'boolean') {
+                    // Check bool before number (important for type detection)
+                    schema[key] = {
+                        type: 'boolean',
+                        path: fieldPath,
+                    };
+                } else if (typeof value === 'number') {
+                    // Check if it's an integer or float
+                    if (Number.isInteger(value)) {
+                        schema[key] = {
+                            type: 'integer',
+                            path: fieldPath,
+                        };
+                    } else {
+                        schema[key] = {
+                            type: 'float',
+                            path: fieldPath,
+                        };
+                    }
+                } else if (typeof value === 'string') {
+                    schema[key] = {
+                        type: 'string',
+                        path: fieldPath,
+                    };
+                } else if (Array.isArray(value)) {
+                    schema[key] = {
+                        type: 'array',
+                        path: fieldPath,
+                        items: value.length > 0 ? this.extractSchema(value[0], fieldPath) : 'unknown',
+                    };
+                } else if (typeof value === 'object') {
+                    schema[key] = {
+                        type: 'object',
+                        path: fieldPath,
+                        properties: this.extractSchema(value, fieldPath),
+                    };
+                } else {
+                    schema[key] = {
+                        type: typeof value,
+                        path: fieldPath,
+                    };
+                }
+            }
+
+            return schema;
+        }
+
+        // Handle primitive types
+        if (typeof obj === 'boolean') {
+            return 'boolean';
+        } else if (typeof obj === 'number') {
+            if (Number.isInteger(obj)) {
+                return 'integer';
+            } else {
+                return 'float';
+            }
+        } else if (typeof obj === 'string') {
+            return 'string';
+        } else {
+            return typeof obj;
+        }
+    }
 }

package/src/socket.ts

@@ -11,6 +11,7 @@ interface PooledConnection {
 export class UsageFlowSocketManger {
     private connections: PooledConnection[] = [];
     private wsUrl: string = "wss://api.usageflow.io/ws";
+    // private wsUrl: string = "ws://localhost:9000/ws";
     private poolSize: number = 10; // Default pool size
     private currentIndex: number = 0; // For round-robin selection
     private connecting: boolean = false;

package/src/types.ts

@@ -5,6 +5,7 @@ declare global {
                 startTime: number;
                 eventId?: string;
                 metadata?: RequestMetadata;
+                responseTrackingField?: string;
             };
             baseUrl: string;
         }
@@ -16,6 +17,8 @@ declare global {
                 startTime: number;
                 eventId?: string;
                 metadata?: RequestMetadata;
+                responseTrackingField?: string;
+
             };
         }
     }
@@ -26,6 +29,7 @@ declare global {
                 startTime: number;
                 eventId?: string;
                 metadata?: RequestMetadata;
+                responseTrackingField?: string;
             };
         }
     }
@@ -63,6 +67,9 @@ export interface UsageFlowConfig {
     identityFieldName?: string;
     identityFieldLocation?: string;
     hasRateLimit?: boolean;
+    responseTrackingField?: string;
+    isResponseTrackingEnabled?: boolean;
+
 }
 
 export interface BlockedEndpoint {
@@ -140,6 +147,7 @@ export interface UsageFlowRequest {
         eventId?: string;
         metadata?: RequestMetadata;
         startTime?: number;
+        responseTrackingField?: string;
     };
     routeOptions?: {
         url: string;