@usageflow/core 0.4.1 → 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,38 @@ 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;
+                    }
+
+                    case "cookie": {
+                        // Handle JWT cookie format: '[technique=jwt]cookieName[pick=claim]'
+                        const jwtCookieMatch = this.parseJwtCookieField(fieldName);
+                        if (jwtCookieMatch) {
+                            const { cookieName, claim } = jwtCookieMatch;
+                            const cookieValue = this.getCookieValue(request.headers, cookieName);
+                            if (cookieValue) {
+                                const claims = this.decodeJwtUnverified(cookieValue);
+                                if (claims?.[claim]) {
+                                    return { ledgerId: `${method} ${url} ${claims[claim]}`, hasLimit, responseTrackingField };
+                                }
+                            }
+                            break;
+                        }
+
+                        // Handle standard cookie access (e.g., "cookie.session" or "session")
+                        let cookieValue: string | null = null;
+                        if (fieldName.toLowerCase().startsWith('cookie.')) {
+                            const cookieName = fieldName.substring(7); // Remove "cookie." prefix
+                            cookieValue = this.getCookieValue(request.headers, cookieName);
+                        } else {
+                            // Use dot notation for regular headers
+                            cookieValue = this.getByDotNotation(request.headers, fieldName);
+                        }
+
+                        if (cookieValue) {
+                            return { ledgerId: `${method} ${url} ${cookieValue}`, hasLimit, responseTrackingField };
                         }
                         break;
                     }
@@ -375,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> {
@@ -445,6 +478,7 @@ export abstract class UsageFlowAPI {
         payload: RequestForAllocation,
         metadata: RequestMetadata,
         hasLimit: boolean,
+        responseTrackingField?: string,
     ): Promise<void> {
         if (this.socketManager && this.socketManager.isConnected()) {
             try {
@@ -477,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(
@@ -648,4 +683,287 @@ export abstract class UsageFlowAPI {
     public getBlockedEndpoints(): Map<string, boolean> {
         return this.blockedEndpoints;
     }
+
+    private getByDotNotation(object: any, path: string): any {
+        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
+     * @param cookieName The name of the cookie to extract (e.g., "session")
+     * @returns The cookie value or null if not found
+     */
+    private getCookieValue(
+        headers: Record<string, string | string[] | undefined> | Headers,
+        cookieName: string,
+    ): string | null {
+        let cookieHeader = this.getHeaderValue(headers, 'cookie');
+        if (!cookieHeader) {
+            cookieHeader = this.getHeaderValue(headers, 'Cookie');
+        }
+
+        if (!cookieHeader) {
+            return null;
+        }
+
+        // Parse cookies from the Cookie header string
+        // Format: "name1=value1; name2=value2; name3=value3"
+        const cookies = cookieHeader.split(';').map(cookie => {
+            const [name, ...valueParts] = cookie.trim().split('=');
+            return {
+                name: name.trim(),
+                value: valueParts.join('=').trim(), // Handle values that might contain '='
+            };
+        });
+
+        // Find the cookie with the matching name (case-insensitive)
+        const cookie = cookies.find(c => c.name.toLowerCase() === cookieName.toLowerCase());
+        return cookie ? cookie.value : null;
+    }
+
+    /**
+     * Parse JWT cookie field format: '[technique=jwt]cookieName[pick=claim]'
+     * @param fieldName The field name to parse
+     * @returns Object with cookieName and claim, or null if not a JWT cookie format
+     */
+    private parseJwtCookieField(
+        fieldName: string,
+    ): { cookieName: string; claim: string } | null {
+        const techniqueMatch = fieldName.match(/^\[technique=([^\]]+)\]/);
+        if (!techniqueMatch || techniqueMatch[1] !== 'jwt') {
+            return null;
+        }
+
+        const pickMatch = fieldName.match(/\[pick=([^\]]+)\]/);
+        if (!pickMatch) {
+            return null;
+        }
+
+        // Extract cookie name: everything between [technique=jwt] and [pick=...]
+        const techniqueEnd = techniqueMatch[0].length;
+        const pickStart = fieldName.indexOf('[pick=');
+        if (pickStart === -1 || pickStart <= techniqueEnd) {
+            return null;
+        }
+
+        const cookieName = fieldName.substring(techniqueEnd, pickStart);
+        if (!cookieName) {
+            return null;
+        }
+
+        return {
+            cookieName,
+            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/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;