@rws-framework/db 3.0.0 → 3.1.0

package/README.md

@@ -1,6 +1,6 @@
 # Models
 
-RWS models are converted to Prisma schemas and are wrapping around generated PrismaClient providing complete typing and better Relation handling + TimeSeries in future minor versions.
+RWS models are converted to Prisma schemas and are wrapping around generated PrismaClient providing complete typing and better Relation handling + TimeSeries in future versions.
 
 ## Models index file
 
@@ -21,11 +21,7 @@ export const models = [ User, ApiKey];
     import ApiKey from './ApiKey';
     import IApiKey from './interfaces/IApiKey';
 
-@RWSCollection('users', { 
-    relations: {
-        transcriptions: true,
-        apiKeys: true
-    },
+@RWSCollection('users', {
     ignored_keys: ['passwd']
 })
 class User extends RWSModel<User> implements IUser {
@@ -68,20 +64,26 @@ export default User;
 
 ***Basic many to one relation***
 ```typescript
-import { RWSModel, TrackType, Relation } from '@rws-framework/db';
+import { RWSCollection, RWSModel, TrackType, Relation } from '@rws-framework/db';
 
 import 'reflect-metadata';
 import User from './User';
+import SomeModel from './SomeModel';
 import IApiKey from './interfaces/IApiKey';
 
+@RWSCollection('user_api_keys', {
+    relations: {
+        dummyIgnoredHydrationRelation: false // ignoring this relation on hydration - will be null
+    }
+})
 class ApiKey extends RWSModel<ApiKey> implements IApiKey {
-    static _RELATIONS = {
-        user: true,
-    };
 
-    @Relation(() => User, true) // second attribute is required = false
+    @Relation(() => User, { requried: false }) // second attribute is required = false
     user: User;
 
+    @Relation(() => SomeModel) // relation to be ignored by 
+    dummyIgnoredHydrationRelation: SomeModel;
+
     @TrackType(Object)
     keyval: string;
 
@@ -111,29 +113,52 @@ export default ApiKey;
 
 ```typescript
 import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
 
-import { RWSModel, OpModelType } from '@rws-framework/db';
+export type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
 
-interface IRelationOpts {
+export interface IRelationOpts {
     required?: boolean
-    key?: string
-    relationField?: string
-    relatedToField?: string
-    relatedTo: OpModelType<Model<any>>
+    key: string
+    relationField: string //name of field that will hold the relation key value
+    relatedToField?: string //name of related field (id by default)
+    mappingName?: string
+    relatedTo: OpModelType<RWSModel<any>>
+    many?: boolean // is it one-to-many or many-to-one
+    embed?: boolean // @deprecated for mongo - new decorator for embeds incoming
+    useUuid?: boolean //for sql dbs - if you're using some text based id
+    relationName?: string
+    cascade?: {
+        onDelete?: CascadingSetup,
+        onUpdate?: CascadingSetup
+    }
 }
+
+const _DEFAULTS: Partial<IRelationOpts> = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' }};
   
-function Relation(theModel: () => OpModelType<RWSModel<any>>, required: boolean = false, relationField: string = null, relatedToField: string = 'id') {
+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 = {required, relatedTo, relatedToField};                    
-            if(!relationField){
-                metaOpts.relationField = relatedTo._collection + '_id';
-            } else{
-                metaOpts.relationField = relationField;
-            }  
-            metaOpts.key = key;
+
+            const metaOpts: IRelationOpts = {
+                ...relationOptions, 
+                cascade: relationOptions.cascade || _DEFAULTS.cascade,
+                relatedTo,
+                relationField: relationOptions.relationField ? relationOptions.relationField : relatedTo._collection + '_id',
+                key,
+                // Generate a unique relation name if one is not provided
+                relationName: relationOptions.relationName ? 
+                  relationOptions.relationName.toLowerCase() : 
+                  `${target.constructor.name.toLowerCase()}_${key}_${relatedTo._collection.toLowerCase()}`
+            };  
+            
+            if(relationOptions.required){
+                metaOpts.cascade.onDelete = 'Restrict';
+            }
+
             return metaOpts;
         });
 
@@ -147,33 +172,41 @@ function Relation(theModel: () => OpModelType<RWSModel<any>>, required: boolean
 
 
 export default Relation;
-export {IRelationOpts};
+
+
 ```
 
 ***Inverse relation decorator*** (one-to-many)
 ```typescript
 import 'reflect-metadata';
-import { RWSModel, OpModelType } from '@rws-framework/db';
+import { RWSModel, OpModelType } from '../models/_model';
 
-interface InverseRelationOpts{
+export interface InverseRelationOpts {
     key: string,
-    inversionModel: OpModelType<RWSModel<any>>,
-    foreignKey: string    
-  }
+    inversionModel: OpModelType<RWSModel<any>>
+    foreignKey: string
+    singular?: boolean
+    relationName?: string
+    mappingName?: string
+}
 
-  function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, foreignKey: string = null) {    
-    return function(target: any, key: string) {     
-        // Store the promise in metadata immediately
+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 model = inversionModel();
             const source = sourceModel();
-    
+
             const metaOpts: InverseRelationOpts = {
+                ...relationOptions,
                 key,
                 inversionModel: model,
-                foreignKey: foreignKey ? foreignKey : `${source._collection}_id`
-            };             
-    
+                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`,
+                // Generate a unique relation name if one is not provided
+                relationName: relationOptions && relationOptions.relationName ?
+                    relationOptions.relationName.toLowerCase() :
+                    `${model._collection}_${key}_${source._collection}`.toLowerCase()
+            };
+
             return metaOpts;
         });
 
@@ -186,7 +219,7 @@ interface InverseRelationOpts{
 }
 
 export default InverseRelation;
-export {InverseRelationOpts};
+
 ```
 
 
@@ -307,99 +340,4 @@ bunx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&r
 
 Code for RWS to prisma conversion from "@rws-framework/server" package:
 
-```typescript
-static async generateModelSections(model: OpModelType<any>): Promise<string> {
-    let section = '';
-    const modelMetadatas: Record<string, {annotationType: string, metadata: any}> = await RWSModel.getModelAnnotations(model);    
-
-    const modelName: string = (model as any)._collection;
-    
-    section += `model ${modelName} {\n`;
-    section += '\tid String @map("_id") @id @default(auto()) @db.ObjectId\n';
-    
-    for (const key in modelMetadatas) {
-        const modelMetadata = modelMetadatas[key].metadata;            
-        let requiredString = modelMetadata.required ? '' : '?';  
-        const annotationType: string = modelMetadatas[key].annotationType;
-
-        if(key === 'id'){
-            continue;
-        }
-
-        
-        if(annotationType === 'Relation'){
-            const relationMeta = modelMetadata as IRelationOpts
-
-            const relatedModel = relationMeta.relatedTo as OpModelType<any>;  
-            const isMany = relationMeta.many;
-            const cascadeOpts = [];
-
-            if (relationMeta.cascade?.onDelete) {
-                cascadeOpts.push(`onDelete: ${relationMeta.cascade.onDelete}`);
-            }
-
-            if (relationMeta.cascade?.onUpdate) {
-                cascadeOpts.push(`onUpdate: ${relationMeta.cascade.onUpdate}`);
-            }
-    
-            if (isMany) {
-                // Handle many-to-many or one-to-many relation
-                section += `\t${key} ${relatedModel._collection}[] @relation("${modelName}_${relatedModel._collection}")\n`;
-            } else {
-                // Handle one-to-one or many-to-one relation
-                section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField || 'id'}], ${cascadeOpts.join(', ')})\n`;
-                section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;
-            }
-        } else if (annotationType === 'InverseRelation'){   
-            const relationMeta = modelMetadata as InverseRelationOpts;
-    
-            // Handle inverse relation (one-to-many or one-to-one)
-            section += `\t${key} ${relationMeta.inversionModel._collection}[] @relation("${ relationMeta.relationName ? relationMeta.relationName : `${relationMeta.inversionModel._collection}_${modelName}`}")\n`;
-        } else if (annotationType === 'InverseTimeSeries'){        
-            section += `\t${key} String[] @db.ObjectId\n`;      
-        } else if (annotationType === 'TrackType'){        
-            const tags: string[] = modelMetadata.tags.map((item: string) => '@' + item);             
-
-            if(modelMetadata.isArray || modelMetadata.type.name === 'Array'){
-                requiredString = '';
-            }       
-            section += `\t${key} ${DbHelper.toConfigCase(modelMetadata)}${requiredString} ${tags.join(' ')}\n`;
-        }
-    }
-    
-    section += '}\n';
-    return section;
-}
-
-static toConfigCase(modelType: IMetaOpts): string {
-    const type = modelType.type;
-    let input = type.name;    
-    
-
-    if(input == 'Number'){
-        input = 'Int';
-    }
-
-    if(input == 'Object'){
-        input = 'Json';
-    }
-
-    if(input == 'Date'){
-        input = 'DateTime';
-    }
-
-    if(input == 'Array'){
-        input = 'Json[]';
-    }
-
-    const firstChar = input.charAt(0).toUpperCase();
-    const restOfString = input.slice(1);
-    let resultField = firstChar + restOfString;
-
-    if(modelType.isArray){
-        resultField += '[]';
-    }
-
-    return resultField;
-}
-```
+[The repo file](https://github.com/rws-framework/db/blob/master/src/helper/DbHelper.ts)

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`;
@@ -151,16 +154,28 @@ datasource db {
             else if (annotationType === 'TrackType') {
                 const trackMeta = modelMetadata;
                 const tags = trackMeta.tags.map((item) => '@' + item);
+                if (key === 'id' && model._NO_ID && !model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes('id'))) {
+                    continue;
+                }
                 if (trackMeta.unique) {
                     const fieldDetail = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
                     tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
                 }
+                if (!trackMeta.required) {
+                    requiredString = '?';
+                }
                 if (trackMeta.isArray || trackMeta.type.name === 'Array') {
                     requiredString = '';
                 }
+                if (model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes(key))) {
+                    requiredString = '';
+                }
                 // 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`;
             }
         }

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;
@@ -54,7 +56,7 @@ declare class RWSModel<T> implements IModel {
     sanitizeDBData(data: any): any;
     static watchCollection<T extends RWSModel<T>>(this: OpModelType<T>, preRun: () => void): Promise<any>;
     static findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
-    static find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    static find<T extends RWSModel<T>>(this: OpModelType<T>, id: string | number, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
     static findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
     static delete<T extends RWSModel<T>>(this: OpModelType<T>, conditions: any): Promise<void>;
     delete<T extends RWSModel<T>>(): Promise<void>;

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,72 +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;
-                if (!cutKeys.includes(relMeta.hydrationField)) {
-                    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) {
@@ -333,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) {