@rws-framework/db 3.0.1 → 3.2.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/decorators/Relation.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const _DEFAULTS = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' } };
+const _DEFAULT_CASCADE = { onDelete: 'SetNull', onUpdate: 'Cascade' };
+const _DEFAULTS = { required: false, many: false, embed: false, cascade: null };
 function Relation(theModel, relationOptions = _DEFAULTS) {
     return function (target, key) {
         // Store the promise in metadata immediately

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

@@ -11,7 +11,6 @@ const _model_1 = require("../../models/_model");
 const utils_1 = require("./utils");
 const type_converter_1 = require("./type-converter");
 const relation_manager_1 = require("./relation-manager");
-const log = console.log;
 /**
  * Handles Prisma schema generation
  */
@@ -47,7 +46,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,12 +80,16 @@ 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 = '?';
+                }
+                const cascadeStr = cascadeOpts.length ? `, ${cascadeOpts.join(', ')}` : '';
                 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`;
+                    section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                 }
                 else {
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;
+                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                     if (!bindingFieldExists) {
                         const relatedFieldMeta = relatedModelMetadatas[relatedToField];
                         if (!relatedFieldMeta.metadata.required) {
@@ -170,15 +173,31 @@ datasource db {
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions(trackMeta, dbType);
                 tags.push(...dbSpecificTags);
-                if (modelName === 'category_translation' && key === 'meta_keywords') {
-                    console.log({ requiredString, trackMeta });
-                }
                 section += `\t${key} ${type_converter_1.TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
             }
         }
+        if (model._SUPER_TAGS.length) {
+            section += '\n';
+        }
         for (const superTag of model._SUPER_TAGS) {
             const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
-            section += `\t@@${superTag.tagType}([${superTag.fields.join(', ')}]${mapStr})\n`;
+            const superFields = [];
+            for (const superField of superTag.fields) {
+                const fieldMetadata = modelMetadatas[superField]['metadata'];
+                let pushed = false;
+                if (fieldMetadata.dbOptions && fieldMetadata.dbOptions.mysql && fieldMetadata.dbOptions.mysql.useType) {
+                    switch (fieldMetadata.dbOptions.mysql.useType) {
+                        case 'db.LongText':
+                            superFields.push(`${superField}(length: 255)`);
+                            pushed = true;
+                            break;
+                    }
+                }
+                if (!pushed) {
+                    superFields.push(superField);
+                }
+            }
+            section += `\t@@${superTag.tagType}([${superFields.join(', ')}]${mapStr})\n`;
         }
         section += '}\n';
         return section;
@@ -221,7 +240,7 @@ datasource db {
             for (const model of dbModels) {
                 const modelSection = await SchemaGenerator.generateModelSections(model, configService);
                 template += '\n\n' + modelSection;
-                log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
+                console.log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
             }
             const [schemaDir, schemaPath] = utils_1.DbUtils.getSchemaDir();
             if (!fs_1.default.existsSync(schemaDir)) {
@@ -233,7 +252,7 @@ datasource db {
             fs_1.default.writeFileSync(schemaPath, template);
             await console_1.rwsShell.runCommand(`${utils_1.DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
             leaveFile = false;
-            log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
+            console.log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
             if (!leaveFile) {
                 // fs.unlinkSync(schemaPath);
             }

package/dist/helper/db/type-converter.js

@@ -13,7 +13,22 @@ class TypeConverter {
         let input = type.name;
         // Handle basic types
         if (input == 'Number') {
-            input = 'Int';
+            let numberOverride = false;
+            if (modelType.dbOptions && modelType.dbOptions.mysql) {
+                if (modelType.dbOptions.mysql.useType) {
+                    if (['db.Float'].includes(modelType.dbOptions.mysql.useType)) {
+                        input = 'Float';
+                        numberOverride = true;
+                    }
+                    if (['db.Decimal'].includes(modelType.dbOptions.mysql.useType)) {
+                        input = 'Decimal';
+                        numberOverride = true;
+                    }
+                }
+            }
+            if (!numberOverride) {
+                input = 'Int';
+            }
         }
         if (input == 'Object') {
             input = 'Json';
@@ -66,20 +81,26 @@ class TypeConverter {
      * @returns Array of tags to apply to the field
      */
     static processTypeOptions(metadata, dbType) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const tags = [...(metadata.tags || [])];
         // Extract any database-specific options from the metadata
         // and convert them to appropriate Prisma schema tags
         if (metadata.dbOptions) {
             // Handle MySQL-specific options
             if (dbType === 'mysql' && metadata.dbOptions.mysql) {
+                let tag = null;
+                if (metadata.dbOptions.mysql.useType && !metadata.dbOptions.mysql.useText) {
+                    const tagName = metadata.dbOptions.mysql.useType === 'VarChar' ? 'db.' + metadata.dbOptions.mysql.useType : metadata.dbOptions.mysql.useType;
+                    let tagParams = tagName === 'db.VarChar' && metadata.dbOptions.mysql.maxLength ? metadata.dbOptions.mysql.maxLength : (((_b = (_a = metadata.dbOptions.mysql) === null || _a === void 0 ? void 0 : _a.params) === null || _b === void 0 ? void 0 : _b.join(', ')) || '');
+                    tag = `@${tagName}(${tagParams})`;
+                }
                 if (metadata.dbOptions.mysql.useText) {
                     tags.push('@db.Text');
                 }
-                else if (metadata.dbOptions.mysql.maxLength) {
-                    tags.push(`@db.VarChar(${metadata.dbOptions.mysql.maxLength})`);
+                if (tag) {
+                    tags.push(tag);
                 }
-                if (metadata.dbOptions.mysql.useUuid && ((_a = metadata.tags) === null || _a === void 0 ? void 0 : _a.includes('id'))) {
+                if (metadata.dbOptions.mysql.useUuid && ((_c = metadata.tags) === null || _c === void 0 ? void 0 : _c.includes('id'))) {
                     tags.push('default(uuid())');
                 }
             }
@@ -88,7 +109,7 @@ class TypeConverter {
                 if (metadata.dbOptions.postgres.useText) {
                     tags.push('@db.Text');
                 }
-                if (metadata.dbOptions.postgres.useUuid && ((_b = metadata.tags) === null || _b === void 0 ? void 0 : _b.includes('id'))) {
+                if (metadata.dbOptions.postgres.useUuid && ((_d = metadata.tags) === null || _d === void 0 ? void 0 : _d.includes('id'))) {
                     tags.push('@default(uuid())');
                     tags.push('@db.Uuid');
                 }

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/interfaces/IDbOpts.d.ts

@@ -5,13 +5,16 @@ export interface IDbOpts {
             useText?: boolean;
             maxLength?: number;
             useUuid?: boolean;
+            params?: string[];
         };
         postgres?: {
             useText?: boolean;
             useUuid?: boolean;
+            params?: string[];
         };
         mongodb?: {
             customType?: string;
+            params?: string[];
         };
     };
 }

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,80 @@
+"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];
+            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/exec/console.js

@@ -15,8 +15,6 @@ const getCachedPath = (key) => path.resolve(rwsCliConfigDir, key);
 
 const currentCwd = path.resolve(__dirname);
 
-console.log({params})
-
 
 const commandString = `npx webpack --config db.rws.webpack.config.js --output-path ./build ${process.cwd()} ${params[2]}`;
 function needsCacheWarming(){

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "3.0.1",
+  "version": "3.2.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/decorators/Relation.ts

@@ -20,13 +20,15 @@ export interface IRelationOpts {
     }
 }
 
-const _DEFAULTS: Partial<IRelationOpts> = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' }};
+const _DEFAULT_CASCADE = { onDelete: 'SetNull', onUpdate: 'Cascade' };
+
+const _DEFAULTS: Partial<IRelationOpts> = { required: false, many: false, embed: false, cascade: null};
   
 function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<IRelationOpts> = _DEFAULTS) {
     return function(target: any, key: string) {     
         // Store the promise in metadata immediately
         
-        const metadataPromise = Promise.resolve().then(() => {            
+        const metadataPromise = Promise.resolve().then(() => {          
             const relatedTo = theModel();
 
             const metaOpts: IRelationOpts = {

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

@@ -15,7 +15,6 @@ import { RelationManager } from './relation-manager';
 import { ITrackerMetaOpts } from '../../decorators/TrackType';
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 
-const log = console.log;
 
 /**
  * Handles Prisma schema generation
@@ -62,7 +61,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,13 +107,19 @@ 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 = '?';
+                }
+
+                const cascadeStr = cascadeOpts.length ? `, ${cascadeOpts.join(', ')}` : '' ;
 
                 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`;
+                    section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                 } else {                    
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;
+                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                     if(!bindingFieldExists){
                         const relatedFieldMeta = relatedModelMetadatas[relatedToField];
 
@@ -200,24 +205,47 @@ datasource db {
                 if(model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes(key))){
                     requiredString = '';
                 }
-
+               
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = TypeConverter.processTypeOptions(trackMeta as { tags: string[], dbOptions: IDbOpts['dbOptions'] }, dbType);
                 tags.push(...dbSpecificTags);
-
-                if(modelName === 'category_translation' && key === 'meta_keywords'){
-                    console.log({requiredString, trackMeta});
-                }
+         
 
                 section += `\t${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
             }
         }
 
+        if(model._SUPER_TAGS.length){
+            section += '\n';
+        }
+
         for(const superTag of model._SUPER_TAGS){
 
             const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
 
-            section += `\t@@${superTag.tagType}([${superTag.fields.join(', ')}]${mapStr})\n`;
+            const superFields = [];
+        
+            for(const superField of superTag.fields){
+                const fieldMetadata = modelMetadatas[superField]['metadata'];
+       
+    
+                let pushed = false;
+
+                if(fieldMetadata.dbOptions && fieldMetadata.dbOptions.mysql && fieldMetadata.dbOptions.mysql.useType){                        
+                    switch(fieldMetadata.dbOptions.mysql.useType){
+                        case 'db.LongText': 
+                            superFields.push(`${superField}(length: 255)`);                                    
+                            pushed = true;
+                        break;
+                    }                    
+                }
+
+                if(!pushed){
+                    superFields.push(superField);
+                }
+            }
+            
+            section += `\t@@${superTag.tagType}([${superFields.join(', ')}]${mapStr})\n`;
         }
 
         section += '}\n';
@@ -276,7 +304,7 @@ datasource db {
 
                 template += '\n\n' + modelSection;
 
-                log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
+                console.log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
             }
 
             const [schemaDir, schemaPath] = DbUtils.getSchemaDir();
@@ -294,7 +322,7 @@ datasource db {
             await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
 
             leaveFile = false;
-            log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
+            console.log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
 
             if (!leaveFile) {
                 // fs.unlinkSync(schemaPath);

package/src/helper/db/type-converter.ts

@@ -16,7 +16,24 @@ export class TypeConverter {
 
         // Handle basic types
         if (input == 'Number') {
-            input = 'Int';
+            let numberOverride = false;
+            if(modelType.dbOptions && modelType.dbOptions.mysql){
+                if(modelType.dbOptions.mysql.useType){
+                    if(['db.Float'].includes(modelType.dbOptions.mysql.useType)){
+                        input = 'Float';
+                        numberOverride = true;
+                    }
+
+                    if(['db.Decimal'].includes(modelType.dbOptions.mysql.useType)){
+                        input = 'Decimal';
+                        numberOverride = true;
+                    }
+                }
+            }
+            
+            if(!numberOverride){
+                input = 'Int';
+            }            
         }
 
         if (input == 'Object') {
@@ -64,7 +81,7 @@ export class TypeConverter {
             } else {
                 resultField += '[]';
             }
-        }
+        }        
 
         return resultField;
     }
@@ -83,10 +100,20 @@ export class TypeConverter {
         if (metadata.dbOptions) {
             // Handle MySQL-specific options
             if (dbType === 'mysql' && metadata.dbOptions.mysql) {
+                let tag = null;
+
+                if (metadata.dbOptions.mysql.useType && !metadata.dbOptions.mysql.useText) {
+                    const tagName = metadata.dbOptions.mysql.useType === 'VarChar' ?  'db.' + metadata.dbOptions.mysql.useType : metadata.dbOptions.mysql.useType;                    
+                    let tagParams = tagName === 'db.VarChar' && metadata.dbOptions.mysql.maxLength ? metadata.dbOptions.mysql.maxLength : (metadata.dbOptions.mysql?.params?.join(', ') || '');                    
+                    tag = `@${tagName}(${tagParams})`;                    
+                }
+
                 if (metadata.dbOptions.mysql.useText) {
                     tags.push('@db.Text');
-                } else if (metadata.dbOptions.mysql.maxLength) {
-                    tags.push(`@db.VarChar(${metadata.dbOptions.mysql.maxLength})`);
+                }
+
+                if(tag){
+                    tags.push(tag);
                 }
 
                 if (metadata.dbOptions.mysql.useUuid && metadata.tags?.includes('id')) {

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/interfaces/IDbOpts.ts

@@ -5,13 +5,16 @@ export interface IDbOpts {
           useText?: boolean;
           maxLength?: number;
           useUuid?: boolean;
+          params?: string[]
         };
         postgres?: {
           useText?: boolean;
           useUuid?: boolean;
+          params?: string[]
         };
         mongodb?: {
           customType?: string;
+          params?: string[]
         };
     }
 }

package/src/models/utils/HydrateUtils.ts

@@ -0,0 +1,100 @@
+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];  
+         
+                 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);
+             }
+         }
+}