3.0.31

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartstream",
-  "version": "3.0.18",
+  "version": "3.0.31",
   "private": false,
   "description": "simplifies access to node streams",
   "main": "dist_ts/index.js",
@@ -22,14 +22,15 @@
   },
   "homepage": "https://gitlab.com/push.rocks/smartstream#readme",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.66",
+    "@git.zone/tsbuild": "^2.1.72",
     "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.84",
+    "@git.zone/tstest": "^1.0.86",
-    "@push.rocks/smartfile": "^11.0.0",
+    "@push.rocks/smartfile": "^11.0.4",
     "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.9.0"
+    "@types/node": "^20.11.20"
   },
   "dependencies": {
+    "@push.rocks/lik": "^6.0.14",
     "@push.rocks/smartpromise": "^4.0.3",
     "@push.rocks/smartrx": "^3.0.7"
   },

test/test.backpressure.ts

@@ -0,0 +1,68 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { SmartDuplex, type ISmartDuplexOptions, StreamWrapper } from '../ts/index.js';
+
+tap.test('should run backpressure test', async (toolsArg) => {
+  const done = toolsArg.defer();
+  async function testBackpressure() {
+    const stream1 = new SmartDuplex({
+      name: 'stream1',
+      objectMode: true,
+      writeFunction: async (chunk, tools) => {
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Slow processing
+        console.log(`processed chunk ${chunk} in stream 1`);
+        return chunk; // Fast processing
+      },
+    });
+    const stream2 = new SmartDuplex({
+      name: 'stream2',
+      objectMode: true,
+      writeFunction: async (chunk, tools) => {
+        await new Promise((resolve) => setTimeout(resolve, 20)); // Slow processing
+        console.log(`processed chunk ${chunk} in stream 2`);
+        await tools.push(chunk);
+        // return chunk, optionally return ;
+      },
+    }); // This stream processes data more slowly
+    const stream3 = new SmartDuplex({
+      objectMode: true,
+      name: 'stream3',
+      writeFunction: async (chunk, tools) => {
+        await new Promise((resolve) => setTimeout(resolve, 200)); // Slow processing
+        console.log(`processed chunk ${chunk} in stream 3`);
+      },
+    });
+
+    stream1.pipe(stream2).pipe(stream3);
+
+    let backpressured = false;
+    for (let i = 0; i < 200; i++) {
+      const canContinue = stream1.write(`Chunk ${i}`, 'utf8');
+      if (!canContinue) {
+        backpressured = true;
+        console.log(`Backpressure at chunk ${i}`);
+      }
+    }
+
+    stream1.end();
+
+    stream1.on('finish', () => {
+      console.log('Stream 1 finished processing.');
+    });
+    stream2.on('finish', () => {
+      console.log('Stream 2 finished processing.');
+    });
+    stream3.on('finish', () => {
+      console.log('Stream 3 finished processing.');
+      if (!backpressured) {
+        throw new Error('No backpressure was observed.');
+      } else {
+        done.resolve();
+      }
+    });
+  }
+
+  testBackpressure();
+  await done.promise;
+});
+
+await tap.start();

test/test.smartstream.ts

@@ -5,9 +5,7 @@ import * as fs from 'fs';
 
 tap.test('should create a SmartStream from a Buffer', async () => {
   const bufferData = Buffer.from('This is a test buffer');
-  const smartStream = SmartDuplex.fromBuffer(bufferData, {
+  const smartStream = SmartDuplex.fromBuffer(bufferData, {});
-    handleBackpressure: false,
-  });
   
   let receivedData = Buffer.alloc(0);
   
@@ -23,26 +21,4 @@ tap.test('should create a SmartStream from a Buffer', async () => {
   });
 });
 
-tap.test('should create a SmartStream from an Observable', async () => {
-  const observableData = 'Observable test data';
-  const testObservable = smartrx.rxjs.of(Buffer.from(observableData));
-  
-  const smartStream = SmartDuplex.fromObservable(testObservable, {
-    handleBackpressure: false,
-  });
-  
-  let receivedData = Buffer.alloc(0);
-
-  return new Promise<void>((resolve) => {
-    smartStream.on('data', (chunk: Buffer) => {
-      receivedData = Buffer.concat([receivedData, chunk]);
-    });
-
-    smartStream.on('end', () => {
-      expect(receivedData.toString()).toEqual(observableData);
-      resolve();
-    });
-  });
-});
-
 tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartstream',
-  version: '3.0.18',
+  version: '3.0.31',
   description: 'simplifies access to node streams'
 }

ts/index.ts

@@ -1,4 +1,3 @@
-export * from './smartstream.classes.passthrough.js';
 export * from './smartstream.classes.smartduplex.js';
 export * from './smartstream.classes.streamwrapper.js';
 export * from './smartstream.classes.streamintake.js';

ts/smartstream.classes.passthrough.ts

@@ -1,21 +0,0 @@
-import * as plugins from './smartstream.plugins.js';
-
-export class PassThrough extends plugins.stream.Duplex {
-  constructor(options?: plugins.stream.DuplexOptions) {
-    super(options);
-  }
-
-  _read(size: number): void {
-    // No-op: Data written will be automatically available for reading.
-  }
-
-  _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
-    if (this.push(chunk, encoding)) {
-      callback();
-    } else {
-      this.once('drain', () => {
-        callback();
-      });
-    }
-  }
-}

ts/smartstream.classes.smartduplex.ts

@@ -3,7 +3,7 @@ import { Duplex, type DuplexOptions } from 'stream';
 
 export interface IStreamTools {
   truncate: () => void;
-  push: (pipeObject: any) => void;
+  push: (pipeObject: any) => Promise<void>;
 }
 
 export interface IStreamWriteFunction<T, rT> {
@@ -15,9 +15,28 @@ export interface IStreamFinalFunction<rT> {
 }
 
 export interface ISmartDuplexOptions<TInput, TOutput> extends DuplexOptions {
-  handleBackpressure?: boolean;
+  /**
+   * wether to print debug logs
+   */
+  debug?: boolean;
+  /**
+   * the name of the stream
+   */
+  name?: string;
+  /**
+   * a function that is being called to read more stuff from whereever to be processed by the stream
+   * @returns
+   */
   readFunction?: () => Promise<void>;
+
+  /**
+   * the write function is called for every chunk that is being written to the stream
+   * it can push or return chunks (but does not have to) to be written to the readable side of the stream
+   */
   writeFunction?: IStreamWriteFunction<TInput, TOutput>;
+  /**
+   * a final function that is being sent to the end of the stream 
+   */
   finalFunction?: IStreamFinalFunction<TOutput>;
   // Add other custom options if necessary
 }
@@ -33,173 +52,108 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
     return smartDuplex;
   }
 
-  static fromObservable(
-    observable: plugins.smartrx.rxjs.Observable<any>,
-    options?: ISmartDuplexOptions<any, any>
-  ): SmartDuplex {
-    const smartStream = new SmartDuplex(options);
-    smartStream.observableSubscription = observable.subscribe({
-      next: (data) => {
-        if (!smartStream.push(data) && smartStream.handleBackpressure) {
-          // Pause the observable if the stream buffer is full
-          smartStream.observableSubscription?.unsubscribe();
-          smartStream.once('drain', () => {
-            // Resume the observable when the stream buffer is drained
-            smartStream.observableSubscription?.unsubscribe();
-            smartStream.observableSubscription = observable.subscribe((data) => {
-              smartStream.push(data);
-            });
-          });
-        }
-      },
-      error: (err) => {
-        smartStream.emit('error', err);
-      },
-      complete: () => {
-        smartStream.push(null); // Signal the end of the data
-      },
-    });
-
-    return smartStream;
-  }
-
-  static fromReplaySubject(
-    replaySubject: plugins.smartrx.rxjs.ReplaySubject<any>,
-    options?: DuplexOptions
-  ): SmartDuplex {
-    const smartStream = new SmartDuplex(options);
-    let isBackpressured = false;
-
-    // Subscribe to the ReplaySubject
-    const subscription = replaySubject.subscribe({
-      next: (data) => {
-        const canPush = smartStream.push(data);
-        if (!canPush) {
-          // If push returns false, pause the subscription because of backpressure
-          isBackpressured = true;
-          subscription.unsubscribe();
-        }
-      },
-      error: (err) => {
-        smartStream.emit('error', err);
-      },
-      complete: () => {
-        smartStream.push(null); // End the stream when the ReplaySubject completes
-      },
-    });
-
-    // Listen for 'drain' event to resume the subscription if it was paused
-    smartStream.on('drain', () => {
-      if (isBackpressured) {
-        isBackpressured = false;
-        // Resubscribe to the ReplaySubject since we previously paused
-        smartStream.observableSubscription = replaySubject.subscribe({
-          next: (data) => {
-            if (!smartStream.push(data)) {
-              smartStream.observableSubscription?.unsubscribe();
-              isBackpressured = true;
-            }
-          },
-          // No need to repeat error and complete handling here because it's already set up above
-        });
-      }
-    });
-
-    return smartStream;
-  }
-
   // INSTANCE
-  private readFunction?: () => Promise<void>;
+  private backpressuredArray: plugins.lik.BackpressuredArray<TOutput>;
-  private handleBackpressure: boolean;
+  public options: ISmartDuplexOptions<TInput, TOutput>;
-  private writeFunction?: IStreamWriteFunction<TInput, TOutput>;
-  private finalFunction?: IStreamFinalFunction<TOutput>;
   private observableSubscription?: plugins.smartrx.rxjs.Subscription;
+  private debugLog(messageArg: string) {
+    if (this.options.debug) {
+      console.log(messageArg);
+    }
+  }
 
   constructor(optionsArg?: ISmartDuplexOptions<TInput, TOutput>) {
-    super(optionsArg);
+    super(Object.assign({
-    this.readFunction = optionsArg?.readFunction;
+      highWaterMark: 1,
-    this.writeFunction = optionsArg?.writeFunction;
+    }, optionsArg));
-    this.finalFunction = optionsArg?.finalFunction;
+    this.options = optionsArg;
-    this.handleBackpressure = optionsArg?.handleBackpressure ?? true;
+    this.backpressuredArray = new plugins.lik.BackpressuredArray<TOutput>(this.options.highWaterMark || 1)
   }
 
   public async _read(size: number): Promise<void> {
-    if (this.readFunction) {
+    this.debugLog(`${this.options.name}: read was called`);
-      await this.readFunction();
+    await this.backpressuredArray.waitForItems();
+    this.debugLog(`${this.options.name}: successfully waited for items.`);
+    if (this.options.readFunction) {
+      await this.options.readFunction();
+    }
+    let canPushMore = true; 
+    while(this.backpressuredArray.data.length > 0 && canPushMore) {
+      const nextChunk = this.backpressuredArray.shift();
+      canPushMore = this.push(nextChunk);
     }
   }
 
-  public notBackpressured = true;
+  public async backpressuredPush (pushArg: TOutput) {
-  public get backpressured(): boolean {
+    const canPushMore = this.backpressuredArray.push(pushArg);
-    return !this.notBackpressured;
+    if (!canPushMore) {
-  }
+      this.debugLog(`${this.options.name}: cannot push more`);
-  public push(chunkArg?: TOutput | null): boolean {
+      await this.backpressuredArray.waitForSpace();
-    const result = super.push(chunkArg);
+      this.debugLog(`${this.options.name}: can push more again`);
-    if (!result && this.handleBackpressure) {
-      this.notBackpressured = false;
-      this.pause();
-      // Listen for 'drain' event to resume
-      this.once('drain', () => {
-        this.notBackpressured = true;
-        this.resume(); // Resume the source of data
-      });
     }
-    return result;
+  };
-  }
 
+  private asyncWritePromiseObjectmap = new plugins.lik.ObjectMap<Promise<any>>();
   // Ensure the _write method types the chunk as TInput and encodes TOutput
   public async _write(chunk: TInput, encoding: string, callback: (error?: Error | null) => void) {
-    if (!this.writeFunction) {
+    if (!this.options.writeFunction) {
       return callback(new Error('No stream function provided'));
     }
 
+    let isTruncated = false;
     const tools: IStreamTools = {
       truncate: () => {
         this.push(null);
+        isTruncated = true;
         callback();
       },
-      push: (pushArg: TOutput) => this.push(pushArg),
+      push: async (pushArg: TOutput) => {
+        await this.backpressuredPush(pushArg);
+      }
     };
 
     try {
-      const modifiedChunk = await this.writeFunction(chunk, tools);
+      const writeDeferred = plugins.smartpromise.defer();
-      if (modifiedChunk) {
+      this.asyncWritePromiseObjectmap.add(writeDeferred.promise);
-        this.push(modifiedChunk)
+      const modifiedChunk = await this.options.writeFunction(chunk, tools);
-        if (this.backpressured && this.handleBackpressure) {
+      if (isTruncated) {
-          this.once('drain', () => {
+        return;
-            callback();
-          });
-        } else {
-          callback();
-        }      
-      } else {
-        callback();
       }
+      if (modifiedChunk) {
+        await tools.push(modifiedChunk);
+      }
+      callback();
+      writeDeferred.resolve();
+      writeDeferred.promise.then(() => {
+        this.asyncWritePromiseObjectmap.remove(writeDeferred.promise);
+      });
     } catch (err) {
       callback(err);
     }
-    return this.notBackpressured;
   }
 
   public async _final(callback: (error?: Error | null) => void) {
-    if (this.finalFunction) {
+    await Promise.all(this.asyncWritePromiseObjectmap.getArray());
+    if (this.options.finalFunction) {
       const tools: IStreamTools = {
         truncate: () => callback(),
-        push: (pipeObject) => this.push(pipeObject),
+        push: async (pipeObject) => {
+          this.backpressuredArray.push(pipeObject);
+        },
       };
 
       try {
-        const finalChunk = await this.finalFunction(tools);
+        const finalChunk = await this.options.finalFunction(tools);
         if (finalChunk) {
-          this.push(finalChunk);
+          this.backpressuredArray.push(finalChunk);
         }
       } catch (err) {
+        this.backpressuredArray.push(null);
         callback(err);
+        return;
       }
-    } else {
-      // nothing here
     }
-    this.push(null);
+    this.backpressuredArray.push(null);
     callback();
   }
 }

ts/smartstream.functions.ts

@@ -19,3 +19,12 @@ export function createTransformFunction<TInput, TOutput>(
 
   return smartDuplexStream;
 }
+
+export const createPassThrough = () => {
+  return new SmartDuplex({
+    objectMode: true,
+    writeFunction: async (chunkArg, toolsArg) => {
+      return chunkArg;
+    }
+  })
+}

ts/smartstream.plugins.ts

@@ -4,8 +4,9 @@ import * as stream from 'stream';
 export { stream };
 
 // pushrocks scope
+import * as lik from '@push.rocks/lik';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';
 
-export { smartpromise, smartrx };
+export { lik, smartpromise, smartrx };