@beinformed/ui 1.65.13 → 1.65.14

package/src/utils/fetch/__tests__/xhr.spec.js

@@ -1,281 +0,0 @@
-/* eslint-disable jest/no-conditional-expect */
-import xhr from "../xhr";
-
-import {
-  FetchException,
-  UnauthorizedException,
-  TimeoutException,
-  NotFoundException,
-  JsonParseException,
-  IllegalArgumentException,
-} from "../../../exceptions";
-import xhrMock from "xhr-mock";
-import Cache from "../../browser/Cache";
-
-const JSON_TYPE = "application/json";
-
-describe("xhr", () => {
-  // replace the real XHR object with the mock XHR object before each test
-  // eslint-disable-next-line jest/no-hooks
-  beforeEach(() => xhrMock.setup());
-
-  // put the real XHR object back and clear the mocks after each test
-  // eslint-disable-next-line jest/no-hooks
-  afterEach(() => xhrMock.teardown());
-
-  it("handles simple get requests", async () => {
-    expect.assertions(2);
-
-    xhrMock.get("/", (req, res) => {
-      expect(req.header("accept")).toBe(JSON_TYPE);
-      expect(req.header("Content-Type")).toBe(JSON_TYPE);
-
-      return res.status(200).body({ data: "ok" });
-    });
-
-    await xhr({ url: "/" });
-  });
-
-  it("should throw when nothing is set or url is missing", () => {
-    expect(() => xhr()).toThrow(IllegalArgumentException);
-    expect(() => xhr("/")).toThrow(IllegalArgumentException);
-    expect(() => xhr({})).toThrow(IllegalArgumentException);
-  });
-
-  it("adds encoded params to the url", async () => {
-    expect.assertions(2);
-
-    xhrMock.use("get", "/test?param1=one&param2=tw%C3%B6", (req, res) => {
-      const { path, query } = req.url();
-
-      expect(path).toBe("/test");
-      expect(query).toMatchObject({
-        param1: "one",
-        param2: "twö",
-      });
-
-      return res.status(200);
-    });
-
-    await xhr({
-      url: "/test",
-      params: "param1=one&param2=twö",
-    });
-  });
-
-  it("adds encoded params to a url with querystring", async () => {
-    expect.assertions(2);
-
-    xhrMock.use(
-      "get",
-      "/test?param1=one&param2=two&param3=thr%C3%A9%C3%AB",
-      (req, res) => {
-        const { path, query } = req.url();
-
-        expect(path).toBe("/test");
-        expect(query).toMatchObject({
-          param1: "one",
-          param2: "two",
-          param3: "thréë",
-        });
-
-        return res.status(200).body({});
-      },
-    );
-
-    await xhr({
-      url: "/test?param1=one",
-      params: "param2=two&param3=thréë",
-    });
-  });
-
-  it("handles json response", async () => {
-    expect.assertions(1);
-
-    xhrMock.get("/", {
-      status: 200,
-      body: {
-        type: "root",
-      },
-    });
-
-    await expect(xhr({ url: "/" })).resolves.toStrictEqual({ type: "root" });
-  });
-
-  it("return JsonParseException when response is not valid json and responseType is text", async () => {
-    expect.assertions(1);
-
-    xhrMock.get("/", {
-      status: 200,
-      headers: {
-        "Content-Type": JSON_TYPE,
-      },
-      body: "root",
-    });
-
-    await expect(() => xhr({ url: "/", responseType: "text" })).rejects.toThrow(
-      JsonParseException,
-    );
-  });
-
-  it("can handle modular ui form responses", async () => {
-    expect.assertions(1);
-
-    xhrMock.post("/form", {
-      status: 400,
-      body: {
-        formresponse: {
-          form: "response",
-        },
-      },
-    });
-
-    const response = await xhr({ url: "/form", method: "post", data: "{}" });
-    expect(response).toStrictEqual({ formresponse: { form: "response" } });
-  });
-
-  it("can handle progress events", async () => {
-    expect.assertions(1);
-
-    xhrMock.post("/", {
-      status: 200,
-      headers: {
-        "Content-Length": "12",
-      },
-      body: "Hello world!",
-    });
-
-    const progressEvents = new Promise((resolve) => {
-      const events = [];
-
-      xhr({
-        url: "/",
-        method: "post",
-        /**
-         */
-        onProgress: ({ type, loaded, total, lengthComputable }) => {
-          events.push({ type, loaded, total, lengthComputable });
-
-          // eslint-disable-next-line jest/no-conditional-in-test
-          if (type === "loadend") {
-            resolve(events);
-          }
-        },
-        data: "Upload data",
-        headers: {
-          "Content-Length": "11",
-        },
-      });
-    });
-
-    await expect(progressEvents).resolves.toStrictEqual([
-      {
-        type: "loadstart",
-        lengthComputable: false,
-        loaded: 0,
-        total: 0,
-      },
-      {
-        type: "progress",
-        lengthComputable: true,
-        loaded: 12,
-        total: 12,
-      },
-      {
-        type: "load",
-        lengthComputable: true,
-        loaded: 12,
-        total: 12,
-      },
-      {
-        type: "loadend",
-        lengthComputable: true,
-        loaded: 12,
-        total: 12,
-      },
-    ]);
-  });
-
-  it("handles error response", async () => {
-    expect.assertions(3);
-    xhrMock.get("/", {
-      status: 500,
-      reason: "Internal Server Error",
-      body: {
-        error: {
-          id: "Error.GeneralError",
-        },
-      },
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(FetchException);
-      expect(error.status).toBe(500);
-      expect(error.id).toBe("Error.GeneralError");
-    });
-  });
-
-  it("handles not found response", async () => {
-    expect.assertions(3);
-    xhrMock.get("/", {
-      status: 404,
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(NotFoundException);
-      expect(error.status).toBe(404);
-      expect(error.id).toBe("NotFoundException");
-    });
-  });
-
-  it("handles unauthorized response", async () => {
-    expect.assertions(3);
-    xhrMock.get("/", {
-      status: 401,
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(UnauthorizedException);
-      expect(error.status).toBe(401);
-      expect(error.id).toBe("UnauthorizedException");
-    });
-  });
-
-  it("handles unauthorized and unexpected response", async () => {
-    expect.assertions(1);
-    xhrMock.get("/", {
-      status: 401,
-      body: {
-        has: "body?",
-      },
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(UnauthorizedException);
-    });
-  });
-
-  it("handles basic authentication", async () => {
-    expect.assertions(1);
-
-    xhrMock.get("/", (req, res) => {
-      expect(req.header("Authorization")).toBe("Basic abcdef");
-      return res.status(200);
-    });
-
-    Cache.addItem("basic", "abcdef");
-
-    await xhr({ url: "/" });
-  });
-
-  it("handles timeouts", async () => {
-    expect.assertions(2);
-
-    xhrMock.get("/", () => new Promise(() => undefined));
-
-    await xhr({ url: "/", timeout: 2000 }).catch((error) => {
-      expect(error).toBeInstanceOf(TimeoutException);
-      expect(error.name).toBe("TimeoutException");
-    });
-  });
-});

package/src/utils/fetch/serverFetch.js

@@ -1,33 +0,0 @@
-// @flow
-import { getBasePath } from "../../constants/Settings";
-import { FetchException } from "../../exceptions";
-
-import type { RequestOptions } from "./types";
-
-/**
- * Fetch data from server (uses nashorn and datafetcher).
- */
-export default function serverFetch(args: RequestOptions): Promise<any> {
-  // remove contextPath of url, when the request is internal the context path is not needed
-  const urlNoBase = args.url.includes("http")
-    ? args.url
-    : args.url.replace(getBasePath(), "");
-  const params = args.params
-    ? args.params.replace("includeContext=true", "")
-    : "";
-  const url = params === "" ? urlNoBase : `${urlNoBase}?${params}`;
-
-  const data = dataFetcher.fetch(url, args);
-
-  try {
-    const jsonData = JSON.parse(data);
-
-    if (jsonData.error) {
-      return Promise.reject(new FetchException(jsonData, null, args));
-    }
-
-    return Promise.resolve(jsonData);
-  } catch (error) {
-    return Promise.reject(error);
-  }
-}

package/src/utils/fetch/types.js

@@ -1,46 +0,0 @@
-// @flow
-import typeof { HTTP_METHODS } from "../../constants/Constants";
-import type { ModularUIModel } from "../../models/types";
-import type { TargetModel } from "../../modularui/types";
-
-export type RequestURLOptions = {
-  url: string,
-};
-
-export type RequestBaseOptions = {
-  origin?: string,
-  contextPath?: string,
-  method?: $Keys<HTTP_METHODS>,
-  params?: string,
-  data?: any,
-  timeout?: number,
-  responseType?: string,
-  headers?: {
-    [headerName: string]: string,
-    Accept?: string,
-    "Accept-Language"?: string,
-    "Content-Type"?: string,
-    "x-filename"?: string,
-    "x-filesize"?: string,
-  },
-  events?: { [eventName: string]: () => void },
-  onProgress?: ProgressEventHandler,
-  includeContext?: boolean,
-  locale?: string,
-  cache?: boolean,
-  isReload?: boolean,
-  withCredentials?: boolean,
-};
-
-export type RequestOptions = { ...RequestURLOptions, ...RequestBaseOptions };
-
-export type UpdateHandler = (newModel: ModularUIModel) => ModularUIModel;
-export type RequestModularUIOptions = {
-  ...RequestBaseOptions,
-  targetModel?: TargetModel,
-  forceTargetModel?: boolean,
-  updateHandler?: UpdateHandler | void,
-  childmodels?: boolean,
-  isValidationRequest?: boolean,
-  removeOnUnmount?: boolean,
-};

package/src/utils/fetch/universalFetch.js

@@ -1,106 +0,0 @@
-// @flow
-import { isPlainObject } from "../helpers/objects";
-
-import { IS_SYNC } from "../../constants/Constants";
-import { cacheContributions } from "../../constants";
-
-import serverFetch from "./serverFetch";
-import xhr from "./xhr";
-import Cache from "../browser/Cache";
-
-import type { RequestOptions } from "./types";
-
-type CachedResponse = any;
-
-const IS_FETCHING = "is-fetching";
-
-/**
- * Checks each x ms if a cache item is set after fetching the item.
- * @private
- */
-const waitForCachedItem = (cacheKey: string) => {
-  let TIMEOUT = 3000;
-  const CHECK_TIMEOUT = 100;
-
-  return new Promise<CachedResponse>((resolve, reject) => {
-    const check = () => {
-      if (Cache.getItem(cacheKey) !== IS_FETCHING) {
-        const cachedItem = Cache.getItem(cacheKey);
-        if (cachedItem != null) {
-          resolve(cachedItem);
-        } else {
-          reject(new Error("Empty cached item"));
-        }
-      } else if (TIMEOUT <= 0) {
-        reject(new Error("Empty cached item"));
-      } else {
-        TIMEOUT = TIMEOUT - CHECK_TIMEOUT;
-        setTimeout(check, CHECK_TIMEOUT);
-      }
-    };
-
-    setTimeout(check, CHECK_TIMEOUT);
-  });
-};
-
-/**
- * @private
- */
-const browserFetch = (args: RequestOptions) => {
-  if (cacheContributions() && args.cache) {
-    const cacheKey = Cache.createResourceKey(args);
-
-    if (Cache.hasItem(cacheKey)) {
-      const cacheItem = Cache.getItem(cacheKey);
-
-      if (cacheItem != null) {
-        if (cacheItem === IS_FETCHING) {
-          return waitForCachedItem(cacheKey);
-        } else if (isPlainObject(cacheItem)) {
-          return Promise.resolve(cacheItem);
-        }
-      }
-    }
-
-    Cache.addItem(cacheKey, IS_FETCHING);
-  }
-
-  return xhr(args).then((response) => {
-    if (cacheContributions() && args.cache) {
-      const cacheKey = Cache.createResourceKey(args);
-
-      Cache.addItem(cacheKey, response);
-    }
-
-    return response;
-  });
-};
-
-/**
- * Request data from server, uses server datafetcher or xhr in browser.
- */
-const universalFetch = (
-  args: RequestOptions,
-): Promise<CachedResponse> | Promise<any> => {
-  // Set locale as Accept-Language header
-  if (args.locale) {
-    // $FlowFixMe
-    args.headers = {
-      ...args.headers,
-      "Accept-Language": args.locale,
-    };
-  }
-
-  if (args.includeContext) {
-    args.url = `${args.url}?includeContext=true`;
-  }
-
-  // server side no access to the browser cache apis, no cache available
-  if (IS_SYNC) {
-    return serverFetch(args);
-  }
-
-  return browserFetch(args);
-};
-
-export default universalFetch;