@drax/identity-back 0.5.1 → 0.5.3

package/src/index.ts

@@ -21,9 +21,7 @@ import {jwtMiddleware} from "./middleware/jwtMiddleware.js";
 import {rbacMiddleware} from "./middleware/rbacMiddleware.js";
 import {apiKeyMiddleware} from "./middleware/apiKeyMiddleware.js";
 
-import IdentityPermissions from "./permissions/IdentityPermissions.js";
 import IdentityConfig from "./config/IdentityConfig.js";
-import UnauthorizedError from "./errors/UnauthorizedError.js";
 import BadCredentialsError from "./errors/BadCredentialsError.js";
 
 import CreateUserIfNotExist from "./setup/CreateUserIfNotExist.js";
@@ -38,6 +36,14 @@ import type {IUserRepository} from "./interfaces/IUserRepository";
 import type {IUserApiKeyRepository} from "./interfaces/IUserApiKeyRepository";
 
 
+import IdentityPermissions from "./permissions/IdentityPermissions.js";
+
+import {RolePermissions} from "./permissions/RolePermissions.js";
+import {TenantPermissions} from "./permissions/TenantPermissions.js";
+import {UserPermissions} from "./permissions/UserPermissions.js";
+import {UserApiKeyPermissions} from "./permissions/UserApiKeyPermissions.js";
+
+
 const graphqlMergeResult = await GraphqlMerge()
 const identityTypeDefs = await graphqlMergeResult.typeDefs;
 const identityResolvers = await graphqlMergeResult.resolvers;
@@ -83,12 +89,15 @@ export {
 
     //Permissions
     IdentityPermissions,
+    RolePermissions,
+    TenantPermissions,
+    UserPermissions,
+    UserApiKeyPermissions,
 
     //Config
     IdentityConfig,
 
     //Errors
-    UnauthorizedError,
     BadCredentialsError,
 
     //Setup

package/src/permissions/IdentityPermissions.ts

@@ -1,3 +1,4 @@
+
 enum IdentityPermissions {
 
 

package/src/permissions/RolePermissions.ts

@@ -0,0 +1,12 @@
+enum RolePermissions {
+    Create = "role:create",
+    Update = "role:update",
+    Delete = "role:delete",
+    View = "role:view",
+    Manage = "role:manage",
+    Permissions = "role:permissions",
+
+}
+
+export default RolePermissions;
+export {RolePermissions};

package/src/permissions/TenantPermissions.ts

@@ -0,0 +1,11 @@
+enum TenantPermissions {
+    Create = "tenant:create",
+    Update = "tenant:update",
+    Delete= "tenant:delete",
+    View = "tenant:view",
+    Manage = "tenant:manage",
+
+}
+
+export default TenantPermissions;
+export {TenantPermissions};

package/src/permissions/UserApiKeyPermissions.ts

@@ -0,0 +1,12 @@
+enum UserApiKeyPermissions {
+    Create = "userApiKey:create",
+    Update = "userApiKey:update",
+    Delete = "userApiKey:delete",
+    View = "userApiKey:view",
+    ViewMy = "userApiKey:myView",
+    Manage = "userApiKey:manage",
+
+}
+
+export default UserApiKeyPermissions;
+export {UserApiKeyPermissions};

package/src/permissions/UserPermissions.ts

@@ -0,0 +1,11 @@
+enum UserPermissions {
+    Create = "user:create",
+    Update = "user:update",
+    Delete = "user:delete",
+    View = "user:view",
+    Manage = "user:manage",
+
+}
+
+export default UserPermissions;
+export {UserPermissions};

package/src/permissions/index.ts

@@ -0,0 +1,15 @@
+import TenantPermissions from './TenantPermissions';
+import UserPermissions from './UserPermissions';
+import RolePermissions from './RolePermissions';
+import UserApiKeyPermissions from './UserApiKeyPermissions';
+
+const permissions = {
+    ...TenantPermissions,
+    ...UserPermissions,
+    ...RolePermissions,
+    ...UserApiKeyPermissions
+};
+
+
+export default permissions;
+export {permissions};

package/src/rbac/Rbac.ts

@@ -1,5 +1,5 @@
 import {IJwtUser, IRole} from "@drax/identity-share";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
+import {UnauthorizedError} from "@drax/common-back";
 
 class Rbac {
     private role: IRole;

package/src/repository/mongo/TenantMongoRepository.ts

@@ -1,55 +1,56 @@
 import {TenantModel} from "../../models/TenantModel.js";
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {mongoose, MongooseSort, MongooseQueryFilter} from "@drax/common-back";
-import { PaginateOptions, PaginateResult} from "mongoose";
+import {PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {ITenant, ITenantBase} from "@drax/identity-share";
 
-class TenantMongoRepository implements ITenantRepository{
+class TenantMongoRepository implements ITenantRepository {
 
     async create(tenantData: ITenantBase): Promise<ITenant> {
-        const tenant : mongoose.HydratedDocument<ITenant> = new TenantModel(tenantData)
+        const tenant: mongoose.HydratedDocument<ITenant> = new TenantModel(tenantData)
         await tenant.save()
         return tenant
     }
 
     async update(id: string, tenantData: ITenantBase): Promise<ITenant> {
-        const tenant : mongoose.HydratedDocument<ITenant> = await TenantModel.findOneAndUpdate({_id: id}, tenantData, {new: true}).exec()
+        const tenant: mongoose.HydratedDocument<ITenant> = await TenantModel.findOneAndUpdate({_id: id}, tenantData, {new: true}).exec()
         return tenant
     }
 
     async delete(id: string): Promise<boolean> {
-        const result : DeleteResult = await TenantModel.deleteOne({_id:id}).exec()
+        const result: DeleteResult = await TenantModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: string): Promise<ITenant | null>{
+    async findById(id: string): Promise<ITenant | null> {
         const tenant: mongoose.HydratedDocument<ITenant> | null = await TenantModel.findById(id).exec()
         return tenant
     }
 
-    async findByName(name: string): Promise<ITenant | null>{
+    async findByName(name: string): Promise<ITenant | null> {
         const tenant: mongoose.HydratedDocument<ITenant> | null = await TenantModel.findOne({name}).exec()
         return tenant
     }
 
-    async fetchAll(): Promise<ITenant[]>{
+    async fetchAll(): Promise<ITenant[]> {
         const tenants: mongoose.HydratedDocument<ITenant>[] = await TenantModel.find().exec()
         return tenants
     }
 
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       order = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
 
         const query = {}
 
-        if(search){
+        if (search) {
             query['$or'] = [
                 {name: new RegExp(search, 'i')},
             ]
@@ -68,6 +69,30 @@ class TenantMongoRepository implements ITenantRepository{
             items: tenants.docs
         }
     }
+
+    async find({
+                   cursor = false,
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<ITenant[]> {
+
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+        const items: ITenant[] = await TenantModel.find(query).sort(sort)
+        return items
+    }
 }
 
 export default TenantMongoRepository

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -3,7 +3,7 @@ import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
+import {IDraxPaginateResult, IDraxPaginateOptions, IDraxFindOptions} from "@drax/crud-share";
 import {SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort} from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 
@@ -143,6 +143,29 @@ class TenantSqliteRepository implements ITenantRepository{
         }
     }
 
+    async find({
+                   cursor = false,
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<ITenant[]>{
+
+        let where=""
+        if (search) {
+            where = ` WHERE name LIKE '%${search}%'`
+        }
+
+        where = SqlQueryFilter.applyFilters(where, filters)
+        const sort = SqlSort.applySort(orderBy, order)
+
+        where += sort
+        const tenants = this.db.prepare('SELECT * FROM tenants '  + where).all();
+
+        return tenants
+    }
+
 
 }
 

package/src/routes/RoleRoutes.ts

@@ -1,9 +1,8 @@
-import { ValidationError} from "@drax/common-back";
+import { ValidationError, UnauthorizedError} from "@drax/common-back";
 import RoleServiceFactory from "../factory/RoleServiceFactory.js";
 import {IRole} from "@drax/identity-share";
 import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
 import {PermissionService} from "../services/PermissionService.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
 import {IDraxPaginateResult} from "@drax/crud-share";
 
 

package/src/routes/TenantRoutes.ts

@@ -1,178 +1,24 @@
-import { ValidationError} from "@drax/common-back";
-import TenantServiceFactory from "../factory/TenantServiceFactory.js";
-import {ITenant} from "@drax/identity-share";
-import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
-import {IDraxPaginateResult} from "@drax/crud-share";
-
-
+import TenantController from '../controllers/TenantController.js'
 
 async function TenantRoutes(fastify, options) {
 
-    fastify.get('/api/tenants/:id', async (request, reply): Promise<ITenant> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
-            const id = request.params.id
-            const tenantService = TenantServiceFactory()
-            let tenant = await tenantService.findById(id)
-            return tenant
-        } catch (e) {
-            console.error(e)
-            if (e instanceof ValidationError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message, inputErrors: e.errors})
-            } else if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
-    })
-
-    fastify.get('/api/tenants/name/:name', async (request, reply): Promise<ITenant> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
-            const name = request.params.name
-            const tenantService = TenantServiceFactory()
-            let tenant = await tenantService.findByName(name)
-            return tenant
-        } catch (e) {
-            console.error(e)
-            if (e instanceof ValidationError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message, inputErrors: e.errors})
-            } else if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
-    })
+    const controller: TenantController = new TenantController()
 
-    fastify.get('/api/tenants/all', async (request, reply): Promise<ITenant[]> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
-            const tenantService = TenantServiceFactory()
-            let tenants = await tenantService.fetchAll()
-            if(request.rbac.getAuthUser.tenantId){
-                return tenants.filter(t => t.id === request.rbac.getAuthUser.tenantId)
-            }else{
-                return tenants
-            }
-        } catch (e) {
-            console.error(e)
-            if (e instanceof ValidationError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message, inputErrors: e.errors})
-            } else if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
-    })
+    fastify.get('/api/tenants/export', (req,rep) => controller.export(req,rep) )
 
-    fastify.get('/api/tenants', async (request, reply): Promise<IDraxPaginateResult<ITenant>> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
-            const page = request.query.page
-            const limit = request.query.limit
-            const orderBy = request.query.orderBy
-            const order = request.query.order
-            const search = request.query.search
-            const tenantService = TenantServiceFactory()
-            let paginateResult = await tenantService.paginate({page, limit,orderBy, order, search})
-            return paginateResult
-        } catch (e) {
-            console.error(e)
-            if (e instanceof ValidationError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message, inputErrors: e.errors})
-            } else if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
-    })
+    fastify.get('/api/tenants/:id', (req,rep) => controller.findById(req,rep) )
 
-    fastify.post('/api/tenants', async (request, reply): Promise<ITenant> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.CreateTenant)
-            const payload = request.body
-            const tenantService = TenantServiceFactory()
-            let tenant = await tenantService.create(payload)
-            return tenant
-        } catch (e) {
-            console.error(e)
-            if (e instanceof ValidationError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message, inputErrors: e.errors})
-            } else if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
+    fastify.get('/api/tenants/name/:name', (req,rep) => controller.findByName(req,rep))
 
-    })
+    fastify.get('/api/tenants/all', (req,rep) => controller.all(req,rep))
 
-    fastify.put('/api/tenants/:id', async (request, reply): Promise<ITenant> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.UpdateTenant)
-            const id = request.params.id
-            const payload = request.body
-            const tenantService = TenantServiceFactory()
+    fastify.get('/api/tenants', (req,rep) => controller.paginate(req,rep))
 
-            let tenant = await tenantService.update(id, payload)
-            return tenant
-        } catch (e) {
-            console.error(e)
-            if (e instanceof ValidationError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message, inputErrors: e.errors})
-            } else if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
+    fastify.post('/api/tenants', (req,rep) => controller.create(req,rep))
 
-    })
+    fastify.put('/api/tenants/:id', (req,rep) => controller.update(req,rep))
 
-    fastify.delete('/api/tenants/:id', async (request, reply): Promise<any> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.DeleteTenant)
-            const id = request.params.id
-            const tenantService = TenantServiceFactory()
-            let r = await tenantService.delete(id)
-            return r
-        } catch (e) {
-            console.error(e)
-            if (e instanceof ValidationError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message, inputErrors: e.errors})
-            } else if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
-    })
+    fastify.delete('/api/tenants/:id', (req,rep) => controller.delete(req,rep))
 
 }
 

package/src/routes/UserApiKeyRoutes.ts

@@ -1,8 +1,7 @@
 import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
 import type {IUserApiKey} from "@drax/identity-share";
-import {ValidationError} from "@drax/common-back";
+import {ValidationError, UnauthorizedError} from "@drax/common-back";
 import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
 import {IDraxPaginateResult} from "@drax/crud-share";
 
 

package/src/routes/UserAvatarRoutes.ts

@@ -1,6 +1,5 @@
 import {join} from "path";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
-import {StoreManager, UploadFileError, DraxConfig, CommonConfig} from "@drax/common-back";
+import {StoreManager, UploadFileError, DraxConfig, CommonConfig, UnauthorizedError} from "@drax/common-back";
 import UserServiceFactory from "../factory/UserServiceFactory.js";
 import IdentityConfig from "../config/IdentityConfig.js";
 

package/src/routes/UserRoutes.ts

@@ -1,8 +1,7 @@
 import UserServiceFactory from "../factory/UserServiceFactory.js";
 import {IUser} from "@drax/identity-share";
-import {ValidationError} from "@drax/common-back";
+import {ValidationError, UnauthorizedError} from "@drax/common-back";
 import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
 import {IDraxPaginateResult} from "@drax/crud-share";
 

package/src/services/TenantService.ts

@@ -4,12 +4,14 @@ import {tenantSchema} from "../zod/TenantZod.js";
 import {ZodError} from "zod";
 import {ITenantBase, ITenant} from "@drax/identity-share";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {AbstractService} from "@drax/crud-back";
 
-class TenantService {
+class TenantService extends AbstractService<ITenant,ITenantBase,ITenantBase> {
 
     _repository: ITenantRepository
 
     constructor(tenantRepostitory: ITenantRepository) {
+        super(tenantRepostitory, tenantSchema)
         this._repository = tenantRepostitory
         console.log("TenantService constructor")
     }

package/tsconfig.json

@@ -3,9 +3,9 @@
   "compilerOptions": {
     "rootDir": "src",
     "outDir": "dist",
-    "declarationDir": "./types",
+    "declarationDir": "types"
   },
-  "exclude": ["types", "test", "dist","node_modules"],
+  "exclude": ["types", "test", "dist","node_modules","tmp"],
   "ts-node": {
     "esm": true
   },