@knime/utils 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @knime/utils
 
+## 1.1.2
+
+### Patch Changes
+
+- 15a4479: add utilities for file extensions
+
+## 1.1.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @knime/styles@1.1.1
+
 ## 1.1.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knime/utils",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Internal utility functions and constants shared across @knime packages.",
   "homepage": "https://knime.github.io/webapps-common/",
   "license": "GPL 3 and Additional Permissions according to Sec. 7 (SEE the file LICENSE)",
@@ -10,13 +10,13 @@
     "consola": "3.2.3",
     "date-fns": "2.30.0",
     "date-fns-tz": "2.0.0",
-    "@knime/styles": "1.1.0"
+    "@knime/styles": "1.1.1"
   },
   "main": "src/index.ts",
   "module": "src/index.ts",
   "files": [
     "src",
-    "!src/__tests__",
+    "!src/**/__tests__/*",
     "test-utils",
     "CHANGELOG.md"
   ],

package/src/fileExtensions.ts

@@ -0,0 +1,68 @@
+export const getFileExtension = (nameOrPath: string) => {
+  const basename = nameOrPath.split(/[\\/]/).pop();
+  const position = basename?.lastIndexOf(".") as number;
+
+  if (basename === "" || position < 1) {
+    return "";
+  }
+
+  return basename?.slice(position + 1);
+};
+
+/**
+ * Metadata for .knar files, which corresponds to exported KNIME Workflow Groups
+ * or Components
+ */
+const KNAR = Object.freeze({
+  extension: "knar",
+  mimeType: "application/vnd.knime.workflow-group+zip",
+  matches(file: File) {
+    const extension = getFileExtension(file.name);
+    return extension === this.extension;
+  },
+});
+
+/**
+ * Metadata for .knwf files, which corresponds to exported KNIME Workflows
+ */
+const KNWF = Object.freeze({
+  extension: "knwf",
+  mimeType: "application/vnd.knime.workflow+zip",
+  matches(file: File) {
+    const extension = getFileExtension(file.name);
+    return extension === this.extension;
+  },
+});
+
+export const knimeFileFormats = { KNAR, KNWF };
+
+/**
+ * Gets the mime type from a given file. Defaults to `application/octet-stream`
+ * if mimeType cannot be detected
+ * @param file File
+ * @returns mimeType
+ */
+export const getFileMimeType = (file: File): string => {
+  const DEFAULT_MIMETYPE = "application/octet-stream";
+
+  const extension = getFileExtension(file.name);
+
+  if (!extension) {
+    return DEFAULT_MIMETYPE;
+  }
+
+  if (KNWF.matches(file)) {
+    return KNWF.mimeType;
+  }
+
+  if (KNAR.matches(file)) {
+    return KNAR.mimeType;
+  }
+
+  // file has extension but unrecognizable mime type
+  if (!file.type) {
+    return DEFAULT_MIMETYPE;
+  }
+
+  return file.type;
+};

package/src/index.ts

@@ -45,6 +45,8 @@ export namespace UploadManagerNS {
   export type UploadStateName = _UploadStateName;
 }
 
+export * from "./fileExtensions";
+
 export {
   uploadManager,
   promise,

package/src/uploadManager/index.ts

@@ -56,12 +56,22 @@ const uploadChunkWithProgress = (params: {
         // https://datatracker.ietf.org/doc/html/rfc7232#section-2.3
         resolve({ partId: etag.replace(/^(?:W\/)?"|"$/g, "") });
       } else {
-        reject(new Error(`Failed to upload chunk ${chunkIndex}`));
+        consola.error("Failed or unexpected XHR response", {
+          xhrStatus: xhr.status,
+          xhrResponse: xhr.response,
+          chunkIndex,
+        });
+        reject(new Error("Failed to upload file"));
       }
     };
 
-    xhr.onerror = () =>
-      reject(new Error(`Failed to upload chunk ${chunkIndex}`));
+    xhr.onerror = (event) => {
+      consola.error("Failed to upload chunk", {
+        xhrErrorEvent: event,
+        chunkIndex,
+      });
+      reject(new Error("Failed to upload file"));
+    };
 
     xhr.send(chunk);
   });

package/src/promise/__tests__/createAbortablePromise.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import flushPromises from "flush-promises";
-
-import { AbortError, createAbortablePromise } from "../createAbortablePromise";
-
-describe("createAbortablePromise", () => {
-  it("should abort promise", async () => {
-    const mockFetchCall = () =>
-      new Promise((r) => setTimeout(() => r("resolved-value"), 300));
-
-    const { abortController, runAbortablePromise } = createAbortablePromise();
-
-    const catchSpy = vi.fn((e) => {
-      if (e instanceof AbortError) {
-        return "aborted";
-      }
-
-      throw e;
-    });
-
-    const promise = runAbortablePromise(() => mockFetchCall()).catch(catchSpy);
-
-    const abortError = new AbortError("aborting");
-    abortController.abort(abortError);
-
-    await flushPromises();
-
-    expect(catchSpy).toHaveBeenCalledWith(abortError);
-    expect(promise).resolves.toBe("aborted");
-  });
-});

package/src/promise/__tests__/retryPromise.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import { retryPromise } from "../retryPromise";
-
-describe("retryPromise", () => {
-  it("should retry", async () => {
-    let callCount = 0;
-    const mockFetchCall = vi.fn(
-      () =>
-        new Promise((resolve, reject) => {
-          callCount++;
-
-          if (callCount < 3) {
-            reject(new Error("failure"));
-            return;
-          }
-
-          if (callCount >= 3) {
-            resolve("success");
-          }
-        }),
-    );
-
-    const doneSpy = vi.fn();
-    const catchSpy = vi.fn();
-
-    const promise = retryPromise(() => mockFetchCall())
-      .then(doneSpy)
-      .catch(catchSpy);
-
-    await promise;
-
-    expect(doneSpy).toHaveBeenCalledOnce();
-    expect(catchSpy).not.toHaveBeenCalled();
-    expect(mockFetchCall).toHaveBeenCalledTimes(3);
-  });
-
-  it("should throw if retry count is exceeded", async () => {
-    const error = new Error("failure");
-    const mockFetchCall = vi.fn(() => Promise.reject(error));
-
-    const doneSpy = vi.fn();
-
-    const promise = retryPromise(() => mockFetchCall()).then(doneSpy);
-
-    await promise.catch(() => {}); // ignore errors caught by test
-    expect(() => promise).rejects.toThrowError(error);
-
-    expect(doneSpy).not.toHaveBeenCalled();
-    expect(mockFetchCall).toHaveBeenCalledTimes(6);
-  });
-
-  it("should not retry for specific errors", async () => {
-    class MyError extends Error {}
-    const myError = new MyError("failure");
-    const mockFetchCall = vi.fn(() => Promise.reject(myError));
-
-    const doneSpy = vi.fn();
-
-    const promise = retryPromise(
-      () => mockFetchCall(),
-      2,
-      0,
-      (e) => e instanceof MyError,
-    ).then(doneSpy);
-
-    await promise.catch(() => {}); // ignore errors caught by test
-    expect(() => promise).rejects.toThrowError(myError);
-
-    expect(doneSpy).not.toHaveBeenCalled();
-    expect(mockFetchCall).toHaveBeenCalledOnce();
-  });
-});

package/src/uploadManager/__tests__/index.test.ts

@@ -1,302 +0,0 @@
-/* eslint-disable vitest/no-disabled-tests */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { newServer } from "mock-xmlhttprequest";
-
-import { createUploadManager } from "..";
-
-describe("uploadManager", () => {
-  const fiftyBytes = new Array(50).fill("A");
-
-  const file = new File(fiftyBytes, "mock-file.txt", {
-    type: "text/plain",
-  });
-
-  type MockXHRHandler = NonNullable<Parameters<typeof newServer>[0]>[string][1];
-
-  const defaultUploadPartResponse: MockXHRHandler = {
-    // status: 200 is the default
-    headers: { "Content-Type": "application/json", Etag: '"partId"' },
-    body: "{}",
-  };
-
-  type Options = {
-    uploadPartResponse?: MockXHRHandler;
-  };
-
-  const setup = ({ uploadPartResponse }: Options = {}) => {
-    const server = newServer({
-      put: ["/success", uploadPartResponse ?? defaultUploadPartResponse],
-    });
-
-    server.install();
-
-    return { server };
-  };
-
-  const mockUploadURLMetadata = { method: "PUT", url: "/success" };
-  const resolveFilePartUploadURL = vi.fn();
-
-  beforeEach(() => {
-    resolveFilePartUploadURL.mockImplementation(() =>
-      Promise.resolve(mockUploadURLMetadata),
-    );
-  });
-
-  const createIdGenerator = () => {
-    const generator = (function* () {
-      let id = 0;
-      while (true) {
-        yield id++;
-      }
-    })();
-
-    return () => `mock-upload--${generator.next().value}`;
-  };
-
-  const getUploadId = createIdGenerator();
-
-  describe("success", () => {
-    it("should handle `uploadFiles`", async () => {
-      setup();
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-      });
-
-      const uploadId = getUploadId();
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId, file },
-      ]);
-
-      expect(completed).toEqual([uploadId]);
-      expect(failed.length).toBe(0);
-      expect(cancelled.length).toBe(0);
-      expect(resolveFilePartUploadURL).toHaveBeenCalled();
-    });
-
-    it("should succeed if resolveFilePartUrl is retried successfully", async () => {
-      let callCount = 0;
-      resolveFilePartUploadURL.mockImplementation(() => {
-        callCount++;
-        if (callCount < 2) {
-          return Promise.reject(new Error("error that will be retried"));
-        }
-
-        return Promise.resolve(mockUploadURLMetadata);
-      });
-
-      setup();
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-      });
-
-      const uploadId = getUploadId();
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId, file },
-      ]);
-
-      expect(completed).toEqual([uploadId]);
-      expect(failed.length).toBe(0);
-      expect(cancelled.length).toBe(0);
-      expect(resolveFilePartUploadURL).toHaveBeenCalled();
-    });
-
-    it("should succeed if uploadPart request is retried successfully", async () => {
-      let callCount = 0;
-      setup({
-        uploadPartResponse: (request) => {
-          callCount++;
-          if (callCount <= 3) {
-            request.respond(400, {});
-          }
-
-          request.respond(200, { Etag: '"partId"' });
-        },
-      });
-
-      const uploadId = getUploadId();
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-      });
-
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId, file },
-      ]);
-
-      expect(completed).toEqual([uploadId]);
-      expect(failed.length).toBe(0);
-      expect(cancelled.length).toBe(0);
-      expect(resolveFilePartUploadURL).toHaveBeenCalled();
-    });
-  });
-
-  describe("callbacks", () => {
-    it("should call onFileUploadComplete", async () => {
-      setup();
-      const onComplete = vi.fn();
-      const onFailed = vi.fn();
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-        onFileUploadComplete: onComplete,
-        onFileUploadFailed: onFailed,
-      });
-
-      const uploadId1 = getUploadId();
-      const uploadId2 = getUploadId();
-
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId: uploadId1, file },
-        { uploadId: uploadId2, file },
-      ]);
-
-      expect(completed).toEqual([uploadId1, uploadId2]);
-      expect(failed.length).toBe(0);
-      expect(cancelled.length).toBe(0);
-      expect(onComplete).toHaveBeenCalledWith({
-        uploadId: uploadId1,
-        filePartIds: { 1: "partId" },
-      });
-      expect(onComplete).toHaveBeenCalledWith({
-        uploadId: uploadId2,
-        filePartIds: { 1: "partId" },
-      });
-      expect(onFailed).not.toHaveBeenCalled();
-    });
-
-    it("should call onFileUploadFailed", async () => {
-      setup({
-        uploadPartResponse: (request) => {
-          request.respond(400, {});
-        },
-      });
-      const onComplete = vi.fn();
-      const onFailed = vi.fn();
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-        onFileUploadComplete: onComplete,
-        onFileUploadFailed: onFailed,
-      });
-
-      const uploadId1 = getUploadId();
-      const uploadId2 = getUploadId();
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId: uploadId1, file },
-        { uploadId: uploadId2, file },
-      ]);
-
-      expect(completed.length).toBe(0);
-      expect(failed).toEqual([uploadId1, uploadId2]);
-      expect(cancelled.length).toBe(0);
-      expect(onFailed).toHaveBeenCalledWith(
-        uploadId1,
-        new Error("Failed to upload chunk 0"),
-      );
-      expect(onFailed).toHaveBeenCalledWith(
-        uploadId2,
-        new Error("Failed to upload chunk 0"),
-      );
-      expect(onComplete).not.toHaveBeenCalled();
-    });
-
-    it("should call onProgress callback", async () => {
-      setup();
-      const onProgress = vi.fn();
-
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-        onProgress,
-      });
-
-      await uploadFiles([{ uploadId: getUploadId(), file }]);
-
-      expect(onProgress).toHaveBeenCalled();
-    });
-  });
-
-  describe("cancellation", () => {
-    it("should handle cancellation", async () => {
-      setup();
-      const { uploadFiles, cancel } = createUploadManager({
-        resolveFilePartUploadURL,
-      });
-
-      const uploadId = getUploadId();
-      const upload = uploadFiles([{ uploadId, file }]);
-
-      cancel(uploadId);
-
-      const { completed, cancelled, failed } = await upload;
-      expect(completed.length).toBe(0);
-      expect(cancelled).toEqual([uploadId]);
-      expect(failed.length).toBe(0);
-    });
-  });
-
-  describe("failures", () => {
-    it("should fail when resolving upload url fails", async () => {
-      resolveFilePartUploadURL.mockImplementation(() =>
-        Promise.reject(new Error("error")),
-      );
-
-      setup();
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-      });
-
-      const uploadId = getUploadId();
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId, file },
-      ]);
-
-      expect(completed.length).toBe(0);
-      expect(failed).toEqual([uploadId]);
-      expect(cancelled.length).toBe(0);
-      expect(resolveFilePartUploadURL).toHaveBeenCalled();
-    });
-
-    it("should fail when uploading part request fails", async () => {
-      setup({
-        uploadPartResponse: (request) => {
-          request.respond(400, {});
-        },
-      });
-
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-      });
-
-      const uploadId = getUploadId();
-
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId, file },
-      ]);
-
-      expect(completed.length).toBe(0);
-      expect(failed).toEqual([uploadId]);
-      expect(cancelled.length).toBe(0);
-      expect(resolveFilePartUploadURL).toHaveBeenCalled();
-    });
-
-    it("should fail when etag is missing from upload part response", async () => {
-      setup({
-        uploadPartResponse: (request) => {
-          request.respond(200, {});
-        },
-      });
-
-      const { uploadFiles } = createUploadManager({
-        resolveFilePartUploadURL,
-      });
-
-      const uploadId = getUploadId();
-
-      const { completed, failed, cancelled } = await uploadFiles([
-        { uploadId, file },
-      ]);
-
-      expect(completed.length).toBe(0);
-      expect(failed).toEqual([uploadId]);
-      expect(cancelled.length).toBe(0);
-      expect(resolveFilePartUploadURL).toHaveBeenCalled();
-    });
-  });
-});