improve promise handling

src/index.ts

@@ -28,8 +28,6 @@ export class Socket {
   private socket: net.Socket | tls.TLSSocket;
   private allowHalfOpen: boolean;
   private secureTransport: SocketOptions['secureTransport'];
-  private closedResolved = false;
-  private closedRejected = false;
   private closedResolve!: () => void;
   private closedReject!: (reason?: unknown) => void;
   private startTlsCalled = false;
@@ -43,11 +41,9 @@ export class Socket {
 
     this.closed = new Promise((resolve, reject) => {
       this.closedResolve = (...args): void => {
-        this.closedResolved = true;
         resolve(...args);
       };
       this.closedReject = (...args): void => {
-        this.closedRejected = true;
         // eslint-disable-next-line prefer-promise-reject-errors
         reject(...args);
       };
@@ -69,18 +65,16 @@ export class Socket {
     }
 
     this.socket.on('close', (hadError) => {
-      if (!hadError && !this.closedFulfilled && !this.closedResolved) {
+      if (!hadError) {
         this.closedResolve();
       }
     });
 
     this.socket.on('error', (err) => {
-      if (!this.closedFulfilled && !this.closedRejected) {
-        this.closedReject(err);
-      }
+      this.closedReject(err);
     });
 
-    // types are wrong. fixed based on docs https://nodejs.org/dist/latest-v19.x/docs/api/stream.html#streamduplextowebstreamduplex
+    // types are wrong. fixed based on docs https://nodejs.org/dist/latest/docs/api/stream.html#streamduplextowebstreamduplex
     const { readable, writable } = Duplex.toWeb(this.socket) as unknown as {
       readable: ReadableStream<unknown>;
       writable: WritableStream<unknown>;
@@ -89,13 +83,10 @@ export class Socket {
     this.writable = writable;
   }
 
-  get closedFulfilled(): boolean {
-    return this.closedResolved || this.closedRejected;
-  }
-
   close(): Promise<void> {
-    this.socket.destroy();
-    this.closedResolve();
+    this.socket.end(() => {
+      this.closedResolve();
+    });
     return this.closed;
   }
 

test/index.test.ts

@@ -1,31 +1,89 @@
 import net from 'node:net';
+import { once } from 'node:events';
 import tap from 'tap';
 import { connect } from '../src';
 import { listenAndGetSocketAddress, writeAndReadSocket } from './utils';
 
 void tap.test(
   'Socket connected to tcp server with secureTransport: off',
-  (t) => {
-    void t.test(
-      'should be able to connect, write, and read data',
-      async (t) => {
-        let connectCount = 0;
-        const message = 'abcde\r\n';
-        const server = net.createServer();
-        server.on('connection', (c) => {
-          connectCount++;
-          c.pipe(c);
-        });
-        const address = await listenAndGetSocketAddress(server);
-        const socket = connect(address);
-        const result = await writeAndReadSocket(socket, message);
-        t.equal(connectCount, 1, 'should connection one time');
-        t.equal(result, message, 'should pipe message');
-        await socket.close();
+  async (t) => {
+    t.plan(6);
+    let connectCount = 0;
+    const message = 'abcde\r\n';
+
+    const server = net.createServer();
+
+    server.on('connection', (c) => {
+      connectCount++;
+      c.setEncoding('utf-8');
+      c.on('data', (data) => {
+        t.equal(data, message);
+      });
+      c.on('end', () => {
         server.close();
-        t.end();
-      },
+      });
+      c.pipe(c);
+    });
+
+    const address = await listenAndGetSocketAddress(server);
+    const socket = connect(address);
+
+    await t.resolveMatch(
+      writeAndReadSocket(socket, message),
+      message,
+      'should pipe message',
+    );
+
+    const close = socket.close();
+    t.equal(
+      socket.closed,
+      close,
+      '`.closed` and `.close()` should be the same object',
     );
-    t.end();
+    await t.resolves(close);
+
+    await t.rejects(
+      writeAndReadSocket(socket, message),
+      'should fail to pipe after close',
+    );
+
+    t.equal(connectCount, 1, 'should connect one time');
+
+    await once(server, 'close');
+  },
+);
+
+void tap.test(
+  'connect method correctly parses address as string',
+  async (t) => {
+    t.plan(4);
+    let connectCount = 0;
+    const message = 'abcde\r\n';
+
+    const server = net.createServer();
+
+    server.on('connection', (c) => {
+      connectCount++;
+      c.setEncoding('utf-8');
+      c.on('data', (data) => {
+        t.equal(data, message);
+      });
+      c.on('end', () => {
+        server.close();
+      });
+    });
+
+    const address = await listenAndGetSocketAddress(server);
+
+    const socket = connect(`tcp://localhost:${address.port}`);
+
+    const writer = socket.writable.getWriter();
+    await t.resolves(writer.write(message));
+
+    await t.resolves(socket.close());
+
+    t.equal(connectCount, 1, 'should connect one time');
+
+    await once(server, 'close');
   },
 );

tsconfig.base.json

@@ -5,8 +5,7 @@
     "lib": ["ES2023"],
     "target": "ES2022",
     "module": "Node16",
-    "moduleResolution": "node",
-    "outDir": "./dist",
+    "moduleResolution": "Node16",
     "noEmit": true
   }
 }