Backwards compatibility for Node <= 9

Author: zyc9012

Diff for: src/utils.ts

@@ -16,12 +16,15 @@ import process from "node:process";
  */
 export const _internals = {
   execute: execute,
-  getBaseUrl: getBaseUrl,
+  getHostnameAndPort: getHostnameAndPort,
 };
 
 /** Facilitates stubbing in tests, e.g. localhost as the base url */
-function getBaseUrl() {
-  return "https://serpapi.com";
+function getHostnameAndPort() {
+  return {
+    hostname: "serpapi.com",
+    port: 443,
+  };
 }
 
 export function getSource() {
@@ -40,25 +43,35 @@ export function getSource() {
   return `nodejs,${moduleSource}`;
 }
 
-export function buildUrl(
+export function buildRequestOptions(
   path: string,
   parameters: qs.ParsedUrlQueryInput,
-): string {
+): http.RequestOptions {
   const clonedParams = { ...parameters };
   for (const k in clonedParams) {
     if (clonedParams[k] === undefined) {
       delete clonedParams[k];
     }
   }
-  return `${_internals.getBaseUrl()}${path}?${qs.stringify(clonedParams)}`;
+  const base = {
+    ..._internals.getHostnameAndPort(),
+    path: `${path}?${qs.stringify(clonedParams)}`,
+    method: "GET",
+  };
+
+  return {
+    ...base,
+    ...(parameters.requestOptions as http.RequestOptions),
+    ...config.requestOptions,
+  };
 }
 
 export function execute(
   path: string,
   parameters: qs.ParsedUrlQueryInput,
   timeout: number,
 ): Promise<string> {
-  const url = buildUrl(path, {
+  const options = buildRequestOptions(path, {
     ...parameters,
     source: getSource(),
   });
@@ -96,13 +109,7 @@ export function execute(
       if (timer) clearTimeout(timer);
     };
 
-    const options = (parameters.requestOptions as http.RequestOptions) ||
-      config.requestOptions ||
-      {};
-
-    const req = https
-      .get(url, options, handleResponse)
-      .on("error", handleError);
+    const req = https.get(options, handleResponse).on("error", handleError);
 
     if (timeout > 0) {
       timer = setTimeout(() => {

Diff for: tests/utils_test.ts

@@ -11,13 +11,24 @@ import {
   assertInstanceOf,
   assertMatch,
 } from "https://deno.land/[email protected]/testing/asserts.ts";
-import { _internals, buildUrl, execute, getSource } from "../src/utils.ts";
+import {
+  _internals,
+  buildRequestOptions,
+  execute,
+  getSource,
+} from "../src/utils.ts";
 import { RequestTimeoutError } from "../src/errors.ts";
 
 loadSync({ export: true });
-const BASE_URL = Deno.env.get("ENV_TYPE") === "local"
-  ? "http://localhost:3000"
-  : "https://serpapi.com";
+const BASE_OPTIONS = Deno.env.get("ENV_TYPE") === "local"
+  ? {
+    hostname: "localhost",
+    port: 3000,
+  }
+  : {
+    hostname: "serpapi.com",
+    port: 443,
+  };
 
 describe("getSource", () => {
   it("use runtime version", async () => {
@@ -28,67 +39,80 @@ describe("getSource", () => {
   });
 });
 
-describe("buildUrl", () => {
+describe("buildRequestOptions", () => {
   let urlStub: Stub;
 
   beforeAll(() => {
-    urlStub = stub(_internals, "getBaseUrl", () => BASE_URL);
+    urlStub = stub(_internals, "getHostnameAndPort", () => BASE_OPTIONS);
   });
 
   afterAll(() => {
     urlStub.restore();
   });
 
   it("with blank path and empty parameters", async () => {
-    assertEquals(await buildUrl("", {}), `${BASE_URL}?`);
+    assertEquals(await buildRequestOptions("", {}), BASE_OPTIONS);
   });
 
   it("with path and empty parameters", async () => {
-    assertEquals(await buildUrl("/", {}), `${BASE_URL}/?`);
+    assertEquals(await buildRequestOptions("/", {}), BASE_OPTIONS);
   });
 
   it("with path and parameters", async () => {
     assertEquals(
-      await buildUrl("/search", { q: "coffee", gl: "us" }),
-      `${BASE_URL}/search?q=coffee&gl=us`,
+      await buildRequestOptions("/search", { q: "coffee", gl: "us" }),
+      BASE_OPTIONS,
     );
   });
 
   it("with source", async () => {
-    const url = await buildUrl("/search", { source: await getSource() });
+    const options = await buildRequestOptions("/search", {
+      source: await getSource(),
+    });
     assertMatch(
-      url,
+      options.path as string,
       /source=(nodejs|deno)%40\d+\.\d+\.\d+%2Cserpapi%40\d+\.\d+\.\d+$/,
     );
   });
 
   it("with undefined parameters", async () => {
     assertEquals(
-      await buildUrl("/search", { q: "coffee", gl: undefined, hl: null }),
-      `${BASE_URL}/search?q=coffee&hl=`,
+      await buildRequestOptions("/search", {
+        q: "coffee",
+        gl: undefined,
+        hl: null,
+      }),
+      {
+        ...BASE_OPTIONS,
+        path: "/search?q=coffee&hl=",
+      },
     );
   });
 });
 
-describe("execute", {
-  sanitizeOps: false,
-  sanitizeResources: false,
-}, () => {
-  let urlStub: Stub;
+describe(
+  "execute",
+  {
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
+  () => {
+    let urlStub: Stub;
 
-  beforeAll(() => {
-    urlStub = stub(_internals, "getBaseUrl", () => BASE_URL);
-  });
+    beforeAll(() => {
+      urlStub = stub(_internals, "getHostnameAndPort", () => BASE_OPTIONS);
+    });
 
-  afterAll(() => {
-    urlStub.restore();
-  });
+    afterAll(() => {
+      urlStub.restore();
+    });
 
-  it("with short timeout", async () => {
-    try {
-      await execute("/search", { q: "coffee", gl: "us" }, 1);
-    } catch (e) {
-      assertInstanceOf(e, RequestTimeoutError);
-    }
-  });
-});
+    it("with short timeout", async () => {
+      try {
+        await execute("/search", { q: "coffee", gl: "us" }, 1);
+      } catch (e) {
+        assertInstanceOf(e, RequestTimeoutError);
+      }
+    });
+  },
+);