@typescriptprime/securereq 1.0.1 → 1.1.0

package/dist/index.js

@@ -6,6 +6,7 @@ var __export = (target, all) => {
 
 // sources/index.ts
 import * as HTTPS from "node:https";
+import * as HTTP2 from "node:http2";
 import * as TLS from "node:tls";
 import * as Process from "node:process";
 
@@ -4241,6 +4242,7 @@ async function HTTPSRequest(Url, Options) {
       Ciphers: ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256"],
       KeyExchanges: ["X25519MLKEM768", "X25519"]
     },
+    HttpMethod: "GET",
     HttpHeaders: {
       "User-Agent": `node/${Process.version} ${Process.platform} ${Process.arch} workspace/false`
     }
@@ -4258,6 +4260,7 @@ async function HTTPSRequest(Url, Options) {
       KeyExchanges: array(string2()).optional()
     }).partial().optional(),
     HttpHeaders: record(string2(), string2()).optional(),
+    HttpMethod: _enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional(),
     ExpectedAs: _enum(["JSON", "String", "ArrayBuffer"]).optional()
   }).parseAsync(Options ?? {});
   if (MergedOptions.TLS?.IsHTTPSEnforced && Url.protocol !== "https:") {
@@ -4274,7 +4277,8 @@ async function HTTPSRequest(Url, Options) {
       minVersion: MergedOptions.TLS?.MinTLSVersion,
       maxVersion: MergedOptions.TLS?.MaxTLSVersion,
       ciphers: MergedOptions.TLS?.Ciphers?.join(":"),
-      ecdhCurve: MergedOptions.TLS?.KeyExchanges?.join(":")
+      ecdhCurve: MergedOptions.TLS?.KeyExchanges?.join(":"),
+      method: MergedOptions.HttpMethod
     }, (Res) => {
       const Chunks = [];
       Res.on("data", (Chunk) => {
@@ -4311,7 +4315,116 @@ async function HTTPSRequest(Url, Options) {
   });
   return HTTPSResponse;
 }
+async function HTTPS2Request(Url, Options) {
+  const DefaultOptions = {
+    TLS: {
+      IsHTTPSEnforced: true,
+      MinTLSVersion: "TLSv1.3",
+      MaxTLSVersion: "TLSv1.3",
+      Ciphers: ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256"],
+      KeyExchanges: ["X25519MLKEM768", "X25519"]
+    },
+    HttpHeaders: {
+      "User-Agent": `node/${Process.version} ${Process.platform} ${Process.arch} workspace/false`
+    },
+    HttpMethod: "GET"
+  };
+  const MergedOptions = { ...DefaultOptions, ...Options ?? {} };
+  if (Url instanceof URL === false) {
+    throw new TypeError("Url must be an instance of URL");
+  }
+  await strictObject({
+    TLS: strictObject({
+      IsHTTPSEnforced: boolean2().optional(),
+      MinTLSVersion: _enum(["TLSv1.2", "TLSv1.3"]).optional(),
+      MaxTLSVersion: _enum(["TLSv1.2", "TLSv1.3"]).optional(),
+      Ciphers: array(string2().refine((Cipher) => TLS.getCiphers().map((C) => C.toLowerCase()).includes(Cipher.toLowerCase()))).optional(),
+      KeyExchanges: array(string2()).optional()
+    }).partial().optional(),
+    HttpHeaders: record(string2(), string2()).optional(),
+    ExpectedAs: _enum(["JSON", "String", "ArrayBuffer"]).optional(),
+    HttpMethod: _enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional()
+  }).parseAsync(Options ?? {});
+  if (MergedOptions.TLS?.IsHTTPSEnforced && Url.protocol !== "https:") {
+    throw new Error("HTTPS is enforced, but the URL protocol is not HTTPS");
+  }
+  const ExpectedAs = Options?.ExpectedAs ?? (Url.pathname.endsWith(".json") ? "JSON" : Url.pathname.endsWith(".txt") ? "String" : "ArrayBuffer");
+  const HTTPSResponse = await new Promise((Resolve, Reject) => {
+    const NormalizedHeaders = Object.fromEntries(Object.entries(MergedOptions.HttpHeaders ?? {}).map(([Key, Value]) => [Key.toLowerCase(), Value]));
+    const HTTP2Session = HTTP2.connect(`https://${Url.hostname}${Url.port ? `:${Url.port}` : ""}`, {
+      createConnection: () => TLS.connect({
+        host: Url.hostname,
+        port: Number(Url.port || 443),
+        servername: Url.hostname,
+        minVersion: MergedOptions.TLS?.MinTLSVersion,
+        maxVersion: MergedOptions.TLS?.MaxTLSVersion,
+        ciphers: MergedOptions.TLS?.Ciphers?.join(":"),
+        ecdhCurve: MergedOptions.TLS?.KeyExchanges?.join(":"),
+        ALPNProtocols: ["h2"]
+      })
+    });
+    HTTP2Session.on("error", (Error2) => {
+      Reject(Error2);
+    });
+    const RequestHeaders = {
+      ":method": MergedOptions.HttpMethod,
+      ":path": Url.pathname + Url.search,
+      ":scheme": "https",
+      ":authority": Url.host,
+      ...NormalizedHeaders
+    };
+    const Request = HTTP2Session.request(RequestHeaders);
+    const Chunks = [];
+    let StatusCode = 0;
+    let ResponseHeaders = {};
+    Request.on("response", (Headers) => {
+      StatusCode = Number(Headers[":status"] ?? 0);
+      ResponseHeaders = Object.fromEntries(Object.entries(Headers).filter(([Key]) => !Key.startsWith(":")).map(([Key, Value]) => {
+        if (Array.isArray(Value)) {
+          return [Key, Value.map((Item) => Item?.toString())];
+        }
+        return [Key, Value?.toString()];
+      }));
+    });
+    Request.on("data", (Chunk) => {
+      Chunks.push(Chunk.buffer.slice(Chunk.byteOffset, Chunk.byteOffset + Chunk.byteLength));
+    });
+    Request.on("end", () => {
+      const BodyBuffer = ConcatArrayBuffers(Chunks);
+      let Body;
+      switch (ExpectedAs) {
+        case "JSON":
+          try {
+            Body = JSON.parse(new TextDecoder("utf-8").decode(BodyBuffer));
+          } catch (Error2) {
+            HTTP2Session.close();
+            return Reject(new Error2("Failed to parse JSON response body"));
+          }
+          break;
+        case "String":
+          Body = new TextDecoder("utf-8").decode(BodyBuffer);
+          break;
+        case "ArrayBuffer":
+          Body = BodyBuffer;
+          break;
+      }
+      HTTP2Session.close();
+      Resolve({
+        StatusCode,
+        Headers: ResponseHeaders,
+        Body
+      });
+    });
+    Request.on("error", (Error2) => {
+      HTTP2Session.close();
+      Reject(Error2);
+    });
+    Request.end();
+  });
+  return HTTPSResponse;
+}
 export {
+  HTTPS2Request,
   HTTPSRequest
 };
 //# sourceMappingURL=index.js.map