Check Closed Controller State

TODO: collapasable, copyable, download, etc

My nodejs has this error ```node:internal/webstreams/readablestream:1040 throw new ERR_INVALID_STATE.TypeError('Controller is already closed'); ^

TypeError [ERR_INVALID_STATE]: Invalid state: Controller is already closed at new NodeError (node:internal/errors:405:5) at ReadableStreamDefaultController.close (node:internal/webstreams/readablestream:1040:13) at Chain.eval (/Users/ozten/Projects/troubleshooter/app/src/routes/v2/infer/create_session/+server.js:96:18) at Chain.emit (node:events:514:28) at endReadableNT (node:internal/streams/readable:1376:12) at process.processTicksAndRejections (node:internal/process/task_queues:82:21) { code: 'ERR_INVALID_STATE' }

Node.js v20.6.1```

Can I check if a controlller is already closed?In Node.js, when dealing with streams, especially with the ReadableStream API that is aligned with the web streams spec, you might encounter the error you've shown when you attempt to perform actions on a stream controller that has already been closed.

In your error stack, there's a call to ReadableStreamDefaultController.close which is failing because the controller is already closed. Unfortunately, there isn't a built-in, direct method to check if a ReadableStreamDefaultController is already closed or not.

However, you can infer the state of the stream by checking if its associated ReadableStream is locked or not, because a stream gets locked to a controller when it's being read. Here's an example of how you might approach it:

function isStreamClosed(stream) {
  if (stream.locked) {
    try {
      // Trying to get a reader on a locked stream will throw, hence the stream is not closed.
      stream.getReader().releaseLock();
      return false;
    } catch (error) {
      // If an error occurred, it's likely because the stream is locked, thus not closed.
      return false;
    }
  } else {
    // If the stream is not locked, it might be closed.
    return true;
  }
}

// Usage:
const stream = new ReadableStream({
  start(controller) {
    // Some initialization if necessary
  },
  close() {
    // Stream is being closed
  }
});

if (!isStreamClosed(stream)) {
  // It is safe to manipulate the stream controller
} else {
  // The stream is closed; handle accordingly
}

Please note that this is a heuristic, not a definitive method. The underlying state of the ReadableStream does not directly expose whether the controller is closed. Also, if the stream is errored, this method might not work as intended, and you may need to handle such cases separately.

In your specific scenario, it might be a good practice to structure your code such that the state of the controller is tracked to prevent calling close on an already closed controller. This could be done by wrapping the controller in an object that tracks its state, or by ensuring that your application logic avoids situations where multiple calls to close can occur.

Here's a quick example of how you might track the state:

class SafeStreamController {
  constructor(stream) {
    this.stream = stream;
    this.isClosed = false;
  }

  close() {
    if (!this.isClosed) {
      this.stream.close();
      this.isClosed = true;
    }
  }
}

// Usage:
const stream = new ReadableStream({...});
const safeController = new SafeStreamController(stream);

// Later in your code
safeController.close();  // This will close the stream
safeController.close();  // This will do nothing, as the stream is already closed

This is a simplistic implementation and may need to be expanded based on the specifics of your application and how the streams are used. It's generally a good idea to centralize stream manipulation to ensure you don't accidentally attempt to close a stream multiple times or when it's not in a state to be closed.

Check Closed Controller State created at Tue Jan 20 1970 16:03:19 GMT+0000 (Coordinated Universal Time)