webledger-auth-plugin 1.0.10 → 2.0.0

package/README.md

@@ -12,3 +12,8 @@ node ace configure webledger-auth-plugin
 ```
 
 [**Instructions**](./instructions.md)
+
+
+## Develop locally
+1. `npm run link`  this will build and link locally, somewhere in your `~/node_modules/<package_name>` or `~/.nvm/versions/node/v18.20.3/lib/node_modules`
+2. at the project folder where you want to install locally try `npm link webledger-auth-plugin` (package.json -> name)

package/build/adonis-typings/AuthService.d.ts

@@ -1,24 +1,30 @@
 declare module '@ioc:AuthService' {
     export interface AuthServiceI {
-        login(email: string, password: string): any;
-        signup(params: any): any;
-        getUser(uuid: string): any;
-        updateUser(uuid: string, params: any): any;
-        forgotPassword(email: string): any;
-        resendEmailVerification(email: string): any;
-        verifyPin(uuid: string, user_pin: string): any;
-        forgotPin(uuid: string, password: string, user_pin: string): any;
-        createToken(sub: string): any;
-        verifyToken(token: string, sub?: string): any;
+        isEnable: boolean;
+        createToken(sub: string): string;
+        verifyToken(token: string, sub?: string): object | null;
+        getApps(): Promise<any>;
+        login(email: string, password: string): Promise<any>;
+        signup(params: any): Promise<any>;
+        getUser(uuid: string): Promise<any>;
+        updateUser(uuid: string, params: any): Promise<any>;
+        forgotPassword(email: string): Promise<any>;
+        resendEmailVerification(email: string): Promise<any>;
+        verifyPin(uuid: string, user_pin: string): Promise<any>;
+        forgotPin(uuid: string, password: string, user_pin: string): Promise<any>;
+        logoutURL(): string;
+        checkLoginURL(): string;
     }
     const authService: AuthServiceI;
     export default authService;
     export interface AuthServiceConfig {
+        enable: boolean;
         host: string;
-        env: string;
-        type: string;
         iss: string;
+        client: string;
         secret: string;
+        env?: string;
+        product?: string;
         expiry?: string;
         timeout?: number;
         paths?: {

package/build/instructions.md

@@ -1,8 +1,8 @@
 Congratulations! You have configured `AuthService` package successfully. Make sure to add the following values inside `env.ts` file:
 
 ```ts
+AUTH_ENABLE: Env.schema.boolean,
 AUTH_HOST: Env.schema.string({ format: 'host' }),
-AUTH_ENV: Env.schema.string(),
-AUTH_PRODUCT_TYPE: Env.schema.string(),
-AUTH_JWT_TOKEN: Env.schema.string(),
+AUTH_CLIENT: Env.schema.string(),
+AUTH_SECRET: Env.schema.string(),
 ```

package/build/providers/AuthServiceProvider.js

@@ -11,7 +11,8 @@ class AuthServiceProvider {
     register() {
         this.app.container.singleton('AuthService', () => {
             const config = this.app.container.use('Adonis/Core/Config');
-            return new AuthService_1.default(config.get('authService'));
+            const service = new AuthService_1.default(config.get('authService'));
+            return service;
         });
     }
 }

package/build/src/AuthService.d.ts

@@ -7,6 +7,55 @@ export default class AuthService implements AuthServiceI {
     createToken(sub: string): any;
     verifyToken(token: string, sub?: string): any;
     private setAuthToken;
+    /**
+     * isEnable is useful if enable both local or server auth
+     * if true means you can use server auth else you can do something else
+     *
+     * Example code for login
+     *
+     * import User from 'App/Models/User'
+     * import AuthService from '@ioc:AuthService'
+     *
+      public async login(ctx: HttpContextContract) {
+          const { email, password } = ctx.request.only(['email', 'password'])
+  
+          try {
+            let user: User | null,
+              token: any = null,
+              sso_url = null
+            if (AuthService.isEnable) {
+              const res = await AuthService.login(email, password)
+              const data = res.data.user
+              sso_url = res.data.sso_url
+              user = await User.findBy('uuid', data.uuid)
+              if (!user) user = await User.findBy('email', email)
+  
+              if (user) {
+                data.isLocked = false
+                user.merge(data)
+                await user.save()
+              } else {
+                user = await User.create(data)
+              }
+              token = await ctx.auth.use('api').generate(user, { expiresIn: '12 hours' })
+            } else {
+              token = await ctx.auth.use('api').attempt(email, password)
+              user = ctx.auth.use('api').user!
+              if (!ctx.auth.use('api').user) {
+                return ctx.response.status(400).json({ message: 'Invalid credentials', token })
+              }
+              await ctx.auth.user?.merge({ isLocked: false }).save()
+            }
+  
+            if (user) return ctx.response.json({ ...user.serialize(), token, sso_url })
+          } catch (e) {
+            this.logger.error(`Error login: ${e.message}`)
+          }
+          return ctx.response.status(400).json({ message: 'Invalid credentials' })
+        }
+     */
+    get isEnable(): boolean;
+    getApps(): Promise<import("axios").AxiosResponse<any, any>>;
     login(email: string, password: string): Promise<import("axios").AxiosResponse<any, any>>;
     signup(params: any): Promise<import("axios").AxiosResponse<any, any>>;
     getUser(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
@@ -15,4 +64,6 @@ export default class AuthService implements AuthServiceI {
     resendEmailVerification(email: string): Promise<import("axios").AxiosResponse<any, any>>;
     verifyPin(uuid: string, user_pin: string): Promise<import("axios").AxiosResponse<any, any>>;
     forgotPin(uuid: string, password: string, user_pin: string): Promise<import("axios").AxiosResponse<any, any>>;
+    logoutURL(): string;
+    checkLoginURL(): string;
 }

package/build/src/AuthService.js

@@ -9,6 +9,7 @@ class AuthService {
     constructor(config) {
         this.config = config;
         this.paths = {
+            apps: '/api/apps',
             login: '/api/login',
             signup: '/api/signup',
             get_user: '/api/users',
@@ -22,34 +23,97 @@ class AuthService {
         this.client.defaults.timeout = config.timeout || 30000; // default is 30seconds
         const headers = {
             'Content-Type': 'application/json',
-            'x-auth-env': config.env,
-            'x-product-type': config.type,
+            'x-auth-client': config.client,
         };
+        const [product, env] = config.client.split('_');
+        config.env = env;
+        config.product = product;
         for (const key in headers) {
             this.client.defaults.headers.common[key] = headers[key];
         }
         this.paths = { ...this.paths, ...config.paths };
     }
     createToken(sub) {
-        const payload = { env: this.config.env, type: this.config.type, iss: this.config.iss, sub };
+        const payload = {
+            env: this.config.env,
+            product: this.config.product,
+            iss: this.config.iss,
+            sub,
+        };
         const jwtAuthToken = (0, jsonwebtoken_1.sign)(payload, this.config.secret, {
             expiresIn: this.config.expiry || '1m',
         });
         return jwtAuthToken;
     }
     verifyToken(token, sub) {
-        const data = (0, jsonwebtoken_1.verify)(token, this.config.secret);
-        if (sub) {
-            if (sub === data.sub) {
+        try {
+            const data = (0, jsonwebtoken_1.verify)(token, this.config.secret);
+            if (!sub)
                 return data;
-            }
+            return sub === data.sub ? data : null;
+        }
+        catch (e) {
             return null;
         }
-        return data;
     }
     setAuthToken(sub) {
         const jwtAuthToken = this.createToken(sub);
-        this.client.defaults.headers.common['Authorization'] = `Bearer ${jwtAuthToken}`;
+        this.client.defaults.headers.common['Authorization'] = jwtAuthToken;
+    }
+    /**
+     * isEnable is useful if enable both local or server auth
+     * if true means you can use server auth else you can do something else
+     *
+     * Example code for login
+     *
+     * import User from 'App/Models/User'
+     * import AuthService from '@ioc:AuthService'
+     *
+      public async login(ctx: HttpContextContract) {
+          const { email, password } = ctx.request.only(['email', 'password'])
+  
+          try {
+            let user: User | null,
+              token: any = null,
+              sso_url = null
+            if (AuthService.isEnable) {
+              const res = await AuthService.login(email, password)
+              const data = res.data.user
+              sso_url = res.data.sso_url
+              user = await User.findBy('uuid', data.uuid)
+              if (!user) user = await User.findBy('email', email)
+  
+              if (user) {
+                data.isLocked = false
+                user.merge(data)
+                await user.save()
+              } else {
+                user = await User.create(data)
+              }
+              token = await ctx.auth.use('api').generate(user, { expiresIn: '12 hours' })
+            } else {
+              token = await ctx.auth.use('api').attempt(email, password)
+              user = ctx.auth.use('api').user!
+              if (!ctx.auth.use('api').user) {
+                return ctx.response.status(400).json({ message: 'Invalid credentials', token })
+              }
+              await ctx.auth.user?.merge({ isLocked: false }).save()
+            }
+  
+            if (user) return ctx.response.json({ ...user.serialize(), token, sso_url })
+          } catch (e) {
+            this.logger.error(`Error login: ${e.message}`)
+          }
+          return ctx.response.status(400).json({ message: 'Invalid credentials' })
+        }
+     */
+    get isEnable() {
+        return this.config.enable;
+    }
+    getApps() {
+        const subject = 'apps';
+        this.setAuthToken(subject);
+        return this.client.get(this.paths[subject]);
     }
     login(email, password) {
         const subject = 'login';
@@ -91,5 +155,13 @@ class AuthService {
         this.setAuthToken(subject);
         return this.client.post(`${this.paths[subject]}/${uuid}/forgot_pin`, { password, user_pin });
     }
+    logoutURL() {
+        const url = `${this.config.host}/sso/${this.config.env}/logout?product=${this.config.product}`;
+        return url;
+    }
+    checkLoginURL() {
+        const url = `${this.config.host}/sso/${this.config.env}/jump/${this.config.product}`;
+        return url;
+    }
 }
 exports.default = AuthService;

package/build/templates/config/AuthService.txt

@@ -2,11 +2,13 @@ import { AuthServiceConfig } from '@ioc:AuthService'
 import Env from '@ioc:Adonis/Core/Env'
 
 const authServiceConfig: AuthServiceConfig = {
+  enable: Env.get('AUTH_ENABLE', true),
   host: Env.get('AUTH_HOST'),
   env: Env.get('AUTH_ENV'),
   type: Env.get('AUTH_PRODUCT_TYPE'),
   iss: Env.get('BASE_URL'),
-  secret: Env.get('AUTH_JWT_TOKEN'),
+  client: Env.get('AUTH_CLIENT'),
+  secret: Env.get('AUTH_SECRET'),
 }
 
 export default authServiceConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webledger-auth-plugin",
-  "version": "1.0.10",
+  "version": "2.0.0",
   "description": "webledger auth service AdonisJS 5 login plugin",
   "main": "build/providers/AuthServiceProvider.js",
   "scripts": {
@@ -12,6 +12,7 @@
     "build": "npm run compile",
     "prepublishOnly": "npm run build",
     "lint": "eslint . --ext=.ts",
+    "link": "npm run build && npm link",
     "format": "prettier --write .",
     "commit": "git-cz",
     "release": "np --message=\"chore(release): %s\"",