@drax/crud-back 0.11.5 → 0.12.2

package/src/repository/AbstractMongoRepository.ts

@@ -1,103 +1,190 @@
 import "mongoose-paginate-v2";
-import mongoose, {Cursor} from "mongoose";
-import {MongooseQueryFilter, MongooseSort, MongooseErrorToValidationError} from "@drax/common-back";
+import mongoose from "mongoose";
+import type {Cursor, PopulateOptions} from "mongoose";
+import {
+    MongooseQueryFilter,
+    MongooseSort,
+    MongooseValidationErrorToValidationError,
+    MongooseCastErrorToValidationError,
+    MongoServerErrorToValidationError
+} from "@drax/common-back";
 import type {DeleteResult} from "mongodb";
 import type {IDraxPaginateOptions, IDraxPaginateResult, IDraxFindOptions, IDraxCrud, IDraxFieldFilter} from "@drax/crud-share";
 import type {PaginateModel, PaginateOptions, PaginateResult} from "mongoose";
+import {InvalidIdError} from "@drax/common-back";
+import {MongoServerError} from "mongodb";
 
 
 class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
     protected _model: mongoose.Model<T> & PaginateModel<T>
     protected _searchFields: string[] = []
-    protected _populateFields: string[] = []
+    protected _populateFields:  string[] | PopulateOptions[] = []
+    protected _lean: boolean = true
+
+    assertId(id: string): void {
+        if(!mongoose.Types.ObjectId.isValid(id)){
+            console.log(`Invalid ID: ${id} is not a valid ObjectId.`)
+            throw new InvalidIdError(id)
+        }
+    }
 
 
     async create(data: C): Promise<T> {
         try {
-            const item: mongoose.HydratedDocument<T> = new this._model(data)
-            await item.save()
+            const item: mongoose.HydratedDocument<T> = await this._model.create(data)
 
-            //@ts-ignore
-            await item.populate(this._populateFields)
-
-            return item
+            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: string, data: U): Promise<T> {
+
+        this.assertId(id)
+
         try {
             const item: mongoose.HydratedDocument<T> = 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: string, data: any): Promise<T> {
+
+        this.assertId(id)
+
         try {
+
             const item: mongoose.HydratedDocument<T> = 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: string): Promise<boolean> {
+        this.assertId(id)
         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
+
+        const item = await this._model
+            .findById(id)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec()
+
+        return item as T;
     }
 
     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
+
+        const items = await this._model
+            .find({_id: {$in: ids}})
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec()
+
+
+        return items as T[]
     }
 
     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
+
+        const item = await this._model
+            .findOne(filter)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec()
+
+
+        return item as T
     }
 
-    async findBy(field: string, value: any): Promise<T[]> {
+    async findBy(field: string, value: any, limit: number  = 0): Promise<T[]> {
         const filter: any = {[field]: value}
-        const items: mongoose.HydratedDocument<T>[] = await this._model.find(filter).populate(this._populateFields).exec()
-        return items
+        const items = await this._model
+            .find(filter)
+            .limit(limit)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec()
+
+
+        return items as T[]
     }
 
     async fetchAll(): Promise<T[]> {
-        const items: mongoose.HydratedDocument<T>[] = await this._model.find().populate(this._populateFields).exec()
-        return items
+
+        const items = await this._model
+            .find()
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec()
+
+
+        return items as T[]
     }
 
     async search(value: string, limit: number = 1000, filters: IDraxFieldFilter[] =[]): Promise<T[]> {
 
         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: mongoose.HydratedDocument<T>[] = await this._model.find(query).limit(limit).exec()
-        return items
+        const items = await this._model
+            .find(query)
+            .limit(limit)
+            .populate(this._populateFields)
+            .lean(this._lean)
+            .exec()
+
+
+        return items as T[]
     }
 
 
@@ -105,22 +192,27 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       order = false,
+                       order = "asc",
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<T>> {
 
         const query = {}
 
-        if (search) {
-            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search, 'i')}))
+        if(search){
+            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} as PaginateOptions
+        const lean = this._lean
+        const options = {page, limit, sort, populate, lean} as PaginateOptions
         const items: PaginateResult<T> = await this._model.paginate(query, options)
         return {
             page: page,
@@ -137,14 +229,23 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         const query = {}
 
-        if (search) {
-            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search, 'i')}))
+        if(search){
+            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 as T
     }
 
     async find({
@@ -157,15 +258,27 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         const query = {}
 
-        if (search) {
-            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search, 'i')}))
+        if(search){
+            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 as T[]
     }
 
     async findCursor({

package/src/repository/AbstractSqliteRepository.ts

@@ -1,59 +1,103 @@
 import sqlite from "better-sqlite3";
-import type {IDraxCrud, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import type {IDraxCrud, IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {randomUUID} from "node:crypto";
 import {
     SqlSort, SqlQueryFilter, SqliteTableBuilder, SqliteTableField,
-    SqliteErrorToValidationError} from "@drax/common-back";
+    SqliteErrorToValidationError
+} from "@drax/common-back";
 
 
-
-class AbstractSqliteRepository<T> implements IDraxCrud<T, T, T>{
+class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
     protected db: any;
-    protected tableName: string;
-    protected dataBase: string;
+    protected dataBaseFile: string;
+    protected tableName: string = '';
     protected searchFields: string[] = [];
     protected booleanFields: string[] = [];
-    protected identifier: string = 'id';
-    protected verbose: boolean;
+    protected identifier: string = '_id';
+    protected populateFields: { field: string, table: string, identifier: string }[]
     protected tableFields: SqliteTableField[];
+    protected verbose: boolean;
 
-    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")
+    constructor(dataBaseFile: string, verbose: boolean = false) {
+        if (!dataBaseFile) {
+            throw new Error("dataBaseFile is required")
         }
 
-
-        this.dataBase = dataBase;
-        this.tableName =  tableName
-        this.identifier =  identifier
-        this.searchFields =  searchFields
-        this.booleanFields =  booleanFields
+        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: any){
+        return data
+    }
+
+    async prepareItem(item: any) {
+        return item
+    }
+
+    async execPopulate(item: any) {
+        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: any) {
+        for (const field of this.booleanFields) {
+            if(item[field] != undefined){
+                item[field] = item[field] === 1 || item[field] === 'true'
+            }
+
+        }
+    }
+
+    async decorate(item: any) {
+        await this.execPopulate(item)
+        this.castToBoolean(item)
+        await this.prepareItem(item)
+    }
+
     async create(data: any): Promise<T> {
-        try{
+        try {
 
-            if(!data[this.identifier]){
+            if (!data[this.identifier]) {
                 data[this.identifier] = randomUUID()
             }
 
-            for(const key in data){
-                if(typeof data[key] === 'boolean'){
-                    data[key] = data[key]? 1 : 0
+            for (const key in data) {
+                if (typeof data[key] === 'boolean') {
+                    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(', ');
@@ -62,47 +106,53 @@ class AbstractSqliteRepository<T> implements IDraxCrud<T, T, T>{
                 .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])
-        }catch (e){
+
+            const item = await this.findById(data[this.identifier])
+            return item
+
+        } 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 updatePartial(id: string, data: any): Promise<T> {
+        return await this.update(id, data)
     }
 
-    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{
+        try {
 
-            for(const key in data){
-                if(typeof data[key] === 'boolean'){
-                    data[key] = data[key]? 1 : 0
+            for (const key in data) {
+                if (typeof data[key] === 'boolean') {
+                    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)
-        }catch (e){
+            const item = await this.findById(id)
+            return item
+
+        } catch (e) {
             console.log(e)
             throw SqliteErrorToValidationError(e, data)
         }
@@ -111,24 +161,33 @@ class AbstractSqliteRepository<T> implements IDraxCrud<T, T, T>{
 
 
     async delete(id: string): Promise<boolean> {
-        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(): Promise<boolean> {
+        const stmt = this.db.prepare(`DELETE
+                                      FROM ${this.tableName}`);
+        stmt.run();
+        return true
+    }
 
 
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= 'desc',
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<T>>{
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       order = 'desc',
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<T>> {
 
         const offset = page > 1 ? (page - 1) * limit : 0
 
-        let where=""
+        let where = ""
         if (search && this.searchFields.length > 0) {
             where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${search}%'`).join(" OR ")}`
         }
@@ -139,16 +198,14 @@ class AbstractSqliteRepository<T> implements IDraxCrud<T, T, T>{
 
         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[];
+        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
-                }
-            }
+        for (const item of items) {
+            await this.decorate(item)
         }
 
         return {
@@ -159,20 +216,87 @@ class AbstractSqliteRepository<T> implements IDraxCrud<T, T, T>{
         }
     }
 
-    async fetchAll(): Promise<any[]>{
-        const items = this.db.prepare(`SELECT * FROM ${this.tableName}`).all();
+    async find({
+                   limit = 5,
+                   orderBy = '',
+                   order = 'desc',
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<any[]> {
+
+
+        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]) as T[];
+
+        for (const item of items) {
+            await this.decorate(item)
+        }
+
+        return items
+    }
+
+    async fetchAll(): Promise<any[]> {
+        const items = this.db.prepare(`SELECT *
+                                       FROM ${this.tableName}`).all();
+        for (const item of items) {
+            await this.decorate(item)
+        }
         return items
     }
 
-    async search(value: any, limit: number = 1000): Promise<any[]>{
-        let where=""
+    async search(value: any, limit: number = 1000): Promise<any[]> {
+        let where = ""
         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: string): Promise<T | null> {
+        const item = this.db.prepare(`SELECT *
+                                      FROM ${this.tableName}
+                                      WHERE ${this.identifier} = ?`).get(id);
+        await this.decorate(item)
+        return item
+    }
+
+    async findBy(field: string, value: any, limit: number = 0): Promise<T[] | null> {
+        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: string, value: any): Promise<T | null> {
+        const item = this.db.prepare(`SELECT *
+                                      FROM ${this.tableName}
+                                      WHERE ${field} = ?`).get(value);
+        await this.decorate(item)
+        return item
+    }
 }
 
 export default AbstractSqliteRepository

package/src/schemas/DeleteBodyResponseSchema.ts

@@ -0,0 +1,12 @@
+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}