@drax/crud-back 0.4.0 → 0.5.1

package/dist/controllers/AbstractFastifyController.js

@@ -1,20 +1,65 @@
-import { ValidationError } from "@drax/common-back";
+import { CommonConfig, DraxConfig, ValidationError } from "@drax/common-back";
 import { UnauthorizedError } from "@drax/identity-back";
+import { join } from "path";
+const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';
+const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, '') : '';
 class AbstractFastifyController {
     constructor(service, permission) {
         this.service = service;
         this.permission = permission;
         console.log("AbstractFastifyController created. Permissions", this.permission);
     }
-    async findById(request, reply) {
+    parseFilters(stringFilters) {
         try {
-            request.rbac.assertPermission(this.permission.View);
+            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 create(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.Create);
+            const payload = request.body;
+            let item = await this.service.create(payload);
+            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, reply) {
+        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);
             return item;
         }
         catch (e) {
@@ -33,16 +78,16 @@ class AbstractFastifyController {
             }
         }
     }
-    async findByIds(request, reply) {
+    async delete(request, reply) {
         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);
@@ -60,11 +105,15 @@ class AbstractFastifyController {
             }
         }
     }
-    async search(request, reply) {
+    async findById(request, reply) {
         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) {
@@ -83,16 +132,16 @@ class AbstractFastifyController {
             }
         }
     }
-    async paginate(request, reply) {
+    async findByIds(request, reply) {
         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);
@@ -110,11 +159,11 @@ class AbstractFastifyController {
             }
         }
     }
-    async create(request, reply) {
+    async search(request, reply) {
         try {
-            request.rbac.assertPermission(this.permission.Create);
-            const payload = request.body;
-            let item = await this.service.create(payload);
+            request.rbac.assertPermission(this.permission.View);
+            const search = request.query.search;
+            let item = await this.service.search(search);
             return item;
         }
         catch (e) {
@@ -133,17 +182,17 @@ class AbstractFastifyController {
             }
         }
     }
-    async update(request, reply) {
+    async paginate(request, reply) {
         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);
-            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);
@@ -161,16 +210,36 @@ class AbstractFastifyController {
             }
         }
     }
-    async delete(request, reply) {
+    async export(request, reply) {
         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' });
+            request.rbac.assertPermission(this.permission.View);
+            const format = request.query.format || '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 = 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,
+            };
         }
         catch (e) {
             console.error(e);

package/dist/exports/AbstractExport.js

@@ -0,0 +1,41 @@
+import { createDirIfNotExist } from "@drax/common-back";
+import crypto from "crypto";
+class AbstractExport {
+    constructor(options) {
+        this.cursor = options.cursor;
+        this.destinationPath = options.destinationPath;
+        this.headers = Array.isArray(options.headers) ? options.headers : options.headers.split(',');
+    }
+    createDirIfNotExist() {
+        createDirIfNotExist(this.destinationPath);
+    }
+    generateFileName(extension) {
+        if (!this.fileName) {
+            const randomUUID = crypto.randomUUID().toString();
+            this.fileName = `export_${randomUUID}.${extension}`;
+        }
+        return this.fileName;
+    }
+    generateFilePath(extension) {
+        this.createDirIfNotExist();
+        this.generateFileName(extension);
+        this.relativeFilePath = `${this.destinationPath}/${this.fileName}`;
+        return this.relativeFilePath;
+    }
+    isIterableAsync(value) {
+        return value != null && typeof value[Symbol.asyncIterator] === 'function';
+    }
+    isIterableSync(value) {
+        return value != null && typeof value[Symbol.iterator] === 'function';
+    }
+    getNestedProperty(obj, path) {
+        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/dist/exports/ExportCsv.js

@@ -0,0 +1,86 @@
+import * as fs from 'fs';
+import AbstractExport from "./AbstractExport.js";
+class ExportCsv extends AbstractExport {
+    constructor(options) {
+        super(options);
+        this.separator = ';';
+        this.separator = options.separator ? options.separator : ';';
+    }
+    // Método principal para procesar los datos y generar el CSV
+    process() {
+        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) {
+        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/dist/exports/ExportJson.js

@@ -0,0 +1,51 @@
+import * as fs from 'fs';
+import AbstractExport from "./AbstractExport.js";
+class ExportJson extends AbstractExport {
+    constructor(options) {
+        super(options);
+    }
+    // Método principal para procesar los datos y generar el CSV
+    process() {
+        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/dist/repository/AbstractMongoRepository.js

@@ -82,6 +82,17 @@ class AbstractMongoRepository {
             items: items.docs
         };
     }
+    async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+        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 = await this._model.find(query).sort(sort).populate(populate);
+        return items;
+    }
 }
 export default AbstractMongoRepository;
 export { AbstractMongoRepository };

package/dist/services/AbstractService.js

@@ -1,5 +1,7 @@
 import { ZodErrorToValidationError } from "@drax/common-back";
 import { ZodError } from "zod";
+import ExportCsv from "../exports/ExportCsv.js";
+import ExportJson from "../exports/ExportJson.js";
 class AbstractService {
     constructor(repository, schema) {
         this._repository = repository;
@@ -117,6 +119,48 @@ class AbstractService {
             throw e;
         }
     }
+    async find({ orderBy = '', order = false, search = '', filters = [] }) {
+        try {
+            const items = await this._repository.find({ orderBy, order, search, filters });
+            return items;
+        }
+        catch (e) {
+            console.error("Error paginating", e);
+            throw e;
+        }
+    }
+    async export({ format = 'JSON', headers = [], separator = ';', orderBy = '', order = false, search = '', filters = [] }, destinationPath) {
+        try {
+            console.log("ExportOptions", {
+                format,
+                headers,
+                separator,
+                outputPath: destinationPath,
+                orderBy,
+                order,
+                search,
+                filters
+            });
+            let cursor;
+            let exporter;
+            switch (format) {
+                case 'JSON':
+                    cursor = await this._repository.find({ orderBy, order, search, filters });
+                    exporter = new ExportJson({ cursor, destinationPath: destinationPath, headers });
+                    return await exporter.process();
+                case 'CSV':
+                    cursor = await this._repository.find({ orderBy, order, search, filters });
+                    exporter = new ExportCsv({ cursor, destinationPath: destinationPath, headers, separator });
+                    return await exporter.process();
+                default:
+                    throw new Error(`Unsupported export format: ${format}`);
+            }
+        }
+        catch (e) {
+            console.error("Error exporting", e);
+            throw e;
+        }
+    }
 }
 export default AbstractService;
 export { AbstractService };

package/dist/workers/ExportCsvWorker.js

@@ -0,0 +1,12 @@
+import { parentPort } from 'worker_threads';
+import ExportCsv from '../exports/ExportCsv'; // Ajusta la ruta según sea necesario
+parentPort.on('message', async (options) => {
+    const exporter = new ExportCsv(options);
+    try {
+        let result = await exporter.process();
+        parentPort.postMessage({ result: result });
+    }
+    catch (error) {
+        parentPort.postMessage({ error: error.message });
+    }
+});

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Crud utils across modules",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -15,14 +15,16 @@
     "copygql": "copyfiles -u 1 ./**/*.graphql dist/",
     "tsc": "tsc -b tsconfig.json",
     "test": "node --import tsx --test test/**/*",
-    "testCache": "node --import tsx --test test/cache/*",
-    "testMongoose": "node --import tsx --test test/mongoose/*"
+    "testService": "node --import tsx --test test/services/*.ts",
+    "testExports": "node --import tsx --test test/exports/*.ts",
+    "testWorkers": "node --import tsx --test test/workers/*.ts"
   },
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^0.4.0",
-    "@drax/common-share": "^0.4.0",
+    "@drax/common-back": "^0.5.1",
+    "@drax/common-share": "^0.5.1",
+    "@drax/media-back": "^0.5.1",
     "@graphql-tools/load-files": "^7.0.0",
     "@graphql-tools/merge": "^9.0.4",
     "mongoose": "^8.6.3",
@@ -41,5 +43,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.6.2"
   },
-  "gitHead": "481b302fe72f403abf092806ceca540dd2765dfa"
+  "gitHead": "6f507c8b52e134f10839fd7698c2466ff65a3d08"
 }