@rws-framework/db 3.0.1 → 3.1.0

package/dist/decorators/InverseRelation.js

@@ -1,16 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
+const ModelUtils_1 = require("../models/utils/ModelUtils");
+function guessForeignKey(inversionModel, bindingModel, decoratorsData) {
+    var _a;
+    let key = null;
+    let defaultKey = `${bindingModel._collection}_id`;
+    const relDecorators = {};
+    const trackDecorators = {};
+    if (Object.keys(trackDecorators).includes(key)) {
+        return key;
+    }
+    for (const decKey of Object.keys(decoratorsData)) {
+        const dec = decoratorsData[decKey];
+        if (dec.annotationType === 'Relation') {
+            relDecorators[decKey] = dec;
+        }
+        if (dec.annotationType === 'TrackType') {
+            trackDecorators[decKey] = dec;
+        }
+    }
+    for (const relKey of Object.keys(relDecorators)) {
+        const prodMeta = (_a = relDecorators[relKey]) === null || _a === void 0 ? void 0 : _a.metadata;
+        if (prodMeta && prodMeta.relatedTo._collection === bindingModel._collection) {
+            return prodMeta.relationField;
+        }
+    }
+    return key;
+}
 function InverseRelation(inversionModel, sourceModel, relationOptions = null) {
     return function (target, key) {
-        const metadataPromise = Promise.resolve().then(() => {
+        const metadataPromise = Promise.resolve().then(async () => {
             const model = inversionModel();
             const source = sourceModel();
+            const decoratorsData = await ModelUtils_1.ModelUtils.getModelAnnotations(model);
             const metaOpts = {
                 ...relationOptions,
                 key,
                 inversionModel: model,
-                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`,
+                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : guessForeignKey(model, source, decoratorsData),
                 // Generate a unique relation name if one is not provided
                 relationName: relationOptions && relationOptions.relationName ?
                     relationOptions.relationName.toLowerCase() :

package/dist/helper/DbHelper.d.ts

@@ -27,6 +27,7 @@ export declare class DbHelper {
      * @param leaveFile Whether to leave the schema file after generation
      */
     static pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
+    static migrateDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
     /**
      * Generate model sections for the schema
      * @param model The model to generate a section for

package/dist/helper/DbHelper.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbHelper = void 0;
+const console_1 = require("@rws-framework/console");
 const db_1 = require("./db");
 /**
  * Database helper class
@@ -27,6 +28,11 @@ class DbHelper {
     static async pushDBModels(configService, dbService, leaveFile = false) {
         return db_1.SchemaGenerator.pushDBModels(configService, dbService, leaveFile);
     }
+    static async migrateDBModels(configService, dbService, leaveFile = false) {
+        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
+        const [_, schemaPath] = db_1.DbUtils.getSchemaDir();
+        await console_1.rwsShell.runCommand(`${db_1.DbUtils.detectInstaller()} prisma migrate dev --create-only --schema=${schemaPath}`, process.cwd());
+    }
     /**
      * Generate model sections for the schema
      * @param model The model to generate a section for

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

@@ -47,7 +47,7 @@ datasource db {
         const modelName = model._collection;
         section += `model ${modelName} {\n`;
         if (!model._NO_ID) {
-            section += `\t${utils_1.DbUtils.generateId(dbType, modelMetadatas, false)}\n`;
+            section += `\t${utils_1.DbUtils.generateId(dbType, modelMetadatas)}\n`;
         }
         for (const key in modelMetadatas) {
             const modelMetadata = modelMetadatas[key].metadata;
@@ -81,6 +81,9 @@ datasource db {
                 const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
                 const relatedToField = modelMetadata.relatedToField || 'id';
                 const bindingFieldExists = !!modelMetadatas[relationFieldName];
+                if (modelMetadata.required === false) {
+                    requiredString = '?';
+                }
                 if (isMany) {
                     // Add an inverse field to the related model if it doesn't exist
                     section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;

package/dist/helper/db/utils.d.ts

@@ -18,7 +18,7 @@ export declare class DbUtils {
     static generateId(dbType: IDbConfigParams['db_type'], modelMeta: Record<string, {
         annotationType: string;
         metadata: IIdMetaOpts;
-    }>, debug?: boolean): string;
+    }>, optional?: boolean): string;
 }
 export declare const workspaceRootPath: string;
 export declare const moduleDirPath: string;

package/dist/helper/db/utils.js

@@ -34,7 +34,7 @@ class DbUtils {
     /**
      * Generate an ID field based on the database type
      */
-    static generateId(dbType, modelMeta, debug = false) {
+    static generateId(dbType, modelMeta, optional = false) {
         var _a, _b, _c, _d;
         let useUuid = false;
         let field = 'id';
@@ -46,9 +46,6 @@ class DbUtils {
                 if (annotationType == 'IdType') {
                     const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions({ tags: [], dbOptions: modelMetadata.dbOptions }, dbType);
                     tags.push(...dbSpecificTags);
-                    if (debug) {
-                        console.log({ modelMetadata: modelMetadata.dbOptions });
-                    }
                     field = key;
                     if ((_b = (_a = modelMetadata.dbOptions) === null || _a === void 0 ? void 0 : _a.mysql) === null || _b === void 0 ? void 0 : _b.useUuid) {
                         useUuid = true;
@@ -63,23 +60,27 @@ class DbUtils {
             }
         }
         let idString;
+        let reqStr = '';
+        if (optional) {
+            reqStr = '?';
+        }
         switch (dbType) {
             case 'mongodb':
-                idString = `${field} String @id @default(auto()) @map("_id") @db.ObjectId`;
+                idString = `${field} String${reqStr} @id @default(auto()) @map("_id") @db.ObjectId`;
                 break;
             case 'mysql':
                 idString = useUuid
-                    ? `${field} String @id @default(uuid())`
-                    : `${field} Int @id @default(autoincrement())`;
+                    ? `${field} String${reqStr} @id @default(uuid())`
+                    : `${field} Int${reqStr} @id @default(autoincrement())`;
                 break;
             case 'postgresql':
             case 'postgres':
                 idString = useUuid
-                    ? `${field} String @id @default(uuid())`
-                    : `${field} Int @id @default(autoincrement())`;
+                    ? `${field} String${reqStr} @id @default(uuid())`
+                    : `${field} Int${reqStr} @id @default(autoincrement())`;
                 break;
             case 'sqlite':
-                idString = `${field} Int @id @default(autoincrement())`;
+                idString = `${field} Int${reqStr} @id @default(autoincrement())`;
                 break;
         }
         if (tags.length) {
@@ -88,9 +89,6 @@ class DbUtils {
         if (!idString) {
             throw new Error(`DB type "${dbType}" is not supported!`);
         }
-        if (debug) {
-            console.log({ idString, useUuid });
-        }
         return idString;
     }
 }

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

@@ -4,6 +4,8 @@ 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;
@@ -30,9 +32,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<import("..").RelOneMetaType<import("../..").IRWSModel>>;
+    static getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
     private getRelationManyMeta;
-    static getRelationManyMeta(model: any, classFields: string[]): Promise<import("..").RelManyMetaType<import("../..").IRWSModel>>;
+    static getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<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

@@ -15,6 +15,7 @@ const FieldsHelper_1 = require("../../helper/FieldsHelper");
 const RelationUtils_1 = require("../utils/RelationUtils");
 const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
 const ModelUtils_1 = require("../utils/ModelUtils");
+const HydrateUtils_1 = require("../utils/HydrateUtils");
 class RWSModel {
     constructor(data = null) {
         if (!this.getCollection()) {
@@ -76,7 +77,6 @@ class RWSModel {
     }
     async _asyncFill(data, fullDataMode = false, allowRelations = true) {
         const collections_to_models = {};
-        const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
         const classFields = FieldsHelper_1.FieldsHelper.getAllClassFields(this.constructor);
         // Get both relation metadata types asynchronously
         const [relOneData, relManyData] = await Promise.all([
@@ -88,73 +88,10 @@ class RWSModel {
         });
         const seriesHydrationfields = [];
         if (allowRelations) {
-            // Handle many-to-many relations
-            for (const key in relManyData) {
-                if (!fullDataMode && this.constructor._CUT_KEYS.includes(key)) {
-                    continue;
-                }
-                const relMeta = relManyData[key];
-                const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(this, relMeta.key);
-                if (relationEnabled) {
-                    this[relMeta.key] = await relMeta.inversionModel.findBy({
-                        conditions: {
-                            [relMeta.foreignKey]: data.id
-                        },
-                        allowRelations: false
-                    });
-                }
-            }
-            // Handle one-to-one relations
-            for (const key in relOneData) {
-                if (!fullDataMode && this.constructor._CUT_KEYS.includes(key)) {
-                    continue;
-                }
-                const relMeta = relOneData[key];
-                const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(this, relMeta.key);
-                if (!data[relMeta.hydrationField] && relMeta.required) {
-                    throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`);
-                }
-                if (relationEnabled && data[relMeta.hydrationField]) {
-                    this[relMeta.key] = await relMeta.model.find(data[relMeta.hydrationField], { allowRelations: false });
-                }
-                else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
-                    const newRelModel = await relMeta.model.create(data[relMeta.key]);
-                    this[relMeta.key] = await newRelModel.save();
-                }
-                const cutKeys = this.constructor._CUT_KEYS;
-                const trackedField = Object.keys((await ModelUtils_1.ModelUtils.getModelAnnotations(this.constructor))).includes(relMeta.hydrationField);
-                if (!cutKeys.includes(relMeta.hydrationField) && !trackedField) {
-                    cutKeys.push(relMeta.hydrationField);
-                }
-            }
+            await HydrateUtils_1.HydrateUtils.hydrateRelations(this, relManyData, relOneData, seriesHydrationfields, fullDataMode, data);
         }
         // Process regular fields and time series
-        for (const key in data) {
-            if (data.hasOwnProperty(key)) {
-                if (!fullDataMode && this.constructor._CUT_KEYS.includes(key)) {
-                    continue;
-                }
-                if (Object.keys(relOneData).includes(key)) {
-                    continue;
-                }
-                if (seriesHydrationfields.includes(key)) {
-                    continue;
-                }
-                const timeSeriesMetaData = timeSeriesIds[key];
-                if (timeSeriesMetaData) {
-                    this[key] = data[key];
-                    const seriesModel = collections_to_models[timeSeriesMetaData.collection];
-                    const dataModels = await seriesModel.findBy({
-                        id: { in: data[key] }
-                    });
-                    seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
-                    this[timeSeriesMetaData.hydrationField] = dataModels;
-                }
-                else {
-                    this[key] = data[key];
-                }
-            }
-        }
+        await HydrateUtils_1.HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
         return this;
     }
     getModelScalarFields(model) {
@@ -334,7 +271,8 @@ class RWSModel {
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering);
+            const paginateParams = (findParams === null || findParams === void 0 ? void 0 : findParams.pagination) ? findParams === null || findParams === void 0 ? void 0 : 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) {

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

@@ -0,0 +1,13 @@
+import { RWSModel } from "../core/RWSModel";
+import { RelManyMetaType, RelOneMetaType } from "../types/RelationTypes";
+import { IRWSModel } from "../../types/IRWSModel";
+export declare class HydrateUtils {
+    static hydrateDataFields(model: RWSModel<any>, collections_to_models: {
+        [key: string]: any;
+    }, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {
+        [key: string]: any;
+    }): Promise<void>;
+    static hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {
+        [key: string]: any;
+    }): Promise<void>;
+}

package/dist/models/utils/HydrateUtils.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HydrateUtils = void 0;
+const TimeSeriesUtils_1 = require("./TimeSeriesUtils");
+const RelationUtils_1 = require("./RelationUtils");
+const ModelUtils_1 = require("./ModelUtils");
+class HydrateUtils {
+    static async hydrateDataFields(model, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data) {
+        const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(model);
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (!fullDataMode && (model).constructor._CUT_KEYS.includes(key)) {
+                    continue;
+                }
+                if (Object.keys(relOneData).includes(key)) {
+                    continue;
+                }
+                if (seriesHydrationfields.includes(key)) {
+                    continue;
+                }
+                const timeSeriesMetaData = timeSeriesIds[key];
+                if (timeSeriesMetaData) {
+                    model[key] = data[key];
+                    const seriesModel = collections_to_models[timeSeriesMetaData.collection];
+                    const dataModels = await seriesModel.findBy({
+                        id: { in: data[key] }
+                    });
+                    seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
+                    model[timeSeriesMetaData.hydrationField] = dataModels;
+                }
+                else {
+                    model[key] = data[key];
+                }
+            }
+        }
+    }
+    static async hydrateRelations(model, relManyData, relOneData, seriesHydrationfields, fullDataMode, data) {
+        // Handle many-to-many relations
+        for (const key in relManyData) {
+            if (!fullDataMode && model.constructor._CUT_KEYS.includes(key)) {
+                continue;
+            }
+            const relMeta = relManyData[key];
+            //  console.log({relMeta});
+            const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
+            if (relationEnabled) {
+                model[relMeta.key] = await relMeta.inversionModel.findBy({
+                    conditions: {
+                        [relMeta.foreignKey]: data.id
+                    },
+                    allowRelations: false
+                });
+            }
+        }
+        // Handle one-to-one relations
+        for (const key in relOneData) {
+            if (!fullDataMode && model.constructor._CUT_KEYS.includes(key)) {
+                continue;
+            }
+            const relMeta = relOneData[key];
+            const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
+            if (!data[relMeta.hydrationField] && relMeta.required) {
+                throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`);
+            }
+            if (relationEnabled && data[relMeta.hydrationField]) {
+                model[relMeta.key] = await relMeta.model.findOneBy({ conditions: { [relMeta.foreignKey]: data[relMeta.hydrationField] } }, { allowRelations: false });
+            }
+            else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
+                const newRelModel = await relMeta.model.create(data[relMeta.key]);
+                model[relMeta.key] = await newRelModel.save();
+            }
+            const cutKeys = model.constructor._CUT_KEYS;
+            const trackedField = Object.keys((await ModelUtils_1.ModelUtils.getModelAnnotations(model.constructor))).includes(relMeta.hydrationField);
+            if (!cutKeys.includes(relMeta.hydrationField) && !trackedField) {
+                cutKeys.push(relMeta.hydrationField);
+            }
+            // seriesHydrationfields.push(relMeta.hydrationField);
+        }
+    }
+}
+exports.HydrateUtils = HydrateUtils;

package/package.json

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

package/src/decorators/InverseRelation.ts

@@ -1,5 +1,6 @@
 import 'reflect-metadata';
 import { RWSModel, OpModelType } from '../models/_model';
+import { ModelUtils } from '../models/utils/ModelUtils';
 
 export interface InverseRelationOpts {
     key: string,
@@ -10,17 +11,57 @@ export interface InverseRelationOpts {
     mappingName?: string
 }
 
+function guessForeignKey(inversionModel: OpModelType<RWSModel<any>>, bindingModel: OpModelType<RWSModel<any>>, decoratorsData: any)
+{
+    let key: string | null = null;
+    let defaultKey = `${bindingModel._collection}_id`;  
+
+    const relDecorators: Record<string, {
+        annotationType: string;
+        metadata: any;
+    }> = {};
+
+    const trackDecorators: Record<string, {
+        annotationType: string;
+        metadata: any;
+    }> = {};
+
+    if(Object.keys(trackDecorators).includes(key)){
+        return key;
+    }
+
+    for(const decKey of Object.keys(decoratorsData)){
+        const dec = decoratorsData[decKey];
+        if(dec.annotationType === 'Relation'){
+            relDecorators[decKey] = dec;
+        }      
+        if(dec.annotationType === 'TrackType'){
+            trackDecorators[decKey] = dec;
+        }                
+    }
+
+    for(const relKey of Object.keys(relDecorators)){
+        const prodMeta = relDecorators[relKey]?.metadata;
+        if(prodMeta && prodMeta.relatedTo._collection === bindingModel._collection){            
+            return prodMeta.relationField;
+        }
+    }
+
+    return key;
+}
+
 function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<InverseRelationOpts> = null) {
     return function (target: any, key: string) {
-        const metadataPromise = Promise.resolve().then(() => {
+        const metadataPromise = Promise.resolve().then(async () => {
             const model = inversionModel();
             const source = sourceModel();
+            const decoratorsData = await ModelUtils.getModelAnnotations(model);           
 
             const metaOpts: InverseRelationOpts = {
                 ...relationOptions,
                 key,
                 inversionModel: model,
-                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`,
+                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : guessForeignKey(model, source, decoratorsData),
                 // Generate a unique relation name if one is not provided
                 relationName: relationOptions && relationOptions.relationName ?
                     relationOptions.relationName.toLowerCase() :

package/src/helper/DbHelper.ts

@@ -1,6 +1,7 @@
 import { IDbConfigHandler, IDbConfigParams, IdGeneratorOptions } from '../types/DbConfigHandler';
 import { OpModelType } from '../models/_model';
 import { DBService } from '../services/DBService';
+import { rwsShell } from '@rws-framework/console';
 
 import {
     DbUtils,
@@ -41,6 +42,14 @@ export class DbHelper {
     static async pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
         return SchemaGenerator.pushDBModels(configService, dbService, leaveFile);
     }
+   
+    static async migrateDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
+       process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
+       
+        const [_, schemaPath] = DbUtils.getSchemaDir();
+
+        await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma migrate dev --create-only --schema=${schemaPath}`, process.cwd());
+    }
 
     /**
      * Generate model sections for the schema

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

@@ -62,7 +62,7 @@ datasource db {
         if(
             !model._NO_ID            
         ){
-            section += `\t${DbUtils.generateId(dbType, modelMetadatas, false)}\n`;
+            section += `\t${DbUtils.generateId(dbType, modelMetadatas)}\n`;
         }              
 
         for (const key in modelMetadatas) {
@@ -108,7 +108,11 @@ datasource db {
                 const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField  : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
 
                 const relatedToField = modelMetadata.relatedToField || 'id';
-                const bindingFieldExists = !!modelMetadatas[relationFieldName];          
+                const bindingFieldExists = !!modelMetadatas[relationFieldName];  
+                
+                if(modelMetadata.required === false){
+                    requiredString = '?';
+                }
 
                 if (isMany) {
                     // Add an inverse field to the related model if it doesn't exist

package/src/helper/db/utils.ts

@@ -40,7 +40,7 @@ export class DbUtils {
     static generateId(
         dbType: IDbConfigParams['db_type'],
         modelMeta: Record<string, { annotationType: string, metadata: IIdMetaOpts }>,
-        debug = false
+        optional = false
     ): string {        
         let useUuid = false;
         let field = 'id';
@@ -53,10 +53,7 @@ export class DbUtils {
             if(key !== 'id'){
                 if(annotationType == 'IdType'){     
                     const dbSpecificTags = TypeConverter.processTypeOptions({ tags: [], dbOptions: modelMetadata.dbOptions }, dbType);
-                    tags.push(...dbSpecificTags);
-                    if(debug){                                     
-                        console.log({modelMetadata: modelMetadata.dbOptions});
-                    }          
+                    tags.push(...dbSpecificTags);                 
                              
                     field = key;
 
@@ -76,29 +73,35 @@ export class DbUtils {
         }
 
         let idString: string;
+        
+        let reqStr = '';
+
+        if(optional){
+            reqStr = '?';
+        }
 
         switch (dbType) {
             case 'mongodb':
-                idString = `${field} String @id @default(auto()) @map("_id") @db.ObjectId`;
+                idString = `${field} String${reqStr} @id @default(auto()) @map("_id") @db.ObjectId`;
                 break;
 
             case 'mysql':
                 idString = useUuid
-                    ? `${field} String @id @default(uuid())`
-                    : `${field} Int @id @default(autoincrement())`;
+                    ? `${field} String${reqStr} @id @default(uuid())`
+                    : `${field} Int${reqStr} @id @default(autoincrement())`;
                 break;
 
             case 'postgresql':
             case 'postgres':
                 idString = useUuid
-                    ? `${field} String @id @default(uuid())`
-                    : `${field} Int @id @default(autoincrement())`;
+                    ? `${field} String${reqStr} @id @default(uuid())`
+                    : `${field} Int${reqStr} @id @default(autoincrement())`;
                     break;    
 
             case 'sqlite':
-                idString = `${field} Int @id @default(autoincrement())`;            
+                idString = `${field} Int${reqStr} @id @default(autoincrement())`;            
                 break;
-        }
+        }        
 
         if(tags.length){
             idString += ' '+tags.join(' ');
@@ -108,9 +111,6 @@ export class DbUtils {
             throw new Error(`DB type "${dbType}" is not supported!`);
         }
 
-        if(debug){                                     
-            console.log({idString, useUuid});
-        }          
 
         return idString;
     }

package/src/models/core/RWSModel.ts

@@ -11,6 +11,9 @@ 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';
 
 class RWSModel<T> implements IModel {
     static services: IRWSModelServices = {};
@@ -97,9 +100,7 @@ class RWSModel<T> implements IModel {
     }
 
     public async _asyncFill(data: any, fullDataMode = false, allowRelations = true): Promise<T> {
-        const collections_to_models: {[key: string]: any} = {};           
-        const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(this);
-    
+        const collections_to_models: {[key: string]: any} = {};               
         const classFields = FieldsHelper.getAllClassFields(this.constructor);        
     
         // Get both relation metadata types asynchronously
@@ -116,93 +117,16 @@ class RWSModel<T> implements IModel {
 
 
         if (allowRelations) {
-            // Handle many-to-many relations
-            for (const key in relManyData) { 
-                if(!fullDataMode && (this as any).constructor._CUT_KEYS.includes(key)){
-                    continue;
-                }
-
-                const relMeta = relManyData[key];  
-        
-                const relationEnabled = !RelationUtils.checkRelDisabled(this, relMeta.key);
-                if (relationEnabled) {                                
-                    this[relMeta.key] = await relMeta.inversionModel.findBy({
-                        conditions: {
-                            [relMeta.foreignKey]: data.id
-                        },
-                        allowRelations: false
-                    });    
-                }                                
-            }
-            
-            // Handle one-to-one relations
-            for (const key in relOneData) {      
-                if(!fullDataMode && (this as any).constructor._CUT_KEYS.includes(key)){
-                    continue;
-                }
-
-                const relMeta = relOneData[key];          
-                const relationEnabled = !RelationUtils.checkRelDisabled(this, relMeta.key);
-                
-                if(!data[relMeta.hydrationField] && relMeta.required){
-                    throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`)
-                }
-                
-                if (relationEnabled && data[relMeta.hydrationField]) {        
-                    this[relMeta.key] = await relMeta.model.find(data[relMeta.hydrationField], { allowRelations: false });    
-                }                                
-                else if(relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]){                    
-                    const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);                    
-                    this[relMeta.key] = await newRelModel.save();
-                }
-
-                const cutKeys = ((this.constructor as any)._CUT_KEYS as string[]);
-
-                const trackedField = Object.keys((await ModelUtils.getModelAnnotations(this.constructor as any))).includes(relMeta.hydrationField);
-                
-                if(!cutKeys.includes(relMeta.hydrationField) && !trackedField){
-                    cutKeys.push(relMeta.hydrationField)
-                }
-            }
+            await HydrateUtils.hydrateRelations(this, relManyData, relOneData, seriesHydrationfields, fullDataMode, data);
         }
     
         // Process regular fields and time series
-        for (const key in data) {         
-            if (data.hasOwnProperty(key)) {                   
-                if(!fullDataMode && (this as any).constructor._CUT_KEYS.includes(key)){
-                    continue;
-                }
-
-                if (Object.keys(relOneData).includes(key)) {               
-                    continue;
-                }                
-    
-                if (seriesHydrationfields.includes(key)) {
-                    continue;
-                }                   
-              
-    
-                const timeSeriesMetaData = timeSeriesIds[key];  
-          
-                if (timeSeriesMetaData) {
-                    this[key] = data[key];
-                    const seriesModel = collections_to_models[timeSeriesMetaData.collection];
-            
-                    const dataModels = await seriesModel.findBy({
-                        id: { in: data[key] }
-                    });                        
-    
-                    seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
-            
-                    this[timeSeriesMetaData.hydrationField] = dataModels;
-                } else {
-                    this[key] = data[key];            
-                }        
-            }       
-        }     
+         await HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
     
         return this as any as T;
-    }    
+    }   
+
+    
 
     private getModelScalarFields(model: RWSModel<T>): string[] {
         return ModelUtils.getModelScalarFields(model);
@@ -449,7 +373,8 @@ class RWSModel<T> implements IModel {
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering);        
+            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[] = [];

package/src/models/utils/HydrateUtils.ts

@@ -0,0 +1,102 @@
+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";
+
+export class HydrateUtils {
+    static async hydrateDataFields(model: RWSModel<any>, collections_to_models: {[key: string]: any}, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {[key: string] : any}){
+        const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(model);
+        for (const key in data) {         
+                    if (data.hasOwnProperty(key)) {                   
+                        if(!fullDataMode && ((model).constructor as OpModelType<any>)._CUT_KEYS.includes(key)){
+                            continue;
+                        }
+        
+                        if (Object.keys(relOneData).includes(key)) {               
+                            continue;
+                        }                
+            
+                        if (seriesHydrationfields.includes(key)) {
+                            continue;
+                        }                   
+                      
+            
+                        const timeSeriesMetaData = timeSeriesIds[key];  
+                  
+                        if (timeSeriesMetaData) {
+                            model[key] = data[key];
+                            const seriesModel = collections_to_models[timeSeriesMetaData.collection];
+                    
+                            const dataModels = await seriesModel.findBy({
+                                id: { in: data[key] }
+                            });                        
+            
+                            seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
+                    
+                            model[timeSeriesMetaData.hydrationField] = dataModels;
+                        } else {
+                            model[key] = data[key];            
+                        }        
+                    }       
+                }    
+     }
+
+     static async hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {[key: string] : any})
+         {
+             // Handle many-to-many relations
+             for (const key in relManyData) { 
+                 if(!fullDataMode && (model as any).constructor._CUT_KEYS.includes(key)){
+                     continue;
+                 }
+     
+                 const relMeta = relManyData[key];  
+
+                //  console.log({relMeta});
+         
+                 const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
+                 if (relationEnabled) {                                
+                    model[relMeta.key] = await relMeta.inversionModel.findBy({
+                         conditions: {
+                             [relMeta.foreignKey]: data.id
+                         },
+                         allowRelations: false
+                     });    
+                 }                                
+             }
+             
+             // Handle one-to-one relations
+             for (const key in relOneData) {      
+                 if(!fullDataMode && ((model as any).constructor as OpModelType<any>)._CUT_KEYS.includes(key)){
+                     continue;
+                 }
+     
+                 const relMeta = relOneData[key];          
+                 const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
+                 
+                 if(!data[relMeta.hydrationField] && relMeta.required){
+                     throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`)
+                 }
+                                  
+                 if (relationEnabled && data[relMeta.hydrationField]) {                        
+                    model[relMeta.key] = await relMeta.model.findOneBy({conditions: {[relMeta.foreignKey] : data[relMeta.hydrationField]}}, { allowRelations: false });    
+                 }                                
+                 else if(relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]){                    
+                     const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);                    
+                     model[relMeta.key] = await newRelModel.save();
+                 }
+     
+                 const cutKeys = ((model.constructor as OpModelType<any>)._CUT_KEYS as string[]);
+     
+                 const trackedField = Object.keys((await ModelUtils.getModelAnnotations(model.constructor as OpModelType<any>))).includes(relMeta.hydrationField);
+                 
+                 if(!cutKeys.includes(relMeta.hydrationField) && !trackedField){
+                     cutKeys.push(relMeta.hydrationField)
+                 }
+     
+                 // seriesHydrationfields.push(relMeta.hydrationField);
+             }
+         }
+}