fix: cleanup

Author: Mqxx

response.txt

@@ -13,7 +13,7 @@ export function parse(response : string) : Response {
   if (headers.get('transfer-encoding') === 'chunked') {
     body = parseChunkedBody(body);
   } else {
-    body = body.replace(/\r\n\r\n$/gm, '');
+    body = body.replace(/\r\n$/gm, '');
   }
 
   return new Response(

src/http/response/parse.ts

@@ -4,6 +4,14 @@ import { Socket } from './socket.ts';
 const socket = new Socket('/var/run/docker.sock');
 
 
-socket.request("/containers/json")
+await socket.request("/containers/json")
   .then(res => res.json())
   .then(json => console.log(json));
+  
+await socket.request("/containers/json")
+  .then(res => res.json())
+  .then(json => console.log(json));
+
+await socket.request("/containers/0954fa1ee0b11120eeabb22c2b4bc924221840a8d8d8a408ac8881616019161a/logs?stdout=true")
+  .then(res => res.text())
+  .then(json => console.log(json));

src/index.ts

@@ -1,8 +1,7 @@
 import { method } from './method.ts';
 import { SocketRequestInit } from './socket_request_init.ts';
 import { SocketOptions } from './socket_options.ts';
-import { parseHttpResponse } from './parse_http_response.ts';
-import * as error from './error/index.ts'
+import { parse } from './http/response/parse.ts';
 
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -61,62 +60,6 @@ export class Socket {
     return connection.write(textEncoder.encode(requestPayload));
   }
 
-  private decodeChunkedBody(
-    bodyStart : string,
-    reader : ReadableStreamDefaultReader<Uint8Array>
-  ) : ReadableStream<Uint8Array> {
-    let buffer = bodyStart;
-
-    return new ReadableStream<Uint8Array>({
-      async pull(controller) : Promise<void> {
-        while (true) {
-          const chunkSizeEnd = buffer.indexOf("\r\n");
-          
-          if (chunkSizeEnd === -1) {
-            const { value, done } = await reader.read();
-            if (done) {
-              controller.close();
-              return;
-            }
-            buffer += textDecoder.decode(value);
-            continue;
-          }
-
-          const chunkSizeHex = buffer.slice(0, chunkSizeEnd).trim();
-          const chunkSize = parseInt(chunkSizeHex, 16);
-
-          if (chunkSize === 0) {
-            controller.close();
-            return;
-          }
-
-          buffer = buffer.slice(chunkSizeEnd + 2);
-
-          while (buffer.length < chunkSize + 2) {
-            const { value, done } = await reader.read();
-            if (done) {
-              controller.close();
-              return;
-            }
-            buffer += textDecoder.decode(value);
-          }
-
-          const chunkData = buffer.slice(0, chunkSize);
-          buffer = buffer.slice(chunkSize + 2);
-
-          controller.enqueue(textEncoder.encode(chunkData));
-
-          if (buffer.length === 0) {
-            return;
-          }
-        }
-      },
-      cancel() : void {
-        reader.releaseLock();
-      }
-    });
-  }
-
   public async request(
     path : string,
     init : SocketRequestInit = {
@@ -127,63 +70,11 @@ export class Socket {
     const connection = await this.connection;
     await this.write(path, init);
 
-    const reader = connection.readable.getReader();
-    let buffer = '';
-
-    const firstChunk = await reader.read();
-    if (firstChunk.done) {
-      throw new error.ConnectionClosedError();
-    }
-
-    buffer = textDecoder.decode(firstChunk.value);
-    
-    while (buffer.indexOf("\r\n\r\n") === -1) {
-      const chunk = await reader.read();
-      if (chunk.done) {
-        break
-      };
-      buffer += textDecoder.decode(
-        chunk.value,
-        {stream: true}
-      );
-    }
-
-    const parsedResponse = parseHttpResponse(buffer);
-
-    const isChunked = parsedResponse.headers['transfer-encoding'] === 'chunked';
-
-    let bodyStream : ReadableStream<Uint8Array>;
-
-    if (isChunked) {
-      bodyStream = this.decodeChunkedBody(parsedResponse.bodyStart, reader);
-    } else {
-      bodyStream = new ReadableStream<Uint8Array>({
-        start(controller) : void {
-          if (parsedResponse.bodyStart) {
-            controller.enqueue(textEncoder.encode(parsedResponse!.bodyStart));
-          }
-        },
-        async pull(controller) : Promise<void> {
-          const { value, done } = await reader.read();
-          if (done) {
-            controller.close();
-            return;
-          }
-          controller.enqueue(value);
-        },
-        cancel() : void {
-          reader.releaseLock();
-        }
-      });
+    let buffer = new Uint8Array()
+    for await (const chunk of connection.readable) {
+      buffer = new Uint8Array([...buffer, ...chunk])
     }
 
-    return new Response(
-      bodyStream,
-      {
-        status: parsedResponse.statusCode,
-        statusText: parsedResponse.statusText,
-        headers: new Headers(parsedResponse.headers)
-      }
-    );
+    return parse(textDecoder.decode(buffer));
   }
 }