Use polyfills only if they don't exist in the runtime

Author: sebastianquek

deno.json

@@ -26,6 +26,7 @@
   "compilerOptions": {
     "lib": [
       "dom",
+      "dom.iterable",
       "deno.ns"
     ]
   }

src/serpapi.ts

@@ -91,7 +91,7 @@ export async function getJson<
     timeout,
   );
   const json = await response.json() as BaseResponse<E>;
-  const nextParametersFromResponse = extractNextParameters<E>(json);
+  const nextParametersFromResponse = await extractNextParameters<E>(json);
   if (
     // https://github.com/serpapi/public-roadmap/issues/562
     // https://github.com/serpapi/public-roadmap/issues/563

src/utils.ts

@@ -1,8 +1,5 @@
 import type { EngineName, EngineParameters } from "./types.ts";
 import { version } from "../version.ts";
-import fetch from "npm:cross-fetch@3.1.4";
-import core from "npm:core-js-pure@3.28.0";
-const { globalThis, URL, URLSearchParams } = core;
 
 type UrlParameters = Record<
   string,
@@ -11,26 +8,48 @@ type UrlParameters = Record<
 
 /**
  * This `_internals` object is needed to support stubbing/spying of
- * fetch, execute and getBaseUrl.
+ * certain functions in this file.
  * https://deno.land/manual@v1.28.3/basics/testing/mocking
  *
- * If fetch is stubbed via `globalThis`, the test phase of the npm build fails.
- * ```ts
- * const fetchStub = stub(globalThis, "fetch", resolvesNext([new Response("data")]));
- * ```
- *
- * [`dnt`](https://github.com/denoland/dnt) shims `fetch` by relying on the
- * `undici` package. It replaces all references to `fetch` with `dntShim.fetch`.
- * As a side effect, stubbing `globalThis.fetch` becomes incorrect; we want to
- * stub `dntShim.fetch` instead.
- *
- * As a workaround, the `_internals` object serves as an indirection and we
- * stub the `fetch` key of this object instead.
+ * It's also useful to encapsulate functions that are polyfilled.
  */
 export const _internals = {
-  fetch: fetch,
+  get fetch() {
+    return (async () => {
+      // Use runtime's `fetch` if it exists, otherwise fallback to `cross-fetch`.
+      return typeof fetch === "function"
+        ? Promise.resolve(fetch)
+        : (await import("npm:cross-fetch@3.1.4")).default;
+    })();
+  },
   execute: execute,
   getBaseUrl: getBaseUrl,
+  get globalThis() {
+    return (async () => {
+      // Use runtime's `globalThis` if it exists, otherwise fallback to `core-js`'s implementation.
+      // dnt-shim-ignore
+      const gt = typeof globalThis !== "undefined" ? globalThis : undefined;
+      return gt !== undefined
+        ? Promise.resolve(gt)
+        : (await import("npm:core-js-pure@3.28.0")).default.globalThis;
+    })();
+  },
+  get URL(): Promise<typeof URL> {
+    return (async () => {
+      // Use runtime's `URL` if it exists, otherwise fallback to `core-js`'s implementation.
+      return typeof URL !== "undefined"
+        ? Promise.resolve(URL)
+        : (await import("npm:core-js-pure@3.28.0")).default.URL;
+    })();
+  },
+  get URLSearchParams(): Promise<typeof URLSearchParams> {
+    return (async () => {
+      // Use runtime's `URLSearchParams` if it exists, otherwise fallback to `core-js`'s implementation.
+      return typeof URLSearchParams !== "undefined"
+        ? Promise.resolve(URLSearchParams)
+        : (await import("npm:core-js-pure@3.28.0")).default.URLSearchParams;
+    })();
+  },
 };
 
 /** Facilitates stubbing in tests, e.g. localhost as the base url */
@@ -46,14 +65,17 @@ type NextParameters<E extends EngineName = EngineName> = {
     >
   ]: string;
 };
-export function extractNextParameters<E extends EngineName = EngineName>(json: {
-  serpapi_pagination?: { next: string };
-  pagination?: { next: string };
-}) {
+export async function extractNextParameters<E extends EngineName = EngineName>(
+  json: {
+    serpapi_pagination?: { next: string };
+    pagination?: { next: string };
+  },
+) {
   const nextUrlString = json["serpapi_pagination"]?.["next"] ||
     json["pagination"]?.["next"];
 
   if (nextUrlString) {
+    const URL = await _internals.URL;
     const nextUrl = new URL(nextUrlString);
     const nextParameters: Record<string, string> = {};
     for (const [k, v] of nextUrl.searchParams.entries()) {
@@ -78,22 +100,20 @@ export function haveParametersChanged(
   );
 }
 
-function getSource() {
+export async function getSource() {
   const moduleSource = `serpapi@${version}`;
   try {
+    const gt = await _internals.globalThis;
+
     // Check if running in Node.js
-    // dnt-shim-ignore
-    // deno-lint-ignore no-explicit-any
-    const nodeVersion = (globalThis as any).process?.versions?.node;
+    const nodeVersion = gt.process?.versions?.node;
     if (nodeVersion) {
       return `nodejs@${nodeVersion},${moduleSource}`;
     }
 
     // Assumes running in Deno instead. https://deno.land/api?s=Deno.version
     // Deno.version is not shimmed since it's not used when ran in a Node env.
-    // dnt-shim-ignore
-    // deno-lint-ignore no-explicit-any
-    const denoVersion = (globalThis as any).Deno?.version?.deno;
+    const denoVersion = gt.Deno?.version?.deno;
     if (denoVersion) {
       return `deno@${denoVersion},${moduleSource}`;
     }
@@ -105,37 +125,40 @@ function getSource() {
   }
 }
 
-export function buildUrl<P extends UrlParameters>(
+export async function buildUrl<P extends UrlParameters>(
   path: string,
   parameters: P,
-): string {
+): Promise<string> {
   const nonUndefinedParams: [string, string][] = Object.entries(parameters)
     .filter(([_, value]) => value !== undefined)
     .map(([key, value]) => [key, `${value}`]);
+  const URLSearchParams = await _internals.URLSearchParams;
   const searchParams = new URLSearchParams(nonUndefinedParams);
   return `${_internals.getBaseUrl()}${path}?${searchParams}`;
 }
 
-export function execute<P extends UrlParameters>(
+export async function execute<P extends UrlParameters>(
   path: string,
   parameters: P,
   timeout: number,
 ): Promise<Response> {
-  const url = buildUrl(path, {
+  const url = await buildUrl(path, {
     ...parameters,
-    source: getSource(),
+    source: await getSource(),
   });
   // https://github.com/github/fetch/issues/175#issuecomment-216791333
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => reject(new Error("Timeout")), timeout);
-    _internals.fetch(url)
-      .then((res) => {
-        clearTimeout(timer);
-        resolve(res);
-      })
-      .catch((err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
+    _internals.fetch.then((fetch) =>
+      fetch(url)
+        .then((res) => {
+          clearTimeout(timer);
+          resolve(res);
+        })
+        .catch((err) => {
+          clearTimeout(timer);
+          reject(err);
+        })
+    );
   });
 }

tests/utils_test.ts

@@ -5,12 +5,7 @@ import {
   describe,
   it,
 } from "https://deno.land/std@0.170.0/testing/bdd.ts";
-import {
-  assertSpyCalls,
-  resolvesNext,
-  Stub,
-  stub,
-} from "https://deno.land/std@0.170.0/testing/mock.ts";
+import { Stub, stub } from "https://deno.land/std@0.170.0/testing/mock.ts";
 import {
   assertEquals,
   assertMatch,
@@ -21,19 +16,19 @@ import {
   buildUrl,
   execute,
   extractNextParameters,
+  getSource,
   haveParametersChanged,
 } from "../src/utils.ts";
-import { Response } from "npm:cross-fetch@3.1.4";
 
 loadSync({ export: true });
 const BASE_URL = Deno.env.get("ENV_TYPE") === "local"
   ? "http://localhost:3000"
   : "https://serpapi.com";
 
 describe("extractNextParameters", () => {
-  it("with serpapi_pagination property", () => {
+  it("with serpapi_pagination property", async () => {
     assertEquals(
-      extractNextParameters<"google">({
+      await extractNextParameters<"google">({
         serpapi_pagination: {
           next:
             "https://serpapi.com/search.json?device=desktop&engine=google&gl=us&google_domain=google.com&hl=en&location=Austin%2C+Texas%2C+United+States&q=coffee&start=10",
@@ -51,9 +46,9 @@ describe("extractNextParameters", () => {
     );
   });
 
-  it("with pagination property", () => {
+  it("with pagination property", async () => {
     assertEquals(
-      extractNextParameters<"google_scholar_profiles">(
+      await extractNextParameters<"google_scholar_profiles">(
         {
           pagination: {
             next:
@@ -170,6 +165,15 @@ describe("haveParametersChanged", () => {
   });
 });
 
+describe("getSource", () => {
+  it("use runtime version", async () => {
+    assertMatch(
+      await getSource(),
+      /(nodejs|deno)@\d+\.\d+\.\d+,serpapi@\d+\.\d+\.\d+$/,
+    );
+  });
+});
+
 describe("buildUrl", () => {
   let urlStub: Stub;
 
@@ -181,24 +185,32 @@ describe("buildUrl", () => {
     urlStub.restore();
   });
 
-  it("with blank path and empty parameters", () => {
-    assertEquals(buildUrl("", {}), `${BASE_URL}?`);
+  it("with blank path and empty parameters", async () => {
+    assertEquals(await buildUrl("", {}), `${BASE_URL}?`);
   });
 
-  it("with path and empty parameters", () => {
-    assertEquals(buildUrl("/", {}), `${BASE_URL}/?`);
+  it("with path and empty parameters", async () => {
+    assertEquals(await buildUrl("/", {}), `${BASE_URL}/?`);
   });
 
-  it("with path and parameters", () => {
+  it("with path and parameters", async () => {
     assertEquals(
-      buildUrl("/search", { q: "coffee", gl: "us" }),
+      await buildUrl("/search", { q: "coffee", gl: "us" }),
       `${BASE_URL}/search?q=coffee&gl=us`,
     );
   });
 
-  it("with undefined parameters", () => {
+  it("with source", async () => {
+    const url = await buildUrl("/search", { source: await getSource() });
+    assertMatch(
+      url,
+      /source=(nodejs|deno)%40\d+\.\d+\.\d+%2Cserpapi%40\d+\.\d+\.\d+$/,
+    );
+  });
+
+  it("with undefined parameters", async () => {
     assertEquals(
-      buildUrl("/search", { q: "coffee", gl: undefined, hl: null }),
+      await buildUrl("/search", { q: "coffee", gl: undefined, hl: null }),
       `${BASE_URL}/search?q=coffee&hl=null`,
     );
   });
@@ -218,27 +230,6 @@ describe("execute", {
     urlStub.restore();
   });
 
-  it("with path and parameters calls fetch with source appended", async () => {
-    const fetchStub = stub(
-      _internals,
-      "fetch",
-      resolvesNext([new Response("data")]),
-    );
-    try {
-      await execute("/search", { q: "coffee", gl: "us" }, 4000);
-    } finally {
-      fetchStub.restore();
-    }
-
-    assertSpyCalls(fetchStub, 1);
-    const url = fetchStub.calls[0].args[0] as string;
-    // e.g. deno@1.28.2,serpapi@1.0.0
-    assertMatch(
-      url,
-      /source=(nodejs|deno)%40\d+\.\d+\.\d+%2Cserpapi%40\d+\.\d+\.\d+$/,
-    );
-  });
-
   it("with short timeout", () => {
     assertRejects(async () =>
       await execute("/search", { q: "coffee", gl: "us" }, 1)