@drax/crud-back 0.11.4 → 0.12.1

package/dist/repository/AbstractMongoRepository.js

@@ -1,94 +1,160 @@
 import "mongoose-paginate-v2";
 import mongoose from "mongoose";
-import { MongooseQueryFilter, MongooseSort, MongooseErrorToValidationError } from "@drax/common-back";
+import { MongooseQueryFilter, MongooseSort, MongooseValidationErrorToValidationError, MongooseCastErrorToValidationError, MongoServerErrorToValidationError } from "@drax/common-back";
+import { InvalidIdError } from "@drax/common-back";
+import { MongoServerError } from "mongodb";
 class AbstractMongoRepository {
     constructor() {
         this._searchFields = [];
         this._populateFields = [];
+        this._lean = true;
+    }
+    assertId(id) {
+        if (!mongoose.Types.ObjectId.isValid(id)) {
+            console.log(`Invalid ID: ${id} is not a valid ObjectId.`);
+            throw new InvalidIdError(id);
+        }
     }
     async create(data) {
         try {
-            const item = new this._model(data);
-            await item.save();
-            //@ts-ignore
-            await item.populate(this._populateFields);
-            return item;
+            const item = await this._model.create(data);
+            if (this._populateFields && this._populateFields.length > 0) {
+                //@ts-ignore
+                await item.populate(this._populateFields);
+            }
+            return this._lean ? item : item.toObject();
         }
         catch (e) {
             if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e);
+                throw MongooseValidationErrorToValidationError(e);
+            }
+            if (e instanceof mongoose.Error.CastError) {
+                throw MongooseCastErrorToValidationError(e);
+            }
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
+                throw MongoServerErrorToValidationError(e);
             }
             throw e;
         }
     }
     async update(id, data) {
+        this.assertId(id);
         try {
             const item = await this._model.findOneAndUpdate({ _id: id }, data, { new: true }).populate(this._populateFields).exec();
-            return item;
+            return this._lean ? item : item.toObject();
         }
         catch (e) {
             if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e);
+                throw MongooseValidationErrorToValidationError(e);
+            }
+            if (e instanceof mongoose.Error.CastError) {
+                throw MongooseCastErrorToValidationError(e);
+            }
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
+                throw MongoServerErrorToValidationError(e);
             }
             throw e;
         }
     }
     async updatePartial(id, data) {
+        this.assertId(id);
         try {
             const item = await this._model.findOneAndUpdate({ _id: id }, data, { new: true }).populate(this._populateFields).exec();
-            return item;
+            return this._lean ? item : item.toObject();
         }
         catch (e) {
             if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e);
+                throw MongooseValidationErrorToValidationError(e);
+            }
+            if (e instanceof mongoose.Error.CastError) {
+                throw MongooseCastErrorToValidationError(e);
+            }
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
+                throw MongoServerErrorToValidationError(e);
             }
             throw e;
         }
     }
     async delete(id) {
+        this.assertId(id);
         const result = await this._model.deleteOne({ _id: id }).exec();
         return result.deletedCount == 1;
     }
     async findById(id) {
-        const item = await this._model.findById(id).populate(this._populateFields).exec();
+        const item = await this._model
+            .findById(id)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
         return item;
     }
     async findByIds(ids) {
-        const items = await this._model.find({ _id: { $in: ids } }).populate(this._populateFields).exec();
+        const items = await this._model
+            .find({ _id: { $in: ids } })
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
         return items;
     }
     async findOneBy(field, value) {
         const filter = { [field]: value };
-        const item = await this._model.findOne(filter).populate(this._populateFields).exec();
+        const item = await this._model
+            .findOne(filter)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
         return item;
     }
-    async findBy(field, value) {
+    async findBy(field, value, limit = 0) {
         const filter = { [field]: value };
-        const items = await this._model.find(filter).populate(this._populateFields).exec();
+        const items = await this._model
+            .find(filter)
+            .limit(limit)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
         return items;
     }
     async fetchAll() {
-        const items = await this._model.find().populate(this._populateFields).exec();
+        const items = await this._model
+            .find()
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
         return items;
     }
     async search(value, limit = 1000, filters = []) {
         const query = {};
-        if (value) {
+        if (mongoose.Types.ObjectId.isValid(value)) {
+            query['_id'] = new mongoose.Types.ObjectId(value);
+        }
+        else if (value) {
             query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value.toString(), 'i') }));
         }
         MongooseQueryFilter.applyFilters(query, filters);
-        const items = await this._model.find(query).limit(limit).exec();
+        const items = await this._model
+            .find(query)
+            .limit(limit)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
         return items;
     }
-    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
+    async paginate({ page = 1, limit = 5, orderBy = '', order = "asc", search = '', filters = [] }) {
         const query = {};
         if (search) {
-            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search, 'i') }));
+            if (mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search);
+            }
+            else {
+                query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
+            }
         }
         MongooseQueryFilter.applyFilters(query, filters);
         const sort = MongooseSort.applySort(orderBy, order);
         const populate = this._populateFields;
-        const options = { page, limit, sort, populate };
+        const lean = this._lean;
+        const options = { page, limit, sort, populate, lean };
         const items = await this._model.paginate(query, options);
         return {
             page: page,
@@ -100,21 +166,41 @@ class AbstractMongoRepository {
     async findOne({ search = '', filters = [] }) {
         const query = {};
         if (search) {
-            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search, 'i') }));
+            if (mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search);
+            }
+            else {
+                query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
+            }
         }
         MongooseQueryFilter.applyFilters(query, filters);
-        const populate = this._populateFields;
-        return this._model.findOne(query).populate(populate);
+        const item = this._model
+            .findOne(query)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
+        return item;
     }
     async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
         const query = {};
         if (search) {
-            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search, 'i') }));
+            if (mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search);
+            }
+            else {
+                query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
+            }
         }
         MongooseQueryFilter.applyFilters(query, filters);
         const sort = MongooseSort.applySort(orderBy, order);
-        const populate = this._populateFields;
-        return this._model.find(query).limit(limit).sort(sort).populate(populate);
+        const items = await this._model
+            .find(query)
+            .limit(limit)
+            .sort(sort)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec();
+        return items;
     }
     async findCursor({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
         const query = {};

package/dist/repository/AbstractSqliteRepository.js

@@ -2,28 +2,56 @@ import sqlite from "better-sqlite3";
 import { randomUUID } from "node:crypto";
 import { SqlSort, SqlQueryFilter, SqliteTableBuilder, SqliteErrorToValidationError } from "@drax/common-back";
 class AbstractSqliteRepository {
-    constructor(dataBase, tableName, identifier = 'id', searchFields = [], booleanFields = [], verbose = false) {
+    constructor(dataBaseFile, verbose = false) {
+        this.tableName = '';
         this.searchFields = [];
         this.booleanFields = [];
-        this.identifier = 'id';
-        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.identifier = '_id';
+        if (!dataBaseFile) {
+            throw new Error("dataBaseFile is required");
+        }
+        this.dataBaseFile = dataBaseFile;
         this.verbose = verbose;
-        this.db = new sqlite(dataBase, { verbose: verbose ? console.log : null });
+        this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
     }
     build() {
-        const builder = new SqliteTableBuilder(this.dataBase, this.tableName, this.tableFields, this.verbose);
+        const builder = new SqliteTableBuilder(this.dataBaseFile, this.tableName, this.tableFields, this.verbose);
         builder.build(this.identifier);
     }
+    hasCreatedAt() {
+        return this.tableFields.some(field => field.name === 'createdAt');
+    }
+    hasUpdatedAt() {
+        return this.tableFields.some(field => field.name === 'updatedAt');
+    }
+    async prepareData(data) {
+        return data;
+    }
+    async prepareItem(item) {
+        return item;
+    }
+    async execPopulate(item) {
+        for (const field of this.populateFields) {
+            if (item[field.field]) {
+                item[field.field] = this.db.prepare(`SELECT *
+                                                     FROM ${field.table}
+                                                     WHERE ${field.identifier} = ?`).get(item[field.field]);
+            }
+        }
+        return item;
+    }
+    castToBoolean(item) {
+        for (const field of this.booleanFields) {
+            if (item[field] != undefined) {
+                item[field] = item[field] === 1 || item[field] === 'true';
+            }
+        }
+    }
+    async decorate(item) {
+        await this.execPopulate(item);
+        this.castToBoolean(item);
+        await this.prepareItem(item);
+    }
     async create(data) {
         try {
             if (!data[this.identifier]) {
@@ -34,32 +62,32 @@ class AbstractSqliteRepository {
                     data[key] = data[key] ? 1 : 0;
                 }
             }
+            if (this.hasCreatedAt()) {
+                data.createdAt = (new Date().toISOString());
+            }
+            if (this.hasUpdatedAt()) {
+                data.updatedAt = (new Date().toISOString());
+            }
+            await this.prepareData(data);
             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})`);
+            const stmt = this.db.prepare(`INSERT INTO ${this.tableName} (${fields})
+                                          VALUES (${values})`);
             stmt.run(data);
-            return this.findById(data[this.identifier]);
+            const item = await this.findById(data[this.identifier]);
+            return item;
         }
         catch (e) {
             console.log(e);
             throw SqliteErrorToValidationError(e, data);
         }
     }
-    async findById(id) {
-        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${this.identifier} = ?`).get(id);
-        return item;
-    }
-    async findBy(field, value) {
-        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${field} = ?`).all(value);
-        return item;
-    }
-    async findOneBy(field, value) {
-        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${field} = ?`).get(value);
-        return item;
+    async updatePartial(id, data) {
+        return await this.update(id, data);
     }
     async update(id, data) {
         try {
@@ -68,13 +96,20 @@ class AbstractSqliteRepository {
                     data[key] = data[key] ? 1 : 0;
                 }
             }
+            if (this.hasUpdatedAt()) {
+                data.updatedAt = (new Date().toISOString());
+            }
+            await this.prepareData(data);
             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 `);
+            const stmt = this.db.prepare(`UPDATE ${this.tableName}
+                                          SET ${setClauses}
+                                          WHERE ${this.identifier} = @identifier `);
             stmt.run(data);
-            return this.findById(id);
+            const item = await this.findById(id);
+            return item;
         }
         catch (e) {
             console.log(e);
@@ -82,10 +117,18 @@ class AbstractSqliteRepository {
         }
     }
     async delete(id) {
-        const stmt = this.db.prepare(`DELETE FROM ${this.tableName} WHERE ${this.identifier} = ?`);
+        const stmt = this.db.prepare(`DELETE
+                                      FROM ${this.tableName}
+                                      WHERE ${this.identifier} = ?`);
         stmt.run(id);
         return true;
     }
+    async deleteAll() {
+        const stmt = this.db.prepare(`DELETE
+                                      FROM ${this.tableName}`);
+        stmt.run();
+        return true;
+    }
     async paginate({ page = 1, limit = 5, orderBy = '', order = 'desc', search = '', filters = [] }) {
         const offset = page > 1 ? (page - 1) * limit : 0;
         let where = "";
@@ -96,15 +139,13 @@ class AbstractSqliteRepository {
             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]);
+        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]);
         for (const item of items) {
-            for (const key in item) {
-                if (this.booleanFields.includes(key)) {
-                    //@ts-ignore
-                    item[key] = item[key] ? true : false;
-                }
-            }
+            await this.decorate(item);
         }
         return {
             page: page,
@@ -113,8 +154,30 @@ class AbstractSqliteRepository {
             items: items
         };
     }
+    async find({ limit = 5, orderBy = '', order = 'desc', search = '', filters = [] }) {
+        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 ? `).all([limit]);
+        for (const item of items) {
+            await this.decorate(item);
+        }
+        return items;
+    }
     async fetchAll() {
-        const items = this.db.prepare(`SELECT * FROM ${this.tableName}`).all();
+        const items = this.db.prepare(`SELECT *
+                                       FROM ${this.tableName}`).all();
+        for (const item of items) {
+            await this.decorate(item);
+        }
         return items;
     }
     async search(value, limit = 1000) {
@@ -122,8 +185,35 @@ class AbstractSqliteRepository {
         if (value && this.searchFields.length > 0) {
             where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${value}%'`).join(" OR ")}`;
         }
-        const items = this.db.prepare(`SELECT * FROM ${this.tableName} ${where}`).all();
+        const items = this.db.prepare(`SELECT *
+                                       FROM ${this.tableName} ${where} LIMIT ${limit}`).all();
+        for (const item of items) {
+            await this.decorate(item);
+        }
         return items;
     }
+    async findById(id) {
+        const item = this.db.prepare(`SELECT *
+                                      FROM ${this.tableName}
+                                      WHERE ${this.identifier} = ?`).get(id);
+        await this.decorate(item);
+        return item;
+    }
+    async findBy(field, value, limit = 0) {
+        const items = this.db.prepare(`SELECT *
+                                       FROM ${this.tableName}
+                                       WHERE ${field} = ? LIMIT ${limit}`).all(value);
+        for (const item of items) {
+            await this.decorate(item);
+        }
+        return items;
+    }
+    async findOneBy(field, value) {
+        const item = this.db.prepare(`SELECT *
+                                      FROM ${this.tableName}
+                                      WHERE ${field} = ?`).get(value);
+        await this.decorate(item);
+        return item;
+    }
 }
 export default AbstractSqliteRepository;

package/dist/schemas/DeleteBodyResponseSchema.js

@@ -0,0 +1,9 @@
+import z from "zod";
+const DeleteBodyResponseSchema = z.object({
+    id: z.string(),
+    deleted: z.boolean(),
+    deletedAt: z.string(),
+    message: z.string()
+});
+export default DeleteBodyResponseSchema;
+export { DeleteBodyResponseSchema };

package/dist/schemas/ErrorBodyResponseSchema.js

@@ -0,0 +1,16 @@
+import z from "zod";
+const ErrorBodyResponseSchema = z.object({
+    statusCode: z.string(),
+    error: z.string(),
+    message: z.string(),
+    i18nMessage: z.string()
+});
+const ValidationErrorBodyResponseSchema = ErrorBodyResponseSchema.extend({
+    inputErrors: z.array(z.object({
+        field: z.string(),
+        reason: z.string(),
+        value: z.any().optional(),
+    })).optional()
+});
+export default ErrorBodyResponseSchema;
+export { ErrorBodyResponseSchema, ValidationErrorBodyResponseSchema };

package/dist/schemas/ExportBodyResponseSchema.js

@@ -0,0 +1,9 @@
+import z from "zod";
+const ExportBodyResponseSchema = z.object({
+    url: z.string(),
+    rowCount: z.number(),
+    time: z.number(),
+    fileName: z.string(),
+});
+export default ExportBodyResponseSchema;
+export { ExportBodyResponseSchema };

package/dist/schemas/FindBySchema.js

@@ -0,0 +1,6 @@
+import z from "zod";
+const FindByParamSchema = z.object({
+    value: z.string(),
+    field: z.string(),
+});
+export { FindByParamSchema };

package/dist/schemas/FindSchema.js

@@ -0,0 +1,9 @@
+import z from "zod";
+import QueryFilterRegex from "../regexs/QueryFilterRegex.js";
+const FindQuerySchema = z.object({
+    orderBy: z.string().optional(),
+    order: z.enum(["asc", "desc"]).optional(),
+    search: z.string().optional(),
+    filters: z.string().regex(QueryFilterRegex).optional().describe("Format: field;operator;value|field;operator;value|..."),
+});
+export { FindQuerySchema };

package/dist/schemas/IdParamSchema.js

@@ -0,0 +1,6 @@
+import z from "zod";
+const IdParamSchema = z.object({
+    id: z.string().min(1, "validation.required")
+});
+export default IdParamSchema;
+export { IdParamSchema };

package/dist/schemas/PaginateBodySchema.js

@@ -0,0 +1,20 @@
+import z from "zod";
+const PaginateQuerySchema = z.object({
+    page: z.number(),
+    limit: z.number(),
+    orderBy: z.string().optional(),
+    order: z.enum(["asc", "desc"]).optional(),
+    search: z.string().optional(),
+    filters: z.array(z.object({
+        field: z.string(),
+        operator: z.string(),
+        value: z.any(),
+    })).optional()
+});
+const PaginateBodyResponseSchema = z.object({
+    page: z.number(),
+    limit: z.number(),
+    total: z.number(),
+    items: z.array(z.any())
+});
+export { PaginateQuerySchema, PaginateBodyResponseSchema };

package/dist/schemas/PaginateSchema.js

@@ -0,0 +1,17 @@
+import z from "zod";
+import QueryFilterRegex from "../regexs/QueryFilterRegex.js";
+const PaginateQuerySchema = z.object({
+    page: z.number().optional(),
+    limit: z.number().optional(),
+    orderBy: z.string().optional(),
+    order: z.enum(["asc", "desc"]).optional(),
+    search: z.string().optional(),
+    filters: z.string().regex(QueryFilterRegex).optional().describe("Format: field;operator;value|field;operator;value|..."),
+});
+const PaginateBodyResponseSchema = z.object({
+    page: z.number(),
+    limit: z.number(),
+    total: z.number(),
+    items: z.array(z.any())
+});
+export { PaginateQuerySchema, PaginateBodyResponseSchema };

package/dist/schemas/SearchSchema.js

@@ -0,0 +1,5 @@
+import z from "zod";
+const SearchQuerySchema = z.object({
+    search: z.string().optional(),
+});
+export { SearchQuerySchema };

package/dist/services/AbstractService.js

@@ -47,6 +47,9 @@ class AbstractService {
     }
     async updatePartial(id, data) {
         try {
+            if (this._schema) {
+                await this._schema.partial().parseAsync(data);
+            }
             const item = await this._repository.updatePartial(id, data);
             return item;
         }
@@ -110,9 +113,9 @@ class AbstractService {
             throw e;
         }
     }
-    async findBy(field, value) {
+    async findBy(field, value, limit = 1000) {
         try {
-            let items = await this._repository.findBy(field, value);
+            let items = await this._repository.findBy(field, value, limit);
             if (this.transformRead) {
                 items = await Promise.all(items.map(item => this.transformRead(item)));
             }
@@ -149,7 +152,7 @@ class AbstractService {
             throw e;
         }
     }
-    async paginate({ page = 1, limit = 5, orderBy = this._defaultOrder, order = false, search = '', filters = [] }) {
+    async paginate({ page = 1, limit = 10, orderBy = this._defaultOrder, order = "asc", search = '', filters = [] }) {
         try {
             const pagination = await this._repository.paginate({ page, limit, orderBy, order, search, filters });
             if (this.transformRead) {
@@ -162,9 +165,9 @@ class AbstractService {
             throw e;
         }
     }
-    async find({ orderBy = '', order = false, search = '', filters = [] }) {
+    async find({ orderBy = '', order = false, search = '', filters = [], limit = 0, }) {
         try {
-            let items = await this._repository.find({ orderBy, order, search, filters });
+            let items = await this._repository.find({ orderBy, order, search, filters, limit });
             return items;
         }
         catch (e) {

package/dist/zod/DeleteBodySchema.js

@@ -0,0 +1,6 @@
+import z from "zod";
+const DeleteBodySchema = z.object({
+    message: z.string(),
+});
+export default DeleteBodySchema;
+export { DeleteBodySchema };

package/dist/zod/IdParamSchema.js

@@ -0,0 +1,6 @@
+import z from "zod";
+const IdParamSchema = z.object({
+    id: z.string().min(1, "validation.required")
+});
+export default IdParamSchema;
+export { IdParamSchema };

package/dist/zod/PaginateBodySchema.js

@@ -0,0 +1,20 @@
+import z from "zod";
+const PaginateBodyRequestSchema = z.object({
+    page: z.number(),
+    limit: z.number(),
+    orderBy: z.string().optional(),
+    order: z.enum(["asc", "desc"]).optional(),
+    search: z.string().optional(),
+    filters: z.array(z.object({
+        field: z.string(),
+        operator: z.string(),
+        value: z.any(),
+    }))
+});
+const PaginateBodyResponseSchema = z.object({
+    page: z.number(),
+    limit: z.number(),
+    total: z.number(),
+    items: z.array(z.any())
+});
+export { PaginateBodyRequestSchema, PaginateBodyResponseSchema };