@usageflow/core 0.4.1 → 0.4.3

package/test/base.test.ts

@@ -162,9 +162,18 @@ describe('UsageFlowAPI', () => {
             method: 'GET',
             url: '/test',
             path: '/test',
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any,
             route: { path: '/test/:id' },
             headers: {},
-            app: {} as any
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any
         };
         const pattern = api.getRoutePattern(request);
         assert.strictEqual(pattern, '/test/:id');
@@ -175,7 +184,8 @@ describe('UsageFlowAPI', () => {
             url: '/users/:id',
             method: 'GET',
             identityFieldName: 'id',
-            identityFieldLocation: 'path_params'
+            identityFieldLocation: 'path_params',
+            hasRateLimit: false
         }];
 
         const request: UsageFlowRequest = {
@@ -183,11 +193,17 @@ describe('UsageFlowAPI', () => {
             url: '/users',
             path: '/users/123',
             params: { id: '123' },
-            headers: {}
+            headers: {},
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any
         };
 
-        const ledgerId = api.guessLedgerId(request);
-        assert.strictEqual(ledgerId, 'GET /users/123 123');
+        const result = api.guessLedgerId(request);
+        assert.strictEqual(result.ledgerId, 'GET /users/123 123');
+        assert.strictEqual(result.hasLimit, false);
     });
 
     test('should guess ledger ID from query params', () => {
@@ -195,18 +211,25 @@ describe('UsageFlowAPI', () => {
             url: '/users',
             method: 'GET',
             identityFieldName: 'userId',
-            identityFieldLocation: 'query_params'
+            identityFieldLocation: 'query_params',
+            hasRateLimit: true
         }];
 
         const request: UsageFlowRequest = {
             method: 'GET',
             url: '/users',
             query: { userId: '456' },
-            headers: {}
+            headers: {},
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any
         };
 
-        const ledgerId = api.guessLedgerId(request);
-        assert.strictEqual(ledgerId, 'GET /users 456');
+        const result = api.guessLedgerId(request);
+        assert.strictEqual(result.ledgerId, 'GET /users 456');
+        assert.strictEqual(result.hasLimit, true);
     });
 
     test('should guess ledger ID from body', () => {
@@ -214,18 +237,25 @@ describe('UsageFlowAPI', () => {
             url: '/users',
             method: 'POST',
             identityFieldName: 'userId',
-            identityFieldLocation: 'body'
+            identityFieldLocation: 'body',
+            hasRateLimit: false
         }];
 
         const request: UsageFlowRequest = {
             method: 'POST',
             url: '/users',
             body: { userId: '789' },
-            headers: {}
+            headers: {},
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any
         };
 
-        const ledgerId = api.guessLedgerId(request);
-        assert.strictEqual(ledgerId, 'POST /users 789');
+        const result = api.guessLedgerId(request);
+        assert.strictEqual(result.ledgerId, 'POST /users 789');
+        assert.strictEqual(result.hasLimit, false);
     });
 
     test('should guess ledger ID from bearer token', () => {
@@ -233,7 +263,8 @@ describe('UsageFlowAPI', () => {
             url: '/users',
             method: 'GET',
             identityFieldName: 'userId',
-            identityFieldLocation: 'bearer_token'
+            identityFieldLocation: 'bearer_token',
+            hasRateLimit: true
         }];
 
         const header = Buffer.from(JSON.stringify({ alg: 'HS256' })).toString('base64');
@@ -243,11 +274,17 @@ describe('UsageFlowAPI', () => {
         const request: UsageFlowRequest = {
             method: 'GET',
             url: '/users',
-            headers: { authorization: `Bearer ${token}` }
+            headers: { authorization: `Bearer ${token}` },
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any
         };
 
-        const ledgerId = api.guessLedgerId(request);
-        assert.strictEqual(ledgerId, 'GET /users token-user');
+        const result = api.guessLedgerId(request);
+        assert.strictEqual(result.ledgerId, 'GET /users token-user');
+        assert.strictEqual(result.hasLimit, true);
     });
 
     test('should guess ledger ID from headers', () => {
@@ -255,17 +292,24 @@ describe('UsageFlowAPI', () => {
             url: '/users',
             method: 'GET',
             identityFieldName: 'x-user-id',
-            identityFieldLocation: 'headers'
+            identityFieldLocation: 'headers',
+            hasRateLimit: false
         }];
 
         const request: UsageFlowRequest = {
             method: 'GET',
             url: '/users',
-            headers: { 'x-user-id': 'header-user' }
+            headers: { 'x-user-id': 'header-user' },
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any
         };
 
-        const ledgerId = api.guessLedgerId(request);
-        assert.strictEqual(ledgerId, 'GET /users header-user');
+        const result = api.guessLedgerId(request);
+        assert.strictEqual(result.ledgerId, 'GET /users header-user');
+        assert.strictEqual(result.hasLimit, false);
     });
 
     test('should return default ledger ID when no config matches', () => {
@@ -274,11 +318,526 @@ describe('UsageFlowAPI', () => {
         const request: UsageFlowRequest = {
             method: 'GET',
             url: '/users',
-            headers: {}
+            headers: {},
+            app: {
+                _router: {
+                    stack: []
+                }
+            } as any
         };
 
-        const ledgerId = api.guessLedgerId(request);
-        assert.strictEqual(ledgerId, 'GET /users');
+        const result = api.guessLedgerId(request);
+        assert.strictEqual(result.ledgerId, 'GET /users');
+        assert.strictEqual(result.hasLimit, false);
+    });
+
+    describe('guessLedgerId - Cookie scenarios', () => {
+        test('should guess ledger ID from standard cookie with cookie. prefix', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'cookie.sessionId',
+                identityFieldLocation: 'cookie',
+                hasRateLimit: true
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { cookie: 'sessionId=abc123; other=value' },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users abc123');
+            assert.strictEqual(result.hasLimit, true);
+        });
+
+        test('should guess ledger ID from standard cookie without prefix (dot notation)', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'sessionId',
+                identityFieldLocation: 'cookie',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { cookie: 'sessionId=xyz789' },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users xyz789');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should guess ledger ID from JWT cookie with technique and pick', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: '[technique=jwt]sess[pick=sub]',
+                identityFieldLocation: 'cookie',
+                hasRateLimit: true
+            }];
+
+            const header = Buffer.from(JSON.stringify({ alg: 'HS256' })).toString('base64');
+            const payload = Buffer.from(JSON.stringify({ sub: 'jwt-user-123', name: 'Test User' })).toString('base64');
+            const jwtToken = `${header}.${payload}.signature`;
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { cookie: `sess=${jwtToken}` },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users jwt-user-123');
+            assert.strictEqual(result.hasLimit, true);
+        });
+
+        test('should handle case-insensitive cookie header (Cookie vs cookie)', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'cookie.sessionId',
+                identityFieldLocation: 'cookie',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { Cookie: 'sessionId=case-test-123' },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users case-test-123');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should return default when cookie not found', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'cookie.missing',
+                identityFieldLocation: 'cookie',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { cookie: 'other=value' },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle JWT cookie with missing claim', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: '[technique=jwt]sess[pick=missingClaim]',
+                identityFieldLocation: 'cookie',
+                hasRateLimit: false
+            }];
+
+            const header = Buffer.from(JSON.stringify({ alg: 'HS256' })).toString('base64');
+            const payload = Buffer.from(JSON.stringify({ sub: 'user-123' })).toString('base64');
+            const jwtToken = `${header}.${payload}.signature`;
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { cookie: `sess=${jwtToken}` },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle JWT cookie with invalid token', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: '[technique=jwt]sess[pick=sub]',
+                identityFieldLocation: 'cookie',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { cookie: 'sess=invalid-token' },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+    });
+
+    describe('guessLedgerId - Edge cases', () => {
+        test('should use first matching config when multiple configs exist', () => {
+            (api as any).apiConfigs = [
+                {
+                    url: '/users',
+                    method: 'GET',
+                    identityFieldName: 'userId',
+                    identityFieldLocation: 'query_params',
+                    hasRateLimit: true
+                },
+                {
+                    url: '/users',
+                    method: 'GET',
+                    identityFieldName: 'id',
+                    identityFieldLocation: 'path_params',
+                    hasRateLimit: false
+                }
+            ];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                query: { userId: 'first-match' },
+                params: { id: 'second-match' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users first-match');
+            assert.strictEqual(result.hasLimit, true);
+        });
+
+        test('should not match when method does not match', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'POST',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'query_params',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                query: { userId: '123' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should not match when URL does not match', () => {
+            (api as any).apiConfigs = [{
+                url: '/posts',
+                method: 'GET',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'query_params',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                query: { userId: '123' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle missing identity field in path params', () => {
+            (api as any).apiConfigs = [{
+                url: '/users/:id',
+                method: 'GET',
+                identityFieldName: 'id',
+                identityFieldLocation: 'path_params',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                params: { otherParam: '123' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle missing identity field in query params', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'query_params',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                query: { otherParam: '123' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle missing identity field in body', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'POST',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'body',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'POST',
+                url: '/users',
+                body: { otherField: '123' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'POST /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle bearer token without authorization header', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'bearer_token',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle bearer token with invalid format', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'bearer_token',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { authorization: 'Invalid token' },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle bearer token with missing claim', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'bearer_token',
+                hasRateLimit: false
+            }];
+
+            const header = Buffer.from(JSON.stringify({ alg: 'HS256' })).toString('base64');
+            const payload = Buffer.from(JSON.stringify({ otherClaim: 'value' })).toString('base64');
+            const token = `${header}.${payload}.signature`;
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { authorization: `Bearer ${token}` },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should handle missing header field', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'x-user-id',
+                identityFieldLocation: 'headers',
+                hasRateLimit: false
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                headers: { 'other-header': 'value' },
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users');
+            assert.strictEqual(result.hasLimit, false);
+        });
+
+        test('should use overrideUrl when provided', () => {
+            (api as any).apiConfigs = [{
+                url: '/custom/path',
+                method: 'GET',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'query_params',
+                hasRateLimit: true
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                query: { userId: 'override-test' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request, '/custom/path');
+            assert.strictEqual(result.ledgerId, 'GET /custom/path override-test');
+            assert.strictEqual(result.hasLimit, true);
+        });
+
+        test('should handle hasRateLimit as undefined (defaults to false)', () => {
+            (api as any).apiConfigs = [{
+                url: '/users',
+                method: 'GET',
+                identityFieldName: 'userId',
+                identityFieldLocation: 'query_params'
+                // hasRateLimit is undefined
+            }];
+
+            const request: UsageFlowRequest = {
+                method: 'GET',
+                url: '/users',
+                query: { userId: '123' },
+                headers: {},
+                app: {
+                    _router: {
+                        stack: []
+                    }
+                } as any
+            };
+
+            const result = api.guessLedgerId(request);
+            assert.strictEqual(result.ledgerId, 'GET /users 123');
+            assert.strictEqual(result.hasLimit, false);
+        });
     });
 
     test('should destroy and clean up resources', () => {
@@ -286,5 +845,163 @@ describe('UsageFlowAPI', () => {
         // Should not throw
         assert.doesNotThrow(() => api.destroy());
     });
+
+    describe('getValueByPath', () => {
+        test('should extract simple property', () => {
+            const obj = { amount: 100 };
+            const result = api.getValueByPath(obj, 'amount');
+            assert.strictEqual(result, 100);
+        });
+
+        test('should extract nested property', () => {
+            const obj = { data: { amount: 200 } };
+            const result = api.getValueByPath(obj, 'data.amount');
+            assert.strictEqual(result, 200);
+        });
+
+        test('should extract deeply nested property', () => {
+            const obj = { response: { data: { result: { amount: 300 } } } };
+            const result = api.getValueByPath(obj, 'response.data.result.amount');
+            assert.strictEqual(result, 300);
+        });
+
+        test('should extract array element by index', () => {
+            const obj = { items: [{ id: 1 }, { id: 2 }, { id: 3 }] };
+            const result = api.getValueByPath(obj, 'items[0].id');
+            assert.strictEqual(result, 1);
+        });
+
+        test('should extract from array with wildcard notation', () => {
+            const obj = { items: [{ id: 1 }, { id: 2 }, { id: 3 }] };
+            const result = api.getValueByPath(obj, 'items[*].id');
+            assert.strictEqual(result, 1); // Should return first found
+        });
+
+        test('should extract from nested array with wildcard', () => {
+            const obj = {
+                data: [
+                    { users: [{ id: 10 }, { id: 20 }] },
+                    { users: [{ id: 30 }] }
+                ]
+            };
+            const result = api.getValueByPath(obj, 'data[*].users[*].id');
+            assert.strictEqual(result, 10); // Should return first found
+        });
+
+        test('should extract amount from response body structure', () => {
+            const responseBody = {
+                success: true,
+                data: {
+                    transaction: {
+                        amount: 1500
+                    }
+                }
+            };
+            const result = api.getValueByPath(responseBody, 'data.transaction.amount');
+            assert.strictEqual(result, 1500);
+        });
+
+        test('should extract amount from array response', () => {
+            const responseBody = {
+                results: [
+                    { id: 1, amount: 100 },
+                    { id: 2, amount: 200 },
+                    { id: 3, amount: 300 }
+                ]
+            };
+            const result = api.getValueByPath(responseBody, 'results[*].amount');
+            assert.strictEqual(result, 100); // First found
+        });
+
+        test('should return undefined for non-existent path', () => {
+            const obj = { data: { amount: 100 } };
+            const result = api.getValueByPath(obj, 'data.missing');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should return undefined for null object', () => {
+            const result = api.getValueByPath(null, 'amount');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should return undefined for undefined object', () => {
+            const result = api.getValueByPath(undefined, 'amount');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should return undefined for empty path', () => {
+            const obj = { amount: 100 };
+            const result = api.getValueByPath(obj, '');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should handle array with wildcard at root level', () => {
+            const obj = [{ id: 1, amount: 50 }, { id: 2, amount: 75 }];
+            const result = api.getValueByPath(obj, '[*].amount');
+            assert.strictEqual(result, 50); // First element's amount
+        });
+
+        test('should handle wildcard when array is empty', () => {
+            const obj = { items: [] };
+            const result = api.getValueByPath(obj, 'items[*].id');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should handle wildcard when property does not exist in array items', () => {
+            const obj = { items: [{ name: 'test' }, { name: 'test2' }] };
+            const result = api.getValueByPath(obj, 'items[*].missing');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should handle complex nested structure with multiple wildcards', () => {
+            const obj = {
+                orders: [
+                    {
+                        items: [
+                            { product: { price: 10 } },
+                            { product: { price: 20 } }
+                        ]
+                    },
+                    {
+                        items: [
+                            { product: { price: 30 } }
+                        ]
+                    }
+                ]
+            };
+            const result = api.getValueByPath(obj, 'orders[*].items[*].product.price');
+            assert.strictEqual(result, 10); // First found
+        });
+
+        test('should handle numeric string indices', () => {
+            const obj = { items: ['first', 'second', 'third'] };
+            const result = api.getValueByPath(obj, 'items[1]');
+            assert.strictEqual(result, 'second');
+        });
+
+        test('should return first element when wildcard is last segment', () => {
+            const obj = { items: [{ id: 1 }, { id: 2 }] };
+            const result = api.getValueByPath(obj, 'items[*]');
+            assert.deepStrictEqual(result, { id: 1 }); // First element
+        });
+
+        test('should handle null values in path', () => {
+            const obj = { data: null };
+            const result = api.getValueByPath(obj, 'data.amount');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should extract from response body with amount field', () => {
+            const responseBody = {
+                status: 'success',
+                amount: 5000,
+                metadata: {
+                    timestamp: '2024-01-01'
+                }
+            };
+            const result = api.getValueByPath(responseBody, 'amount');
+            assert.strictEqual(result, 5000);
+        });
+    });
 });