@drax/crud-back 0.4.0

package/src/controllers/AbstractFastifyController.ts

@@ -0,0 +1,209 @@
+import AbstractService from "../services/AbstractService";
+import {ValidationError} from "@drax/common-back";
+import {UnauthorizedError, Rbac} from "@drax/identity-back";
+import type {FastifyReply, FastifyRequest} from "fastify";
+import {IEntityPermission} from "../interfaces/IEntityPermission";
+
+declare module 'fastify' {
+    interface FastifyRequest {
+        rbac?: Rbac;
+    }
+}
+
+type CustomRequest = FastifyRequest<{
+    Params: {
+        id?: string
+        ids?: string
+    };
+    Querystring:{
+        page?: number
+        limit?: number
+        orderBy?: string
+        order?: 'asc' | 'desc' | boolean
+        search?: string
+    }
+}>
+
+class AbstractFastifyController<T,C,U>{
+
+    protected service: AbstractService<T,C,U>
+    protected permission: IEntityPermission
+
+    constructor(service: AbstractService<T, C, U>, permission: IEntityPermission) {
+        this.service = service
+        this.permission = permission
+        console.log("AbstractFastifyController created. Permissions", this.permission)
+    }
+
+
+    async findById(request:CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            if(!request.params.id){
+                reply.statusCode = 400
+                reply.send({error: 'BAD REQUEST'})
+            }
+            const id = request.params.id
+            let item = await this.service.findById(id)
+            return item
+        } 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'})
+            }
+        }
+    }
+
+    async findByIds(request:CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            if(!request.params.ids){
+                reply.statusCode = 400
+                reply.send({error: 'BAD REQUEST'})
+            }
+            const ids = request.params.ids.split(",")
+            let items = await this.service.findByIds(ids)
+            return items
+        } 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'})
+            }
+        }
+    }
+
+    async search(request:CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            const search = request.query.search
+            let item = await this.service.search(search)
+            return item
+        } 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'})
+            }
+        }
+    }
+
+    async paginate(request: CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            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
+            let paginateResult = await this.service.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'})
+            }
+        }
+    }
+
+    async create(request: CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.Create)
+            const payload = request.body
+            let item = await this.service.create(payload as C)
+            return item
+        } 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'})
+            }
+        }
+    }
+
+    async update(request: CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.Update)
+            if(!request.params.id){
+                reply.statusCode = 400
+                reply.send({error: 'BAD REQUEST'})
+            }
+            const id = request.params.id
+            const payload = request.body
+            let item = await this.service.update(id, payload as U)
+            return item
+        } 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'})
+            }
+        }
+    }
+
+    async delete(request: CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.Delete)
+            if(!request.params.id){
+                reply.statusCode = 400
+                reply.send({error: 'BAD REQUEST'})
+            }
+            const id = request.params.id
+            await this.service.delete(id)
+            reply.send({message: 'Item deleted successfully'})
+        } 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'})
+            }
+        }
+    }
+}
+
+export default AbstractFastifyController;
+export {AbstractFastifyController}

package/src/index.ts

@@ -0,0 +1,19 @@
+//CRUD
+import AbstractMongoRepository from "./repository/AbstractMongoRepository.js";
+import AbstractSqliteRepository from "./repository/AbstractSqliteRepository.js";
+import AbstractService from "./services/AbstractService.js";
+import AbstractFastifyController from "./controllers/AbstractFastifyController.js";
+
+import type {ICrudRepository} from "./interfaces/ICrudRepository";
+
+export type {ICrudRepository}
+
+export {
+
+    //CRUD
+    AbstractMongoRepository,
+    AbstractSqliteRepository,
+    AbstractService,
+    AbstractFastifyController,
+
+}

package/src/interfaces/ICrudRepository.ts

@@ -0,0 +1,16 @@
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+
+interface ICrudRepository<T,C,U>{
+    paginate(options: IDraxPaginateOptions): Promise<IDraxPaginateResult<T>>
+    create(input: C): Promise<T>
+    update(id: string, input: U): Promise<T>
+    delete(id: string): Promise<any>
+
+    findById?(id: string): Promise<T | null>
+    findByIds?(ids: Array<string>): Promise<T[]>
+    findOneBy?(field: string, value: any): Promise<T | null>
+    findBy?(field: string, value: any): Promise<T[]>
+    fetchAll?(): Promise<T[]>
+    search?(value: any, limit ?: number): Promise<T[]>
+}
+export type { ICrudRepository }

package/src/interfaces/IEntityPermission.ts

@@ -0,0 +1,10 @@
+interface IEntityPermission {
+    Create: string
+    Update: string
+    Delete: string
+    View: string
+    Manage: string
+    [key: string]: string
+}
+
+export type { IEntityPermission }

package/src/repository/AbstractMongoRepository.ts

@@ -0,0 +1,118 @@
+import "mongoose-paginate-v2";
+import mongoose from "mongoose";
+import {MongooseQueryFilter, MongooseSort, MongooseErrorToValidationError} from "@drax/common-back";
+import type {DeleteResult} from "mongodb";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import type {PaginateModel, PaginateOptions, PaginateResult} from "mongoose";
+import type {ICrudRepository} from "../interfaces/ICrudRepository";
+
+
+
+class AbstractMongoRepository<T,C,U> implements ICrudRepository<T,C,U> {
+
+    _model: mongoose.Model<T> & PaginateModel<T>
+    _searchFields: string[] = []
+    _populateFields: string[] = []
+
+
+    async create(data: C): Promise<T> {
+        try {
+            const item: mongoose.HydratedDocument<T> = new this._model(data)
+            await item.save()
+
+            //@ts-ignore
+            await item.populate(this._populateFields)
+
+            return item
+        } catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e)
+            }
+            throw e
+        }
+    }
+
+    async update(id: string, data: U): Promise<T> {
+        try {
+            const item: mongoose.HydratedDocument<T> = await this._model.findOneAndUpdate({_id: id}, data, {new: true}).populate(this._populateFields).exec()
+            return item
+        } catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e)
+            }
+            throw e
+        }
+    }
+
+    async delete(id: string): Promise<boolean> {
+        const result: DeleteResult = await this._model.deleteOne({_id: id}).exec()
+        return result.deletedCount == 1
+    }
+
+    async findById(id: string): Promise<T | null> {
+        const item: mongoose.HydratedDocument<T> | null = await this._model.findById(id).populate(this._populateFields).exec()
+        return item
+    }
+
+    async findByIds(ids: Array<string>): Promise<T[]> {
+        const items: mongoose.HydratedDocument<T>[] = await this._model.find({_id: {$in: ids}}).populate(this._populateFields).exec()
+        return items
+    }
+
+    async findOneBy(field: string, value: any): Promise<T | null> {
+        const filter: any = {[field]: value}
+        const item: mongoose.HydratedDocument<T> | null = await this._model.findOne(filter).populate(this._populateFields).exec()
+        return item
+    }
+
+    async findBy(field: string, value: any): Promise<T[]> {
+        const filter: any = {[field]: value}
+        const items: mongoose.HydratedDocument<T>[] = await this._model.find(filter).populate(this._populateFields).exec()
+        return items
+    }
+
+    async fetchAll(): Promise<T[]> {
+        const items: mongoose.HydratedDocument<T>[] = await this._model.find().populate(this._populateFields).exec()
+        return items
+    }
+
+    async search(value: string, limit : number = 1000): Promise<T[]> {
+        const query = {}
+        query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(value, 'i')}))
+        const items: mongoose.HydratedDocument<T>[] = await this._model.find(query).limit(limit).exec()
+        return items
+    }
+
+
+    async paginate({
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       order = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<T>> {
+
+        const query = {}
+
+        if (search) {
+            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search, 'i')}))
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+        const populate = this._populateFields
+        const options = {page, limit, sort, populate} as PaginateOptions
+        const items: PaginateResult<T> = await this._model.paginate(query, options)
+        return {
+            page: page,
+            limit: limit,
+            total: items.totalDocs,
+            items: items.docs
+        }
+    }
+}
+
+export default AbstractMongoRepository
+export {AbstractMongoRepository}

package/src/repository/AbstractSqliteRepository.ts

@@ -0,0 +1,170 @@
+import sqlite from "better-sqlite3";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {randomUUID} from "node:crypto";
+import {
+    SqlSort, SqlQueryFilter, SqliteTableBuilder, SqliteTableField,
+    SqliteErrorToValidationError} from "@drax/common-back";
+
+
+
+class AbstractSqliteRepository<T>{
+    protected db: any;
+    protected tableName: string;
+    protected dataBase: string;
+    protected searchFields: string[] = [];
+    protected booleanFields: string[] = [];
+    protected identifier: string = 'id';
+    protected verbose: boolean;
+    protected tableFields: SqliteTableField[];
+
+    constructor(dataBase:string, tableName: string, identifier:string = 'id',searchFields:string[] = [], booleanFields:string[] = [], verbose:boolean = false) {
+        if(!dataBase){
+            throw new Error("dataBase is required")
+        }
+
+        if(!tableName){
+            throw new Error("tableName is required")
+        }
+
+
+        this.dataBase = dataBase;
+        this.tableName =  tableName
+        this.identifier =  identifier
+        this.searchFields =  searchFields
+        this.booleanFields =  booleanFields
+        this.verbose = verbose;
+        this.db = new sqlite(dataBase, {verbose: verbose ? console.log : null});
+    }
+
+    build() {
+        const builder = new SqliteTableBuilder(this.dataBase, this.tableName, this.tableFields, this.verbose);
+        builder.build(this.identifier)
+    }
+
+    async create(data: any): Promise<T> {
+        try{
+
+            if(!data[this.identifier]){
+                data[this.identifier] = randomUUID()
+            }
+
+            for(const key in data){
+                if(typeof data[key] === 'boolean'){
+                    data[key] = data[key]? 1 : 0
+                }
+            }
+
+            const fields = Object.keys(data)
+                .map(field => `${field}`)
+                .join(', ');
+
+            const values = Object.keys(data)
+                .map(field => `@${field}`)
+                .join(', ');
+
+            const stmt = this.db.prepare(`INSERT INTO ${this.tableName} (${fields}) VALUES (${values})`);
+            stmt.run(data)
+            return this.findById(data[this.identifier])
+        }catch (e){
+            console.log(e)
+            throw SqliteErrorToValidationError(e, data)
+        }
+    }
+
+    async findById(id: string): Promise<T | null>{
+        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${this.identifier} = ?`).get(id);
+        return item
+    }
+
+    async findBy(field: string, value: any): Promise<T[] | null>{
+        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${field} = ?`).all(value);
+        return item
+    }
+
+    async findOneBy(field: string, value: any): Promise<T | null>{
+        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${field} = ?`).get(value);
+        return item
+    }
+
+    async update(id: string, data: any): Promise<T> {
+        try{
+
+            for(const key in data){
+                if(typeof data[key] === 'boolean'){
+                    data[key] = data[key]? 1 : 0
+                }
+            }
+
+            const setClauses = Object.keys(data)
+                .map(field => `${field} = @${field}`)
+                .join(', ');
+            data.identifier = id
+            const stmt = this.db.prepare( `UPDATE ${this.tableName} SET ${setClauses} WHERE ${this.identifier} = @identifier `);
+            stmt.run(data);
+            return this.findById(id)
+        }catch (e){
+            console.log(e)
+            throw SqliteErrorToValidationError(e, data)
+        }
+
+    }
+
+
+    async delete(id: string): Promise<boolean> {
+        const stmt = this.db.prepare(`DELETE FROM ${this.tableName} WHERE ${this.identifier} = ?`);
+        stmt.run(id);
+        return true
+    }
+
+
+
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       order= 'desc',
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<T>>{
+
+        const offset = page > 1 ? (page - 1) * limit : 0
+
+        let where=""
+        if (search && this.searchFields.length > 0) {
+            where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${search}%'`).join(" OR ")}`
+        }
+
+        if (filters.length > 0) {
+            where = SqlQueryFilter.applyFilters(where, filters)
+        }
+
+        const sort = SqlSort.applySort(orderBy, order)
+
+        const rCount = this.db.prepare(`SELECT COUNT(*) as count FROM ${this.tableName} ${where}`).get();
+        const items = this.db.prepare(`SELECT * FROM ${this.tableName} ${where} ${sort} LIMIT ? OFFSET ? `).all([limit, offset]) as T[];
+
+        for(const item of items){
+            for(const key in item) {
+                if (this.booleanFields.includes(key)) {
+                    //@ts-ignore
+                    item[key] = item[key] ? true : false
+                }
+            }
+        }
+
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: items
+        }
+    }
+
+    async fetchAll(): Promise<any[]>{
+        const tenants = this.db.prepare(`SELECT * FROM ${this.tableName}`).all();
+
+        return tenants
+    }
+
+}
+
+export default AbstractSqliteRepository

package/src/services/AbstractService.ts

@@ -0,0 +1,145 @@
+import {ValidationError, ZodErrorToValidationError} from "@drax/common-back"
+import {ZodError} from "zod";
+import type {ZodSchema} from "zod";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import type {ICrudRepository} from "../interfaces/ICrudRepository";
+
+class AbstractService<T,C,U> {
+
+    _repository: ICrudRepository<T,C,U>
+    _schema?: ZodSchema | undefined
+
+    constructor(repository: ICrudRepository<T,C,U>, schema?: ZodSchema) {
+        this._repository = repository
+        this._schema = schema
+    }
+
+    async create(data: C): Promise<T> {
+        try {
+            if(this._schema){
+                await this._schema.parseAsync(data)
+            }
+            const item: T = await this._repository.create(data)
+            return item
+        } catch (e) {
+            console.error("Error creating", e)
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data)
+            }
+            throw e
+        }
+    }
+
+    async update(id: string, data: U): Promise<T> {
+        try {
+            if(this._schema){
+                await this._schema.parseAsync(data)
+            }
+            const item : T = await this._repository.update(id, data)
+            return item
+        } catch (e) {
+            console.error("Error updating", e)
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data)
+            }
+            throw e
+        }
+    }
+
+    async delete(id: string): Promise<boolean> {
+        try {
+            const deleted = await this._repository.delete(id);
+            return deleted;
+        } catch (e) {
+            console.error("Error deleting", e)
+            throw e;
+        }
+
+    }
+
+    async findById(id: string): Promise<T | null> {
+        try {
+            const item: T = await this._repository.findById(id);
+            return item
+        } catch (e) {
+            console.error("Error finding Auto by id", e)
+            throw e;
+        }
+    }
+
+    async findByIds(ids: Array<string>): Promise<T[]> {
+        try {
+            const items: T[] = await this._repository.findByIds(ids);
+            return items
+        } catch (e) {
+            console.error("Error finding Auto by id", e)
+            throw e;
+        }
+    }
+
+    async findOneBy(field: string, value: string): Promise<T | null> {
+        try {
+            const item: T = await this._repository.findOneBy(field, value);
+            return item
+        } catch (e) {
+            console.error("Error finding Auto findOneBy", e)
+            throw e;
+        }
+
+    }
+
+    async findBy(field: string, value: string): Promise<T[] | null> {
+        try {
+            const items: T[] = await this._repository.findBy(field, value);
+            return items
+        } catch (e) {
+            console.error("Error finding Auto findBy", e)
+            throw e;
+        }
+
+    }
+
+    async fetchAll(): Promise<T[]> {
+        try {
+            const items: T[] = await this._repository.fetchAll();
+            return items
+        } catch (e) {
+            console.error("Error fetching all Autos", e)
+            throw e;
+        }
+
+    }
+
+    async search(value: string): Promise<T[]> {
+        try {
+            const items: T[] = await this._repository.search(value);
+            return items
+        } catch (e) {
+            console.error("Error fetching all Autos", e)
+            throw e;
+        }
+
+    }
+
+    async paginate({
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       order = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<T>> {
+        try {
+            const pagination = await this._repository.paginate({page, limit, orderBy, order, search, filters});
+            return pagination;
+        } catch (e) {
+            console.error("Error paginating", e)
+            throw e;
+        }
+
+    }
+
+}
+
+export default AbstractService
+export {AbstractService}