@rws-framework/db 3.3.1 → 3.3.3

package/dist/helper/db/schema-generator.js

@@ -109,9 +109,15 @@ datasource db {
                             requiredString = '';
                         }
                         let relatedFieldType = type_converter_1.TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
+                        /**
+                         * @todo: Detect type
+                         */
                         if (relatedToField === 'id' && dbType !== 'mongodb') {
                             relatedFieldType = 'Int';
                         }
+                        if (relationMeta.required === false) {
+                            requiredString = '?';
+                        }
                         // Add relation field with appropriate type based on database
                         if (dbType === 'mongodb') {
                             section += `\t${relationFieldName} String${requiredString} @db.ObjectId\n`;

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/models/utils/RelationUtils.js

@@ -58,8 +58,23 @@ class RelationUtils {
         return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
     }
     static checkRelDisabled(model, key) {
-        return Object.keys(model.constructor._RELATIONS).includes(key) &&
-            model.constructor._RELATIONS[key] === false;
+        const constructor = model.constructor;
+        let declaredRelations = [];
+        for (const relKey in constructor._RELATIONS) {
+            const relEntry = constructor._RELATIONS[relKey];
+            if (relEntry === true) {
+                declaredRelations.push(relKey);
+            }
+        }
+        // if((model.constructor as OpModelType<any>)._collection === 'product'){
+        //     console.log({key, declaredRelations});
+        //  }         
+        // A relation disabled through declared relations
+        if (declaredRelations.length && !declaredRelations.includes(key)) {
+            return true;
+        }
+        // A relation disabled directly
+        return Object.keys(constructor._RELATIONS).includes(key) && constructor._RELATIONS[key] === false;
     }
 }
 exports.RelationUtils = RelationUtils;

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.1",
+  "version": "3.3.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/helper/db/schema-generator.ts

@@ -146,9 +146,16 @@ datasource db {
                         
                         let relatedFieldType = TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
         
+                        /**
+                         * @todo: Detect type
+                         */
                         if(relatedToField === 'id' && dbType !== 'mongodb'){
                             relatedFieldType = 'Int';
-                        }                                       
+                        }                                      
+                        
+                        if(relationMeta.required === false){
+                            requiredString = '?';
+                        }
                     
                         // Add relation field with appropriate type based on database
                         if (dbType === 'mongodb') {

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/HydrateUtils.ts

@@ -55,6 +55,9 @@ export class HydrateUtils {
                  const relMeta = relManyData[key];  
          
                  const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
+
+                       
+
                  if (relationEnabled) {                                
                     model[relMeta.key] = await relMeta.inversionModel.findBy({
                          conditions: {

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/models/utils/RelationUtils.ts

@@ -1,6 +1,6 @@
 import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
 import { IRWSModel } from '../../types/IRWSModel';
-import { RWSModel } from '../_model';
+import { OpModelType, RWSModel } from '../_model';
 
 export class RelationUtils {
     static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
@@ -70,7 +70,28 @@ export class RelationUtils {
     }
 
     static checkRelDisabled(model: RWSModel<any>, key: string): boolean {
-        return Object.keys((model.constructor as any)._RELATIONS).includes(key) && 
-               (model.constructor as any)._RELATIONS[key] === false;
+        const constructor = model.constructor as OpModelType<any>;
+
+        let declaredRelations: string[] = [];
+
+        for(const relKey in constructor._RELATIONS){
+            const relEntry = constructor._RELATIONS[relKey];
+
+            if(relEntry === true){
+                declaredRelations.push(relKey);
+            }
+        }
+
+        // if((model.constructor as OpModelType<any>)._collection === 'product'){
+        //     console.log({key, declaredRelations});
+        //  }         
+
+        // A relation disabled through declared relations
+        if(declaredRelations.length && !declaredRelations.includes(key)){
+            return true;
+        }
+
+        // A relation disabled directly
+        return Object.keys(constructor._RELATIONS).includes(key) && constructor._RELATIONS[key] === false;
     }
 }

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);
     }