Change notification when extension is not found (#5184)

* Change notification when extension is not found

- Removes legacy downloadFile and downloadJson in favour of using
  `node-fetch`

- A notification will be displayed if the URL provided results in a
  status of 404

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Resolve PR comments

Signed-off-by: Sebastian Malton <sebastian@malton.name>

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/common/fetch/download-binary.injectable.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { RequestInit, Response } from "node-fetch";
+import type { AsyncResult } from "../utils/async-result";
+import fetchInjectable from "./fetch.injectable";
+
+export interface DownloadBinaryOptions {
+  signal?: AbortSignal | null | undefined;
+}
+
+export type DownloadBinary = (url: string, opts?: DownloadBinaryOptions) => Promise<AsyncResult<Buffer, string>>;
+
+const downloadBinaryInjectable = getInjectable({
+  id: "download-binary",
+  instantiate: (di): DownloadBinary => {
+    const fetch = di.inject(fetchInjectable);
+
+    return async (url, opts) => {
+      let result: Response;
+
+      try {
+        // TODO: upgrade node-fetch once we switch to ESM
+        result = await fetch(url, opts as RequestInit);
+      } catch (error) {
+        return {
+          callWasSuccessful: false,
+          error: String(error),
+        };
+      }
+
+      if (result.status < 200 || 300 <= result.status) {
+        return {
+          callWasSuccessful: false,
+          error: result.statusText,
+        };
+      }
+
+      try {
+        return {
+          callWasSuccessful: true,
+          response: await result.buffer(),
+        };
+      } catch (error) {
+        return {
+          callWasSuccessful: false,
+          error: String(error),
+        };
+      }
+    };
+  },
+});
+
+export default downloadBinaryInjectable;

src/common/fetch/download-json.injectable.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { RequestInit, Response } from "node-fetch";
+import type { JsonValue } from "type-fest";
+import type { AsyncResult } from "../utils/async-result";
+import fetchInjectable from "./fetch.injectable";
+
+export interface DownloadJsonOptions {
+  signal?: AbortSignal | null | undefined;
+}
+
+export type DownloadJson = (url: string, opts?: DownloadJsonOptions) => Promise<AsyncResult<JsonValue, string>>;
+
+const downloadJsonInjectable = getInjectable({
+  id: "download-json",
+  instantiate: (di): DownloadJson => {
+    const fetch = di.inject(fetchInjectable);
+
+    return async (url, opts) => {
+      let result: Response;
+
+      try {
+        result = await fetch(url, opts as RequestInit);
+      } catch (error) {
+        return {
+          callWasSuccessful: false,
+          error: String(error),
+        };
+      }
+
+      if (result.status < 200 || 300 <= result.status) {
+        return {
+          callWasSuccessful: false,
+          error: result.statusText,
+        };
+      }
+
+      try {
+        return {
+          callWasSuccessful: true,
+          response: await result.json(),
+        };
+      } catch (error) {
+        return {
+          callWasSuccessful: false,
+          error: String(error),
+        };
+      }
+    };
+  },
+});
+
+export default downloadJsonInjectable;

src/common/fetch/fetch.injectable.ts

@@ -3,10 +3,10 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import type { RequestInfo, RequestInit, Response } from "node-fetch";
 import fetch from "node-fetch";
+import type { RequestInit, Response } from "node-fetch";
 
-export type Fetch = (url: RequestInfo, init?: RequestInit) => Promise<Response>;
+export type Fetch = (url: string, init?: RequestInit) => Promise<Response>;
 
 const fetchInjectable = getInjectable({
   id: "fetch",

src/common/fetch/timeout-controller.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+/**
+ * Creates an AbortController with an associated timeout
+ * @param timeout The number of milliseconds before this controller will auto abort
+ */
+export function withTimeout(timeout: number): AbortController {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+
+  controller.signal.addEventListener("abort", () => clearTimeout(id));
+
+  return controller;
+}

src/common/utils/camelCase.ts

@@ -6,7 +6,8 @@
 // Convert object's keys to camelCase format
 import { camelCase } from "lodash";
 import type { SingleOrMany } from "./types";
-import { isObject } from "./type-narrowing";
+import { isObject, isString } from "./type-narrowing";
+import * as object from "./objects";
 
 export function toCamelCase<T extends Record<string, unknown>[]>(obj: T): T;
 export function toCamelCase<T extends Record<string, unknown>>(obj: T): T;
@@ -17,11 +18,10 @@ export function toCamelCase(obj: SingleOrMany<Record<string, unknown> | unknown>
   }
 
   if (isObject(obj)) {
-    return Object.fromEntries(
-      Object.entries(obj)
-        .map(([key, value]) => {
-          return [camelCase(key), toCamelCase(value)];
-        }),
+    return object.fromEntries(
+      object.entries(obj)
+        .filter((pair): pair is [string, unknown] => isString(pair[0]))
+        .map(([key, value]) => [camelCase(key), isObject(value) ? toCamelCase(value) : value]),
     );
   }
 

src/common/utils/downloadFile.ts

@@ -1,53 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import request from "request";
-import type { JsonValue } from "type-fest";
-import { parse } from "./json";
-
-export interface DownloadFileOptions {
-  url: string;
-  gzip?: boolean;
-  timeout?: number;
-}
-
-export interface DownloadFileTicket<T> {
-  url: string;
-  promise: Promise<T>;
-  cancel(): void;
-}
-
-export function downloadFile({ url, timeout, gzip = true }: DownloadFileOptions): DownloadFileTicket<Buffer> {
-  const fileChunks: Buffer[] = [];
-  const req = request(url, { gzip, timeout });
-  const promise: Promise<Buffer> = new Promise((resolve, reject) => {
-    req.on("data", (chunk: Buffer) => {
-      fileChunks.push(chunk);
-    });
-    req.once("error", err => {
-      reject({ url, err });
-    });
-    req.once("complete", () => {
-      resolve(Buffer.concat(fileChunks));
-    });
-  });
-
-  return {
-    url,
-    promise,
-    cancel() {
-      req.abort();
-    },
-  };
-}
-
-export function downloadJson(args: DownloadFileOptions): DownloadFileTicket<JsonValue> {
-  const { promise, ...rest } = downloadFile(args);
-
-  return {
-    promise: promise.then(res => parse(res.toString())),
-    ...rest,
-  };
-}

src/common/utils/index.ts

@@ -14,7 +14,6 @@ export * from "./convertMemory";
 export * from "./debouncePromise";
 export * from "./delay";
 export * from "./disposer";
-export * from "./downloadFile";
 export * from "./escapeRegExp";
 export * from "./formatDuration";
 export * from "./getRandId";

src/common/utils/type-narrowing.ts

@@ -103,7 +103,7 @@ export function isBoolean(val: unknown): val is boolean {
  * checks if val is of type object and isn't null
  * @param val the value to be checked
  */
-export function isObject(val: unknown): val is object {
+export function isObject(val: unknown): val is Record<string | symbol | number, unknown> {
   return typeof val === "object" && val !== null;
 }