@drax/crud-back 0.4.0 → 0.5.1

package/src/services/AbstractService.ts

@@ -1,22 +1,31 @@
 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>
+import type {
+    IDraxPaginateOptions,
+    IDraxPaginateResult,
+    IDraxFindOptions,
+    IDraxCrud,
+    IDraxExportOptions
+} from "@drax/crud-share";
+import {IDraxCrudService} from "@drax/crud-share";
+import ExportCsv from "../exports/ExportCsv.js";
+import ExportJson from "../exports/ExportJson.js";
+import {IDraxExportResult} from "@drax/crud-share";
+
+class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
+
+    _repository: IDraxCrud<T, C, U>
     _schema?: ZodSchema | undefined
 
-    constructor(repository: ICrudRepository<T,C,U>, schema?: ZodSchema) {
+    constructor(repository: IDraxCrud<T, C, U>, schema?: ZodSchema) {
         this._repository = repository
         this._schema = schema
     }
 
     async create(data: C): Promise<T> {
         try {
-            if(this._schema){
+            if (this._schema) {
                 await this._schema.parseAsync(data)
             }
             const item: T = await this._repository.create(data)
@@ -32,10 +41,10 @@ class AbstractService<T,C,U> {
 
     async update(id: string, data: U): Promise<T> {
         try {
-            if(this._schema){
+            if (this._schema) {
                 await this._schema.parseAsync(data)
             }
-            const item : T = await this._repository.update(id, data)
+            const item: T = await this._repository.update(id, data)
             return item
         } catch (e) {
             console.error("Error updating", e)
@@ -139,6 +148,68 @@ class AbstractService<T,C,U> {
 
     }
 
+    async find({
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<T[]> {
+        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 = []
+                 }: IDraxExportOptions,
+                 destinationPath: string): Promise<IDraxExportResult> {
+        try {
+
+            console.log("ExportOptions", {
+                format,
+                headers,
+                separator,
+                outputPath: destinationPath,
+                orderBy,
+                order,
+                search,
+                filters
+            })
+
+            let cursor:any
+            let exporter:any
+
+            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

package/src/workers/ExportCsvWorker.js

@@ -0,0 +1,12 @@
+import { parentPort } from 'worker_threads';
+import ExportCsv from '../exports/ExportCsv.js'; // 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/src/workers/ExportCsvWorker.ts

@@ -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/test/_mocks/MockRepository.ts

@@ -0,0 +1,58 @@
+import type {IDraxCrud, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+
+class MockRepository implements IDraxCrud<any, any, any> {
+    async create(data: any): Promise<any> {
+        return {id: '1',...data}
+    }
+
+    async update(id: string, data: any): Promise<any> {
+        return {...data}
+    }
+
+    async delete(id: string): Promise<boolean> {
+        return true
+    }
+
+    async findById(id: string): Promise<any | null> {
+        return {id: '1', name: 'John Doe'}
+    }
+
+    async findByIds(ids: string[]): Promise<any[]> {
+        return [{id: '1', name: 'John Doe'}, {id: '2', name: 'Jane Doe'}]
+    }
+
+    async findOneBy(field: string, value: string): Promise<any | null> {
+        return {id: '1', name: 'John Doe'}
+    }
+
+    async findBy(field: string, value: string): Promise<any[]> {
+        return [{id: '1', name: 'John Doe'}, {id: '2', name: 'Jane Doe'}]
+    }
+
+    async fetchAll(): Promise<any[]> {
+        return [{id: '1', name: 'John Doe'}, {id: '2', name: 'Jane Doe'}]
+    }
+
+    async search(value: string): Promise<any[]> {
+        return [{id: '1', name: 'John Doe'}, {id: '2', name: 'Jane Doe'}]
+    }
+
+    async find(options?: any): Promise<any[]> {
+        return [{id: '1', name: 'John Doe'}, {id: '2', name: 'Jane Doe'}]
+    }
+
+    paginate(options: IDraxPaginateOptions): Promise<IDraxPaginateResult<any>> {
+
+        return Promise.resolve({
+            page: 1,
+            limit: 10,
+            total: 2,
+            items: [{id: '1', name: 'John Doe'}, {id: '2', name: 'Jane Doe'}]
+        })
+    }
+
+
+}
+
+export {MockRepository}
+export default MockRepository

package/test/exports/ExportCsv.test.ts

@@ -0,0 +1,137 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import * as fs from 'fs';
+import ExportCsv from '../../src/exports/ExportCsv';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+// Simulación de un cursor para MongoDB o SQLite
+function createMockCursor(data: any[]) {
+    let index = 0;
+    return {
+        async *[Symbol.asyncIterator]() {
+            while (index < data.length) {
+                yield data[index++];
+            }
+        },
+    };
+}
+
+//@ts-ignore
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+// Utilidad para leer el contenido del CSV generado
+function readGeneratedCSV(filePath: string): string[] {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return content.split('\n').filter(line => line.length > 0);
+}
+
+// Eliminar el archivo de salida después de cada prueba
+function cleanUp(outputFilePath) {
+    if (fs.existsSync(outputFilePath)) {
+        fs.unlinkSync(outputFilePath);
+    }
+}
+
+const mockData = [
+    {
+        id: '123',
+        name: 'Cristian',
+        lastname: 'Incarnato',
+        age: 39,
+        address: {
+            street: 'Directorio',
+            number: '3935',
+            floor: '6',
+            depto: 'c'
+        },
+        phones: [
+            { number: '1234567', type: 'personal' },
+            { number: '87456123', type: 'laboral' },
+        ],
+        hobbies: ['soccer', 'gym'],
+        pets: [
+            {name: 'capitan', colors: ['grey'], skills: [{name: 'jump', level: 2}] },
+            {name: 'indio', colors: ['grey', 'white'], skills: [{name: 'jump', level: 5}, {name: 'run', level: 4}]},
+        ],
+        jobs: ['developer','devops']
+    },
+];
+
+
+// Prueba para exportar datos con arrays de subdocumentos
+test('Debe exportar atributos base a un archivo CSV', async () => {
+    const outputFilePath = path.resolve(__dirname, 'output_base_test.csv');
+
+    cleanUp(outputFilePath);
+
+    const mockCursor = createMockCursor(mockData);
+    const exportCsv = new ExportCsv({
+        cursor: mockCursor,
+        destinationPath: outputFilePath,
+        headers: ['name', 'lastname', 'address','phones', 'hobbies'],
+        separator: ';',
+    });
+
+    await exportCsv.process();
+
+    const output = readGeneratedCSV(outputFilePath);
+
+    // Verificar que el archivo CSV tenga las filas correctas para los arrays
+    assert.strictEqual(output[0], 'name;lastname;address;phones;hobbies');
+    assert.strictEqual(output[1], 'Cristian;Incarnato;{"street":"Directorio","number":"3935","floor":"6","depto":"c"};[{"number":"1234567","type":"personal"},{"number":"87456123","type":"laboral"}];soccer,gym');
+
+    //cleanUp(outputFilePath);
+})
+
+test('Debe exportar atributos de objeto a un archivo CSV', async () => {
+    const outputFilePath = path.resolve(__dirname, 'output_object_test.csv');
+
+    cleanUp(outputFilePath);
+
+    const mockCursor = createMockCursor(mockData);
+    const exportCsv = new ExportCsv({
+        cursor: mockCursor,
+        destinationPath: outputFilePath,
+        headers: ['name', 'lastname', 'address.street','address.number'],
+        separator: ';',
+    });
+
+    await exportCsv.process();
+
+    const output = readGeneratedCSV(outputFilePath);
+
+    // Verificar que el archivo CSV tenga las filas correctas para los arrays
+    assert.strictEqual(output[0], 'name;lastname;address.street;address.number');
+    assert.strictEqual(output[1], 'Cristian;Incarnato;Directorio;3935');
+
+    //cleanUp(outputFilePath);
+})
+
+
+
+test('Debe exportar atributos de un array de objetos a un archivo CSV', async () => {
+    const outputFilePath = path.resolve(__dirname, 'output_object_test.csv');
+
+    cleanUp(outputFilePath);
+
+    const mockCursor = createMockCursor(mockData);
+    const exportCsv = new ExportCsv({
+        cursor: mockCursor,
+        destinationPath: outputFilePath,
+        headers: ['name', 'lastname', 'phones.number','phones.type'],
+        separator: ';',
+    });
+
+    await exportCsv.process();
+
+    const output = readGeneratedCSV(outputFilePath);
+
+    // Verificar que el archivo CSV tenga las filas correctas para los arrays
+    assert.strictEqual(output[0], 'name;lastname;phones.number;phones.type');
+    assert.strictEqual(output[1], 'Cristian;Incarnato;1234567|87456123;personal|laboral');
+
+    //cleanUp(outputFilePath);
+})

package/test/services/AbstractService.test.ts

@@ -0,0 +1,40 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import MockRepository from "../_mocks/MockRepository.js";
+import {AbstractService} from "../../src/services/AbstractService.js";
+import {fileURLToPath} from "url";
+import path from "path";
+
+//@ts-ignore
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const mockRepository = new MockRepository();
+const abstractService = new AbstractService(mockRepository);
+
+test('create', async () => {
+    const item: any = await abstractService.create({name: 'John Doe'})
+    assert.deepStrictEqual(item.name, 'John Doe');
+})
+
+
+test('export', async () => {
+    const file = 'test.csv'
+    const outputPath = path.resolve(__dirname, file);
+
+    const result:any = await abstractService.export(
+        {
+            format: 'CSV',
+            headers: ['name'],
+            separator: ';',
+            limit: 0,
+            search: '',
+            filters: [],
+        }
+    )
+
+    console.log("result",result)
+
+    assert.deepStrictEqual(outputPath, result.outputPath);
+    assert.deepStrictEqual(2, result.rowCount);
+})

package/test/workers/ExportCsvWorker.test.ts

@@ -0,0 +1,92 @@
+
+// Reemplazo de __dirname para ES modules
+import {test} from "node:test";
+import path from "path";
+import assert from "node:assert";
+import {WorkerHandler} from "@drax/common-back"
+import {fileURLToPath} from "url";
+import * as fs from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function createMockCursor(data: any[]) {
+    let index = 0;
+    return {
+        async *[Symbol.asyncIterator]() {
+            while (index < data.length) {
+                yield data[index++];
+            }
+        },
+    };
+}
+
+// Utilidad para leer el contenido del CSV generado
+function readGeneratedCSV(filePath: string): string[] {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return content.split('\n').filter(line => line.length > 0);
+}
+
+// Eliminar el archivo de salida después de cada prueba
+function cleanUp(outputFilePath) {
+    if (fs.existsSync(outputFilePath)) {
+        fs.unlinkSync(outputFilePath);
+    }
+}
+
+
+const mockData = [
+    {
+        id: '123',
+        name: 'Cristian',
+        lastname: 'Incarnato',
+        age: 39,
+        address: {
+            street: 'Directorio',
+            number: '3935',
+            floor: '6',
+            depto: 'c'
+        },
+        phones: [
+            { number: '1234567', type: 'personal' },
+            { number: '87456123', type: 'laboral' },
+        ],
+        hobbies: ['soccer', 'gym'],
+        pets: [
+            {name: 'capitan', colors: ['grey'], skills: [{name: 'jump', level: 2}] },
+            {name: 'indio', colors: ['grey', 'white'], skills: [{name: 'jump', level: 5}, {name: 'run', level: 4}]},
+        ],
+        jobs: ['developer','devops']
+    },
+];
+
+test('Debe exportar atributos base a un archivo CSV', async () => {
+    const outputFilePath = path.resolve(__dirname, 'output_base_worker_test.csv');
+
+    cleanUp(outputFilePath);
+
+    const mockCursor = createMockCursor(mockData);
+    const workerFile = './src/workers/ExportCsvWorker.js'
+    const params = {
+        cursor: mockCursor,
+        outputPath: outputFilePath,
+        headers: ['name', 'lastname', 'address','phones', 'hobbies'],
+        separator: ';',
+    }
+
+    try{
+        const result = await WorkerHandler(workerFile,params)
+        console.log("result", result)
+    }catch (error) {
+        console.log("error", error)
+    }
+
+
+    const output = readGeneratedCSV(outputFilePath);
+
+    // Verificar que el archivo CSV tenga las filas correctas para los arrays
+    assert.strictEqual(output[0], 'name;lastname;address;phones;hobbies');
+    assert.strictEqual(output[1], 'Cristian;Incarnato;{"street":"Directorio","number":"3935","floor":"6","depto":"c"};[{"number":"1234567","type":"personal"},{"number":"87456123","type":"laboral"}];soccer,gym');
+
+    //cleanUp(outputFilePath);
+})

package/tsconfig.json

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