3.0.19

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartstream",
-  "version": "3.0.6",
+  "version": "3.0.19",
   "private": false,
   "description": "simplifies access to node streams",
   "main": "dist_ts/index.js",
@@ -24,12 +24,14 @@
   "devDependencies": {
     "@git.zone/tsbuild": "^2.1.66",
     "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.77",
+    "@git.zone/tstest": "^1.0.84",
-    "@push.rocks/smartfile": "^10.0.37",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartfile": "^11.0.0",
     "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.8.10"
+    "@types/node": "^20.9.0"
   },
   "dependencies": {
+    "@push.rocks/lik": "^6.0.6",
     "@push.rocks/smartpromise": "^4.0.3",
     "@push.rocks/smartrx": "^3.0.7"
   },

test/backpressure.ts

@@ -0,0 +1,57 @@
+import { SmartDuplex, type ISmartDuplexOptions, StreamWrapper } from '../ts/index.js';
+
+import * as smartdelay from '@push.rocks/smartdelay';
+
+async function testBackpressure() {
+  const stream1 = new SmartDuplex({
+    objectMode: true,
+    handleBackpressure: true,
+    writeFunction: async (chunk, tools) => {
+      console.log(`processed chunk ${chunk} in stream 1`);
+      return chunk; // Fast processing
+    }
+  });
+  const stream2 = new SmartDuplex({
+    objectMode: true,
+    handleBackpressure: true,
+    writeFunction: async (chunk, tools) => {
+      await new Promise(resolve => setTimeout(resolve, 100)); // Slow processing
+      console.log(`processed chunk ${chunk} in stream 2`);
+      return chunk;
+    }
+  }); // This stream processes data more slowly
+  const stream3 = new SmartDuplex({
+    handleBackpressure: false,
+    writeFunction: async (chunk, tools) => {
+      console.log(`finished chunk ${chunk} in stream 3`);
+    }
+  });
+
+  stream1.pipe(stream2).pipe(stream3);
+
+  let backpressured = false;
+  for (let i = 1; i < 100; 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) {
+      console.log('No backpressure was observed.');
+    }
+  });
+}
+
+testBackpressure();

test/test.smartstream.ts

@@ -5,7 +5,9 @@ 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);
   
@@ -25,7 +27,9 @@ 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);
+  const smartStream = SmartDuplex.fromObservable(testObservable, {
+    handleBackpressure: false,
+  });
   
   let receivedData = Buffer.alloc(0);
 

test/test.streamfunction.ts

@@ -10,7 +10,7 @@ tap.test('should handle a read stream', async (tools) => {
   const streamWrapper = new smartstream.StreamWrapper([
     smartfile.fsStream.createReadStream('./test/assets/readabletext.txt'),
     new smartstream.SmartDuplex({
-      writeAndTransformFunction: async (chunkStringArg: Buffer, streamTools) => {
+      writeFunction: async (chunkStringArg: Buffer, streamTools) => {
         // do something with the stream here
         const result = chunkStringArg.toString().substr(0, 100);
         streamTools.push('wow =========== \n');
@@ -21,7 +21,7 @@ tap.test('should handle a read stream', async (tools) => {
       },
     }),
     new smartstream.SmartDuplex({
-      writeAndTransformFunction: async (chunkStringArg) => {
+      writeFunction: async (chunkStringArg) => {
         console.log(chunkStringArg.toString());
       },
       finalFunction: async (tools) => {
@@ -29,7 +29,7 @@ tap.test('should handle a read stream', async (tools) => {
       },
     })
   ]);
-  // await streamWrapper.run();
+  await streamWrapper.run();
 });
 
 tap.test('should create a valid Intake', async (tools) => {
@@ -37,7 +37,7 @@ tap.test('should create a valid Intake', async (tools) => {
   testIntake.pipe(
       new smartstream.SmartDuplex({
         objectMode: true,
-        writeAndTransformFunction: async (chunkStringArg: string, streamTools) => {
+        writeFunction: async (chunkStringArg: string, streamTools) => {
           await tools.delayFor(100);
           console.log(chunkStringArg);
           return chunkStringArg;

ts/00_commitinfo_data.ts

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

ts/smartstream.classes.passthrough.ts

@@ -13,7 +13,9 @@ export class PassThrough extends plugins.stream.Duplex {
     if (this.push(chunk, encoding)) {
       callback();
     } else {
-      this.once('drain', callback);
+      this.once('drain', () => {
+        callback();
+      });
     }
   }
 }

ts/smartstream.classes.smartduplex.ts

@@ -6,40 +6,41 @@ export interface IStreamTools {
   push: (pipeObject: any) => void;
 }
 
-export interface IWriteAndTransformFunction<T, rT> {
+export interface IStreamWriteFunction<T, rT> {
   (chunkArg: T, toolsArg: IStreamTools): Promise<rT>;
 }
 
-export interface IStreamEndFunction<rT> {
+export interface IStreamFinalFunction<rT> {
   (toolsArg: IStreamTools): Promise<rT>;
 }
 
-export interface SmartStreamOptions<TInput, TOutput> extends DuplexOptions {
+export interface ISmartDuplexOptions<TInput, TOutput> extends DuplexOptions {
+  handleBackpressure?: boolean;
   readFunction?: () => Promise<void>;
-  writeAndTransformFunction?: IWriteAndTransformFunction<TInput, TOutput>;
+  writeFunction?: IStreamWriteFunction<TInput, TOutput>;
-  finalFunction?: IStreamEndFunction<TOutput>;
+  finalFunction?: IStreamFinalFunction<TOutput>;
   // Add other custom options if necessary
 }
 
 export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
   // STATIC
-  static fromBuffer(buffer: Buffer, options?: DuplexOptions): SmartDuplex {
+  static fromBuffer(buffer: Buffer, options?: ISmartDuplexOptions<any, any>): SmartDuplex {
-    const smartStream = new SmartDuplex(options);
+    const smartDuplex = new SmartDuplex(options);
     process.nextTick(() => {
-      smartStream.push(buffer);
+      smartDuplex.push(buffer);
-      smartStream.push(null); // Signal the end of the data
+      smartDuplex.push(null); // Signal the end of the data
     });
-    return smartStream;
+    return smartDuplex;
   }
 
   static fromObservable(
     observable: plugins.smartrx.rxjs.Observable<any>,
-    options?: DuplexOptions
+    options?: ISmartDuplexOptions<any, any>
   ): SmartDuplex {
     const smartStream = new SmartDuplex(options);
     smartStream.observableSubscription = observable.subscribe({
       next: (data) => {
-        if (!smartStream.push(data)) {
+        if (!smartStream.push(data) && smartStream.handleBackpressure) {
           // Pause the observable if the stream buffer is full
           smartStream.observableSubscription?.unsubscribe();
           smartStream.once('drain', () => {
@@ -109,15 +110,17 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
 
   // INSTANCE
   private readFunction?: () => Promise<void>;
-  private writeAndTransformFunction?: IWriteAndTransformFunction<TInput, TOutput>;
+  private handleBackpressure: boolean;
-  private streamEndFunction?: IStreamEndFunction<TOutput>;
+  private writeFunction?: IStreamWriteFunction<TInput, TOutput>;
+  private finalFunction?: IStreamFinalFunction<TOutput>;
   private observableSubscription?: plugins.smartrx.rxjs.Subscription;
 
-  constructor(optionsArg?: SmartStreamOptions<TInput, TOutput>) {
+  constructor(optionsArg?: ISmartDuplexOptions<TInput, TOutput>) {
     super(optionsArg);
     this.readFunction = optionsArg?.readFunction;
-    this.writeAndTransformFunction = optionsArg?.writeAndTransformFunction;
+    this.writeFunction = optionsArg?.writeFunction;
-    this.streamEndFunction = optionsArg?.finalFunction;
+    this.finalFunction = optionsArg?.finalFunction;
+    this.handleBackpressure = optionsArg?.handleBackpressure ?? true;
   }
 
   public async _read(size: number): Promise<void> {
@@ -126,9 +129,11 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
     }
   }
 
+  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.writeAndTransformFunction) {
+    if (!this.writeFunction) {
       return callback(new Error('No stream function provided'));
     }
 
@@ -141,37 +146,57 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
     };
 
     try {
-      const modifiedChunk = await this.writeAndTransformFunction(chunk, tools);
+      const writeDeferred = plugins.smartpromise.defer();
+      this.asyncWritePromiseObjectmap.add(writeDeferred.promise);
+      const modifiedChunk = await this.writeFunction(chunk, tools);
       if (modifiedChunk) {
-        if (!this.push(modifiedChunk)) {
+        const drainDeferred = plugins.smartpromise.defer();
-          // Handle backpressure if necessary
+        this.once('drain', () => {
+          drainDeferred.resolve();
+        });
+        const canPushMore = this.push(modifiedChunk);
+        if (!canPushMore) {
+          await drainDeferred.promise;
+          console.log('jojojo');
+          callback();
+          writeDeferred.resolve();
+        } else {
+          callback();
+          writeDeferred.resolve();
         }
+      } else {
+        callback();
+        writeDeferred.resolve();
       }
-      callback();
+      writeDeferred.resolve();
+      writeDeferred.promise.then(() => {
+        this.asyncWritePromiseObjectmap.remove(writeDeferred.promise);
+      });
     } catch (err) {
       callback(err);
     }
   }
 
   public async _final(callback: (error?: Error | null) => void) {
-    if (this.streamEndFunction) {
+    await Promise.all(this.asyncWritePromiseObjectmap.getArray());
+    if (this.finalFunction) {
       const tools: IStreamTools = {
         truncate: () => callback(),
         push: (pipeObject) => this.push(pipeObject),
       };
 
       try {
-        const finalChunk = await this.streamEndFunction(tools);
+        const finalChunk = await this.finalFunction(tools);
         if (finalChunk) {
           this.push(finalChunk);
         }
-        callback();
       } catch (err) {
+        this.push(null);
         callback(err);
+        return;
       }
-    } else {
-      this.push(null),
-      callback();
     }
+    this.push(null);
+    callback();
   }
 }

ts/smartstream.functions.ts

@@ -1,4 +1,5 @@
 import { Transform, type TransformCallback, type TransformOptions } from 'stream';
+import { SmartDuplex } from './smartstream.classes.smartduplex.js';
 
 export interface AsyncTransformFunction<TInput, TOutput> {
   (chunkArg: TInput): Promise<TOutput>;
@@ -7,20 +8,14 @@ export interface AsyncTransformFunction<TInput, TOutput> {
 export function createTransformFunction<TInput, TOutput>(
   asyncFunction: AsyncTransformFunction<TInput, TOutput>,
   options?: TransformOptions
-): Transform {
+): SmartDuplex {
-  const transformStream = new Transform({
+  const smartDuplexStream = new SmartDuplex({
     ...options,
-    objectMode: true, // Ensure we operate in object mode
+    writeFunction: async (chunkArg, toolsArg) => {
-    async transform(chunk: TInput, encoding: string, callback: TransformCallback) {
+      const result = await asyncFunction(chunkArg);
-      try {
+      return result;
-        const transformed = await asyncFunction(chunk);
-        this.push(transformed);
-        callback();
-      } catch (error) {
-        callback(error instanceof Error ? error : new Error(String(error)));
-      }
     }
   });
 
-  return transformStream;
+  return smartDuplexStream;
 }

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 };