@drax/crud-back 0.4.0 → 0.5.1

package/src/controllers/AbstractFastifyController.ts

@@ -1,8 +1,9 @@
 import AbstractService from "../services/AbstractService";
-import {ValidationError} from "@drax/common-back";
+import {CommonConfig, DraxConfig, ValidationError} from "@drax/common-back";
 import {UnauthorizedError, Rbac} from "@drax/identity-back";
 import type {FastifyReply, FastifyRequest} from "fastify";
-import {IEntityPermission} from "../interfaces/IEntityPermission";
+import {IDraxExportResult, IDraxPermission} from "@drax/crud-share";
+import {join} from "path";
 
 declare module 'fastify' {
     interface FastifyRequest {
@@ -14,37 +15,88 @@ type CustomRequest = FastifyRequest<{
     Params: {
         id?: string
         ids?: string
+        format?: string
     };
     Querystring:{
+        format?: string
         page?: number
         limit?: number
         orderBy?: string
         order?: 'asc' | 'desc' | boolean
         search?: string
+        filters?: string
+        headers?: string
+        separator?: string
     }
 }>
 
+const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';
+const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, '') : ''
+
+
 class AbstractFastifyController<T,C,U>{
 
     protected service: AbstractService<T,C,U>
-    protected permission: IEntityPermission
+    protected permission: IDraxPermission
 
-    constructor(service: AbstractService<T, C, U>, permission: IEntityPermission) {
+    constructor(service: AbstractService<T, C, U>, permission: IDraxPermission) {
         this.service = service
         this.permission = permission
         console.log("AbstractFastifyController created. Permissions", this.permission)
     }
 
+    parseFilters(stringFilters: string): any {
+        try {
+            if (!stringFilters) {
+                return {}
+            }
+            const filterArray = stringFilters.split(";")
+            const filters = []
+            filterArray.forEach((filter) => {
+                const [field, operator, value] = filter.split(",")
+                filters.push({field, operator, value})
+            })
+            return filters
+        } catch (e) {
+            console.error(e)
+            throw e
+        }
+    }
+
 
-    async findById(request:CustomRequest, reply: FastifyReply) {
+
+
+    async create(request: CustomRequest, reply: FastifyReply) {
         try {
-            request.rbac.assertPermission(this.permission.View)
+            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
-            let item = await this.service.findById(id)
+            const payload = request.body
+            let item = await this.service.update(id, payload as U)
             return item
         } catch (e) {
             console.error(e)
@@ -61,16 +113,16 @@ class AbstractFastifyController<T,C,U>{
         }
     }
 
-    async findByIds(request:CustomRequest, reply: FastifyReply) {
+    async delete(request: CustomRequest, reply: FastifyReply) {
         try {
-            request.rbac.assertPermission(this.permission.View)
-            if(!request.params.ids){
+            request.rbac.assertPermission(this.permission.Delete)
+            if(!request.params.id){
                 reply.statusCode = 400
                 reply.send({error: 'BAD REQUEST'})
             }
-            const ids = request.params.ids.split(",")
-            let items = await this.service.findByIds(ids)
-            return items
+            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) {
@@ -86,11 +138,15 @@ class AbstractFastifyController<T,C,U>{
         }
     }
 
-    async search(request:CustomRequest, reply: FastifyReply) {
+    async findById(request:CustomRequest, reply: FastifyReply) {
         try {
             request.rbac.assertPermission(this.permission.View)
-            const search = request.query.search
-            let item = await this.service.search(search)
+            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)
@@ -107,16 +163,16 @@ class AbstractFastifyController<T,C,U>{
         }
     }
 
-    async paginate(request: CustomRequest, reply: FastifyReply) {
+    async findByIds(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
+            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) {
@@ -132,11 +188,11 @@ class AbstractFastifyController<T,C,U>{
         }
     }
 
-    async create(request: CustomRequest, reply: FastifyReply) {
+    async search(request:CustomRequest, reply: FastifyReply) {
         try {
-            request.rbac.assertPermission(this.permission.Create)
-            const payload = request.body
-            let item = await this.service.create(payload as C)
+            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)
@@ -153,17 +209,17 @@ class AbstractFastifyController<T,C,U>{
         }
     }
 
-    async update(request: CustomRequest, reply: FastifyReply) {
+    async paginate(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
+            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
+            //const filters = this.parseFilters(request.query.filters)
+            let paginateResult = await this.service.paginate({page, limit, orderBy, order, search})
+            return paginateResult
         } catch (e) {
             console.error(e)
             if (e instanceof ValidationError) {
@@ -179,16 +235,44 @@ class AbstractFastifyController<T,C,U>{
         }
     }
 
-    async delete(request: CustomRequest, reply: FastifyReply) {
+    async export(request:CustomRequest, reply: FastifyReply) {
         try {
-            request.rbac.assertPermission(this.permission.Delete)
-            if(!request.params.id){
-                reply.statusCode = 400
-                reply.send({error: 'BAD REQUEST'})
+            request.rbac.assertPermission(this.permission.View)
+
+            const format = request.query.format as 'CSV'|'JSON' || 'JSON'
+            const headers = request.query.headers ? request.query.headers.split(",") : []
+            const separator = request.query.separator || ";"
+            const limit = request.query.limit
+            const orderBy = request.query.orderBy
+            const order = request.query.order
+            const search = request.query.search
+
+            const year = (new Date().getFullYear()).toString()
+            const month = (new Date().getMonth() + 1).toString().padStart(2, '0')
+            const exportPath = 'exports'
+
+            const destinationPath = join(BASE_FILE_DIR, 'exports',year,month)
+
+            let result: IDraxExportResult = await this.service.export({
+                separator,
+                format,
+                headers,
+                limit,
+                orderBy,
+                order,
+                search,
+            }, destinationPath)
+
+            const url = `${BASE_URL}/api/file/${exportPath}/${year}/${month}/${result.fileName}`
+
+
+            return {
+                url: url,
+                rowCount: result.rowCount,
+                time: result.time,
+                fileName: result.fileName,
             }
-            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) {

package/src/exports/AbstractExport.ts

@@ -0,0 +1,74 @@
+import {createDirIfNotExist} from "@drax/common-back";
+import crypto from "crypto";
+
+
+interface ExportOptions {
+    cursor: any
+    destinationPath: string
+    headers: string[] | string
+}
+
+export type {ExportOptions}
+
+class AbstractExport {
+
+    cursor: any
+    destinationPath: string
+    headers: string[]
+
+    fileName: string
+    relativeFilePath: string
+
+    constructor(options: ExportOptions) {
+        this.cursor = options.cursor;
+        this.destinationPath = options.destinationPath;
+        this.headers = Array.isArray(options.headers) ? options.headers : options.headers.split(',');
+    }
+
+
+    createDirIfNotExist(): void {
+        createDirIfNotExist(this.destinationPath);
+    }
+
+    generateFileName(extension:string): string {
+        if (!this.fileName) {
+            const randomUUID = crypto.randomUUID().toString();
+            this.fileName = `export_${randomUUID}.${extension}`;
+        }
+        return this.fileName;
+
+    }
+
+    generateFilePath(extension:string) {
+        this.createDirIfNotExist();
+        this.generateFileName(extension);
+        this.relativeFilePath = `${this.destinationPath}/${this.fileName}`;
+        return this.relativeFilePath;
+    }
+
+
+    isIterableAsync(value: any) {
+        return value != null && typeof value[Symbol.asyncIterator] === 'function';
+    }
+
+    isIterableSync(value: any) {
+        return value != null && typeof value[Symbol.iterator] === 'function';
+    }
+
+    getNestedProperty(obj: object, path: string) {
+        return path.split('.').reduce((acc, part) => {
+            if (Array.isArray(acc)) {
+                return acc.map(item => item[part]).join('|');
+            }
+            return acc && acc[part];
+        }, obj);
+    }
+
+}
+
+
+export {
+    AbstractExport,
+}
+
+export default AbstractExport;

package/src/exports/ExportCsv.ts

@@ -0,0 +1,107 @@
+import * as fs from 'fs';
+import AbstractExport from "./AbstractExport.js";
+import type {ExportOptions} from "./AbstractExport";
+
+
+interface ExportCsvOptions extends ExportOptions {
+    separator: string
+}
+
+class ExportCsv extends AbstractExport {
+
+    separator: string = ';'
+
+    constructor(options: ExportCsvOptions) {
+        super(options)
+        this.separator = options.separator ? options.separator : ';';
+    }
+
+    // Método principal para procesar los datos y generar el CSV
+    process(): Promise<any> {
+        return new Promise(async (resolve, reject) => {
+
+            try {
+
+                this.generateFilePath('csv')
+                let rowCount = 0
+                const start = Date.now();
+
+                const writableStream = fs.createWriteStream(this.relativeFilePath);
+
+                writableStream.on('error', reject);
+                writableStream.on('finish', () => resolve({
+                    status: 'success',
+                    destinationPath: this.destinationPath,
+                    fileName: this.fileName,
+                    filePath: this.destinationPath + '/' + this.fileName,
+                    relativeFilePath: this.relativeFilePath,
+                    rowCount: rowCount,
+                    time: Date.now() - start,
+                    message: 'Export successful',
+                }))
+
+
+                const csvHeaders = this.headers.join(this.separator);
+                writableStream.write(csvHeaders + '\n');
+
+                if (this.isIterableAsync(this.cursor)) {
+                    for await (const record of this.cursor) {
+                        const csvRow = this.convertRecordToCSVrow(record);
+                        console.log("csvRow", csvRow);
+                        writableStream.write(csvRow + '\n');
+                        rowCount++
+                    }
+                } else if (this.isIterableSync(this.cursor)) {
+                    // Si es un cursor de SQLite (better-sqlite3), usamos iterate()
+                    for (const record of this.cursor) {
+                        const csvRow = this.convertRecordToCSVrow(record);
+                        writableStream.write(csvRow + '\n');
+                        rowCount++
+                    }
+                }
+                writableStream.end();
+            } catch (e) {
+                reject(e);
+            }
+
+        })
+    }
+
+
+    // Método que convierte un registro en una o más filas de CSV
+    convertRecordToCSVrow(record: object): string {
+        let fields = []
+
+        for (const header of this.headers) {
+
+            let value
+            if (header.includes('.')) {
+                value = this.getNestedProperty(record, header);
+            } else {
+                value = record[header];
+            }
+
+            if (value === undefined) {
+                fields.push('');
+                continue;
+            }
+
+            if (Array.isArray(value)) {
+                if (value.length > 0 && typeof value[0] === 'object') {
+                    fields.push(JSON.stringify(value));
+                } else {
+                    fields.push(value.join(','));
+                }
+            } else if (typeof value === 'object') {
+                fields.push(JSON.stringify(value));
+
+            } else {
+                fields.push(value.toString());
+            }
+        }
+        return fields.join(this.separator);
+    }
+
+}
+
+export default ExportCsv;

package/src/exports/ExportJson.ts

@@ -0,0 +1,64 @@
+import * as fs from 'fs';
+import AbstractExport from "./AbstractExport.js";
+import type {ExportOptions} from "./AbstractExport";
+
+
+
+
+class ExportJson extends AbstractExport {
+
+    constructor(options: ExportOptions) {
+        super(options)
+    }
+
+    // Método principal para procesar los datos y generar el CSV
+    process(): Promise<any> {
+        return new Promise(async (resolve, reject) => {
+
+            try{
+                this.generateFilePath('json')
+                let rowCount = 0
+                const start = Date.now();
+
+                const writableStream = fs.createWriteStream(this.relativeFilePath);
+
+                writableStream.on('error', reject);
+                writableStream.on('finish', () => resolve({
+                    status: 'success',
+                    destinationPath: this.destinationPath,
+                    fileName: this.fileName,
+                    filePath: this.destinationPath + '/' + this.fileName,
+                    relativeFilePath: this.relativeFilePath,
+                    rowCount: rowCount,
+                    time: Date.now() - start,
+                    message: 'Export successful',
+                }))
+
+                writableStream.write('[');
+
+                if (this.isIterableAsync(this.cursor)) {
+                    for await (const record of this.cursor) {
+                        const csvRow = JSON.stringify(record);
+                        console.log("csvRow", csvRow);
+                        writableStream.write(csvRow + ',\n');
+                        rowCount++
+                    }
+                } else if (this.isIterableSync(this.cursor)) {
+                    for (const record of this.cursor) {
+                        const csvRow = JSON.stringify(record);
+                        writableStream.write(csvRow + ',\n');
+                        rowCount++
+                    }
+                }
+                writableStream.write(']');
+                writableStream.end();
+            }catch (e){
+                reject(e);
+            }
+
+        })
+    }
+
+}
+
+export default ExportJson;

package/src/index.ts

@@ -4,9 +4,6 @@ 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 {
 

package/src/repository/AbstractMongoRepository.ts

@@ -2,13 +2,11 @@ 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 {IDraxPaginateOptions, IDraxPaginateResult, IDraxFindOptions, IDraxCrud} from "@drax/crud-share";
 import type {PaginateModel, PaginateOptions, PaginateResult} from "mongoose";
-import type {ICrudRepository} from "../interfaces/ICrudRepository";
 
 
-
-class AbstractMongoRepository<T,C,U> implements ICrudRepository<T,C,U> {
+class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
     _model: mongoose.Model<T> & PaginateModel<T>
     _searchFields: string[] = []
@@ -76,7 +74,7 @@ class AbstractMongoRepository<T,C,U> implements ICrudRepository<T,C,U> {
         return items
     }
 
-    async search(value: string, limit : number = 1000): Promise<T[]> {
+    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()
@@ -112,6 +110,28 @@ class AbstractMongoRepository<T,C,U> implements ICrudRepository<T,C,U> {
             items: items.docs
         }
     }
+
+    async find({
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<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 items: T[] = await this._model.find(query).sort(sort).populate(populate)
+        return items
+    }
 }
 
 export default AbstractMongoRepository

package/src/repository/AbstractSqliteRepository.ts

@@ -1,5 +1,5 @@
 import sqlite from "better-sqlite3";
-import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {randomUUID} from "node:crypto";
 import {
     SqlSort, SqlQueryFilter, SqliteTableBuilder, SqliteTableField,