@drax/identity-back 0.0.3

package/src/graphql/resolvers/auth.resolvers.ts

@@ -0,0 +1,19 @@
+import AuthServiceFactory from "../../factory/AuthServiceFactory.js";
+
+const authService = AuthServiceFactory()
+export default {
+    Query: {
+
+    },
+    Mutation: {
+        auth: async (_,{input}) => {
+            try{
+                return await authService.auth(input.username, input.password)
+            }catch (e) {
+                console.log(e)
+            }
+
+        },
+
+    }
+}

package/src/graphql/resolvers/role.resolvers.ts

@@ -0,0 +1,25 @@
+import RoleServiceFactory from "../../factory/RoleServiceFactory.js";
+
+const roleService = RoleServiceFactory()
+export default {
+    Query: {
+        findRoleById:  async (_,{id}) => {
+            return await roleService.findById(id)
+        },
+        paginateRole: async () => {
+            return await roleService.paginate()
+        }
+    },
+    Mutation: {
+        createRole: async (_,{input}) => {
+            return await roleService.create(input)
+
+        },
+        updateRole: async (_,{id, input}) => {
+            return await roleService.update(id, input)
+        },
+        deleteRole: async (_,{id}) => {
+            return await roleService.delete(id)
+        }
+    }
+}

package/src/graphql/resolvers/user.resolvers.ts

@@ -0,0 +1,27 @@
+import UserServiceFactory from "../../factory/UserServiceFactory.js";
+
+const userService = UserServiceFactory()
+export default {
+    Query: {
+        findUserById:  async (_,{id}) => {
+            return await userService.findById(id)
+        },
+        paginateUser: async () => {
+            console.log("paginateUser")
+            return await userService.paginate()
+        }
+    },
+    Mutation: {
+        createUser: async (_,{input}) => {
+            console.log("createUser")
+            const user =  await userService.create(input)
+            return user
+        },
+        updateUser: async (_,{id, input}) => {
+            return await userService.update(id, input)
+        },
+        deleteUser: async (_,{id}) => {
+            return await userService.delete(id)
+        }
+    }
+}

package/src/graphql/types/auth.graphql

@@ -0,0 +1,8 @@
+input AuthInput{
+    username: String!
+    password: String!
+}
+
+type Mutation{
+    auth(input: AuthInput): String
+}

package/src/graphql/types/role.graphql

@@ -0,0 +1,32 @@
+type Role {
+    _id: ID!
+    name: String
+    readonly: Boolean
+    childRoles: [Role]
+    permissions: [String]
+}
+
+type RolePaginated{
+    totalDocs: Int
+    page: Int
+    limit: Int
+    docs: [Role]
+}
+
+type Query{
+    paginateRole: RolePaginated
+    findRoleById(id: ID): Role
+}
+
+input RoleInput{
+    name: String
+    permissions: [String]
+    readonly: Boolean
+    childRoles: [ID]
+}
+
+type Mutation{
+    createRole(input: RoleInput): Role
+    updateRole(id: ID!, input: RoleInput): Role
+    deleteRole(id: ID!): Boolean
+}

package/src/graphql/types/user.graphql

@@ -0,0 +1,34 @@
+type User {
+    _id: ID!
+    username: String!
+    email: String
+    role: Role
+    phone: String
+
+}
+
+type UserPaginated{
+    totalDocs: Int
+    page: Int
+    limit: Int
+    docs: [User]
+}
+
+type Query{
+    findUserByUsername(username: String!): User
+    findUserById(id: ID!): User
+    paginateUser: UserPaginated
+}
+
+input UserInput{
+    username: String!
+    email: String!
+    password: String!
+    role: ID
+}
+
+type Mutation{
+    createUser(input: UserInput): User
+    updateUser(id: ID!, input: UserInput): User
+    deleteUser(id: ID!): Boolean
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+import GraphqlMerge from "./graphql/index.js"
+import UserServiceFactory from "./factory/UserServiceFactory.js";
+import RoleServiceFactory from "./factory/RoleServiceFactory.js";
+import AuthServiceFactory from "./factory/AuthServiceFactory.js";
+
+const graphqlMergeResult = await GraphqlMerge()
+const identityTypeDefs = await graphqlMergeResult.typeDefs;
+const identityResolvers = await graphqlMergeResult.resolvers;
+
+const userService = UserServiceFactory()
+const roleService = RoleServiceFactory()
+
+const authService = AuthServiceFactory()
+
+export {
+    identityTypeDefs,
+    identityResolvers,
+    userService,
+    roleService,
+    authService
+}
+
+
+/// <reference types="index.d.ts" />

package/src/interfaces/IRole.ts

@@ -0,0 +1,11 @@
+import {mongoose} from "@drax/common-back";
+
+interface IRole{
+    _id?: mongoose.Types.ObjectId
+    name: string
+    permissions: string[]
+    childRoles?: mongoose.Types.ObjectId[]
+    readonly: boolean
+}
+
+export {IRole}

package/src/interfaces/IRoleRepository.ts

@@ -0,0 +1,11 @@
+import {IRole} from './IRole'
+interface IRoleRepository{
+    create(role: IRole): Promise<IRole>;
+    update(_id: any, updatedRole: IRole): Promise<IRole | null>;
+    delete(_id: any): Promise<boolean>;
+    findById(_id: any): Promise<IRole | null>;
+
+    paginate(query: any, options: any): any;
+}
+
+export {IRoleRepository}

package/src/interfaces/IUser.ts

@@ -0,0 +1,21 @@
+import {mongoose} from "@drax/common-back";
+import {IRole} from "./IRole";
+import {IUserGroup} from "./IUserGroup";
+
+interface IUser {
+    _id?: mongoose.Types.ObjectId
+    username: string
+    email: string
+    password: string
+    active: boolean
+    name?: string
+    phone?: string
+    avatar?: string
+    avatarurl?: string
+    code?: string
+    role: mongoose.Types.ObjectId | IRole
+    groups: mongoose.Types.ObjectId[] | IUserGroup[]
+
+}
+
+export {IUser}

package/src/interfaces/IUserGroup.ts

@@ -0,0 +1,10 @@
+import {mongoose} from "@drax/common-back";
+import {IUser} from "./IUser";
+
+interface IUserGroup{
+    _id?: mongoose.Types.ObjectId
+    name: string
+    users: mongoose.Types.ObjectId[] | IUser[]
+}
+
+export {IUserGroup}

package/src/interfaces/IUserRepository.ts

@@ -0,0 +1,11 @@
+import {IUser} from './IUser'
+interface IUserRepository{
+    create(role: IUser): Promise<IUser>;
+    update(_id: any, updatedRole: IUser): Promise<IUser | null>;
+    delete(_id: any): Promise<boolean>;
+    findById(_id: any): Promise<IUser | null>;
+    findByUsername(username: string): Promise<IUser | null>;
+    paginate(query: any, options: any): any;
+}
+
+export {IUserRepository}

package/src/models/RoleModel.ts

@@ -0,0 +1,48 @@
+import {mongoose, MongooseSoftDelete} from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import {IRole} from '../interfaces/IRole'
+const Schema = mongoose.Schema
+import {PaginateModel} from "mongoose";
+
+
+const RoleSchema = new Schema<IRole>({
+    name: {
+        type: String, unique: true, required: true, index: true,
+        validate: [
+            {
+                validator: function(v) {
+                    return !/(\s){2}/.test(v);
+                },
+                message: props => `Role name cant contain two spaces`
+            },
+
+        ],
+    },
+    permissions: [{type: String, required: true}],
+    childRoles: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Role',
+        required: false,
+    }],
+    readonly: {type: Boolean, required: false, default: false},
+});
+
+RoleSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+RoleSchema.plugin(MongooseSoftDelete);
+RoleSchema.plugin(mongoosePaginate);
+
+
+RoleSchema.set('toJSON', {getters: true});
+
+const ROLE_MODEL_NAME = 'Role';
+const ROLE_COLLECTION_NAME = 'roles';
+const RoleModel = mongoose.model<IRole, PaginateModel<IRole>>(ROLE_MODEL_NAME, RoleSchema,ROLE_COLLECTION_NAME);
+
+export {
+    RoleSchema,
+    RoleModel
+}
+
+export default RoleModel
+

package/src/models/UserGroupModel.ts

@@ -0,0 +1,48 @@
+import {mongoose, MongooseSoftDelete} from '@drax/common-back';
+import {IUserGroup} from "../interfaces/IUserGroup";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import {PaginateModel} from "mongoose";
+
+
+// Defining user Mongoose Schema
+const UserGroupSchema = new mongoose.Schema<IUserGroup>({
+    name: {
+        type: String,
+        unique: true,
+        required: true,
+        index: true,
+        validate: {
+            validator: function (value: string) {
+                let r = /^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$/;
+                return r.test(value);
+            },
+            message: "Invalid name format"
+        }
+    },
+    users: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: false,
+    }],
+}, {timestamps: true});
+
+UserGroupSchema.set('toJSON', {getters: true});
+
+UserGroupSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+
+UserGroupSchema.plugin(MongooseSoftDelete);
+UserGroupSchema.plugin(mongoosePaginate);
+
+const USERGROUP_MODEL_NAME = 'UserGroup';
+const USERGROUP_COLLECTION_NAME = 'userGroups';
+
+const UserGroupModel = mongoose.model<IUserGroup,PaginateModel<IUserGroup>>(USERGROUP_MODEL_NAME, UserGroupSchema,USERGROUP_COLLECTION_NAME);
+
+export {
+    UserGroupSchema,
+    UserGroupModel
+}
+
+export default UserGroupModel
+

package/src/models/UserModel.ts

@@ -0,0 +1,94 @@
+import {mongoose, MongooseSoftDelete} from '@drax/common-back';
+import {IUser} from "../interfaces/IUser";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import {PaginateModel} from "mongoose";
+
+
+// Defining user Mongoose Schema
+const UserSchema = new mongoose.Schema<IUser>({
+    username: {
+        type: String,
+        unique: true,
+        required: true,
+        index: true,
+        validate: {
+            validator: function (value: string) {
+                let r = /^[a-zA-Z0-9]+$/;
+                return r.test(value);
+            },
+            message: "Invalid username format"
+        }
+    },
+    email: {
+        type: String,
+        unique: true,
+        required: true,
+        index: true,
+        validate: {
+            validator: function (value: string) {
+                let r = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
+                return r.test(value);
+            },
+            message: "Invalid email format"
+        }
+    },
+    password: {type: String, required: true},
+    code: {type: String, required: false},
+    name: {type: String, required: false},
+    active: {type: Boolean, required: true, default: false},
+    phone: {
+        type: String,
+        required: false,
+        validate: {
+            validator: function (value: string) {
+                let r = /[0-9]+/;
+                return value ? r.test(value) : true;
+            },
+            message: "Invalid Phone format"
+        }
+    },
+    avatar: {type: String, required: false},
+    avatarurl: {type: String, required: false},
+    role: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Role',
+        required: true,
+    },
+    groups: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Group',
+        required: false,
+    }],
+  /*  refreshToken: {
+        type: [
+            {
+                id: {type: String},
+                expiryDate: {type: Date},
+                sessionId: {type: String},
+            }
+        ],
+        default: [],
+        _id: false
+    }*/
+}, {timestamps: true});
+
+UserSchema.set('toJSON', {getters: true});
+
+UserSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+
+UserSchema.plugin(MongooseSoftDelete);
+UserSchema.plugin(mongoosePaginate);
+
+const USER_MODEL_NAME = 'User';
+const USER_COLLECTION_NAME = 'users';
+
+const UserModel = mongoose.model<IUser,PaginateModel<IUser>>(USER_MODEL_NAME, UserSchema,USER_COLLECTION_NAME);
+
+export {
+    UserSchema,
+    UserModel
+}
+
+export default UserModel
+

package/src/repository/RoleRepository.ts

@@ -0,0 +1,42 @@
+import {RoleModel} from "../models/RoleModel.js";
+import {IRole} from '../interfaces/IRole'
+import {IRoleRepository} from '../interfaces/IRoleRepository'
+import {mongoose} from "@drax/common-back";
+import {FilterQuery, PaginateOptions, PaginateResult} from "mongoose";
+import {DeleteResult} from "mongodb";
+
+class RoleRepository implements IRoleRepository{
+
+    async create(roleData: IRole): Promise<IRole> {
+        const role : mongoose.HydratedDocument<IRole> = new RoleModel(roleData)
+        await role.save()
+        return role
+    }
+
+    async update(_id: mongoose.Types.ObjectId, roleData: IRole): Promise<IRole> {
+        const role : mongoose.HydratedDocument<IRole> = await RoleModel.findOneAndUpdate(_id, roleData, {new: true}).exec()
+        return role
+    }
+
+    async delete(_id: mongoose.Types.ObjectId): Promise<boolean> {
+        const result : DeleteResult = await RoleModel.deleteOne(_id).exec()
+        return result.deletedCount == 1
+    }
+
+    async findById(_id: mongoose.Types.ObjectId): Promise<IRole | null>{
+        const role: mongoose.HydratedDocument<IRole> | null = await RoleModel.findById(_id).exec()
+        return role
+    }
+
+    async fetch(): Promise<IRole[]>{
+        const roles: mongoose.HydratedDocument<IRole>[] = await RoleModel.find().exec()
+        return roles
+    }
+
+    async paginate(query ?: FilterQuery<IRole>, options ?: PaginateOptions): Promise<PaginateResult<IRole>>{
+        const roles: PaginateResult<IRole> = await RoleModel.paginate(query, options)
+        return roles
+    }
+}
+
+export default RoleRepository

package/src/repository/UserRepository.ts

@@ -0,0 +1,47 @@
+import {UserModel} from "../models/UserModel.js";
+import {mongoose} from "@drax/common-back"
+import {FilterQuery, PaginateOptions, PaginateResult} from "mongoose";
+import {IUser} from "../interfaces/IUser";
+import {DeleteResult} from "mongodb";
+
+class UserRepository {
+
+    async create(userData: IUser): Promise<IUser> {
+        const user: mongoose.HydratedDocument<IUser> = new UserModel(userData)
+        await user.save()
+        await user.populate('role')
+        return user
+    }
+
+    async update(_id: mongoose.Types.ObjectId, userData: IUser): Promise<IUser> {
+        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOneAndUpdate(_id, userData).populate('role').exec()
+        return user
+    }
+
+    async delete(_id: mongoose.Types.ObjectId): Promise<boolean> {
+        const result: DeleteResult = await UserModel.deleteOne(_id).exec()
+        return result.deletedCount == 1
+    }
+
+    async findById(_id: mongoose.Types.ObjectId): Promise<IUser> {
+        console.log("_id",_id)
+        const user: mongoose.HydratedDocument<IUser> = await UserModel.findById(_id).populate('role').exec()
+        console.log("user",user)
+        return user
+    }
+
+    async findByUsername(username: string): Promise<IUser> {
+        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOne({username: username}).populate('role').exec()
+        return user
+    }
+
+    async paginate(query ?: FilterQuery<IUser>, options ?: PaginateOptions): Promise<PaginateResult<IUser>> {
+
+        options.populate = ['role']
+
+        const userPaginated: PaginateResult<IUser> = await UserModel.paginate(query, options)
+        return userPaginated
+    }
+}
+
+export default UserRepository

package/src/services/AuthService.ts

@@ -0,0 +1,29 @@
+import UserService from "./UserService.js";
+import AuthUtils from "../utils/AuthUtils.js";
+class AuthService {
+
+    private _userService: UserService;
+
+    constructor(userService : UserService) {
+        this._userService = userService
+    }
+
+
+    async auth(username : string, password : string){
+        let user = null
+
+        user = await this._userService.findByUsername(username)
+
+        //Si obtuve usuario chequeo la password
+        if (user && AuthUtils.checkPassword(password, user.password)) {
+            //TODO: Generar Sesion
+            const session = '123'
+            const token = AuthUtils.generateToken(user._id.toString(), user.username, session)
+            return token
+        }else{
+            throw Error('BadCredentials')
+        }
+    }
+}
+
+export default AuthService

package/src/services/RoleService.ts

@@ -0,0 +1,51 @@
+import {IRole} from "../interfaces/IRole";
+import {IRoleRepository} from "../interfaces/IRoleRepository";
+import { IPaginateFilter} from "@drax/common-back"
+
+class RoleService {
+
+    _repository: IRoleRepository
+
+    constructor(roleRepostitory: IRoleRepository) {
+        this._repository = roleRepostitory
+    }
+
+    async create(roleData: IRole): Promise<IRole> {
+        const role = await this._repository.create(roleData)
+        return role
+    }
+
+    async update(_id: any, roleData: IRole) {
+        const role = await this._repository.update(_id, roleData)
+        return role
+    }
+
+    async delete(_id: any): Promise<boolean> {
+        const deletedRole = await this._repository.delete(_id);
+        return deletedRole;
+    }
+
+    async findById(_id: any): Promise<IRole | null> {
+        const role : IRole =  await this._repository.findById(_id);
+        return role
+    }
+
+    async paginate(filters ?: IPaginateFilter, page: number = 1, limit: number = 10): Promise<{ roles: IRole[], totalCount: number }> {
+
+        const query = {
+
+        }
+
+        const options = {
+            page: page,
+            limit: limit
+        }
+
+        const pagination = await this._repository.paginate(query, options);
+        return pagination;
+    }
+
+
+}
+
+export default RoleService

package/src/services/UserService.ts

@@ -0,0 +1,67 @@
+import {IPaginateFilter} from "@drax/common-back"
+import {IUser} from "../interfaces/IUser";
+import {IUserRepository} from "../interfaces/IUserRepository";
+import AuthUtils from "../utils/AuthUtils.js";
+
+class UserService {
+
+    _repository: IUserRepository
+
+    constructor(userRepository: IUserRepository) {
+        this._repository = userRepository;
+    }
+
+    async create(userData: IUser): Promise<IUser> {
+
+        userData.name = userData?.name?.trim()
+        userData.username = userData.username.trim()
+        userData.password = AuthUtils.hashPassword(userData.password.trim())
+
+        const user: IUser = await this._repository.create(userData)
+        return user
+    }
+
+    async update(_id: any, userData: IUser) {
+
+        userData.name = userData.name.trim()
+        userData.username = userData.username.trim()
+        delete userData.password
+
+        const user: IUser = await this._repository.update(_id, userData)
+        return user
+    }
+
+    async delete(_id: any): Promise<boolean> {
+        const deletedRole: boolean = await this._repository.delete(_id);
+        return deletedRole;
+    }
+
+    async findById(_id: any): Promise<IUser | null> {
+        const user: IUser = await this._repository.findById(_id);
+        return user
+    }
+
+    async findByUsername(username: string): Promise<IUser | null> {
+        const user: IUser = await this._repository.findByUsername(username);
+        return user
+    }
+
+    async paginate(filters ?: IPaginateFilter, page : number = 1, limit : number = 10): Promise<{
+        roles: IUser[],
+        totalCount: number
+    }> {
+
+        const query = {}
+
+        const options = {
+            page: page,
+            limit: limit
+        }
+
+        const pagination = await this._repository.paginate(query, options);
+        console.log("pagination",pagination)
+        return pagination;
+    }
+}
+
+export default UserService