lhisp-oauth-client 1.0.11 → 1.0.14

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

@@ -16,18 +16,18 @@ 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');
+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}"}`;
+const basicAuth = `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`;
+const contentTypeApplicationJson = lhisp_oauth_client_t_1.ContentType.APPLICATION_JSON;
+const contentTypeApplicationXFormUrlEncoded = lhisp_oauth_client_t_1.ContentType.APPLICATION_X_WWW_FORM_URLENCODED;
+const defaultGrantValue = "client_credentials";
+const defaultGrantType = `grant_type=${defaultGrantValue}`;
 describe("Get Access Token", () => {
     beforeEach(() => {
         mockedAxios.request.mockReset();
@@ -39,116 +39,128 @@ describe("Get Access Token", () => {
         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' }));
+        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,
+                "Content-Type": contentTypeApplicationXFormUrlEncoded,
             },
             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' }));
+        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,
+                "Content-Type": contentTypeApplicationXFormUrlEncoded,
             },
-            data: '{"grant_type":"PermissaoCustom"}',
+            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' }));
+        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,
+                "Content-Type": contentTypeApplicationXFormUrlEncoded,
             },
-            data: `{"grant_type":"${defaultGrantValue}","scope":"EscopoCustom"}`,
+            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 }));
+        const cli = getOauthClient(Object.assign(Object.assign({}, baseClientParams), { authContentType: contentTypeApplicationJson, sendAuthCredentialsOnRequestBody: true }));
         yield accessTokenValidator(cli);
         expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
             url: authUrl,
             method: "POST",
             headers: {
                 Authorization: basicAuth,
-                'Content-Type': contentTypeApplicationJson,
+                "Content-Type": contentTypeApplicationJson,
             },
             data: `{"grant_type":"${defaultGrantValue}","client_id":"${clientId}","client_secret":"${clientSecret}"}`,
         }));
     }));
+    it("Shoud Get with Credentials without ContentType", () => __awaiter(void 0, void 0, void 0, function* () {
+        const cli = getOauthClient(Object.assign(Object.assign({}, baseClientParams), { disableAuthContentType: true }));
+        yield accessTokenValidator(cli);
+        expect(mockedAxios.request).toBeCalledWith(expect.objectContaining({
+            url: authUrl,
+            method: "POST",
+            headers: {
+                Authorization: basicAuth,
+            },
+            data: `grant_type=${defaultGrantValue}`,
+        }));
+    }));
 });
 describe("Request", () => {
     beforeEach(() => {
         mockedAxios.request.mockReset();
         mockedAxios.request.mockResolvedValueOnce({ data: mockedAccessToken });
-        mockedAxios.request.mockResolvedValueOnce({ data: { "status": "ok" } });
+        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' });
+        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,
+                "Content-Type": contentTypeApplicationJson,
             },
-            data: undefined
+            data: undefined,
         }));
-        expect(resp).toStrictEqual({ "status": "ok" });
+        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 } });
+        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,
+                "Content-Type": contentTypeApplicationJson,
             },
             params: { id: 1 },
-            data: undefined
+            data: undefined,
         }));
-        expect(resp).toStrictEqual({ "status": "ok" });
+        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' } });
+        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,
+                "Content-Type": contentTypeApplicationJson,
             },
-            data: { id: 1, user: 'test' }
+            data: { id: 1, user: "test" },
         }));
-        expect(resp).toStrictEqual({ "status": "ok" });
+        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
+            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({
@@ -156,30 +168,30 @@ describe("Request", () => {
             method: "POST",
             headers: {
                 Authorization: `Bearer SomeAccessToken`,
-                'Content-Type': contentTypeApplicationXFormUrlEncoded,
+                "Content-Type": contentTypeApplicationXFormUrlEncoded,
             },
-            data: { id: 1, user: 'test' }
+            data: { id: 1, user: "test" },
         }));
-        expect(resp).toStrictEqual({ "status": "ok" });
+        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
+            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,
+                "x-token": `Bearer SomeAccessToken`,
+                "Content-Type": contentTypeApplicationXFormUrlEncoded,
             },
-            data: { id: 1, user: 'test' }
+            data: { id: 1, user: "test" },
         }));
-        expect(resp).toStrictEqual({ "status": "ok" });
+        expect(resp).toStrictEqual({ status: "ok" });
     }));
 });
 function validateDefaultGetAccessToken() {
@@ -188,7 +200,7 @@ function validateDefaultGetAccessToken() {
         method: "POST",
         headers: {
             Authorization: basicAuth,
-            'Content-Type': contentTypeApplicationJson,
+            "Content-Type": contentTypeApplicationXFormUrlEncoded,
         },
         data: defaultGrantType,
     }));
@@ -202,7 +214,6 @@ function accessTokenValidator(cli) {
         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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lhisp-oauth-client",
-  "version": "1.0.11",
+  "version": "1.0.14",
   "main": "src/index",
   "types": "src/index.d.ts",
   "repository": "git@bitbucket.org:leandro_costa/lhisp-oauth-client.git",

package/src/index.d.ts

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

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import https from "https";
 import { AccessToken, ContentType, ExecutarRequestParams, LhispOauthClientConstructorParams } from "./lhisp-oauth-client.t";
-export declare class LhispOauthClient {
+export declare class LhispOauthClient<iAccessToken extends AccessToken = AccessToken> {
     protected authUrl: string;
     protected apiUrl: string;
     protected clientId: string;
@@ -9,14 +9,17 @@ export declare class LhispOauthClient {
     protected authHeaderName: string;
     protected tokenHeaderName: string;
     protected authContentType: ContentType;
+    protected disableAuthContentType: boolean;
     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 accessToken?: iAccessToken;
+    protected refreshToken?: iAccessToken;
+    protected tokenCreatedAt: number;
+    protected tokenExpiresIn: number;
     protected sendAuthCredentialsOnRequestBody?: boolean;
     constructor(params: LhispOauthClientConstructorParams);
     getAuthHeaderValue(): string;
@@ -24,9 +27,9 @@ export declare class LhispOauthClient {
         data: any;
         contentType: string;
     }): string | undefined;
-    isTokenValid(token: AccessToken): boolean;
-    getAccessToken(): Promise<AccessToken>;
-    buildAccessToken(data: Omit<AccessToken, "created_at">): AccessToken;
+    isTokenValid(): boolean;
+    getAccessToken(): Promise<iAccessToken>;
+    buildAccessToken(data: any): iAccessToken;
     getAuthToken(): string;
     executarRequest<ResponseType>({ method, path, data, params, contentType, }: ExecutarRequestParams): Promise<ResponseType>;
     get<ResponseType>({ path, contentType, params }: ExecutarRequestParams): Promise<ResponseType>;

package/src/lhisp-oauth-client.js

@@ -20,6 +20,9 @@ const lhisp_oauth_client_t_1 = require("./lhisp-oauth-client.t");
 const lhisp_logger_1 = __importDefault(require("lhisp-logger"));
 class LhispOauthClient {
     constructor(params) {
+        this.disableAuthContentType = false;
+        this.tokenCreatedAt = 0;
+        this.tokenExpiresIn = 0;
         if (params.certificado) {
             this.agent = new https_1.default.Agent({
                 pfx: params.certificado,
@@ -39,6 +42,7 @@ class LhispOauthClient {
         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.disableAuthContentType = Boolean(params.disableAuthContentType);
         this.clientId = params.clientId;
         this.clientSecret = params.clientSecret;
         this.authHeaderName = params.authHeaderName || lhisp_oauth_client_t_1.defaultAuthHeaderName;
@@ -60,18 +64,19 @@ class LhispOauthClient {
                 throw new Error(`Content Type Inválido: [${contentType}]`);
         }
     }
-    isTokenValid(token) {
-        if (!token)
+    isTokenValid() {
+        if (!this.accessToken)
             return false;
-        if (!token.created_at)
+        if (!this.tokenCreatedAt)
             return false;
-        const timeDiff = (Date.now() - token.created_at) / 1000;
-        return timeDiff < token.expires_in - 10;
+        const timeDiff = (Date.now() - this.tokenCreatedAt) / 1000;
+        return timeDiff < this.tokenExpiresIn - 10;
     }
     getAccessToken() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this.accessToken && this.isTokenValid(this.accessToken)) {
+                if (this.accessToken && this.isTokenValid()) {
                     return this.accessToken;
                 }
                 // TODO: Implementar Refresh Token.
@@ -79,10 +84,7 @@ class LhispOauthClient {
                     method: "POST",
                     url: this.authUrl,
                     httpsAgent: this.agent,
-                    headers: {
-                        [this.authHeaderName]: this.getAuthHeaderValue(),
-                        "Content-Type": this.authContentType,
-                    },
+                    headers: Object.assign({ [this.authHeaderName]: this.getAuthHeaderValue() }, (this.disableAuthContentType ? {} : { "Content-Type": this.authContentType })),
                     data: {},
                 };
                 if (this.grantType)
@@ -95,12 +97,12 @@ class LhispOauthClient {
                     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);
+                authRequestOpt.data = this.parseData({ data: authRequestOpt.data, contentType: this.authContentType });
+                const resp = yield axios_1.default.request(authRequestOpt);
+                this.accessToken = this.buildAccessToken(resp.data);
+                this.tokenCreatedAt = new Date().getTime();
+                this.tokenExpiresIn = ((_a = this.accessToken) === null || _a === void 0 ? void 0 : _a.expires_in) || this.tokenCreatedAt + 60000;
+                return this.accessToken;
             }
             catch (error) {
                 lhisp_logger_1.default.error({ message: "LhispOauthClient.getAccessToken", error });
@@ -109,25 +111,19 @@ class LhispOauthClient {
         });
     }
     buildAccessToken(data) {
-        this.accessToken = Object.assign(Object.assign({}, data), { created_at: Date.now() });
-        return this.accessToken;
+        return data;
     }
     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* () {
             try {
                 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,

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

@@ -16,6 +16,7 @@ export interface LhispOauthClientConstructorParams {
     grantType?: string;
     authContentType?: ContentType;
     sendAuthCredentialsOnRequestBody?: boolean;
+    disableAuthContentType?: boolean;
     debug?: boolean;
 }
 export interface ExecutarRequestParams extends AxiosRequestConfig {
@@ -27,7 +28,6 @@ export interface AccessToken {
     access_token: string;
     expires_in: number;
     scope?: string;
-    created_at?: number;
 }
 export declare enum ContentType {
     APPLICATION_JSON = "application/json",

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

@@ -6,7 +6,7 @@ var ContentType;
     ContentType["APPLICATION_JSON"] = "application/json";
     ContentType["APPLICATION_X_WWW_FORM_URLENCODED"] = "application/x-www-form-urlencoded";
 })(ContentType || (exports.ContentType = ContentType = {}));
-exports.defaultGrantType = 'client_credentials';
+exports.defaultGrantType = "client_credentials";
 exports.defaultAuthContentType = ContentType.APPLICATION_X_WWW_FORM_URLENCODED;
-exports.defaultAuthHeaderName = 'Authorization';
-exports.defaultTokenHeaderName = 'Authorization';
+exports.defaultAuthHeaderName = "Authorization";
+exports.defaultTokenHeaderName = "Authorization";