Implement uniform return interface for js functions

.gitignore

@@ -3,4 +3,7 @@
 node_modules
 dist
 lib
-package-lock.json
+lib/*
+package-lock.json
+.idea
+.history

__test__/index.test.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 const { Authorizer } = require('../lib')
 
 const authRef = new Authorizer({
@@ -17,7 +18,8 @@ describe('signup success', () => {
       password,
       confirm_password: password,
     })
-    expect(signupRes.message.length).not.toEqual(0)
+    expect(signupRes?.ok).toEqual(true)
+    expect(signupRes?.response?.message?.length).not.toEqual(0)
   })
 
   it('should verify email', async () => {
@@ -47,41 +49,40 @@ describe('signup success', () => {
 
     const verifyEmailRes = await authRef.verifyEmail({ token: item.token })
 
-    expect(verifyEmailRes.access_token.length).not.toEqual(0)
+    expect(verifyEmailRes?.response?.access_token?.length).toBeGreaterThan(0)
   })
 })
 
 describe('login failures', () => {
   it('should throw password invalid error', async () => {
-    try {
-      await authRef.login({
+
+     const resp= await authRef.login({
         email,
         password: `${password}test`,
       })
-    } catch (e) {
-      expect(e.message).toContain('bad user credentials')
-    }
+
+      expect(resp?.error?.message).toContain('bad user credentials')
   })
 
   it('should throw password invalid role', async () => {
-    try {
-      await authRef.login({
-        email,
-        password,
-        roles: ['admin'],
-      })
-    } catch (e) {
-      expect(e.message).toMatch('invalid role')
-    }
+
+    const resp = await authRef.login({
+      email,
+      password,
+      roles: ['admin'],
+    })
+    expect(resp.error?.message).toMatch('invalid role')
+    expect(resp.ok).toBeFalsy()
   })
+
 })
 
 describe('forgot password success', () => {
   it('should create forgot password request', async () => {
     const forgotPasswordRes = await authRef.forgotPassword({
       email,
     })
-    expect(forgotPasswordRes.message.length).not.toEqual(0)
+    expect(forgotPasswordRes?.error?.message?.length).not.toEqual(0)
   })
 
   it('should reset password', async () => {
@@ -116,7 +117,7 @@ describe('forgot password success', () => {
         password,
         confirm_password: password,
       })
-      expect(resetPasswordRes.message.length).not.toEqual(0)
+      expect(resetPasswordRes?.error?.message?.length).not.toEqual(0)
     }
   })
 })
@@ -129,18 +130,18 @@ describe('login success', () => {
       password,
       scope: ['openid', 'profile', 'email', 'offline_access'],
     })
-    expect(loginRes.access_token.length).not.toEqual(0)
-    expect(loginRes.refresh_token.length).not.toEqual(0)
-    expect(loginRes.expires_in).not.toEqual(0)
-    expect(loginRes.id_token.length).not.toEqual(0)
+    expect(loginRes?.response?.access_token.length).not.toEqual(0)
+    expect(loginRes?.response?.refresh_token.length).not.toEqual(0)
+    expect(loginRes?.response?.expires_in).not.toEqual(0)
+    expect(loginRes?.response?.id_token.length).not.toEqual(0)
   })
 
   it('should validate jwt token', async () => {
     const validateRes = await authRef.validateJWTToken({
       token_type: 'access_token',
-      token: loginRes.access_token,
+      token: loginRes?.response?.access_token,
     })
-    expect(validateRes.is_valid).toEqual(true)
+    expect(validateRes?.response?.is_valid).toEqual(true)
   })
 
   it('should update profile successfully', async () => {
@@ -149,41 +150,41 @@ describe('login success', () => {
         given_name: 'bob',
       },
       {
-        Authorization: `Bearer ${loginRes.access_token}`,
+        Authorization: `Bearer ${loginRes?.response?.access_token}`,
       }
     )
-    expect(updateProfileRes.message.length).not.toEqual(0)
+    expect(updateProfileRes?.error?.message?.length).not.toEqual(0)
   })
 
   it('should fetch profile successfully', async () => {
     const profileRes = await authRef.getProfile({
-      Authorization: `Bearer ${loginRes.access_token}`,
+      Authorization: `Bearer ${loginRes?.response?.access_token}`,
     })
-    expect(profileRes.given_name).toMatch('bob')
+    expect(profileRes?.response?.given_name).toMatch('bob')
   })
 
   it('should validate get token', async () => {
     const tokenRes = await authRef.getToken({
       grant_type: 'refresh_token',
-      refresh_token: loginRes.refresh_token,
+      refresh_token: loginRes?.response?.refresh_token,
     })
-    expect(tokenRes.access_token.length).not.toEqual(0)
+    expect(tokenRes?.response?.access_token.length).not.toEqual(0)
   })
 
   it('should deactivate account', async () => {
-    console.log(`loginRes.access_token`, loginRes.access_token)
+    console.log(`loginRes?.response?.access_token`, loginRes?.response?.access_token)
     const deactivateRes = await authRef.deactivateAccount({
-      Authorization: `Bearer ${loginRes.access_token}`,
+      Authorization: `Bearer ${loginRes?.response?.access_token}`,
     })
-    expect(deactivateRes.message.length).not.toEqual(0)
+    expect(deactivateRes?.error?.message?.length).not.toEqual(0)
   })
 
   it('should throw error while accessing profile after deactivation', async () => {
-    await expect(
+    const resp=await
       authRef.getProfile({
-        Authorization: `Bearer ${loginRes.access_token}`,
+        Authorization: `Bearer ${loginRes?.response?.access_token}`,
       })
-    ).rejects.toThrow('Error: unauthorized')
+    expect(resp?.error?.message).toEqual('Error: unauthorized')
   })
 
   it('should clear data', async () => {
@@ -210,7 +211,7 @@ describe('magic login success', () => {
       email,
     })
 
-    expect(magicLinkLoginRes.message.length).not.toEqual(0)
+    expect(magicLinkLoginRes?.error?.message?.length).not.toEqual(0)
   })
 
   it('should verify email', async () => {