@drax/identity-back 0.0.3

package/dist/factory/AuthServiceFactory.js

@@ -0,0 +1,8 @@
+import AuthService from "../services/AuthService.js";
+import UserServiceFactory from "./UserServiceFactory.js";
+const AuthServiceFactory = () => {
+    const userService = UserServiceFactory();
+    const authService = new AuthService(userService);
+    return authService;
+};
+export default AuthServiceFactory;

package/dist/factory/RoleServiceFactory.js

@@ -0,0 +1,8 @@
+import RoleService from "../services/RoleService.js";
+import RoleRepository from "../repository/RoleRepository.js";
+const RoleServiceFactory = () => {
+    const roleRepository = new RoleRepository;
+    const roleService = new RoleService(roleRepository);
+    return roleService;
+};
+export default RoleServiceFactory;

package/dist/factory/UserServiceFactory.js

@@ -0,0 +1,8 @@
+import UserRepository from "../repository/UserRepository.js";
+import UserService from "../services/UserService.js";
+const UserServiceFactory = () => {
+    const userRepository = new UserRepository;
+    const userService = new UserService(userRepository);
+    return userService;
+};
+export default UserServiceFactory;

package/dist/graphql/index.js

@@ -0,0 +1,7 @@
+import { GraphqlMerger } from "@drax/common-back";
+export default async () => {
+    const __dirname = new URL(".", import.meta.url).pathname;
+    const typeDefs = GraphqlMerger.mergeTypeDefs(__dirname);
+    const resolvers = GraphqlMerger.mergeResolvers(__dirname);
+    return { typeDefs, resolvers };
+};

package/dist/graphql/resolvers/auth.resolvers.js

@@ -0,0 +1,15 @@
+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/dist/graphql/resolvers/role.resolvers.js

@@ -0,0 +1,23 @@
+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/dist/graphql/resolvers/user.resolvers.js

@@ -0,0 +1,26 @@
+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/dist/graphql/types/auth.graphql

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

package/dist/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/dist/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/dist/index.js

@@ -0,0 +1,12 @@
+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/dist/interfaces/IRole.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IRoleRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IUser.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IUserGroup.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IUserRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/models/RoleModel.js

@@ -0,0 +1,33 @@
+import { mongoose, MongooseSoftDelete } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const Schema = mongoose.Schema;
+const RoleSchema = new Schema({
+    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(ROLE_MODEL_NAME, RoleSchema, ROLE_COLLECTION_NAME);
+export { RoleSchema, RoleModel };
+export default RoleModel;

package/dist/models/UserGroupModel.js

@@ -0,0 +1,33 @@
+import { mongoose, MongooseSoftDelete } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+// Defining user Mongoose Schema
+const UserGroupSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        unique: true,
+        required: true,
+        index: true,
+        validate: {
+            validator: function (value) {
+                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(USERGROUP_MODEL_NAME, UserGroupSchema, USERGROUP_COLLECTION_NAME);
+export { UserGroupSchema, UserGroupModel };
+export default UserGroupModel;

package/dist/models/UserModel.js

@@ -0,0 +1,79 @@
+import { mongoose, MongooseSoftDelete } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+// Defining user Mongoose Schema
+const UserSchema = new mongoose.Schema({
+    username: {
+        type: String,
+        unique: true,
+        required: true,
+        index: true,
+        validate: {
+            validator: function (value) {
+                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) {
+                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) {
+                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(USER_MODEL_NAME, UserSchema, USER_COLLECTION_NAME);
+export { UserSchema, UserModel };
+export default UserModel;

package/dist/repository/RoleRepository.js

@@ -0,0 +1,29 @@
+import { RoleModel } from "../models/RoleModel.js";
+class RoleRepository {
+    async create(roleData) {
+        const role = new RoleModel(roleData);
+        await role.save();
+        return role;
+    }
+    async update(_id, roleData) {
+        const role = await RoleModel.findOneAndUpdate(_id, roleData, { new: true }).exec();
+        return role;
+    }
+    async delete(_id) {
+        const result = await RoleModel.deleteOne(_id).exec();
+        return result.deletedCount == 1;
+    }
+    async findById(_id) {
+        const role = await RoleModel.findById(_id).exec();
+        return role;
+    }
+    async fetch() {
+        const roles = await RoleModel.find().exec();
+        return roles;
+    }
+    async paginate(query, options) {
+        const roles = await RoleModel.paginate(query, options);
+        return roles;
+    }
+}
+export default RoleRepository;

package/dist/repository/UserRepository.js

@@ -0,0 +1,33 @@
+import { UserModel } from "../models/UserModel.js";
+class UserRepository {
+    async create(userData) {
+        const user = new UserModel(userData);
+        await user.save();
+        await user.populate('role');
+        return user;
+    }
+    async update(_id, userData) {
+        const user = await UserModel.findOneAndUpdate(_id, userData).populate('role').exec();
+        return user;
+    }
+    async delete(_id) {
+        const result = await UserModel.deleteOne(_id).exec();
+        return result.deletedCount == 1;
+    }
+    async findById(_id) {
+        console.log("_id", _id);
+        const user = await UserModel.findById(_id).populate('role').exec();
+        console.log("user", user);
+        return user;
+    }
+    async findByUsername(username) {
+        const user = await UserModel.findOne({ username: username }).populate('role').exec();
+        return user;
+    }
+    async paginate(query, options) {
+        options.populate = ['role'];
+        const userPaginated = await UserModel.paginate(query, options);
+        return userPaginated;
+    }
+}
+export default UserRepository;

package/dist/services/AuthService.js

@@ -0,0 +1,21 @@
+import AuthUtils from "../utils/AuthUtils.js";
+class AuthService {
+    constructor(userService) {
+        this._userService = userService;
+    }
+    async auth(username, password) {
+        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/dist/services/RoleService.js

@@ -0,0 +1,31 @@
+class RoleService {
+    constructor(roleRepostitory) {
+        this._repository = roleRepostitory;
+    }
+    async create(roleData) {
+        const role = await this._repository.create(roleData);
+        return role;
+    }
+    async update(_id, roleData) {
+        const role = await this._repository.update(_id, roleData);
+        return role;
+    }
+    async delete(_id) {
+        const deletedRole = await this._repository.delete(_id);
+        return deletedRole;
+    }
+    async findById(_id) {
+        const role = await this._repository.findById(_id);
+        return role;
+    }
+    async paginate(filters, page = 1, limit = 10) {
+        const query = {};
+        const options = {
+            page: page,
+            limit: limit
+        };
+        const pagination = await this._repository.paginate(query, options);
+        return pagination;
+    }
+}
+export default RoleService;

package/dist/services/UserService.js

@@ -0,0 +1,43 @@
+import AuthUtils from "../utils/AuthUtils.js";
+class UserService {
+    constructor(userRepository) {
+        this._repository = userRepository;
+    }
+    async create(userData) {
+        userData.name = userData?.name?.trim();
+        userData.username = userData.username.trim();
+        userData.password = AuthUtils.hashPassword(userData.password.trim());
+        const user = await this._repository.create(userData);
+        return user;
+    }
+    async update(_id, userData) {
+        userData.name = userData.name.trim();
+        userData.username = userData.username.trim();
+        delete userData.password;
+        const user = await this._repository.update(_id, userData);
+        return user;
+    }
+    async delete(_id) {
+        const deletedRole = await this._repository.delete(_id);
+        return deletedRole;
+    }
+    async findById(_id) {
+        const user = await this._repository.findById(_id);
+        return user;
+    }
+    async findByUsername(username) {
+        const user = await this._repository.findByUsername(username);
+        return user;
+    }
+    async paginate(filters, page = 1, limit = 10) {
+        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;

package/dist/utils/AuthUtils.js

@@ -0,0 +1,36 @@
+import bcryptjs from "bcryptjs";
+import jsonwebtoken from "jsonwebtoken";
+class AuthUtils {
+    static hashPassword(password) {
+        if (!password) {
+            throw new Error("password must be provided");
+        }
+        let salt = bcryptjs.genSaltSync(10);
+        let hashPassword = bcryptjs.hashSync(password, salt);
+        return hashPassword;
+    }
+    static checkPassword(password, hashPassword) {
+        return bcryptjs.compareSync(password, hashPassword);
+    }
+    static tokenSignPayload(userId, username, session) {
+        return {
+            id: userId,
+            username: username,
+            session: session
+        };
+    }
+    static generateToken(userId, username, session) {
+        const payload = AuthUtils.tokenSignPayload(userId, username, session);
+        const JWT_SECRET = process.env.JWT_SECRET ? process.env.JWT_SECRET : 'KRgDV3CeR5lVhsFF';
+        const options = {
+            expiresIn: process.env.JWT_LOGIN_EXPIRED_IN || '1h',
+            jwtid: userId,
+            algorithm: 'HS256',
+            audience: username,
+            issuer: process.env.ISSUER ? process.env.ISSUER : 'drax'
+        };
+        let token = jsonwebtoken.sign(payload, JWT_SECRET, options);
+        return token;
+    }
+}
+export default AuthUtils;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@drax/identity-back",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.3",
+  "description": "Identity module for user management, authentication and authorization.",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "serve": "nodemon --exec node --loader ts-node/esm src/index.ts",
+    "prepublish": "npm run tsc && npm run copygql",
+    "clean": "rm -rf dist",
+    "copygql": "copyfiles -u 1 ./**/*.graphql dist/",
+    "tsc": "tsc -b tsconfig.json",
+    "test": "node --loader tsx --test test/**/*",
+    "testRepositoryRole": "node --loader tsx --test test/repository/role*",
+    "testServiceRole": "node --loader tsx --test test/service/role*",
+    "testRepositoryUser": "node --loader tsx --test test/repository/user*",
+    "testServiceUser": "node --loader tsx --test test/service/user*",
+    "testcoverage": "node --loader tsx --experimental-test-coverage  test/service/*"
+  },
+  "author": "Cristian Incarnato & Drax Team",
+  "license": "ISC",
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "express-jwt": "^8.4.1",
+    "jsonwebtoken": "^9.0.2"
+  },
+  "peerDependencies": {
+    "mongoose": "^8.3.4",
+    "mongoose-paginate-v2": "^1.8.0",
+    "mongoose-unique-validator": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/node": "^20.12.10",
+    "copyfiles": "^2.4.1",
+    "glob": "^10.2.6",
+    "mongodb-memory-server": "^9.2.0",
+    "nodemon": "^3.1.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^3.12.7",
+    "typescript": "^5.4.5"
+  },
+  "config": {
+    "mongodbMemoryServer": {
+      "debug": "0"
+    }
+  },
+  "gitHead": "f47b34b60c6b1392c0ad671461645fa55e5b649b"
+}

package/src/factory/AuthServiceFactory.ts

@@ -0,0 +1,10 @@
+import AuthService from "../services/AuthService.js";
+import UserServiceFactory from "./UserServiceFactory.js";
+
+const AuthServiceFactory = () : AuthService => {
+    const userService = UserServiceFactory()
+    const authService = new AuthService(userService)
+    return authService
+}
+
+ export default AuthServiceFactory

package/src/factory/RoleServiceFactory.ts

@@ -0,0 +1,10 @@
+import RoleService from "../services/RoleService.js";
+import RoleRepository from "../repository/RoleRepository.js";
+
+const RoleServiceFactory = () : RoleService => {
+    const roleRepository = new RoleRepository
+    const roleService = new RoleService(roleRepository)
+    return roleService
+}
+
+ export default RoleServiceFactory

package/src/factory/UserServiceFactory.ts

@@ -0,0 +1,10 @@
+import UserRepository from "../repository/UserRepository.js";
+import UserService from "../services/UserService.js";
+
+const UserServiceFactory = () : UserService => {
+    const userRepository = new UserRepository
+    const userService = new UserService(userRepository)
+    return userService
+}
+
+ export default UserServiceFactory

package/src/graphql/index.ts

@@ -0,0 +1,8 @@
+import {GraphqlMerger} from "@drax/common-back"
+
+export default async () => {
+     const __dirname = new URL(".", import.meta.url).pathname;
+    const typeDefs = GraphqlMerger.mergeTypeDefs(__dirname)
+    const resolvers = GraphqlMerger.mergeResolvers(__dirname)
+    return {typeDefs, resolvers}
+}