lhisp-oauth-client 1.0.5

package/__tests__/lhisp-oauth-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/__tests__/lhisp-oauth-client.test.js

@@ -0,0 +1,216 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const lhisp_oauth_client_1 = require("../src/lhisp-oauth-client");
+const lhisp_oauth_client_t_1 = require("../src/lhisp-oauth-client.t");
+// Mock jest and set the type
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+const apiUrl = "https://myapi.com";
+const authUrl = "https://auth.myapi.com/oauth/token";
+const clientId = "testClientdId";
+const clientSecret = "testClientSecret";
+const baseClientParams = { apiUrl, authUrl, clientId, clientSecret };
+const basicAuth = `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString('base64')}`;
+const contentTypeApplicationJson = "application/json";
+const contentTypeApplicationXFormUrlEncoded = "application/x-www-form-urlencoded";
+const defaultGrantValue = 'client_credentials';
+const defaultGrantType = `{"grant_type":"${defaultGrantValue}"}`;
+describe("Get Access Token", () => {
+    beforeEach(() => {
+        mockedAxios.request.mockReset();
+        mockedAxios.request.mockResolvedValueOnce({ data: mockedAccessToken });
+    });
+    it("Shoud Get with Standard Config", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient();
+        yield accessTokenValidator(cli);
+        validateDefaultGetAccessToken();
+    }));
+    it("Shoud Get with Custom Auth Header", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient(Object.assign(Object.assign({}, baseClientParams), { authHeaderName: 'CustomAuthorizationHeader' }));
+        yield accessTokenValidator(cli);
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: authUrl,
+            method: "POST",
+            headers: {
+                CustomAuthorizationHeader: basicAuth,
+                'Content-Type': contentTypeApplicationJson,
+            },
+            data: defaultGrantType,
+        }));
+    }));
+    it("Shoud Get with Custom Grant Type", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient(Object.assign(Object.assign({}, baseClientParams), { grantType: 'PermissaoCustom' }));
+        yield accessTokenValidator(cli);
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: authUrl,
+            method: "POST",
+            headers: {
+                Authorization: basicAuth,
+                'Content-Type': contentTypeApplicationJson,
+            },
+            data: '{"grant_type":"PermissaoCustom"}',
+        }));
+    }));
+    it("Shoud Get with Custom Auth Scope", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient(Object.assign(Object.assign({}, baseClientParams), { authScope: 'EscopoCustom' }));
+        yield accessTokenValidator(cli);
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: authUrl,
+            method: "POST",
+            headers: {
+                Authorization: basicAuth,
+                'Content-Type': contentTypeApplicationJson,
+            },
+            data: `{"grant_type":"${defaultGrantValue}","scope":"EscopoCustom"}`,
+        }));
+    }));
+    it("Shoud Get with Credentials on Request body", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient(Object.assign(Object.assign({}, baseClientParams), { sendAuthCredentialsOnRequestBody: true }));
+        yield accessTokenValidator(cli);
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: authUrl,
+            method: "POST",
+            headers: {
+                Authorization: basicAuth,
+                'Content-Type': contentTypeApplicationJson,
+            },
+            data: `{"grant_type":"${defaultGrantValue}","client_id":"${clientId}","client_secret":"${clientSecret}"}`,
+        }));
+    }));
+});
+describe("Request", () => {
+    beforeEach(() => {
+        mockedAxios.request.mockReset();
+        mockedAxios.request.mockResolvedValueOnce({ data: mockedAccessToken });
+        mockedAxios.request.mockResolvedValueOnce({ data: { "status": "ok" } });
+    });
+    it("Get without Params", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient();
+        const resp = yield cli.get({ path: '/my-test-url' });
+        validateDefaultGetAccessToken();
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: `${apiUrl}/my-test-url`,
+            method: "GET",
+            headers: {
+                Authorization: `Bearer SomeAccessToken`,
+                'Content-Type': contentTypeApplicationJson,
+            },
+            data: undefined
+        }));
+        expect(resp).toStrictEqual({ "status": "ok" });
+    }));
+    it("Get with Params", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient();
+        const resp = yield cli.get({ path: '/my-test-url', params: { id: 1 } });
+        validateDefaultGetAccessToken();
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: `${apiUrl}/my-test-url`,
+            method: "GET",
+            headers: {
+                Authorization: `Bearer SomeAccessToken`,
+                'Content-Type': contentTypeApplicationJson,
+            },
+            params: { id: 1 },
+            data: undefined
+        }));
+        expect(resp).toStrictEqual({ "status": "ok" });
+    }));
+    it("Post", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient();
+        const resp = yield cli.post({ path: '/my-test-url-post', data: { id: 1, user: 'test' } });
+        validateDefaultGetAccessToken();
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: `${apiUrl}/my-test-url-post`,
+            method: "POST",
+            headers: {
+                Authorization: `Bearer SomeAccessToken`,
+                'Content-Type': contentTypeApplicationJson,
+            },
+            data: { id: 1, user: 'test' }
+        }));
+        expect(resp).toStrictEqual({ "status": "ok" });
+    }));
+    it("Post with different contentType", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient();
+        const resp = yield cli.post({
+            path: '/my-test-url-post',
+            data: { id: 1, user: 'test' },
+            contentType: lhisp_oauth_client_t_1.ContentType.APPLICATION_X_WWW_FORM_URLENCODED
+        });
+        validateDefaultGetAccessToken();
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: `${apiUrl}/my-test-url-post`,
+            method: "POST",
+            headers: {
+                Authorization: `Bearer SomeAccessToken`,
+                'Content-Type': contentTypeApplicationXFormUrlEncoded,
+            },
+            data: { id: 1, user: 'test' }
+        }));
+        expect(resp).toStrictEqual({ "status": "ok" });
+    }));
+    it("Post with Different Token Header Name", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient(Object.assign(Object.assign({}, baseClientParams), { tokenHeaderName: "x-token" }));
+        const resp = yield cli.post({
+            path: '/my-test-url-post',
+            data: { id: 1, user: 'test' },
+            contentType: lhisp_oauth_client_t_1.ContentType.APPLICATION_X_WWW_FORM_URLENCODED
+        });
+        validateDefaultGetAccessToken();
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: `${apiUrl}/my-test-url-post`,
+            method: "POST",
+            headers: {
+                'x-token': `Bearer SomeAccessToken`,
+                'Content-Type': contentTypeApplicationXFormUrlEncoded,
+            },
+            data: { id: 1, user: 'test' }
+        }));
+        expect(resp).toStrictEqual({ "status": "ok" });
+    }));
+});
+function validateDefaultGetAccessToken() {
+    expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+        url: authUrl,
+        method: "POST",
+        headers: {
+            Authorization: basicAuth,
+            'Content-Type': contentTypeApplicationJson,
+        },
+        data: defaultGrantType,
+    }));
+}
+function accessTokenValidator(cli) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const now = Date.now();
+        const accessToken = yield cli.getAccessToken();
+        expect(accessToken).toBeDefined();
+        expect(accessToken.token_type).toBe(mockedAccessToken.token_type);
+        expect(accessToken.access_token).toBe(mockedAccessToken.access_token);
+        expect(accessToken.expires_in).toBe(mockedAccessToken.expires_in);
+        expect(accessToken.scope).toBe(mockedAccessToken.scope);
+        expect(accessToken.created_at).toBeGreaterThanOrEqual(now);
+    });
+}
+function getOauthClient(opt = baseClientParams) {
+    return new lhisp_oauth_client_1.LhispOauthClient(opt);
+}
+const mockedAccessToken = {
+    token_type: "Bearer",
+    access_token: "SomeAccessToken",
+    expires_in: 600,
+    scope: "cobrancas.boletos-requisicao cobrancas.boletos-info",
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "lhisp-oauth-client",
+  "version": "1.0.5",
+  "main": "src/index",
+  "types": "src/index.d.ts",
+  "repository": "git@bitbucket.org:leandro_costa/lhisp-oauth-client.git",
+  "author": "Leandro Costa <contato@leandrocosta.pro.br>",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watchAll"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.4.0",
+    "@types/node": "^18.11.18",
+    "jest": "^29.4.1",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "axios": "^1.2.5"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lhisp-oauth-client';
+export * from './lhisp-oauth-client.t';

package/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lhisp-oauth-client"), exports);
+__exportStar(require("./lhisp-oauth-client.t"), exports);

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

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import https from 'https';
+import { AccessToken, ContentType, ExecutarRequestParams, LhispOauthClientConstructorParams } from "./lhisp-oauth-client.t";
+export declare 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);
+    getAuthHeaderValue(): string;
+    parseData({ data, contentType }: {
+        data: any;
+        contentType: string;
+    }): string | undefined;
+    isTokenValid(token: AccessToken): boolean;
+    getAccessToken(): Promise<AccessToken>;
+    buildAccessToken(data: Omit<AccessToken, 'created_at'>): AccessToken;
+    getAuthToken(): string;
+    executarRequest({ method, path, data, params, contentType }: ExecutarRequestParams): Promise<any>;
+    get({ path, contentType, params }: ExecutarRequestParams): Promise<any>;
+    put({ path, data, contentType }: ExecutarRequestParams): Promise<any>;
+    post({ path, data, contentType }: ExecutarRequestParams): Promise<any>;
+    delete({ path, contentType }: ExecutarRequestParams): Promise<any>;
+}

package/src/lhisp-oauth-client.js

@@ -0,0 +1,151 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LhispOauthClient = void 0;
+const querystring_1 = __importDefault(require("querystring"));
+const https_1 = __importDefault(require("https"));
+const axios_1 = __importDefault(require("axios"));
+const lhisp_oauth_client_t_1 = require("./lhisp-oauth-client.t");
+class LhispOauthClient {
+    constructor(params) {
+        if (params.certificado) {
+            this.agent = new https_1.default.Agent({
+                pfx: params.certificado,
+                passphrase: params.senhaCertificado,
+                rejectUnauthorized: false,
+            });
+        }
+        else {
+            this.agent = new https_1.default.Agent({
+                rejectUnauthorized: false
+            });
+        }
+        this.certificado = params.certificado;
+        this.headers = (params.headers ? params.headers : {});
+        this.apiUrl = params.apiUrl;
+        this.authUrl = params.authUrl;
+        this.authScope = params.authScope;
+        this.grantType = params.grantType || lhisp_oauth_client_t_1.defaultGrantType;
+        this.authContentType = params.authContentType || lhisp_oauth_client_t_1.defaultAuthContentType;
+        this.clientId = params.clientId;
+        this.clientSecret = params.clientSecret;
+        this.authHeaderName = params.authHeaderName || lhisp_oauth_client_t_1.defaultAuthHeaderName;
+        this.tokenHeaderName = params.tokenHeaderName || lhisp_oauth_client_t_1.defaultTokenHeaderName;
+        this.sendAuthCredentialsOnRequestBody = params.sendAuthCredentialsOnRequestBody;
+    }
+    getAuthHeaderValue() {
+        return `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64")}`;
+    }
+    parseData({ data, contentType = lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON }) {
+        if (!data || Object.keys(data).length === 0)
+            return undefined;
+        switch (contentType) {
+            case lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON: return JSON.stringify(data);
+            case lhisp_oauth_client_t_1.ContentType.APPLICATION_X_WWW_FORM_URLENCODED: return querystring_1.default.stringify(data);
+            default:
+                throw new Error(`Content Type Inválido: [${contentType}]`);
+        }
+    }
+    isTokenValid(token) {
+        if (!token)
+            return false;
+        if (!token.created_at)
+            return false;
+        const timeDiff = (Date.now() - token.created_at) / 1000;
+        return timeDiff < token.expires_in - 10;
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.accessToken && this.isTokenValid(this.accessToken)) {
+                return this.accessToken;
+            }
+            // TODO: Implementar Refresh Token.
+            let authRequestOpt = {
+                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 = yield axios_1.default.request(authRequestOpt);
+            return this.buildAccessToken(response.data);
+        });
+    }
+    buildAccessToken(data) {
+        this.accessToken = Object.assign(Object.assign({}, data), { created_at: Date.now() });
+        return this.accessToken;
+    }
+    getAuthToken() {
+        var _a, _b;
+        return `${(_a = this.accessToken) === null || _a === void 0 ? void 0 : _a.token_type} ${(_b = this.accessToken) === null || _b === void 0 ? void 0 : _b.access_token}`;
+    }
+    executarRequest({ method, path, data, params, contentType = lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getAccessToken();
+            if (!((_a = this.accessToken) === null || _a === void 0 ? void 0 : _a.token_type)) {
+                console.log("## LHOAUTH2 NO TOKEN ?:", this.accessToken);
+            }
+            let headers = {
+                'Content-Type': contentType,
+                [this.tokenHeaderName]: this.getAuthToken(),
+                // ...this.headers
+            };
+            const response = yield axios_1.default.request({
+                method,
+                url: `${this.apiUrl}${path}`,
+                httpsAgent: this.agent,
+                headers,
+                data,
+                params
+            });
+            return response.data;
+        });
+    }
+    get({ path, contentType = lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON, params }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executarRequest({ method: 'GET', path, contentType, params });
+        });
+    }
+    put({ path, data, contentType = lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executarRequest({ method: 'PUT', path, data, contentType });
+        });
+    }
+    post({ path, data, contentType = lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executarRequest({ method: 'POST', path, data, contentType });
+        });
+    }
+    delete({ path, contentType = lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executarRequest({ method: 'DELETE', path, contentType });
+        });
+    }
+}
+exports.LhispOauthClient = LhispOauthClient;

package/src/lhisp-oauth-client.t.d.ts

@@ -0,0 +1,39 @@
+import { AxiosRequestConfig } from "axios";
+export interface Headers {
+    [name: string]: any;
+}
+export interface LhispOauthClientConstructorParams {
+    authUrl: string;
+    apiUrl: string;
+    clientId: string;
+    clientSecret: string;
+    certificado?: string;
+    senhaCertificado?: string;
+    authScope?: string;
+    authHeaderName?: string;
+    tokenHeaderName?: string;
+    headers?: Headers;
+    grantType?: string;
+    authContentType?: ContentType;
+    sendAuthCredentialsOnRequestBody?: boolean;
+    debug?: boolean;
+}
+export interface ExecutarRequestParams extends AxiosRequestConfig {
+    path: string;
+    contentType?: ContentType;
+}
+export interface AccessToken {
+    token_type: string;
+    access_token: string;
+    expires_in: number;
+    scope?: string;
+    created_at?: number;
+}
+export declare enum ContentType {
+    APPLICATION_JSON = "application/json",
+    APPLICATION_X_WWW_FORM_URLENCODED = "application/x-www-form-urlencoded"
+}
+export declare const defaultGrantType = "client_credentials";
+export declare const defaultAuthContentType = ContentType.APPLICATION_X_WWW_FORM_URLENCODED;
+export declare const defaultAuthHeaderName = "Authorization";
+export declare const defaultTokenHeaderName = "Authorization";

package/src/lhisp-oauth-client.t.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTokenHeaderName = exports.defaultAuthHeaderName = exports.defaultAuthContentType = exports.defaultGrantType = exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType["APPLICATION_JSON"] = "application/json";
+    ContentType["APPLICATION_X_WWW_FORM_URLENCODED"] = "application/x-www-form-urlencoded";
+})(ContentType = exports.ContentType || (exports.ContentType = {}));
+exports.defaultGrantType = 'client_credentials';
+exports.defaultAuthContentType = ContentType.APPLICATION_X_WWW_FORM_URLENCODED;
+exports.defaultAuthHeaderName = 'Authorization';
+exports.defaultTokenHeaderName = 'Authorization';