@drax/identity-front 0.0.9 → 0.0.10

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -24,22 +24,13 @@
     "format": "prettier --write src/"
   },
   "dependencies": {
-    "@drax/common-front": "^0.0.9"
-  },
-  "peerDependencies": {
-    "pinia": "^2.1.7",
-    "vue": "^3.4.21",
-    "vuetify": "^3.6.4"
+    "@drax/common-front": "^0.0.10"
   },
   "devDependencies": {
     "@rushstack/eslint-patch": "^1.8.0",
     "@tsconfig/node20": "^20.1.4",
-    "@types/jsdom": "^21.1.6",
+    "@types/jsdom": "^21.1.7",
     "@types/node": "^20.12.5",
-    "@vitejs/plugin-vue": "^5.0.4",
-    "@vue/eslint-config-prettier": "^9.0.0",
-    "@vue/eslint-config-typescript": "^13.0.0",
-    "@vue/test-utils": "^2.4.5",
     "@vue/tsconfig": "^0.5.1",
     "cypress": "^13.7.2",
     "eslint": "^8.57.0",
@@ -47,17 +38,13 @@
     "eslint-plugin-vue": "^9.23.0",
     "jsdom": "^24.0.0",
     "npm-run-all2": "^6.1.2",
-    "pinia": "^2.1.7",
     "prettier": "^3.2.5",
     "start-server-and-test": "^2.0.3",
     "typescript": "~5.4.0",
     "vite": "^5.2.8",
     "vite-plugin-css-injected-by-js": "^3.5.1",
     "vite-plugin-dts": "^3.9.1",
-    "vitest": "^1.4.0",
-    "vue": "^3.4.21",
-    "vue-tsc": "^2.0.11",
-    "vuetify": "^3.6.4"
+    "vitest": "^1.4.0"
   },
-  "gitHead": "26465c7ca403bae9b9a67fa249aee660fb4f3dd4"
+  "gitHead": "c30e1965d551cc63001a301b8dc98e26eba3afe1"
 }

package/src/errors/BadCredentialsError.ts

@@ -0,0 +1,8 @@
+class BadCredentialsError extends Error {
+    constructor(message: string = 'Bad credentials') {
+        super(message)
+        this.name = 'BadCredentialsError'
+    }
+}
+
+export default BadCredentialsError

package/src/{core/factories → factories}/providers/AuthProviderFactory.ts

@@ -1,26 +1,26 @@
-import type {IGqlClientInterface, IHttpClientInterface} from '@drax/common-front'
-import {GqlApolloClientFactory, HttpFetchClientFactory} from '@drax/common-front';
-import type {IAuthProviderInterface} from "@/core/interfaces/IAuthProviderInterface";
+import type {IGqlClient, IHttpClient} from '@drax/common-front'
+import {HttpGqlClientFactory, HttpFetchClientFactory} from '@drax/common-front';
+import type {IAuthProvider} from "@/core/interfaces/IAuthProvider";
 import AuthRestProvider from "@/core/providers/rest/AuthRestProvider";
 import AuthGqlProvider from "@/core/providers/gql/AuthGqlProvider";
 class AuthProviderFactory{
-    static create(type: string = 'rest'): IAuthProviderInterface {
+    static create(type: string = 'rest'): IAuthProvider {
         if (type === 'gql') {
             return AuthProviderFactory.createGql()
         }
         return AuthProviderFactory.createRest()
     }
 
-    static createGql(): IAuthProviderInterface {
-        const gqlClient: IGqlClientInterface = GqlApolloClientFactory.create('/graphql')
+    static createGql(): IAuthProvider {
+        const gqlClient: IGqlClient = HttpGqlClientFactory.create('/graphql')
         return new AuthGqlProvider(gqlClient)
     }
 
-    static createRest(): IAuthProviderInterface {
+    static createRest(): IAuthProvider {
         const baseUrl = import.meta.env.API_URL ? import.meta.env.API_URL : ''
         console.log("baseUrl",baseUrl)
         const baseHeaders = new Headers()
-        const httpClient: IHttpClientInterface = HttpFetchClientFactory.create(baseUrl,baseHeaders)
+        const httpClient: IHttpClient = HttpFetchClientFactory.create(baseUrl,baseHeaders)
         return new AuthRestProvider(httpClient)
     }
 }

package/src/{core/factories → factories}/system/AuthSystemFactory.ts

@@ -1,11 +1,11 @@
 import AuthSystem from "@/core/system/AuthSystem";
-import type {IAuthProviderInterface} from "@/core/interfaces/IAuthProviderInterface";
+import type {IAuthProvider} from "@/core/interfaces/IAuthProvider";
 import AuthRestProviderFactory from "@/core/factories/providers/AuthProviderFactory";
 
 class AuthSystemFactory {
 
     static create(type: string = 'rest'): AuthSystem {
-        const provider: IAuthProviderInterface = AuthRestProviderFactory.create(type)
+        const provider: IAuthProvider = AuthRestProviderFactory.create(type)
 
         return new AuthSystem(provider)
     }

package/src/helpers/AuthHelper.ts

@@ -0,0 +1,32 @@
+import {jwtDecodeHelper} from './JwtDecodeHelper.js'
+import type {JwtPayload} from './JwtDecodeHelper'
+
+class AuthHelper {
+
+    static isJWTValid(accessToken: string) {
+        try {
+
+            if (!accessToken) return false
+
+            let payload = jwtDecodeHelper(accessToken) as JwtPayload
+
+            if (!payload.exp) return false
+
+            let dateToken = new Date(payload.exp * 1000)
+
+            let now = new Date()
+            if (now > dateToken) return false
+
+            return true
+
+        } catch (err) {
+            console.error("isJWTValid", err)
+            return false
+        }
+
+    }
+
+}
+
+export default AuthHelper
+export {AuthHelper}

package/src/helpers/JwtDecodeHelper.ts

@@ -0,0 +1,79 @@
+export class InvalidTokenError extends Error {
+}
+InvalidTokenError.prototype.name = "InvalidTokenError";
+
+export interface JwtDecodeOptions {
+    header?: boolean;
+}
+export interface JwtHeader {
+    typ?: string;
+    alg?: string;
+    kid?: string;
+}
+export interface JwtPayload {
+    iss?: string;
+    sub?: string;
+    aud?: string[] | string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+}
+
+
+function b64DecodeUnicode(str:string) {
+    return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+        let code = p.charCodeAt(0).toString(16).toUpperCase();
+        if (code.length < 2) {
+            code = "0" + code;
+        }
+        return "%" + code;
+    }));
+}
+function base64UrlDecode(str:string) {
+    let output = str.replace(/-/g, "+").replace(/_/g, "/");
+    switch (output.length % 4) {
+        case 0:
+            break;
+        case 2:
+            output += "==";
+            break;
+        case 3:
+            output += "=";
+            break;
+        default:
+            throw new Error("base64 string is not of the correct length");
+    }
+    try {
+        return b64DecodeUnicode(output);
+    }
+    catch (err) {
+        return atob(output);
+    }
+}
+export function jwtDecodeHelper(token:string, options?: JwtDecodeOptions):JwtPayload|JwtHeader {
+    if (typeof token !== "string") {
+        throw new InvalidTokenError("Invalid token specified: must be a string");
+    }
+    options || (options = {});
+    const pos = options.header === true ? 0 : 1;
+    const part = token.split(".")[pos];
+    if (typeof part !== "string") {
+        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+    }
+    let decoded;
+    try {
+        decoded = base64UrlDecode(part);
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : "unknown error";
+        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${errorMessage})`);
+    }
+    try {
+        return JSON.parse(decoded);
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : "unknown error";
+        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${errorMessage})`);
+    }
+}

package/src/i18n/identity-permissions-i18n.ts

@@ -0,0 +1,43 @@
+const messages = {
+    en: {
+        permission: {
+            'user':'User',
+            'role':'Role',
+            'permissions': 'Permissions',
+            'user:view': 'View User',
+            'user:create': 'Create User',
+            'user:update': 'Edit User',
+            'user:delete': 'Delete User',
+            'user:manage': 'Manage User',
+            'role:view': 'View Role',
+            'role:create': 'Create Role',
+            'role:edit': 'Edit Role',
+            'role:delete': 'Delete Role',
+            'role:manage': 'Manage Role',
+            'role:permissions': 'Permissions',
+
+        }
+    },
+    es: {
+        permission: {
+            'user':'Usuario',
+            'role':'Rol',
+            'permissions': 'Permisos',
+            'user:view': 'Ver Usuario',
+            'user:create': 'Crear Usuario',
+            'user:update': 'Editar Usuario',
+            'user:delete': 'Eliminar Usuario',
+            'user:manage': 'Administrar Usuario',
+            'role:view': 'Ver Rol',
+            'role:create': 'Crear Rol',
+            'role:edit': 'Editar Rol',
+            'role:delete': 'Eliminar Rol',
+            'role:manage': 'Administrar Rol',
+            'role:permissions': 'Permisos',
+
+        }
+    }
+}
+
+
+export default messages

package/src/i18n/identity-role-i18n.ts

@@ -0,0 +1,27 @@
+const messages = {
+    en: {
+        role: {
+            name: "Name",
+            permissions: "Username",
+            readonly: "Read Only",
+            updating: "Updating Role",
+            creating: "Creating Role",
+            deleting: "Deleting Role",
+            managing: 'Managing Role',
+        }
+    },
+    es: {
+        role:{
+            name: "Nombre",
+            permissions: "Permisos",
+            readonly: "Solo lectura",
+            updating: "Actualizando Rol",
+            creating: "Creando Rol",
+            deleting: "Eliminando Rol",
+            managing: 'Gestionando Rol',
+        }
+    }
+}
+
+
+export default messages

package/src/i18n/identity-user-i18n.ts

@@ -0,0 +1,59 @@
+const messages = {
+    en: {
+        user: {
+            name: "Name",
+            username: "Username",
+            email: "Email",
+            password: "Password",
+            phone: "Phone",
+            avatar: "Avatar",
+            role: "Role",
+            active: "Active",
+            groups: "Groups",
+            code: "Code",
+            currentPassword: "Current Password",
+            newPassword: "New Password",
+            confirmPassword: "Confirm Password",
+            changeOwnPassword: "Change Password",
+            passwordChanged: "Password Changed",
+            updating: "Updating User",
+            creating: "Creating User",
+            deleting: "Deleting User",
+            changingPassword: "Changing User Password",
+            managing: 'Managing Users',
+            profile:'Profile',
+            login:'Login',
+            logout:'Logout'
+        }
+    },
+    es: {
+        user:{
+            name: "Nombre",
+            username: "Usuario",
+            email: "Email",
+            password: "Clave",
+            phone: "Télefono",
+            avatar: "Avatar",
+            role: "Rol",
+            active: "Activo",
+            groups: "Grupos",
+            code: "Codigo",
+            currentPassword: "Clave Actual",
+            newPassword: "Nueva Clave",
+            confirmPassword: "Confirmar Clave",
+            changeOwnPassword: "Cambiar Clave",
+            passwordChanged: "Clave Cambiada",
+            updating: "Actualizando Usuario",
+            creating: "Creando Usuario",
+            deleting: "Eliminando Usuario",
+            changingPassword: "Cambiando Clave de Usuario",
+            managing: 'Administrando Usuarios',
+            profile:'Perfil',
+            login:'Iniciar Sesión',
+            logout:'Cerrar Sesión'
+        }
+    }
+}
+
+
+export default messages

package/src/i18n/identity-validation-i18n.ts

@@ -0,0 +1,29 @@
+const messages = {
+    en: {
+        validation: {
+            email: {
+                invalid: 'Invalid Email',
+            },
+            password: {
+                min8: 'Password must be at least 8 characters long',
+                max32: 'Password must be at most 32 characters long',
+                confirmed: 'Passwords do not match',
+            },
+        }
+    },
+    es: {
+        validation: {
+            email:{
+                invalid: 'Email invalido',
+            },
+            password:{
+                min8: 'La contraseña debe tener al menos 8 caracteres',
+                max32: 'La contraseña debe tener como maximo 32 caracteres',
+                confirmed: 'Las contraseñas no coinciden',
+            },
+        }
+    }
+}
+
+
+export default messages

package/src/i18n/index.ts

@@ -0,0 +1,10 @@
+import merge from 'deepmerge'
+import identityValidationI18n from "./identity-validation-i18n.js";
+import identityPermissionI18n from "./identity-permissions-i18n.js";
+import identityUserI18n from "./identity-user-i18n.js";
+import identityRoleI18n from "./identity-role-i18n.js";
+
+const IdentityI18nMessages = merge.all([identityValidationI18n, identityUserI18n, identityRoleI18n, identityPermissionI18n])
+
+export default IdentityI18nMessages
+export {IdentityI18nMessages}

package/src/index.ts

@@ -1,26 +1,62 @@
-import IdentityLogin from "@/components/IdentityLogin/IdentityLogin.vue";
-import AuthSystem from "./core/system/AuthSystem.js"
-import AuthRestProvider from "./core/providers/rest/AuthRestProvider.js";
-import AuthGqlProvider from "./core/providers/gql/AuthGqlProvider.js";
-import {useAuthStore} from "./stores/auth/AuthStore.js";
+import AuthSystem from "./system/AuthSystem.js"
+import UserSystem from "./system/UserSystem.js"
+import RoleSystem from "./system/RoleSystem.js"
+import {AuthHelper} from "./helpers/AuthHelper.js"
+import {jwtDecodeHelper} from "./helpers/JwtDecodeHelper.js"
 
-import type {IAuthProviderInterface} from "./core/interfaces/IAuthProviderInterface"
+import AuthRestProvider from "./providers/rest/AuthRestProvider.js";
+import AuthGqlProvider from "./providers/gql/AuthGqlProvider.js";
+
+import UserRestProvider from "./providers/rest/UserRestProvider.js";
+import UserGqlProvider from "./providers/gql/UserGqlProvider.js";
+
+import RoleRestProvider from "./providers/rest/RoleRestProvider.js";
+import RoleGqlProvider from "./providers/gql/RoleGqlProvider.js";
+
+import {IdentityI18nMessages} from "./i18n/index.js"
+
+import type {IAuthProvider} from "./interfaces/IAuthProvider"
+import type {IUserProvider} from "./interfaces/IUserProvider"
+import type {IRoleProvider} from "./interfaces/IRoleProvider"
+import type {IAuthUser} from "./interfaces/IAuthUser"
+import type {IUser, IUserCreate, IUserUpdate, IUserPassword} from "./interfaces/IUser"
+import type {IRole} from "./interfaces/IRole"
+import type {ILoginResponse} from "./interfaces/ILoginResponse"
 
 export type {
-    IAuthProviderInterface
+    IAuthProvider,
+    IUserProvider,
+    IRoleProvider,
+    IAuthUser,
+    IUser,
+    IUserCreate,
+    IUserUpdate,
+    IUserPassword,
+    IRole,
+    ILoginResponse
 }
 
 export {
-    //Vue Components
-    IdentityLogin,
-
     //Providers
     AuthRestProvider,
     AuthGqlProvider,
 
+    UserGqlProvider,
+    UserRestProvider,
+
+    RoleGqlProvider,
+    RoleRestProvider,
+
     //Systems
     AuthSystem,
+    UserSystem,
+    RoleSystem,
+
+    //Helpers
+    AuthHelper,
+    jwtDecodeHelper,
+
+    //I18n
+    IdentityI18nMessages
 
-    //Stores
-    useAuthStore
 }

package/src/interfaces/IAuthProvider.ts

@@ -0,0 +1,12 @@
+import type {IAuthUser} from "@/interfaces/IAuthUser";
+import type {ILoginResponse} from "@/interfaces/ILoginResponse";
+
+interface IAuthProvider {
+    login(username: string, password: string): Promise<ILoginResponse>
+    me(): Promise<IAuthUser>
+    logout(): void
+    changeOwnPassword(currentPassword:string, newPassword:string):Promise<boolean>
+
+}
+
+export type {IAuthProvider}

package/src/interfaces/IAuthUser.ts

@@ -0,0 +1,15 @@
+import type {IRole} from "@/interfaces/IRole";
+
+interface IAuthUser {
+    id: string
+    username: string
+    email: string
+    active: boolean
+    name: string
+    phone: string
+    avatar: string
+    role: IRole
+
+}
+
+export type {IAuthUser}

package/src/interfaces/ILoginResponse.ts

@@ -0,0 +1,5 @@
+interface ILoginResponse {
+    accessToken: string;
+}
+
+export type {ILoginResponse}

package/src/interfaces/IRole.ts

@@ -0,0 +1,10 @@
+
+interface IRole{
+    id ?: string
+    name: string
+    permissions: string[]
+    childRoles?: IRole[]
+    readonly: boolean
+}
+
+export type {IRole}

package/src/interfaces/IRoleProvider.ts

@@ -0,0 +1,13 @@
+import type {IRole} from "@/interfaces/IRole";
+import type {IPaginateClient} from "@drax/common-front";
+
+interface IRoleProvider {
+    fetchRole(): Promise<any>
+    fetchPermissions(): Promise<any>
+    paginateRole(page: number, limit: number, search:string): Promise<IPaginateClient>
+    createRole(input: IRole): Promise<any>
+    editRole(id: string, input: IRole): Promise<IRole>
+    deleteRole(id: string): Promise<any>
+}
+
+export type {IRoleProvider}

package/src/interfaces/IUser.ts

@@ -0,0 +1,39 @@
+import type {IRole} from "@/interfaces/IRole";
+
+interface IUser {
+    id: string
+    name: string
+    username: string
+    email: string
+    active: boolean
+    phone: string
+    avatar: string
+    role: IRole
+
+}
+
+interface IUserCreate {
+    name: string
+    username: string
+    password: string
+    email: string
+    active: boolean
+    phone: string
+    role: string
+}
+
+interface IUserUpdate {
+    name: string
+    username: string
+    email: string
+    active: boolean
+    phone: string
+    role: string
+}
+
+interface IUserPassword {
+    newPassword: string
+    confirmPassword: string
+}
+
+export type {IUser, IUserCreate, IUserUpdate, IUserPassword}

package/src/interfaces/IUserProvider.ts

@@ -0,0 +1,14 @@
+import type {IUser, IUserCreate, IUserUpdate} from "@/interfaces/IUser";
+import type {IPaginateClient} from "@drax/common-front";
+
+
+
+interface IUserProvider {
+    paginateUser(page: number, limit: number, search?:string): Promise<IPaginateClient>
+    createUser(input: IUserCreate): Promise<IUser>
+    editUser(id: string, input: IUserUpdate): Promise<IUser>
+    deleteUser(id: string): Promise<any>
+    changeUserPassword(id: string, newPassword: string): Promise<boolean>
+}
+
+export type {IUserProvider}

package/src/providers/gql/AuthGqlProvider.ts

@@ -0,0 +1,59 @@
+import type {IGqlClient} from '@drax/common-front'
+import type {IAuthProvider} from "../../interfaces/IAuthProvider.ts";
+import type {IAuthUser} from "../../interfaces/IAuthUser";
+import type {ILoginResponse} from "../../interfaces/ILoginResponse";
+
+class AuthGqlProvider implements IAuthProvider {
+
+    gqlClient: IGqlClient
+
+    constructor(gqlClient: IGqlClient) {
+        this.gqlClient = gqlClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.gqlClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.gqlClient.removeHeader('Authorization')
+    }
+
+    logout(): void {
+        this.removeHttpClientToken()
+    }
+
+    async login(username: string, password: string): Promise<ILoginResponse> {
+
+        const query: string = `mutation auth($input: AuthInput) { auth(input: $input) {accessToken} }`
+        const variables = {input: {username, password}}
+        let data = await this.gqlClient.mutation(query, variables)
+        const {accessToken} = data.auth
+        this.setHttpClientToken(accessToken)
+        return {accessToken}
+    }
+
+    async me(): Promise<IAuthUser> {
+        const query: string = `query me { me {id,username, email, role {id, name, permissions}} }`
+        let data = await this.gqlClient.query(query)
+        return data.me
+    }
+
+    async changeOwnPassword(currentPassword: string, newPassword: string): Promise<boolean> {
+        const query: string = `mutation changeOwnPassword($currentPassword: String!, $newPassword: String!) 
+        { changeOwnPassword(currentPassword: $currentPassword, newPassword: $newPassword) }`
+        const variables = {currentPassword, newPassword}
+        let r = await this.gqlClient.mutation(query, variables)
+        return /true/i.test(r as string)
+    }
+
+    async changeUserPassword(currentPassword: string, newPassword: string): Promise<boolean> {
+        const query: string = `mutation changeUserPassword($userId: ID!, $newPassword: String!) 
+        { changeUserPassword(userId: $userId, newPassword: $newPassword) }`
+        const variables = {currentPassword, newPassword}
+        let r = await this.gqlClient.mutation(query, variables)
+        return /true/i.test(r as string)
+    }
+}
+
+export default AuthGqlProvider