lhisp-oauth-client/src/lhisp-oauth-client.ts

import qs from "querystring";
import https from "https";
import axios, { AxiosRequestConfig } from "axios";
import {
  AccessToken,
  ContentType,
  defaultAuthContentType,
  defaultAuthHeaderName,
  defaultGrantType,
  defaultTokenHeaderName,
  ExecutarRequestParams,
  LhispOauthClientConstructorParams,
} from "./lhisp-oauth-client.t";
import logger from "lhisp-logger";

export class LhispOauthClient {
  protected authUrl: string;
  protected apiUrl: string;
  protected clientId: string;
  protected clientSecret: string;
  protected authHeaderName: string;
  protected tokenHeaderName: string;
  protected authContentType: ContentType;
  protected certificado?: string;
  protected senhaCertificado?: string;
  protected authScope?: string;
  protected headers?: Headers;
  protected grantType?: string;
  protected agent: https.Agent;
  protected accessToken?: AccessToken;
  protected refreshToken?: AccessToken;
  protected sendAuthCredentialsOnRequestBody?: boolean;

  constructor(params: LhispOauthClientConstructorParams) {
    if (params.certificado) {
      this.agent = new https.Agent({
        pfx: params.certificado,
        passphrase: params.senhaCertificado,
        rejectUnauthorized: false,
      });
    } else {
      this.agent = new https.Agent({
        rejectUnauthorized: false,
      });
    }

    this.certificado = params.certificado;
    this.headers = (params.headers ? params.headers : {}) as any as Headers;
    this.apiUrl = params.apiUrl;
    this.authUrl = params.authUrl;
    this.authScope = params.authScope;
    this.grantType = params.grantType || defaultGrantType;
    this.authContentType = params.authContentType || defaultAuthContentType;
    this.clientId = params.clientId;
    this.clientSecret = params.clientSecret;
    this.authHeaderName = params.authHeaderName || defaultAuthHeaderName;
    this.tokenHeaderName = params.tokenHeaderName || defaultTokenHeaderName;
    this.sendAuthCredentialsOnRequestBody = params.sendAuthCredentialsOnRequestBody;
  }

  getAuthHeaderValue(): string {
    return `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64")}`;
  }

  parseData({ data, contentType = ContentType.APPLICATION_JSON }: { data: any; contentType: string }) {
    if (!data || Object.keys(data).length === 0) return undefined;

    switch (contentType) {
      case ContentType.APPLICATION_JSON:
        return JSON.stringify(data);
      case ContentType.APPLICATION_X_WWW_FORM_URLENCODED:
        return qs.stringify(data);
      default:
        throw new Error(`Content Type Inválido: [${contentType}]`);
    }
  }

  isTokenValid(token: AccessToken) {
    if (!token) return false;
    if (!token.created_at) return false;
    const timeDiff = (Date.now() - token.created_at) / 1000;
    return timeDiff < token.expires_in - 10;
  }

  async getAccessToken(): Promise<AccessToken> {
    try {
      if (this.accessToken && this.isTokenValid(this.accessToken)) {
        return this.accessToken;
      }

      // TODO: Implementar Refresh Token.

      let authRequestOpt: AxiosRequestConfig = {
        method: "POST",
        url: this.authUrl,
        httpsAgent: this.agent,
        headers: {
          [this.authHeaderName]: this.getAuthHeaderValue(),
          "Content-Type": this.authContentType,
        },
        data: {},
      };

      if (this.grantType) authRequestOpt.data.grant_type = this.grantType;
      if (this.authScope) authRequestOpt.data.scope = this.authScope;

      if (this.sendAuthCredentialsOnRequestBody) {
        if (this.clientId) authRequestOpt.data.client_id = this.clientId;
        if (this.clientSecret) authRequestOpt.data.client_secret = this.clientSecret;
      }

      authRequestOpt.data = this.parseData({
        data: authRequestOpt.data,
        contentType: this.authContentType,
      });
      const response = await axios.request(authRequestOpt);
      return this.buildAccessToken(response.data);
    } catch (error) {
      logger.error({ message: "LhispOauthClient.getAccessToken", error });
      throw error;
    }
  }

  buildAccessToken(data: Omit<AccessToken, "created_at">): AccessToken {
    this.accessToken = {
      ...data,
      created_at: Date.now(),
    };

    return this.accessToken;
  }

  getAuthToken() {
    return `${this.accessToken?.token_type} ${this.accessToken?.access_token}`;
  }

  async executarRequest<ResponseType>({
    method,
    path,
    data,
    params,
    contentType = ContentType.APPLICATION_JSON,
  }: ExecutarRequestParams): Promise<ResponseType> {
    try {
      await this.getAccessToken();
      if (!this.accessToken?.token_type) {
        console.log("## LHOAUTH2 NO TOKEN ?:", this.accessToken);
      }

      let headers = {
        "Content-Type": contentType,
        [this.tokenHeaderName]: this.getAuthToken(),
        // ...this.headers
      };

      const response = await axios.request<ResponseType>({
        method,
        url: `${this.apiUrl}${path}`,
        httpsAgent: this.agent,
        headers,
        data,
        params,
      });

      return response.data;
    } catch (error) {
      logger.error({ message: "LhispOauthClient.executarRequest", method, path, data, params, contentType, error });
      throw error;
    }
  }

  async get<ResponseType>({ path, contentType = ContentType.APPLICATION_JSON, params }: ExecutarRequestParams) {
    return this.executarRequest<ResponseType>({
      method: "GET",
      path,
      contentType,
      params,
    });
  }

  async put<ResponseType>({ path, data, contentType = ContentType.APPLICATION_JSON }: ExecutarRequestParams) {
    return this.executarRequest<ResponseType>({
      method: "PUT",
      path,
      data,
      contentType,
    });
  }

  async post<ResponseType>({ path, data, contentType = ContentType.APPLICATION_JSON }: ExecutarRequestParams) {
    return this.executarRequest<ResponseType>({
      method: "POST",
      path,
      data,
      contentType,
    });
  }

  async delete<ResponseType>({ path, contentType = ContentType.APPLICATION_JSON }: ExecutarRequestParams) {
    return this.executarRequest<ResponseType>({
      method: "DELETE",
      path,
      contentType,
    });
  }
}