@rws-framework/db 3.3.2 → 3.3.3

package/dist/models/core/RWSModel.d.ts

@@ -4,8 +4,6 @@ import { OpModelType } from '../interfaces/OpModelType';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { DBService } from '../../services/DBService';
 import { ISuperTagData } from '../../decorators/RWSCollection';
-import { RelManyMetaType, RelOneMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
 declare class RWSModel<T> implements IModel {
     static services: IRWSModelServices;
     [key: string]: any;
@@ -32,9 +30,9 @@ declare class RWSModel<T> implements IModel {
     _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean): Promise<T>;
     private getModelScalarFields;
     private getRelationOneMeta;
-    static getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    static getRelationOneMeta(model: any, classFields: string[]): Promise<import("..").RelOneMetaType<import("../..").IRWSModel>>;
     private getRelationManyMeta;
-    static getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    static getRelationManyMeta(model: any, classFields: string[]): Promise<import("..").RelManyMetaType<import("../..").IRWSModel>>;
     static paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams: IPaginationParams, findParams?: FindByType): Promise<T[]>;
     toMongo(): Promise<any>;
     getCollection(): string | null;

package/dist/models/core/RWSModel.js

@@ -16,6 +16,7 @@ const RelationUtils_1 = require("../utils/RelationUtils");
 const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
 const ModelUtils_1 = require("../utils/ModelUtils");
 const HydrateUtils_1 = require("../utils/HydrateUtils");
+const FindUtils_1 = require("../utils/FindUtils");
 class RWSModel {
     static services = {};
     id;
@@ -119,29 +120,7 @@ class RWSModel {
         return RelationUtils_1.RelationUtils.getRelationManyMeta(model, classFields);
     }
     static async paginate(paginateParams, findParams) {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-        const collection = Reflect.get(this, '_collection');
-        this.checkForInclusionWithThrow(this.name);
-        try {
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
-            if (dbData.length) {
-                const instanced = [];
-                for (const data of dbData) {
-                    const inst = new this();
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
-                }
-                return instanced;
-            }
-            return [];
-        }
-        catch (rwsError) {
-            console.error(rwsError);
-            throw rwsError;
-        }
+        return await FindUtils_1.FindUtils.paginate(this, paginateParams, findParams);
     }
     async toMongo() {
         const data = {};
@@ -178,9 +157,11 @@ class RWSModel {
     async save() {
         const data = await this.toMongo();
         let updatedModelData = data;
-        if (this.id) {
+        const entryExists = await ModelUtils_1.ModelUtils.entryExists(this);
+        if (entryExists) {
             this.preUpdate();
-            updatedModelData = await this.dbService.update(data, this.getCollection());
+            const compoundId = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
+            updatedModelData = await this.dbService.update(data, this.getCollection(), Array.isArray(compoundId) ? compoundId : null);
             await this._asyncFill(updatedModelData);
             this.postUpdate();
         }
@@ -239,59 +220,13 @@ class RWSModel {
         return await this.services.dbService.watchCollection(collection, preRun);
     }
     static async findOneBy(findParams) {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-        this.checkForInclusionWithThrow('');
-        const collection = Reflect.get(this, '_collection');
-        const dbData = await this.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
-        if (dbData) {
-            const inst = new this();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-        return null;
+        return await FindUtils_1.FindUtils.findOneBy(this, findParams);
     }
     static async find(id, findParams = null) {
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-        const collection = Reflect.get(this, '_collection');
-        this.checkForInclusionWithThrow(this.name);
-        const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
-        if (dbData) {
-            const inst = new this();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-        return null;
+        return await FindUtils_1.FindUtils.find(this, id, findParams);
     }
     static async findBy(findParams) {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-        const collection = Reflect.get(this, '_collection');
-        this.checkForInclusionWithThrow(this.name);
-        try {
-            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
-            if (dbData.length) {
-                const instanced = [];
-                for (const data of dbData) {
-                    const inst = new this();
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
-                }
-                return instanced;
-            }
-            return [];
-        }
-        catch (rwsError) {
-            console.error(rwsError);
-            throw rwsError;
-        }
+        return await FindUtils_1.FindUtils.findBy(this, findParams);
     }
     static async delete(conditions) {
         const collection = Reflect.get(this, '_collection');

package/dist/models/utils/FindUtils.d.ts

@@ -0,0 +1,9 @@
+import { RWSModel } from "../core/RWSModel";
+import { OpModelType } from "..";
+import { FindByType, IPaginationParams } from "../../types/FindParams";
+export declare class FindUtils {
+    static findOneBy<T extends RWSModel<T>>(opModel: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
+    static find<T extends RWSModel<T>>(opModel: OpModelType<T>, id: string | number, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    static findBy<T extends RWSModel<T>>(opModel: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
+    static paginate<T extends RWSModel<T>>(opModel: OpModelType<T>, paginateParams: IPaginationParams, findParams?: FindByType): Promise<T[]>;
+}

package/dist/models/utils/FindUtils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindUtils = void 0;
+class FindUtils {
+    static async findOneBy(opModel, findParams) {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        opModel.checkForInclusionWithThrow('');
+        const collection = Reflect.get(opModel, '_collection');
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
+        if (dbData) {
+            const inst = new opModel();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+        return null;
+    }
+    static async find(opModel, id, findParams = null) {
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
+        if (dbData) {
+            const inst = new opModel();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+        return null;
+    }
+    static async findBy(opModel, findParams) {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new opModel();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+    static async paginate(opModel, paginateParams, findParams) {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new opModel();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+}
+exports.FindUtils = FindUtils;

package/dist/models/utils/ModelUtils.d.ts

@@ -1,4 +1,5 @@
 import { RWSModel } from "../core/RWSModel";
+import { OpModelType } from "..";
 export declare class ModelUtils {
     static getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
         annotationType: string;
@@ -7,4 +8,6 @@ export declare class ModelUtils {
     static checkDbVariable(constructor: any, variable: string): Promise<boolean>;
     static isSubclass<T, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
     static getModelScalarFields(model: RWSModel<any>): string[];
+    static findPrimaryKeyFields(opModel: OpModelType<any>): string | string[];
+    static entryExists(model: RWSModel<any>): Promise<boolean>;
 }

package/dist/models/utils/ModelUtils.js

@@ -59,5 +59,57 @@ class ModelUtils {
             .filter((item) => item.indexOf('TrackType') === 0)
             .map((item) => item.split(':').at(-1));
     }
+    static findPrimaryKeyFields(opModel) {
+        if (opModel._NO_ID) {
+            const foundSuperId = opModel._SUPER_TAGS.find(tag => tag.tagType === 'id');
+            if (foundSuperId) {
+                return foundSuperId.fields;
+            }
+            const foundSuperUnique = opModel._SUPER_TAGS.find(tag => tag.tagType === 'unique');
+            if (foundSuperUnique) {
+                return foundSuperUnique.fields;
+            }
+        }
+        return 'id';
+    }
+    static async entryExists(model) {
+        let entryHasData = true;
+        let compoundId = false;
+        const foundPrimaryKey = this.findPrimaryKeyFields(model.constructor);
+        if (Array.isArray(foundPrimaryKey)) {
+            compoundId = true;
+            for (const idKey of foundPrimaryKey) {
+                if (!Object.hasOwn(model, idKey)) {
+                    entryHasData = false;
+                }
+                if (Object.hasOwn(model, idKey) && !model[idKey]) {
+                    entryHasData = false;
+                }
+            }
+        }
+        else {
+            if (Object.hasOwn(model, foundPrimaryKey) && !model[foundPrimaryKey]) {
+                entryHasData = false;
+            }
+            if (!Object.hasOwn(model, foundPrimaryKey)) {
+                entryHasData = false;
+            }
+        }
+        if (!entryHasData) {
+            return false;
+        }
+        const constructor = model.constructor;
+        const conditions = {};
+        if (compoundId) {
+            for (const key of foundPrimaryKey) {
+                conditions[key] = model[key];
+            }
+            return (await constructor.findOneBy({ conditions }) !== null);
+        }
+        else {
+            conditions[foundPrimaryKey] = model[foundPrimaryKey];
+        }
+        return (await constructor.findOneBy({ conditions })) !== null;
+    }
 }
 exports.ModelUtils = ModelUtils;

package/dist/services/DBService.d.ts

@@ -21,7 +21,9 @@ declare class DBService {
     cloneDatabase(source: string, target: string): Promise<void>;
     watchCollection(collectionName: string, preRun: () => void): Promise<any>;
     insert(data: any, collection: string, isTimeSeries?: boolean): Promise<any>;
-    update(data: any, collection: string): Promise<IModel>;
+    update(data: any, collection: string, compoundId?: {
+        [key: string]: any;
+    }): Promise<IModel>;
     findOneBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
         [fieldName: string]: string;
     }, allowRelations?: boolean): Promise<IModel | null>;

package/dist/services/DBService.js

@@ -101,17 +101,24 @@ class DBService {
         result = await prismaCollection.create({ data });
         return await this.findOneBy(collection, { id: result.id });
     }
-    async update(data, collection) {
-        const model_id = data.id;
-        delete data['id'];
+    async update(data, collection, compoundId = null) {
         const prismaCollection = this.getCollectionHandler(collection);
+        const where = compoundId ? compoundId : {
+            id: data.id,
+        };
+        if (!compoundId) {
+            delete data['id'];
+        }
+        else {
+            for (const cKey in compoundId) {
+                delete data[cKey];
+            }
+        }
         await prismaCollection.update({
-            where: {
-                id: model_id,
-            },
+            where,
             data: data,
         });
-        return await this.findOneBy(collection, { id: model_id });
+        return await this.findOneBy(collection, where);
     }
     async findOneBy(collection, conditions, fields = null, ordering = null, allowRelations = true) {
         const params = { where: conditions };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "3.3.2",
+  "version": "3.3.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/models/core/RWSModel.ts

@@ -1,7 +1,7 @@
 import { IModel } from '../interfaces/IModel';
 import { IRWSModelServices } from '../interfaces/IRWSModelServices';
 import { OpModelType } from '../interfaces/OpModelType';
-import { TrackType, ITrackerMetaOpts } from '../../decorators';
+import { TrackType } from '../../decorators';
 import { FieldsHelper } from '../../helper/FieldsHelper';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { RelationUtils } from '../utils/RelationUtils';
@@ -11,9 +11,8 @@ import { ModelUtils } from '../utils/ModelUtils';
 // import timeSeriesModel from './TimeSeriesModel';      
 import { DBService } from '../../services/DBService';
 import { ISuperTagData } from '../../decorators/RWSCollection';
-import { RelManyMetaType, RelOneMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
 import { HydrateUtils } from '../utils/HydrateUtils';
+import { FindUtils } from '../utils/FindUtils';
 
 class RWSModel<T> implements IModel {
     static services: IRWSModelServices = {};
@@ -153,33 +152,7 @@ class RWSModel<T> implements IModel {
         paginateParams: IPaginationParams,  
         findParams?: FindByType
     ): Promise<T[]> {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-
-        const collection = Reflect.get(this, '_collection');
-        this.checkForInclusionWithThrow(this.name);
-        try {
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);   
-            if (dbData.length) {
-                const instanced: T[] = [];
-        
-                for (const data of dbData) { 
-                    const inst: T = new (this as { new(): T })();
-                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
-                }
-        
-                return instanced;
-            }
-        
-            return [];
-        } catch (rwsError: Error | any) {
-            console.error(rwsError);
-
-            throw rwsError;
-        }                 
+        return await FindUtils.paginate(this, paginateParams, findParams);
     }
 
     public async toMongo(): Promise<any> {
@@ -227,11 +200,16 @@ class RWSModel<T> implements IModel {
 
     async save(): Promise<this> {
         const data = await this.toMongo();
-        let updatedModelData = data;         
-        if (this.id) {
+        let updatedModelData = data;  
+
+        const entryExists = await ModelUtils.entryExists(this);        
+
+        if (entryExists) {
             this.preUpdate();
 
-            updatedModelData = await this.dbService.update(data, this.getCollection());
+            const compoundId = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<any>);
+
+            updatedModelData = await this.dbService.update(data, this.getCollection(), Array.isArray(compoundId) ? compoundId : null);
 
             await this._asyncFill(updatedModelData);
             this.postUpdate();
@@ -316,25 +294,7 @@ class RWSModel<T> implements IModel {
         this: OpModelType<T>,
         findParams?: FindByType
     ): Promise<T | null> {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-
-        this.checkForInclusionWithThrow('');
-
-        
-        const collection = Reflect.get(this, '_collection');        
-        const dbData = await this.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
-        
-    
-        if (dbData) {
-            const inst: T = new (this as { new(): T })();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-    
-        return null;
+        return await FindUtils.findOneBy(this, findParams);
     }
 
     public static async find<T extends RWSModel<T>>(
@@ -342,58 +302,14 @@ class RWSModel<T> implements IModel {
         id: string | number,        
         findParams: Omit<FindByType, 'conditions'> = null
     ): Promise<T | null> {        
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;          
-        const fullData = findParams?.fullData ?? false;
-
-        const collection = Reflect.get(this, '_collection');
-        this.checkForInclusionWithThrow(this.name);
-
-        const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
-    
-        if (dbData) {            
-            const inst: T = new (this as { new(): T })();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-    
-        return null;
+        return await FindUtils.find(this, id, findParams)
     }   
     
     public static async findBy<T extends RWSModel<T>>(
         this: OpModelType<T>,    
         findParams?: FindByType
     ): Promise<T[]> {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-
-        const collection = Reflect.get(this, '_collection');
-        this.checkForInclusionWithThrow(this.name);
-        try {
-            const paginateParams =  findParams?.pagination ? findParams?.pagination : undefined;
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);        
-
-            if (dbData.length) {
-                const instanced: T[] = [];
-        
-                for (const data of dbData) { 
-                    const inst: T = new (this as { new(): T })();
-
-                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
-                }
-        
-                return instanced;
-            }
-        
-            return [];
-        } catch (rwsError: Error | any) {
-            console.error(rwsError);
-
-            throw rwsError;
-        }                 
+        return await FindUtils.findBy(this, findParams);                
     }
 
     public static async delete<T extends RWSModel<T>>(

package/src/models/utils/FindUtils.ts

@@ -0,0 +1,128 @@
+import { RWSModel } from "../core/RWSModel";
+import { RelManyMetaType, RelOneMetaType } from "../types/RelationTypes";
+import { IRWSModel } from "../../types/IRWSModel";
+import { TimeSeriesUtils } from "./TimeSeriesUtils";
+import { RelationUtils } from "./RelationUtils";
+import { OpModelType } from "..";
+import { ModelUtils } from "./ModelUtils";
+import { FindByType, IPaginationParams } from "../../types/FindParams";
+
+export class FindUtils {
+    public static async findOneBy<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        findParams?: FindByType
+    ): Promise<T | null> {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+
+        opModel.checkForInclusionWithThrow('');
+
+
+        const collection = Reflect.get(opModel, '_collection');
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
+
+
+        if (dbData) {
+            const inst: T = new (opModel as { new(): T })();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+
+        return null;
+    }
+
+    public static async find<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        id: string | number,
+        findParams: Omit<FindByType, 'conditions'> = null
+    ): Promise<T | null> {
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+
+        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
+
+        if (dbData) {
+            const inst: T = new (opModel as { new(): T })();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+
+        return null;
+    }
+
+    public static async findBy<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        findParams?: FindByType
+    ): Promise<T[]> {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+
+            if (dbData.length) {
+                const instanced: T[] = [];
+
+                for (const data of dbData) {
+                    const inst: T = new (opModel as { new(): T })();
+
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)) as T);
+                }
+
+                return instanced;
+            }
+
+            return [];
+        } catch (rwsError: Error | any) {
+            console.error(rwsError);
+
+            throw rwsError;
+        }
+    }
+
+    public static async paginate<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        paginateParams: IPaginationParams,
+        findParams?: FindByType
+    ): Promise<T[]> {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced: T[] = [];
+
+                for (const data of dbData) {
+                    const inst: T = new (opModel as { new(): T })();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)) as T);
+                }
+
+                return instanced;
+            }
+
+            return [];
+        } catch (rwsError: Error | any) {
+            console.error(rwsError);
+
+            throw rwsError;
+        }
+    }
+}

package/src/models/utils/ModelUtils.ts

@@ -1,5 +1,8 @@
 import { RWSModel } from "../core/RWSModel";
 import { FieldsHelper } from '../../helper/FieldsHelper';
+import { OpModelType } from "..";
+import { ISuperTagData } from "../../decorators/RWSCollection";
+import { FindByType } from "../../types/FindParams";
 
 export class ModelUtils {
     static async getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {annotationType: string, metadata: any}>> {    
@@ -71,4 +74,71 @@ export class ModelUtils {
                 .filter((item: string) => item.indexOf('TrackType') === 0)
                 .map((item: string) => item.split(':').at(-1));
     }
+
+    static findPrimaryKeyFields(opModel: OpModelType<any>): string  | string[]
+    {
+        if(opModel._NO_ID){
+            const foundSuperId: ISuperTagData = opModel._SUPER_TAGS.find(tag => tag.tagType === 'id');
+
+            if(foundSuperId){
+                return foundSuperId.fields;
+            }
+
+            const foundSuperUnique: ISuperTagData = opModel._SUPER_TAGS.find(tag => tag.tagType === 'unique');
+
+            if(foundSuperUnique){
+                return foundSuperUnique.fields;
+            }
+        }
+
+        return 'id';
+    }
+
+    static async entryExists(model: RWSModel<any>): Promise<boolean>
+    {
+        let entryHasData = true;
+        let compoundId = false;
+
+        const foundPrimaryKey = this.findPrimaryKeyFields(model.constructor as OpModelType<any>);
+
+        if(Array.isArray(foundPrimaryKey)){
+            compoundId = true;
+            for(const idKey of foundPrimaryKey){
+                if(!Object.hasOwn(model, idKey)){
+                    entryHasData = false;
+                }
+
+                if(Object.hasOwn(model, idKey) && !model[idKey]){
+                    entryHasData = false;
+                }
+            }
+        }else{
+            if(Object.hasOwn(model, foundPrimaryKey) && !model[foundPrimaryKey]){
+                entryHasData = false;
+            }
+
+            if(!Object.hasOwn(model, foundPrimaryKey)){
+                entryHasData = false;
+            }
+        }
+
+        if(!entryHasData){
+            return false;
+        }        
+
+        const constructor = model.constructor as OpModelType<any>;
+        const conditions: FindByType['conditions'] = {};
+
+        if(compoundId){           
+            for(const key of foundPrimaryKey){
+                conditions[key] = model[key];
+            }
+
+            return (await constructor.findOneBy({ conditions  }) !== null);
+        }else{
+            conditions[foundPrimaryKey as string] = model[foundPrimaryKey as string];
+        }
+
+        return (await constructor.findOneBy({ conditions })) !== null;
+    }
 }

package/src/services/DBService.ts

@@ -137,22 +137,30 @@ class DBService {
         return await this.findOneBy(collection, { id: result.id });
     }
 
-    async update(data: any, collection: string): Promise<IModel> 
-    {
-        const model_id: string = data.id;    
-        delete data['id'];
+    async update(data: any, collection: string, compoundId: {[key: string]: any} = null): Promise<IModel> 
+    {        
 
         const prismaCollection = this.getCollectionHandler(collection);
 
+        const where = compoundId ? compoundId : {
+            id: data.id,
+        };
+
+        if(!compoundId){
+            delete data['id'];
+        }else{
+            for(const cKey in compoundId){
+                delete data[cKey];
+            }
+        }        
+
         await prismaCollection.update({
-            where: {
-                id: model_id,
-            },
+            where,
             data: data,
         });    
 
         
-        return await this.findOneBy(collection, { id: model_id });
+        return await this.findOneBy(collection, where);
     }