@rdfc/js-runner 3.0.2 → 3.1.0-alpha.1

package/lib/writer.js

@@ -9,6 +9,10 @@ export class WriterInstance {
     awaitingProcessed = [];
     openStreams = 0;
     shouldClose = [];
+    closed = false;
+    _canceled = false;
+    cancelSignal = new AbortController();
+    cancelHandlers = new Set();
     runnerId;
     constructor(uri, client, notifyOrchestrator, runnerId, logger) {
         this.client = client;
@@ -17,8 +21,62 @@ export class WriterInstance {
         this.logger = logger;
         this.runnerId = runnerId;
     }
+    get canceled() {
+        return this._canceled;
+    }
+    on(event, listener) {
+        if (event === 'cancel') {
+            this.cancelHandlers.add(listener);
+        }
+        return this;
+    }
+    cancellationError() {
+        return new Error(`Writer for channel ${this.uri} was canceled by the connected reader`);
+    }
+    emitCancel() {
+        for (const handler of this.cancelHandlers) {
+            try {
+                Promise.resolve(handler()).catch((error) => {
+                    this.logger.error(`Cancel listener for channel ${this.uri} failed: ${String(error)}`);
+                });
+            }
+            catch (error) {
+                this.logger.error(`Cancel listener for channel ${this.uri} failed: ${String(error)}`);
+            }
+        }
+    }
+    assertCanWrite() {
+        if (this._canceled) {
+            throw this.cancellationError();
+        }
+        if (this.closed) {
+            throw new Error(`Writer for channel ${this.uri} is closed`);
+        }
+    }
+    async raceWithCancellation(promise) {
+        this.assertCanWrite();
+        return await new Promise((resolve, reject) => {
+            const onAbort = () => reject(this.cancellationError());
+            this.cancelSignal.signal.addEventListener('abort', onAbort, {
+                once: true,
+            });
+            promise.then((value) => {
+                this.cancelSignal.signal.removeEventListener('abort', onAbort);
+                resolve(value);
+            }, (error) => {
+                this.cancelSignal.signal.removeEventListener('abort', onAbort);
+                reject(error);
+            });
+        });
+    }
+    rejectPendingProcessed(error) {
+        while (this.awaitingProcessed.length > 0) {
+            this.awaitingProcessed.shift().reject(error);
+        }
+    }
     awaitProcessed() {
-        return new Promise((res) => this.awaitingProcessed.push(res));
+        this.assertCanWrite();
+        return new Promise((resolve, reject) => this.awaitingProcessed.push({ resolve, reject }));
     }
     async any(any) {
         if ('stream' in any) {
@@ -32,6 +90,7 @@ export class WriterInstance {
         }
     }
     async buffer(buffer) {
+        this.assertCanWrite();
         this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`);
         const localSequenceNumber = this.localSequenceNumber++;
         const handledPromise = this.awaitProcessed();
@@ -41,33 +100,43 @@ export class WriterInstance {
         await handledPromise;
     }
     async stream(buffer, transform) {
+        this.assertCanWrite();
         this.openStreams += 1;
         const t = transform || ((x) => x);
         const stream = this.client.sendStreamMessage();
-        const handledPromise = this.awaitProcessed();
-        const writeStreamMessageChunk = promisify(stream.write.bind(stream));
-        const localSequenceNumber = this.localSequenceNumber++;
-        await writeStreamMessageChunk({
-            id: {
-                channel: this.uri,
-                localSequenceNumber,
-                runner: this.runnerId,
-            },
-        });
-        const id = await new Promise((res) => stream.once('data', res));
-        this.logger.debug(`${this.uri} streams message with id ${JSON.stringify(id)}`);
-        for await (const msg of buffer) {
-            const processedPromise = new Promise((res) => stream.once('data', res));
-            await writeStreamMessageChunk({ data: { data: t(msg) } });
-            await processedPromise;
-        }
-        stream.end();
-        await handledPromise;
-        this.openStreams -= 1;
-        if (this.shouldClose.length > 0)
-            await this.close();
+        try {
+            const handledPromise = this.awaitProcessed();
+            const writeStreamMessageChunk = promisify(stream.write.bind(stream));
+            const localSequenceNumber = this.localSequenceNumber++;
+            await writeStreamMessageChunk({
+                id: {
+                    channel: this.uri,
+                    localSequenceNumber,
+                    runner: this.runnerId,
+                },
+            });
+            const id = await this.raceWithCancellation(new Promise((res) => stream.once('data', res)));
+            this.logger.debug(`${this.uri} streams message with id ${JSON.stringify(id)}`);
+            for await (const msg of buffer) {
+                const processedPromise = new Promise((res) => stream.once('data', res));
+                await writeStreamMessageChunk({ data: { data: t(msg) } });
+                await processedPromise;
+            }
+            stream.end();
+            await handledPromise;
+        }
+        finally {
+            this.openStreams -= 1;
+            if (!stream.writableEnded) {
+                stream.end();
+            }
+            if (this.shouldClose.length > 0) {
+                await this.close();
+            }
+        }
     }
     async string(msg) {
+        this.assertCanWrite();
         this.logger.debug(`${this.uri} sends string ${msg.length} characters`);
         const localSequenceNumber = this.localSequenceNumber++;
         const handledPromise = this.awaitProcessed();
@@ -81,16 +150,34 @@ export class WriterInstance {
         await handledPromise;
     }
     async close(issued = false) {
+        if (issued) {
+            if (!this.closed) {
+                this._canceled = true;
+                this.emitCancel();
+            }
+            this.closed = true;
+            const cancelError = this.cancellationError();
+            this.rejectPendingProcessed(cancelError);
+            this.cancelSignal.abort(cancelError);
+            let waiting = this.shouldClose.pop();
+            while (waiting) {
+                waiting();
+                waiting = this.shouldClose.pop();
+            }
+            return;
+        }
+        if (this.closed) {
+            return;
+        }
         if (this.openStreams !== 0) {
             await new Promise((resolve) => this.shouldClose.push(resolve));
             return;
         }
         this.logger.debug(`${this.uri} closes stream`);
-        if (!issued) {
-            await this.notifyOrchestrator({
-                close: { channel: this.uri },
-            });
-        }
+        this.closed = true;
+        await this.notifyOrchestrator({
+            close: { channel: this.uri },
+        });
         let resolve = this.shouldClose.pop();
         while (resolve) {
             resolve();
@@ -99,7 +186,10 @@ export class WriterInstance {
     }
     handled() {
         if (this.awaitingProcessed.length > 0) {
-            this.awaitingProcessed.shift()();
+            this.awaitingProcessed.shift().resolve();
+        }
+        else if (this.closed || this._canceled) {
+            return;
         }
         else {
             this.logger.error('Expected to be waiting for a message to be processed, but this is not the case ' +
@@ -107,4 +197,4 @@ export class WriterInstance {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../src/writer.ts"],"names":[],"mappings":"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","sourcesContent":["import { FromRunner, RunnerClient } from '@rdfc/proto'\nimport { promisify } from 'util'\nimport { Logger } from 'winston'\nimport { Any } from './reader'\n\ntype Writable = (msg: FromRunner) => Promise<unknown>\nexport interface Writer {\n  readonly uri: string\n  buffer(buffer: Uint8Array): Promise<void>\n\n  stream(buffer: AsyncIterable<Uint8Array>): Promise<void>\n  stream<T>(\n    buffer: AsyncIterable<T>,\n    transform: (x: T) => Uint8Array,\n  ): Promise<void>\n\n  string(buffer: string): Promise<void>\n  any(any: Any): Promise<void>\n  close(): Promise<void>\n}\nconst encoder = new TextEncoder()\nexport class WriterInstance implements Writer {\n  readonly uri: string\n  localSequenceNumber: number = 1\n  private readonly client: RunnerClient\n  private readonly notifyOrchestrator: Writable\n  private readonly logger: Logger\n\n  private awaitingProcessed: Array<() => void> = []\n\n  private openStreams: number = 0\n  private shouldClose: Array<() => void> = []\n\n  private readonly runnerId: string\n\n  constructor(\n    uri: string,\n    client: RunnerClient,\n    notifyOrchestrator: Writable,\n    runnerId: string,\n    logger: Logger,\n  ) {\n    this.client = client\n    this.notifyOrchestrator = notifyOrchestrator\n    this.uri = uri\n    this.logger = logger\n    this.runnerId = runnerId\n  }\n\n  private awaitProcessed(): Promise<void> {\n    return new Promise((res) => this.awaitingProcessed.push(res))\n  }\n\n  async any(any: Any): Promise<void> {\n    if ('stream' in any) {\n      await this.stream(any.stream)\n    }\n    if ('buffer' in any) {\n      await this.buffer(any.buffer)\n    }\n    if ('string' in any) {\n      await this.string(any.string)\n    }\n  }\n\n  async buffer(buffer: Uint8Array): Promise<void> {\n    this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: { data: buffer, channel: this.uri, localSequenceNumber },\n    })\n    await handledPromise\n  }\n\n  async stream<T = Uint8Array>(\n    buffer: AsyncIterable<T>,\n    transform?: (x: T) => Uint8Array,\n  ) {\n    this.openStreams += 1\n    const t = transform || ((x: unknown) => <Uint8Array>x)\n    const stream = this.client.sendStreamMessage()\n\n    const handledPromise = this.awaitProcessed()\n    const writeStreamMessageChunk = promisify(stream.write.bind(stream))\n    const localSequenceNumber = this.localSequenceNumber++\n    await writeStreamMessageChunk({\n      id: {\n        channel: this.uri,\n        localSequenceNumber,\n        runner: this.runnerId,\n      },\n    })\n\n    const id = await new Promise((res) => stream.once('data', res))\n\n    this.logger.debug(\n      `${this.uri} streams message with id ${JSON.stringify(id)}`,\n    )\n\n    for await (const msg of buffer) {\n      const processedPromise = new Promise((res) => stream.once('data', res))\n      await writeStreamMessageChunk({ data: { data: t(msg) } })\n      // Await a message on the stream, indicating that the chunk has been processed\n      await processedPromise\n    }\n\n    stream.end()\n\n    await handledPromise\n\n    this.openStreams -= 1\n\n    if (this.shouldClose.length > 0) await this.close()\n  }\n\n  async string(msg: string): Promise<void> {\n    this.logger.debug(`${this.uri} sends string ${msg.length} characters`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: {\n        data: encoder.encode(msg),\n        channel: this.uri,\n        localSequenceNumber,\n      },\n    })\n\n    await handledPromise\n  }\n\n  /**\n   * Gracefully closes this channel.\n   *\n   * Behavior:\n   * - If there are still active streams, closing is deferred until they complete.\n   * - If multiple callers invoke `close()` while waiting, their Promises are queued and\n   *   resolved once the channel actually closes.\n   * - If this side initiated the close (`issued = false`), a close message is sent to the remote.\n   *\n   * @param issued - If true, indicates the close request originated remotely\n   */\n  async close(issued = false): Promise<void> {\n    // Case 1: Active streams still running → wait until they finish\n    if (this.openStreams !== 0) {\n      await new Promise<void>((resolve) => this.shouldClose.push(resolve))\n      return\n    }\n\n    // Case 2: No active streams → perform actual close\n    this.logger.debug(`${this.uri} closes stream`)\n    if (!issued) {\n      await this.notifyOrchestrator({\n        close: { channel: this.uri },\n      })\n    }\n\n    let resolve = this.shouldClose.pop()\n    while (resolve) {\n      resolve()\n      resolve = this.shouldClose.pop()\n    }\n  }\n\n  /**\n   * A message is handled, let's notify the fifo {@link awaitProcessed}\n   */\n  handled(): void {\n    if (this.awaitingProcessed.length > 0) {\n      this.awaitingProcessed.shift()!()\n    } else {\n      this.logger.error(\n        'Expected to be waiting for a message to be processed, but this is not the case ' +\n          this.uri,\n      )\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../src/writer.ts"],"names":[],"mappings":"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","sourcesContent":["import { FromRunner, RunnerClient } from '@rdfc/proto'\nimport { promisify } from 'util'\nimport { Logger } from 'winston'\nimport { Any } from './reader'\n\ntype Writable = (msg: FromRunner) => Promise<unknown>\nexport type Handler<T = void> = [T] extends [void]\n  ? () => void | Promise<void>\n  : (value: T) => void | Promise<void>\n\nexport interface Writer {\n  readonly uri: string\n  readonly canceled: boolean\n  on(event: 'cancel', listener: Handler): this\n  buffer(buffer: Uint8Array): Promise<void>\n\n  stream(buffer: AsyncIterable<Uint8Array>): Promise<void>\n  stream<T>(\n    buffer: AsyncIterable<T>,\n    transform: (x: T) => Uint8Array,\n  ): Promise<void>\n\n  string(buffer: string): Promise<void>\n  any(any: Any): Promise<void>\n  close(): Promise<void>\n}\nconst encoder = new TextEncoder()\nexport class WriterInstance implements Writer {\n  readonly uri: string\n  localSequenceNumber: number = 1\n  private readonly client: RunnerClient\n  private readonly notifyOrchestrator: Writable\n  private readonly logger: Logger\n\n  // FIFO of message-level acknowledgements coming back from the orchestrator.\n  private awaitingProcessed: Array<{\n    resolve: () => void\n    reject: (reason: Error) => void\n  }> = []\n\n  private openStreams: number = 0\n  // Close callers wait here while active streams are still flushing.\n  private shouldClose: Array<() => void> = []\n  private closed = false\n  private _canceled = false\n\n  // Shared cancellation signal to abort in-flight waits when the remote closes.\n  private readonly cancelSignal = new AbortController()\n  // Processors can subscribe here to stop upstream work when downstream cancels.\n  private readonly cancelHandlers = new Set<Handler>()\n\n  private readonly runnerId: string\n\n  constructor(\n    uri: string,\n    client: RunnerClient,\n    notifyOrchestrator: Writable,\n    runnerId: string,\n    logger: Logger,\n  ) {\n    this.client = client\n    this.notifyOrchestrator = notifyOrchestrator\n    this.uri = uri\n    this.logger = logger\n    this.runnerId = runnerId\n  }\n\n  get canceled(): boolean {\n    return this._canceled\n  }\n\n  on(event: 'cancel', listener: Handler): this {\n    if (event === 'cancel') {\n      this.cancelHandlers.add(listener)\n    }\n\n    return this\n  }\n\n  private cancellationError(): Error {\n    return new Error(\n      `Writer for channel ${this.uri} was canceled by the connected reader`,\n    )\n  }\n\n  private emitCancel() {\n    for (const handler of this.cancelHandlers) {\n      try {\n        Promise.resolve(handler()).catch((error: unknown) => {\n          this.logger.error(\n            `Cancel listener for channel ${this.uri} failed: ${String(error)}`,\n          )\n        })\n      } catch (error: unknown) {\n        this.logger.error(\n          `Cancel listener for channel ${this.uri} failed: ${String(error)}`,\n        )\n      }\n    }\n  }\n\n  private assertCanWrite() {\n    if (this._canceled) {\n      throw this.cancellationError()\n    }\n\n    if (this.closed) {\n      throw new Error(`Writer for channel ${this.uri} is closed`)\n    }\n  }\n\n  private async raceWithCancellation<T>(promise: Promise<T>): Promise<T> {\n    this.assertCanWrite()\n\n    return await new Promise<T>((resolve, reject) => {\n      const onAbort = () => reject(this.cancellationError())\n      this.cancelSignal.signal.addEventListener('abort', onAbort, {\n        once: true,\n      })\n\n      promise.then(\n        (value) => {\n          // Clean up the abort listener if the original operation finished first.\n          this.cancelSignal.signal.removeEventListener('abort', onAbort)\n          resolve(value)\n        },\n        (error) => {\n          this.cancelSignal.signal.removeEventListener('abort', onAbort)\n          reject(error)\n        },\n      )\n    })\n  }\n\n  private rejectPendingProcessed(error: Error) {\n    // Reject all queued message waits so callers do not hang during cancellation.\n    while (this.awaitingProcessed.length > 0) {\n      this.awaitingProcessed.shift()!.reject(error)\n    }\n  }\n\n  private awaitProcessed(): Promise<void> {\n    this.assertCanWrite()\n    return new Promise((resolve, reject) =>\n      this.awaitingProcessed.push({ resolve, reject }),\n    )\n  }\n\n  async any(any: Any): Promise<void> {\n    if ('stream' in any) {\n      await this.stream(any.stream)\n    }\n    if ('buffer' in any) {\n      await this.buffer(any.buffer)\n    }\n    if ('string' in any) {\n      await this.string(any.string)\n    }\n  }\n\n  async buffer(buffer: Uint8Array): Promise<void> {\n    this.assertCanWrite()\n    this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: { data: buffer, channel: this.uri, localSequenceNumber },\n    })\n    await handledPromise\n  }\n\n  async stream<T = Uint8Array>(\n    buffer: AsyncIterable<T>,\n    transform?: (x: T) => Uint8Array,\n  ) {\n    this.assertCanWrite()\n    this.openStreams += 1\n    const t = transform || ((x: unknown) => <Uint8Array>x)\n    const stream = this.client.sendStreamMessage()\n\n    try {\n      // Message-level ack that signals the whole stream message is fully handled.\n      const handledPromise = this.awaitProcessed()\n      const writeStreamMessageChunk = promisify(stream.write.bind(stream))\n      const localSequenceNumber = this.localSequenceNumber++\n      await writeStreamMessageChunk({\n        id: {\n          channel: this.uri,\n          localSequenceNumber,\n          runner: this.runnerId,\n        },\n      })\n\n      // First response confirms stream id registration on the remote side.\n      const id = await this.raceWithCancellation(\n        new Promise((res) => stream.once('data', res)),\n      )\n\n      this.logger.debug(\n        `${this.uri} streams message with id ${JSON.stringify(id)}`,\n      )\n\n      for await (const msg of buffer) {\n        const processedPromise = new Promise((res) => stream.once('data', res))\n        await writeStreamMessageChunk({ data: { data: t(msg) } })\n        // Await a message on the stream, indicating that the chunk has been processed\n        await processedPromise\n      }\n\n      stream.end()\n\n      await handledPromise\n    } finally {\n      this.openStreams -= 1\n\n      if (!stream.writableEnded) {\n        stream.end()\n      }\n\n      // If a close call was deferred while streaming, complete it now.\n      if (this.shouldClose.length > 0) {\n        await this.close()\n      }\n    }\n  }\n\n  async string(msg: string): Promise<void> {\n    this.assertCanWrite()\n    this.logger.debug(`${this.uri} sends string ${msg.length} characters`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: {\n        data: encoder.encode(msg),\n        channel: this.uri,\n        localSequenceNumber,\n      },\n    })\n\n    await handledPromise\n  }\n\n  /**\n   * Gracefully closes this channel.\n   *\n   * Behavior:\n   * - If there are still active streams, closing is deferred until they complete.\n   * - If multiple callers invoke `close()` while waiting, their Promises are queued and\n   *   resolved once the channel actually closes.\n   * - If this side initiated the close (`issued = false`), a close message is sent to the remote.\n   *\n   * @param issued - If true, indicates the close request originated remotely\n   */\n  async close(issued = false): Promise<void> {\n    if (issued) {\n      if (!this.closed) {\n        // Remote initiated close: mark writer canceled to fail future writes.\n        this._canceled = true\n\n        // Notify processors so they can stop producing upstream work as well.\n        this.emitCancel()\n      }\n      this.closed = true\n\n      const cancelError = this.cancellationError()\n      this.rejectPendingProcessed(cancelError)\n      this.cancelSignal.abort(cancelError)\n\n      // Unblock any local close() callers waiting for streams to settle.\n      let waiting = this.shouldClose.pop()\n      while (waiting) {\n        waiting()\n        waiting = this.shouldClose.pop()\n      }\n      return\n    }\n\n    if (this.closed) {\n      return\n    }\n\n    // Case 1: Active streams still running → wait until they finish\n    if (this.openStreams !== 0) {\n      await new Promise<void>((resolve) => this.shouldClose.push(resolve))\n      return\n    }\n\n    // Case 2: No active streams → perform actual close\n    this.logger.debug(`${this.uri} closes stream`)\n    this.closed = true\n    await this.notifyOrchestrator({\n      close: { channel: this.uri },\n    })\n\n    let resolve = this.shouldClose.pop()\n    while (resolve) {\n      resolve()\n      resolve = this.shouldClose.pop()\n    }\n  }\n\n  /**\n   * A message is handled, let's notify the fifo {@link awaitProcessed}\n   */\n  handled(): void {\n    if (this.awaitingProcessed.length > 0) {\n      this.awaitingProcessed.shift()!.resolve()\n    } else if (this.closed || this._canceled) {\n      // A late ack can arrive after a close/cancel race; nothing to resolve anymore.\n      return\n    } else {\n      this.logger.error(\n        'Expected to be waiting for a message to be processed, but this is not the case ' +\n          this.uri,\n      )\n    }\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdfc/js-runner",
-  "version": "3.0.2",
+  "version": "3.1.0-alpha.1",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
@@ -25,32 +25,33 @@
     ]
   },
   "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": "",
+  "author": "Arthur Vercruysse",
+  "contributors": [
+    "Ieben Smessaert",
+    "Julián Rojas"
+  ],
+  "license": "MIT",
+  "description": "JavaScript runner implementation for RDF-Connect",
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
     "@rdfjs/types": "^2.0.1",
-    "@types/jest": "^30.0.0",
     "@types/jsonld": "^1.5.15",
     "@types/n3": "^1.26.1",
-    "@types/node": "^24.10.9",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
-    "@typescript-eslint/parser": "^8.54.0",
-    "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^9.21.0",
+    "@types/node": "^25.5.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.2",
+    "@typescript-eslint/parser": "^8.57.2",
+    "@vitest/coverage-v8": "^4.1.1",
+    "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^17.3.0",
+    "globals": "^17.4.0",
     "husky": "^9.1.7",
-    "jest": "^30.2.0",
-    "lint-staged": "^16.2.7",
+    "lint-staged": "^16.4.0",
     "prettier": "^3.8.1",
-    "ts-jest": "^29.4.6",
     "tsc-alias": "^1.8.16",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
-    "vitest": "^4.0.18"
+    "typescript-eslint": "^8.57.2",
+    "vitest": "^4.1.1"
   },
   "dependencies": {
     "@grpc/grpc-js": "^1.14.3",
@@ -58,8 +59,8 @@
     "@treecg/types": "^0.4.6",
     "jsonld": "^9.0.0",
     "jsonld-streaming-parser": "^5.0.1",
-    "n3": "^2.0.1",
-    "rdf-lens": "^1.3.6",
+    "n3": "^2.0.3",
+    "rdf-lens": "^1.3.7",
     "winston": "^3.19.0",
     "winston-transport": "^4.9.0"
   }

package/src/logger.ts

@@ -8,6 +8,7 @@ export class RpcTransport extends Transport {
   private readonly stream: grpc.ClientWritableStream<LogMessage>
   private readonly entities: string[]
   private readonly aliases: string[]
+  private draining: boolean
 
   constructor(opts: {
     stream: grpc.ClientWritableStream<LogMessage>
@@ -19,23 +20,30 @@ export class RpcTransport extends Transport {
     this.stream = opts.stream
     this.entities = opts.entities
     this.aliases = opts.aliases || []
+    this.draining = true
+
+    this.stream.on('drain', () => {
+      this.draining = true
+    })
   }
 
   log(info: LogEntry, callback: () => void) {
-    if (!this.stream.closed) {
-      this.stream.write(
-        {
+    if (!this.stream.closed && !this.stream.destroyed && this.stream.writable) {
+      if (this.draining) {
+        const ok = this.stream.write({
           msg: info.message,
           level: info.level,
           entities: this.entities,
           aliases: this.aliases,
-        },
-        callback,
-      )
+        })
+        if (!ok) {
+          this.draining = false
+        }
+      }
     } else {
       console.log('Output stream closed')
-      callback()
     }
+    callback()
   }
 
   withEntity(entity: string): RpcTransport {

package/src/reader.ts

@@ -18,14 +18,14 @@ import { promisify } from 'util'
 
 export type Any =
   | {
-    string: string
-  }
+      string: string
+    }
   | {
-    stream: AsyncGenerator<Uint8Array>
-  }
+      stream: AsyncGenerator<Uint8Array>
+    }
   | {
-    buffer: Uint8Array
-  }
+      buffer: Uint8Array
+    }
 
 export interface Reader {
   readonly uri: string
@@ -33,6 +33,7 @@ export interface Reader {
   streams(): AsyncIterable<AsyncGenerator<Uint8Array>>
   buffers(): AsyncIterable<Uint8Array>
   anys(): AsyncIterable<Any>
+  cancel(): Promise<void>
 }
 
 type Todo<T> = {
@@ -44,12 +45,18 @@ class MyIter<T> implements AsyncIterable<T> {
   private convertor: Convertor<T>
   private queue: Todo<T | undefined>[] = []
   private resolveNext: ((value: undefined) => void) | null = null
+  private closed = false
 
   constructor(convertor: Convertor<T>) {
     this.convertor = convertor
   }
 
   push(buffer: Uint8Array, onComplete: () => void) {
+    if (this.closed) {
+      onComplete()
+      return
+    }
+
     const item = this.convertor.from(buffer)
     this.queue.push({ item, onComplete })
     if (this.resolveNext) {
@@ -59,6 +66,12 @@ class MyIter<T> implements AsyncIterable<T> {
   }
 
   close(onComplete: () => void) {
+    if (this.closed) {
+      onComplete()
+      return
+    }
+
+    this.closed = true
     this.queue.push({ item: undefined, onComplete })
     if (this.resolveNext) {
       this.resolveNext(undefined)
@@ -67,8 +80,13 @@ class MyIter<T> implements AsyncIterable<T> {
   }
 
   async pushStream(chunks: AsyncIterable<DataChunk>, onComplete: () => void) {
+    if (this.closed) {
+      onComplete()
+      return
+    }
+
     // This is an async generator that transforms DataChunks to Buffers
-    const stream = (async function*(stream) {
+    const stream = (async function* (stream) {
       for await (const chunk of stream) {
         yield chunk.data
       }
@@ -108,6 +126,8 @@ export class ReaderInstance implements Reader {
   private readonly notifyOrchestrator: Writable
 
   private consumers: MyIter<unknown>[] = []
+  private closed = false
+  private canceled = false
 
   constructor(
     uri: string,
@@ -148,6 +168,16 @@ export class ReaderInstance implements Reader {
   handleMsg(msg: ReceivingMessage) {
     this.logger.debug(`${this.uri} handling message`)
 
+    if (this.closed) {
+      this.notifyOrchestrator({
+        processed: {
+          globalSequenceNumber: msg.globalSequenceNumber,
+          channel: this.uri,
+        },
+      })
+      return
+    }
+
     const promises = []
     for (const iter of this.consumers) {
       promises.push(new Promise((res) => iter.push(msg.data, () => res(null))))
@@ -164,11 +194,28 @@ export class ReaderInstance implements Reader {
   }
 
   close() {
+    if (this.closed) {
+      return
+    }
+
+    this.closed = true
     for (const iter of this.consumers) {
-      iter.close(() => { })
+      iter.close(() => {})
     }
   }
 
+  async cancel(): Promise<void> {
+    if (this.canceled) {
+      return
+    }
+
+    this.canceled = true
+    this.close()
+    await this.notifyOrchestrator({
+      close: { channel: this.uri },
+    })
+  }
+
   // There is a stream message available for this reader
   async handleStreamingMessage({
     channel,
@@ -176,6 +223,13 @@ export class ReaderInstance implements Reader {
   }: ReceivingStreamMessage) {
     this.logger.debug(`${this.uri} handling streaming message`)
 
+    if (this.closed) {
+      await this.notifyOrchestrator({
+        processed: { globalSequenceNumber, channel },
+      })
+      return
+    }
+
     const chunks = this.client.receiveStreamMessage()
     const writeControlMessage = promisify(chunks.write.bind(chunks))
     const consumersConsumed = []

package/src/runner.ts

@@ -93,7 +93,9 @@ export class Runner {
       )
       .map((x) => x.object.value)
 
-    this.logger.info(`Parsing processor '${proc.uri}' of type(s) [${ty.join(', ')}]`)
+    this.logger.info(
+      `Parsing processor '${proc.uri}' of type(s) [${ty.join(', ')}]`,
+    )
     const args = this.shapes.lenses[RDFL.TypedExtract].execute({
       id: new NamedNode(proc.uri),
       quads: this.quads,

package/src/testUtils/duplex.ts

@@ -1,8 +1,5 @@
 import { Duplex } from 'stream'
-import type {
-  ClientDuplexStream,
-  InterceptingCall,
-} from '@grpc/grpc-js'
+import type { ClientDuplexStream, InterceptingCall } from '@grpc/grpc-js'
 import { AuthContext } from '@grpc/grpc-js/build/src/auth-context'
 
 type Matcher<Req, T> = (req: Req) => T | undefined

package/src/testUtils/index.ts

@@ -1,22 +1,28 @@
-import { DataChunk, FromRunner, LogMessage, Processor as ProcConfig, ToRunner } from "@rdfc/proto";
-import { extractShapes } from "rdf-lens";
-import { NamedNode, Parser, Writer as N3Writer } from "n3";
-import { readFile } from "fs/promises";
-import winston, { createLogger } from "winston";
-import { Processor } from "../processor";
-import { FullProc, Runner, Writable } from "../runner";
-import { Quad } from "@rdfjs/types";
-import { createTermNamespace } from "@treecg/types";
+import {
+  DataChunk,
+  FromRunner,
+  LogMessage,
+  Processor as ProcConfig,
+  ToRunner,
+} from '@rdfc/proto'
+import { extractShapes } from 'rdf-lens'
+import { NamedNode, Parser, Writer as N3Writer } from 'n3'
+import { readFile } from 'fs/promises'
+import winston, { createLogger } from 'winston'
+import { Processor } from '../processor'
+import { FullProc, Runner, Writable } from '../runner'
+import { Quad } from '@rdfjs/types'
+import { createTermNamespace } from '@treecg/types'
 import {
   ReceivingStreamControl,
   SendingStreamControl,
   StreamChunk,
   StreamIdentify,
-} from "@rdfc/proto/lib/generated/common";
-import { MockClientDuplexStream } from "./duplex";
-import { promisify } from "util";
-import { Reader } from "../reader";
-import { Writer } from "../writer";
+} from '@rdfc/proto/lib/generated/common'
+import { MockClientDuplexStream } from './duplex'
+import { promisify } from 'util'
+import { Reader } from '../reader'
+import { Writer } from '../writer'
 
 export function channel(runner: Runner, name: string): [Writer, Reader] {
   const n = new NamedNode(name)
@@ -352,13 +358,11 @@ export class ProcHelper<T extends Processor<unknown>> {
       pipeline: new N3Writer().quadsToString(this.quads),
     })
 
-    return await this.runner.createProcessor<T>(
-      {
-        config: JSON.stringify(this.config),
-        arguments: '',
-        uri,
-      },
-    )
+    return await this.runner.createProcessor<T>({
+      config: JSON.stringify(this.config),
+      arguments: '',
+      uri,
+    })
   }
 }