@scm-manager/ui-api 2.36.1 → 2.36.2-20220522-120507

package/src/apiclient.test.ts

@@ -1,126 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020-present Cloudogu GmbH and Contributors
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-import { apiClient, createUrl, extractXsrfTokenFromCookie } from "./apiclient";
-import fetchMock from "fetch-mock";
-import { BackendError, BadGatewayError } from "./errors";
-
-describe("create url", () => {
-  it("should not change absolute urls", () => {
-    expect(createUrl("https://www.scm-manager.org")).toBe("https://www.scm-manager.org");
-  });
-
-  it("should add prefix for api", () => {
-    expect(createUrl("/users")).toBe("/api/v2/users");
-    expect(createUrl("users")).toBe("/api/v2/users");
-  });
-});
-
-describe("error handling tests", () => {
-  const earthNotFoundError = {
-    transactionId: "42t",
-    errorCode: "42e",
-    message: "earth not found",
-    context: [
-      {
-        type: "planet",
-        id: "earth"
-      }
-    ]
-  };
-
-  afterEach(() => {
-    fetchMock.reset();
-    fetchMock.restore();
-  });
-
-  it("should create a normal error, if the content type is not scmm-error", done => {
-    fetchMock.getOnce("/api/v2/error", {
-      status: 404
-    });
-
-    apiClient.get("/error").catch((err: Error) => {
-      expect(err.name).toEqual("Error");
-      expect(err.message).toContain("404");
-      done();
-    });
-  });
-
-  it("should create a bad gateway error", done => {
-    fetchMock.getOnce("/api/v2/error", {
-      status: 502
-    });
-
-    apiClient.get("/error").catch((err: Error) => {
-      expect(err).toBeInstanceOf(BadGatewayError);
-      done();
-    });
-  });
-
-  it("should create an backend error, if the content type is scmm-error", done => {
-    fetchMock.getOnce("/api/v2/error", {
-      status: 404,
-      headers: {
-        "Content-Type": "application/vnd.scmm-error+json;v=2"
-      },
-      body: earthNotFoundError
-    });
-
-    apiClient.get("/error").catch((err: BackendError) => {
-      expect(err).toBeInstanceOf(BackendError);
-
-      expect(err.message).toEqual("earth not found");
-      expect(err.statusCode).toBe(404);
-
-      expect(err.transactionId).toEqual("42t");
-      expect(err.errorCode).toEqual("42e");
-      expect(err.context).toEqual([
-        {
-          type: "planet",
-          id: "earth"
-        }
-      ]);
-      done();
-    });
-  });
-});
-
-describe("extract xsrf token", () => {
-  it("should return undefined if no cookie exists", () => {
-    const token = extractXsrfTokenFromCookie(undefined);
-    expect(token).toBeUndefined();
-  });
-
-  it("should return undefined without X-Bearer-Token exists", () => {
-    const token = extractXsrfTokenFromCookie("a=b; c=d; e=f");
-    expect(token).toBeUndefined();
-  });
-
-  it("should return xsrf token", () => {
-    const cookie =
-      "a=b; X-Bearer-Token=eyJhbGciOiJIUzI1NiJ9.eyJ4c3JmIjoiYjE0NDRmNWEtOWI5Mi00ZDA0LWFkMzMtMTAxYjY3MWQ1YTc0Iiwic3ViIjoic2NtYWRtaW4iLCJqdGkiOiI2RFJpQVphNWwxIiwiaWF0IjoxNTc0MDcyNDQ4LCJleHAiOjE1NzQwNzYwNDgsInNjbS1tYW5hZ2VyLnJlZnJlc2hFeHBpcmF0aW9uIjoxNTc0MTE1NjQ4OTU5LCJzY20tbWFuYWdlci5wYXJlbnRUb2tlbklkIjoiNkRSaUFaYTVsMSJ9.VUJtKeWUn3xtHCEbG51r7ceXZ8CF3cmN8J-eb9EDY_U; c=d";
-    const token = extractXsrfTokenFromCookie(cookie);
-    expect(token).toBe("b1444f5a-9b92-4d04-ad33-101b671d5a74");
-  });
-});

package/src/apiclient.ts

@@ -1,336 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020-present Cloudogu GmbH and Contributors
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-import { contextPath } from "./urls";
-import {
-  BackendErrorContent,
-  BadGatewayError,
-  createBackendError,
-  ForbiddenError,
-  isBackendError,
-  TOKEN_EXPIRED_ERROR_CODE,
-  TokenExpiredError,
-  UnauthorizedError
-} from "./errors";
-
-type SubscriptionEvent = {
-  type: string;
-};
-
-type OpenEvent = SubscriptionEvent;
-
-type ErrorEvent = SubscriptionEvent & {
-  error: Error;
-};
-
-type MessageEvent = SubscriptionEvent & {
-  data: string;
-  lastEventId?: string;
-};
-
-type MessageListeners = {
-  [eventType: string]: (event: MessageEvent) => void;
-};
-
-type SubscriptionContext = {
-  onOpen?: OpenEvent;
-  onMessage: MessageListeners;
-  onError?: ErrorEvent;
-};
-
-type SubscriptionArgument = MessageListeners | SubscriptionContext;
-
-type Cancel = () => void;
-
-const sessionId = (
-  Date.now().toString(36) +
-  Math.random()
-    .toString(36)
-    .substr(2, 5)
-).toUpperCase();
-
-const extractXsrfTokenFromJwt = (jwt: string) => {
-  const parts = jwt.split(".");
-  if (parts.length === 3) {
-    return JSON.parse(atob(parts[1])).xsrf;
-  }
-};
-
-// @VisibleForTesting
-export const extractXsrfTokenFromCookie = (cookieString?: string) => {
-  if (cookieString) {
-    const cookies = cookieString.split(";");
-    for (const c of cookies) {
-      const parts = c.trim().split("=");
-      if (parts[0] === "X-Bearer-Token" || parts[0] === "X-SCM-Init-Token") {
-        return extractXsrfTokenFromJwt(parts[1]);
-      }
-    }
-  }
-};
-
-const extractXsrfToken = () => {
-  return extractXsrfTokenFromCookie(document.cookie);
-};
-
-const createRequestHeaders = () => {
-  const headers: { [key: string]: string } = {
-    // disable caching for now
-    Cache: "no-cache",
-    // identify the request as ajax request
-    "X-Requested-With": "XMLHttpRequest",
-    // identify the web interface
-    "X-SCM-Client": "WUI",
-    // identify the window session
-    "X-SCM-Session-ID": sessionId
-  };
-
-  const xsrf = extractXsrfToken();
-  if (xsrf) {
-    headers["X-XSRF-Token"] = xsrf;
-  }
-  return headers;
-};
-
-const applyFetchOptions: (p: RequestInit) => RequestInit = o => {
-  if (o.headers) {
-    o.headers = {
-      ...createRequestHeaders()
-    };
-  } else {
-    o.headers = createRequestHeaders();
-  }
-  o.credentials = "same-origin";
-  return o;
-};
-
-function handleFailure(response: Response) {
-  if (!response.ok) {
-    if (response.status === 401) {
-      if (isBackendError(response)) {
-        return response.json().then((content: BackendErrorContent) => {
-          if (content.errorCode === TOKEN_EXPIRED_ERROR_CODE) {
-            throw new TokenExpiredError("Token expired", 401);
-          } else {
-            throw new UnauthorizedError("Unauthorized", 401);
-          }
-        });
-      }
-      throw new UnauthorizedError("Unauthorized", 401);
-    } else if (response.status === 403) {
-      throw new ForbiddenError("Forbidden", 403);
-    } else if (response.status === 502) {
-      throw new BadGatewayError("Bad Gateway", 502);
-    } else if (isBackendError(response)) {
-      return response.json().then((content: BackendErrorContent) => {
-        throw createBackendError(content, response.status);
-      });
-    } else {
-      throw new Error("server returned status code " + response.status);
-    }
-  }
-  return response;
-}
-
-export function createUrl(url: string) {
-  if (url.includes("://")) {
-    return url;
-  }
-  let urlWithStartingSlash = url;
-  if (url.indexOf("/") !== 0) {
-    urlWithStartingSlash = "/" + urlWithStartingSlash;
-  }
-  return `${contextPath}/api/v2${urlWithStartingSlash}`;
-}
-
-export function createUrlWithIdentifiers(url: string): string {
-  return createUrl(url) + "?X-SCM-Client=WUI&X-SCM-Session-ID=" + sessionId;
-}
-
-type ErrorListener = (error: Error) => void;
-
-type RequestListener = (url: string, options?: RequestInit) => void;
-
-class ApiClient {
-  errorListeners: ErrorListener[] = [];
-  requestListeners: RequestListener[] = [];
-
-  get = (url: string): Promise<Response> => {
-    return this.request(url, applyFetchOptions({}))
-      .then(handleFailure)
-      .catch(this.notifyAndRethrow);
-  };
-
-  post = (
-    url: string,
-    payload?: any,
-    contentType = "application/json",
-    additionalHeaders: Record<string, string> = {}
-  ) => {
-    return this.httpRequestWithJSONBody("POST", url, contentType, additionalHeaders, payload);
-  };
-
-  postText = (url: string, payload: string, additionalHeaders: Record<string, string> = {}) => {
-    return this.httpRequestWithTextBody("POST", url, additionalHeaders, payload);
-  };
-
-  putText = (url: string, payload: string, additionalHeaders: Record<string, string> = {}) => {
-    return this.httpRequestWithTextBody("PUT", url, additionalHeaders, payload);
-  };
-
-  postBinary = (url: string, fileAppender: (p: FormData) => void, additionalHeaders: Record<string, string> = {}) => {
-    const formData = new FormData();
-    fileAppender(formData);
-
-    const options: RequestInit = {
-      method: "POST",
-      body: formData,
-      headers: additionalHeaders
-    };
-    return this.httpRequestWithBinaryBody(options, url);
-  };
-
-  put(url: string, payload: any, contentType = "application/json", additionalHeaders: Record<string, string> = {}) {
-    return this.httpRequestWithJSONBody("PUT", url, contentType, additionalHeaders, payload);
-  }
-
-  head = (url: string) => {
-    let options: RequestInit = {
-      method: "HEAD"
-    };
-    options = applyFetchOptions(options);
-    return this.request(url, options)
-      .then(handleFailure)
-      .catch(this.notifyAndRethrow);
-  };
-
-  delete = (url: string): Promise<Response> => {
-    let options: RequestInit = {
-      method: "DELETE"
-    };
-    options = applyFetchOptions(options);
-    return this.request(url, options)
-      .then(handleFailure)
-      .catch(this.notifyAndRethrow);
-  };
-
-  httpRequestWithJSONBody = (
-    method: string,
-    url: string,
-    contentType: string,
-    additionalHeaders: Record<string, string>,
-    payload?: any
-  ): Promise<Response> => {
-    const options: RequestInit = {
-      method: method,
-      headers: additionalHeaders
-    };
-    if (payload) {
-      options.body = JSON.stringify(payload);
-    }
-    return this.httpRequestWithBinaryBody(options, url, contentType);
-  };
-
-  httpRequestWithTextBody = (
-    method: string,
-    url: string,
-    additionalHeaders: Record<string, string> = {},
-    payload: string
-  ) => {
-    const options: RequestInit = {
-      method: method,
-      headers: additionalHeaders
-    };
-    options.body = payload;
-    return this.httpRequestWithBinaryBody(options, url, "text/plain");
-  };
-
-  httpRequestWithBinaryBody = (options: RequestInit, url: string, contentType?: string) => {
-    options = applyFetchOptions(options);
-    if (contentType) {
-      if (!options.headers) {
-        options.headers = {};
-      }
-      // @ts-ignore We are sure that here we only get headers of type {[name:string]: string}
-      options.headers["Content-Type"] = contentType;
-    }
-
-    return this.request(url, options)
-      .then(handleFailure)
-      .catch(this.notifyAndRethrow);
-  };
-
-  subscribe(url: string, argument: SubscriptionArgument): Cancel {
-    const es = new EventSource(createUrlWithIdentifiers(url), {
-      withCredentials: true
-    });
-
-    let listeners: MessageListeners;
-    // type guard, to identify that argument is of type SubscriptionContext
-    if ("onMessage" in argument) {
-      listeners = (argument as SubscriptionContext).onMessage;
-      if (argument.onError) {
-        // @ts-ignore typing of EventSource is weird
-        es.onerror = argument.onError;
-      }
-      if (argument.onOpen) {
-        // @ts-ignore typing of EventSource is weird
-        es.onopen = argument.onOpen;
-      }
-    } else {
-      listeners = argument;
-    }
-
-    for (const type in listeners) {
-      // @ts-ignore typing of EventSource is weird
-      es.addEventListener(type, listeners[type]);
-    }
-
-    return () => es.close();
-  }
-
-  onRequest = (requestListener: RequestListener) => {
-    this.requestListeners.push(requestListener);
-  };
-
-  onError = (errorListener: ErrorListener) => {
-    this.errorListeners.push(errorListener);
-  };
-
-  private request = (url: string, options: RequestInit) => {
-    this.notifyRequestListeners(url, options);
-    return fetch(createUrl(url), options);
-  };
-
-  private notifyRequestListeners = (url: string, options: RequestInit) => {
-    this.requestListeners.forEach(requestListener => requestListener(url, options));
-  };
-
-  private notifyAndRethrow = (error: Error): never => {
-    this.errorListeners.forEach(errorListener => errorListener(error));
-    throw error;
-  };
-}
-
-export const apiClient = new ApiClient();

package/src/base.test.ts

@@ -1,238 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020-present Cloudogu GmbH and Contributors
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-import fetchMock from "fetch-mock-jest";
-import { useIndex, useIndexJsonResource, useIndexLink, useIndexLinks, useRequiredIndexLink, useVersion } from "./base";
-import { renderHook } from "@testing-library/react-hooks";
-import { LegacyContext } from "./LegacyContext";
-import { IndexResources, Link } from "@scm-manager/ui-types";
-import createWrapper from "./tests/createWrapper";
-import { QueryClient } from "react-query";
-
-describe("Test base api hooks", () => {
-  describe("useIndex tests", () => {
-    fetchMock.get("/api/v2/", {
-      version: "x.y.z",
-      _links: {}
-    });
-
-    it("should return index", async () => {
-      const { result, waitFor } = renderHook(() => useIndex(), { wrapper: createWrapper() });
-      await waitFor(() => {
-        return !!result.current.data;
-      });
-      expect(result.current?.data?.version).toEqual("x.y.z");
-    });
-
-    it("should call onIndexFetched of LegacyContext", async () => {
-      let index: IndexResources;
-      const context: LegacyContext = {
-        onIndexFetched: fetchedIndex => {
-          index = fetchedIndex;
-        },
-        initialize: () => null
-      };
-      const { result, waitFor } = renderHook(() => useIndex(), { wrapper: createWrapper(context) });
-      await waitFor(() => {
-        return !!result.current.data;
-      });
-      expect(index!.version).toEqual("x.y.z");
-    });
-  });
-
-  describe("useIndexLink tests", () => {
-    it("should throw an error if index is not available", () => {
-      const { result } = renderHook(() => useIndexLink("spaceships"), { wrapper: createWrapper() });
-      expect(result.error).toBeDefined();
-    });
-
-    it("should return undefined for unknown link", () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z",
-        _links: {}
-      });
-      const { result } = renderHook(() => useIndexLink("spaceships"), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-      expect(result.current).toBeUndefined();
-    });
-
-    it("should return undefined for link array", () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z",
-        _links: {
-          spaceships: [
-            {
-              name: "heartOfGold",
-              href: "/spaceships/heartOfGold"
-            },
-            {
-              name: "razorCrest",
-              href: "/spaceships/razorCrest"
-            }
-          ]
-        }
-      });
-      const { result } = renderHook(() => useIndexLink("spaceships"), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-      expect(result.current).toBeUndefined();
-    });
-
-    it("should return link", () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z",
-        _links: {
-          spaceships: {
-            href: "/api/spaceships"
-          }
-        }
-      });
-      const { result } = renderHook(() => useIndexLink("spaceships"), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-      expect(result.current).toBe("/api/spaceships");
-    });
-  });
-
-  describe("useIndexLinks tests", () => {
-    it("should throw an error if index is not available", async () => {
-      const { result } = renderHook(() => useIndexLinks(), { wrapper: createWrapper() });
-      expect(result.error).toBeDefined();
-    });
-
-    it("should return links", () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z",
-        _links: {
-          spaceships: {
-            href: "/api/spaceships"
-          }
-        }
-      });
-      const { result } = renderHook(() => useIndexLinks(), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-      expect((result.current!.spaceships as Link).href).toBe("/api/spaceships");
-    });
-  });
-
-  describe("useVersion tests", () => {
-    it("should throw an error if version is not available", async () => {
-      const { result } = renderHook(() => useVersion(), { wrapper: createWrapper() });
-      expect(result.error).toBeDefined();
-    });
-
-    it("should return version", () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z"
-      });
-      const { result } = renderHook(() => useVersion(), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-      expect(result.current).toBe("x.y.z");
-    });
-  });
-
-  describe("useRequiredIndexLink tests", () => {
-    it("should throw error for undefined link", () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z",
-        _links: {}
-      });
-      const { result } = renderHook(() => useRequiredIndexLink("spaceships"), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-      expect(result.error).toBeDefined();
-    });
-
-    it("should return link", () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z",
-        _links: {
-          spaceships: {
-            href: "/api/spaceships"
-          }
-        }
-      });
-      const { result } = renderHook(() => useRequiredIndexLink("spaceships"), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-      expect(result.current).toBe("/api/spaceships");
-    });
-  });
-
-  describe("useIndexJsonResource tests", () => {
-    it("should return json resource from link", async () => {
-      const queryClient = new QueryClient();
-      queryClient.setQueryData("index", {
-        version: "x.y.z",
-        _links: {
-          spaceships: {
-            href: "/spaceships"
-          }
-        }
-      });
-
-      const spaceship = {
-        name: "heartOfGold"
-      };
-
-      fetchMock.get("/api/v2/spaceships", spaceship);
-
-      const { result, waitFor } = renderHook(() => useIndexJsonResource<typeof spaceship>("spaceships"), {
-        wrapper: createWrapper(undefined, queryClient)
-      });
-
-      await waitFor(() => {
-        return !!result.current.data;
-      });
-
-      expect(result.current.data!.name).toBe("heartOfGold");
-    });
-  });
-
-  it("should return nothing if link is not available", () => {
-    const queryClient = new QueryClient();
-    queryClient.setQueryData("index", {
-      version: "x.y.z",
-      _links: {}
-    });
-
-    const { result } = renderHook(() => useIndexJsonResource<{}>("spaceships"), {
-      wrapper: createWrapper(undefined, queryClient)
-    });
-
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBeFalsy();
-    expect(result.current.data).toBeFalsy();
-  });
-});