feat: support for body

Author: Mqxx

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescriptplayground/socket",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "license": "./LICENSE",
   "exports": {
     ".": "./src/index.ts"

deno.lock

@@ -1,3 +1,4 @@
+export { InvalidBodyTypeError } from './invalid_body_type_error.ts'
 export { InvalidChunkSizeError } from './invalid_chunk_size_error.ts'
 export { InvalidResponseError } from './invalid_response_error.ts'
 export { InvalidStartLineError } from './invalid_start_line_error.ts'

src/http/error/index.ts

@@ -0,0 +1,5 @@
+export class InvalidBodyTypeError extends Error {
+  constructor() {
+    super(`Invalid body type`);
+  }
+}

src/http/error/invalid_body_type_error.ts

@@ -0,0 +1,77 @@
+import { assertEquals } from '@std/assert'
+import { bodyToString } from './body_to_string.ts';
+
+Deno.test('Tests "bodyToString"', async (test) => {
+  await test.step({
+    name: 'Convert string to string.',
+    fn() : void {
+      const testString = 'string';
+
+      const result = bodyToString(testString);
+
+      assertEquals(
+        result,
+        testString
+      )
+    }
+  })
+
+  await test.step({
+    name: 'Convert ArrayBuffer to string.',
+    async fn() : Promise<void> {
+      const testString = 'ArrayBuffer';
+
+      const buffer = new TextEncoder().encode(testString).buffer;
+
+      const result = await bodyToString(buffer);
+
+      assertEquals(result, testString);
+    },
+  });
+
+  await test.step({
+    name: "Convert Blob to string.",
+    async fn() : Promise<void> {
+      const testString = 'Blob';
+
+      const blob = new Blob([testString]);
+
+      const result = await bodyToString(blob);
+
+      assertEquals(result, testString);
+    },
+  });
+
+  await test.step({
+    name: 'Convert DataView to string.',
+    async fn() : Promise<void> {
+      const testString = 'DataView';
+
+      const buffer = new TextEncoder().encode(testString).buffer;
+      const dataView = new DataView(buffer);
+
+      const result = await bodyToString(dataView);
+
+      assertEquals(result, testString);
+    },
+  });
+
+  await test.step({
+    name: 'Convert ReadableStream to string.',
+    async fn() : Promise<void> {
+      const testString = 'ReadableStream';
+
+      const textEncoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) : void {
+          controller.enqueue(textEncoder.encode(testString));
+          controller.close();
+        },
+      });
+
+      const result = await bodyToString(stream);
+
+      assertEquals(result, testString);
+    },
+  });
+})

src/http/request/body_to_string.test.ts

@@ -0,0 +1,35 @@
+import { InvalidBodyTypeError } from '../error/index.ts';
+
+/**
+ * This function converts the different input type into a string.
+ * 
+ * @param body Input body
+ * 
+ * @throws `InvalidBodyTypeError` if the input is an invalid
+ * @returns The body as a string.
+ */
+export function bodyToString(body : string | ArrayBuffer | Blob | DataView | ReadableStream) : string | Promise<string> {
+  const textDecoder = new TextDecoder()
+  
+  if (typeof body === "string") {
+    return body;
+  }
+
+  if (body instanceof Blob) {
+    return body.text();
+  }
+
+  if (body instanceof ArrayBuffer) {
+    return textDecoder.decode(body);
+  }
+
+  if (body instanceof DataView) {
+    return textDecoder.decode(body.buffer);
+  }
+
+  if (body instanceof ReadableStream) {
+    return new Response(body).text();
+  }
+
+  throw new InvalidBodyTypeError();
+}

src/http/request/body_to_string.ts

@@ -0,0 +1 @@
+export { bodyToString } from './body_to_string.ts';

src/http/request/index.ts

@@ -2,6 +2,7 @@ import { method } from './method.ts';
 import { SocketRequestInit } from './socket_request_init.ts';
 import { SocketOptions } from './socket_options.ts';
 import { parse } from './http/response/parse.ts';
+import { bodyToString } from './http/request/index.ts';
 
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -34,27 +35,29 @@ export class Socket {
 
   public async request(
     path : string,
-    init : SocketRequestInit = {
-      method: method.GET,
-      headers: {}
-    }
+    init? : SocketRequestInit
   ) : Promise<Response> {
     const connection = await this.connect();
 
     const headers = Object.assign({
       Connection: 'close',
-      Host: 'localhost'
-    }, {...init.headers})
+      Host: 'localhost',
+    }, {...init?.headers})
+
+    let bodyString = '';
+    if (init?.body) {
+      bodyString = await bodyToString(init.body);
+      headers['Content-Length'] ??= new TextEncoder().encode(bodyString).length.toString();
+    }
 
-    const headerLines = [
-      `${init.method} ${path} HTTP/1.1`,
+    const payload = [
+      `${init?.method ?? method.GET} ${path} HTTP/1.1`,
       ...Object.entries(headers).map(([key, value]) => `${key}: ${value}`),
       '',
-      ''
-    ];
+      bodyString
+    ].join("\r\n");
 
-    const requestPayload = headerLines.join("\r\n");
-    await connection.write(textEncoder.encode(requestPayload));
+    await connection.write(textEncoder.encode(payload));
 
     let buffer = new Uint8Array()
     for await (const chunk of connection.readable) {

src/socket.ts

@@ -2,5 +2,6 @@ import { Method } from './method.ts';
 
 export interface SocketRequestInit {
   method? : Method,
-  headers : Record<string, string>
+  headers? : Record<string, string>,
+  body? : string | ArrayBuffer | Blob | DataView | ReadableStream
 }