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, 
    defaultTokenHeaderName,
    ExecutarRequestParams, 
    GrantType, LhispOauthClientConstructorParams,
} from "./lhisp-oauth-client.t";

export default 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?: GrantType;
    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;
        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 }) {
        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> {
        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,
            },
        }

        if(this.sendAuthCredentialsOnRequestBody) {
            let data: any = {};
            if(this.grantType) data.grant_type = this.grantType;
            if(this.authScope) data.scope = this.authScope;
            if(this.clientId) data.client_id = this.clientId;
            if(this.clientSecret) data.client_secret = this.clientSecret;

            authRequestOpt.data = this.parseData({ data, contentType: this.authContentType });
        }

        const response = await axios.request(authRequestOpt);
        return this.buildAccessToken(response.data);
    }

    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({ method, path, data, params, contentType = ContentType.APPLICATION_JSON } : ExecutarRequestParams) {
        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({
            method,
            url: `${this.apiUrl}${path}`,
            httpsAgent: this.agent,
            headers,
            data,
            params
        });

        return response.data;
    }

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

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

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

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