MermaidChart.js

import { v4 as uuid } from "uuid";
import fetch from "node-fetch";
import { getEncodedSHA256Hash } from "./index.js";

const CLIENT_KEY = "all";

class MermaidChart {
  addon;
  clientID;
  baseURL;
  axios;
  redirectURI;
  URLS = {
    oauth: {
      authorize: (params) =>
        `/oauth/authorize?${new URLSearchParams(
          Object.entries(params)
        ).toString()}`,
      token: `/oauth/token`,
    },
    rest: {
      users: {
        self: `/rest-api/users/me`,
      },
      documents: {
        get: (documentID) => {
          return `/rest-api/documents/${documentID}`;
        },
      },
      projects: {
        list: `/rest-api/projects`,
        get: (projectID) => {
          return {
            documents: `/rest-api/projects/${projectID}/documents`,
          };
        },
      },
    },
    raw: (document, theme = "light") => {
      const base = `/raw/${document.documentID}?version=v${document.major}.${document.minor}&theme=${theme}&format=`;

      return {
        html: base + "html",
        svg: base + "svg",
        png: base + "png",
      };
    },
    diagram: (d) => {
      const base = `/app/projects/${d.projectID}/diagrams/${d.documentID}/version/v${d.major}.${d.minor}`;
      return {
        self: base,
        edit: base + "/edit",
        view: base + "/view",
      };
    },
  };

  constructor({ clientID, baseURL, redirectURI, addon }) {
    this.addon = addon;
    this.clientID = clientID;
    this.setBaseURL(baseURL);
    if (redirectURI) {
      this.setRedirectURI(redirectURI);
    }
  }

  setRedirectURI(redirectURI) {
    this.redirectURI = redirectURI;
  }

  setBaseURL(baseURL) {
    if (this.baseURL && this.baseURL === baseURL) {
      return;
    }
    this.baseURL = baseURL;
  }

  async getAuthorizationData({ state, scope } = {}) {
    if (!this.redirectURI) {
      throw new Error("redirectURI is not set");
    }

    const stateID = state ?? uuid();
    const codeVerifier = uuid();

    await this.setCodeVerifier(stateID, codeVerifier);

    const params = {
      client_id: this.clientID,
      redirect_uri: this.redirectURI,
      response_type: "code",
      code_challenge_method: "S256",
      code_challenge: await getEncodedSHA256Hash(codeVerifier),
      state: stateID,
      scope: scope ?? "email",
    };

    setTimeout(async () => {
      await this.delCodeVerifier(stateID);
    }, 5 * 60 * 1000);

    const url = `${this.baseURL}${this.URLS.oauth.authorize(params)}`;
    return {
      url,
      state: stateID,
      scope: params.scope,
    };
  }

  async handleAuthorizationResponse(query) {
    const authorizationToken = query.code;
    const state = query.state;

    if (!authorizationToken) {
      throw new RequiredParameterMissingError("token");
    }
    if (!state) {
      throw new RequiredParameterMissingError("state");
    }

    const codeVerifier = await this.getCodeVerifier(state);
    // Check if it is a valid auth request started by the extension
    if (!codeVerifier) {
      throw new OAuthError("invalid_state");
    }

    const tokenResponse = await fetch(this.baseURL + this.URLS.oauth.token, {
      method: "post",
      body: JSON.stringify({
        client_id: this.clientID,
        redirect_uri: this.redirectURI,
        code_verifier: codeVerifier,
        code: authorizationToken,
      }),
      headers: {
        "Content-type": "application/json",
      },
    });

    if (!tokenResponse.ok) {
      throw new OAuthError(
        `invalid_token ${tokenResponse.status} ${tokenResponse.statusText}`
      );
    }

    await this.setToken(state, (await tokenResponse.json()).access_token);
    setTimeout(async () => {
      await this.delToken(state);
    }, 30 * 60 * 1000);
  }

  async getUser(accessToken) {
    const response = await fetch(
      `${this.baseURL}${this.URLS.rest.users.self}`,
      {
        headers: {
          Authorization: `Bearer ${accessToken}`,
        },
      }
    );
    if (!response.ok) {
      throw new OAuthError("Invalid token to get user info");
    }
    return await response.json();
  }

  getEditURL(document) {
    const url = `${this.baseURL}${this.URLS.diagram(document).edit}`;
    return url;
  }

  getViewURL(document) {
    const url = `${this.baseURL}${this.URLS.diagram(document).view}`;
    return url;
  }

  getDocumentAsPngUrl(document, theme = "light") {
    const url = `${this.baseURL}${this.URLS.raw(document, theme).png}`;
    return url;
  }

  async getDocumentAsPng(document, accessToken, theme = "light") {
    const url = `${this.baseURL}${this.URLS.raw(document, theme).png}`;
    const png = await fetch(url, {
      headers: {
        Authorization: `Bearer ${accessToken}`,
      },
    });
    const base64Image = Buffer.from(await png.arrayBuffer(), "binary").toString(
      "base64"
    );

    return base64Image;
  }

  async getRawDocument(document, theme = "light") {
    const raw = await fetch(
      `${this.baseURL}${this.URLS.raw(document, theme).svg}`
    );
    return await raw.text();
  }

  async getCodeVerifier(state) {
    return await this.addon.settings.get(`state:${state}:code`, CLIENT_KEY);
  }

  async setCodeVerifier(state, code) {
    return await this.addon.settings.set(
      `state:${state}:code`,
      code,
      CLIENT_KEY
    );
  }

  async delCodeVerifier(state) {
    return await this.addon.settings.del(`state:${state}:code`, CLIENT_KEY);
  }

  async getToken(state) {
    return await this.addon.settings.get(`state:${state}:token`, CLIENT_KEY);
  }

  async setToken(state, code) {
    return await this.addon.settings.set(
      `state:${state}:token`,
      code,
      CLIENT_KEY
    );
  }

  async delToken(state) {
    return await this.addon.settings.del(`state:${state}:token`, CLIENT_KEY);
  }
}

class RequiredParameterMissingError extends Error {
  constructor(parameterName) {
    super(`Required parameter ${parameterName} is missing`);
  }
}

class OAuthError extends Error {
  constructor(message) {
    super(message);
  }
}

export { MermaidChart };