feat(js): add streaming support for streamedListObjects

Updates JavaScript SDK templates to support the streaming API endpoint
for unlimited object retrieval. Templates now handle streaming operations
differently using vendor extension conditionals.

Changes:
- Add streaming.mustache template with NDJSON parser for Node.js
- Update api.mustache to import createStreamingRequestFunction
- Update apiInner.mustache with x-fga-streaming vendor extension logic
  - Uses createStreamingRequestFunction for streaming ops
  - Returns Promise<any> instead of PromiseResult<T>
  - Simplified telemetry (method name only)
- Update index.mustache to export parseNDJSONStream
- Update config.overrides.json with streaming file + feature flag
- Add README documentation for Streamed List Objects API
- Update API endpoints table with streaming endpoint

Implementation:
- Conditional template logic based on x-fga-streaming vendor extension
- Preserves telemetry while returning raw Node.js stream
- Aligned with Python SDK template patterns
- Fixed error propagation in async iterator adapter
- Widened parseNDJSONStream type signature for better DX

Dependencies:
- Requires x-fga-streaming: true in OpenAPI spec (openfga/api)

Related:
- Fixes #76 (JavaScript SDK)
- Implements openfga/js-sdk#236
- Related PR: openfga/js-sdk#280

Author: daniel-jonathan

config/clients/js/template/streaming.mustache

@@ -7,13 +7,13 @@ const createAsyncIterableFromReadable = (readable: any): AsyncIterable<any> => {
   return {
     [Symbol.asyncIterator](): AsyncIterator<any> {
       const chunkQueue: any[] = [];
-      const pendingResolvers: Array<(value: IteratorResult<any>) => void> = [];
+      const pendings: Array<{ resolve: (v: IteratorResult<any>) => void; reject: (e?: any) => void }> = [];
       let ended = false;
       let error: any = null;
 
       const onData = (chunk: any) => {
-        if (pendingResolvers.length > 0) {
-          const resolve = pendingResolvers.shift()!;
+        if (pendings.length > 0) {
+          const { resolve } = pendings.shift()!;
           resolve({ value: chunk, done: false });
         } else {
           chunkQueue.push(chunk);
@@ -22,18 +22,17 @@ const createAsyncIterableFromReadable = (readable: any): AsyncIterable<any> => {
 
       const onEnd = () => {
         ended = true;
-        while (pendingResolvers.length > 0) {
-          const resolve = pendingResolvers.shift()!;
+        while (pendings.length > 0) {
+          const { resolve } = pendings.shift()!;
           resolve({ value: undefined, done: true });
         }
       };
 
       const onError = (err: any) => {
         error = err;
-        while (pendingResolvers.length > 0) {
-          const resolve = pendingResolvers.shift()!;
-          // Rejecting inside async iterator isn't straightforward; surface as end and throw later
-          resolve({ value: undefined, done: true });
+        while (pendings.length > 0) {
+          const { reject } = pendings.shift()!;
+          reject(err);
         }
       };
 
@@ -61,8 +60,8 @@ const createAsyncIterableFromReadable = (readable: any): AsyncIterable<any> => {
             cleanup();
             return Promise.resolve({ value: undefined, done: true });
           }
-          return new Promise<IteratorResult<any>>((resolve) => {
-            pendingResolvers.push(resolve);
+          return new Promise<IteratorResult<any>>((resolve, reject) => {
+            pendings.push({ resolve, reject });
           });
         },
         return(): Promise<IteratorResult<any>> {
@@ -80,10 +79,12 @@ const createAsyncIterableFromReadable = (readable: any): AsyncIterable<any> => {
 
 /**
  * Parse newline-delimited JSON (NDJSON) from a Node.js readable stream
- * @param stream - Node.js readable stream
+ * @param stream - Node.js readable stream, AsyncIterable, string, or Buffer
  * @returns AsyncGenerator that yields parsed JSON objects
  */
-export async function* parseNDJSONStream(stream: Readable): AsyncGenerator<any> {
+export async function* parseNDJSONStream(
+  stream: Readable | AsyncIterable<Uint8Array | string | Buffer> | string | Uint8Array | Buffer
+): AsyncGenerator<any> {
   const decoder = new TextDecoder("utf-8");
   let buffer = "";
 
@@ -110,8 +111,8 @@ export async function* parseNDJSONStream(stream: Readable): AsyncGenerator<any>
     return;
   }
 
-  const isAsyncIterable = stream && typeof stream[Symbol.asyncIterator] === "function";
-  const source: AsyncIterable<any> = isAsyncIterable ? stream : createAsyncIterableFromReadable(stream);
+  const isAsyncIterable = stream && typeof (stream as any)[Symbol.asyncIterator] === "function";
+  const source: AsyncIterable<any> = isAsyncIterable ? (stream as any) : createAsyncIterableFromReadable(stream as any);
 
   for await (const chunk of source) {
     // Node.js streams can return Buffer or string chunks