feat: add streamedListObjects for unlimited object retrieval

Adds streamedListObjects method to enable retrieving more than 1000 objects
via the streaming API endpoint. This is a Node.js-only implementation using
axios streaming with resilient NDJSON parsing.

Requires OpenFGA server v1.2.0+ for streaming endpoint support.

Key changes:
- Add streaming.ts with parseNDJSONStream for Node.js Readable streams
- Add StreamedListObjectsResponse interface to apiModel.ts
- Add OpenFgaClient.streamedListObjects() async generator method
- Add createStreamingRequestFunction to common.ts for telemetry integration
- Export parseNDJSONStream from index.ts for public use
- Add comprehensive streaming tests (259 lines, all passing)
- Add two example implementations (full model and minimal local)
- Update CHANGELOG.md with streaming feature and server version requirement

Features:
- No 1000-object limit (streams until completion)
- Memory-efficient incremental results via async generators
- Telemetry maintained through API layer streaming request path
- Robust error propagation through async iterators
- Stream cleanup on early consumer break (prevents connection leaks)
- Widened type signature to accept Readable|AsyncIterable|string|Buffer

Error handling improvements:
- Fixed error propagation in createAsyncIterableFromReadable
- Pending promises now properly rejected on stream errors
- Added guard to prevent onEnd processing after error
- Added try/finally to destroy streams when consumers break early

Testing:
- All 153 tests passing (10/10 test suites)
- Verified with live server:
  - Local example: 3 objects streamed
  - Full example: 2000 objects streamed (vs 1000 standard limit)
- Aligned with Python SDK async generator pattern

Fixes #236

Author: daniel-jonathan

streaming.ts

@@ -31,6 +31,7 @@ const createAsyncIterableFromReadable = (readable: any): AsyncIterable<any> => {
       };
 
       const onEnd = () => {
+        if (error) return; // Don't process end if error already occurred
         ended = true;
         while (pendings.length > 0) {
           const { resolve } = pendings.shift()!;
@@ -44,6 +45,7 @@ const createAsyncIterableFromReadable = (readable: any): AsyncIterable<any> => {
           const { reject } = pendings.shift()!;
           reject(err);
         }
+        cleanup();
       };
 
       readable.on("data", onData);
@@ -59,7 +61,6 @@ const createAsyncIterableFromReadable = (readable: any): AsyncIterable<any> => {
       return {
         next(): Promise<IteratorResult<any>> {
           if (error) {
-            cleanup();
             return Promise.reject(error);
           }
           if (chunkQueue.length > 0) {

tests/streaming.test.ts

@@ -161,7 +161,7 @@ describe("Streaming Utilities", () => {
             expect(out).toEqual([{ a: 1 }, { b: 2 }]);
         });
 
-        it("should end iteration when classic emitter errors while pending", async () => {
+        it("should reject pending iteration when classic emitter errors", async () => {
             const emitter = new EventEmitter() as any;
             const gen = parseNDJSONStream(emitter);
 
@@ -173,10 +173,10 @@ describe("Streaming Utilities", () => {
             const pendingNext = gen.next();
             emitter.emit("error", new Error("boom"));
 
-            // Pending next resolves with done: true due to iterator design
-            await expect(pendingNext).resolves.toEqual({ value: undefined, done: true });
+            // Pending next should now reject with the error
+            await expect(pendingNext).rejects.toThrow("boom");
 
-            // Generator should be completed afterwards
+            // After error, iterator is exhausted (standard async iterator behavior)
             await expect(gen.next()).resolves.toEqual({ value: undefined, done: true });
         });