@rws-framework/db 2.1.11 → 2.2.1

package/src/models/utils/PaginationUtils.ts

@@ -0,0 +1,42 @@
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { OpModelType, RWSModel } from '../_model';
+import { FindByType, IPaginationParams } from '../../types/FindParams';
+
+export class PaginationUtils {
+
+    public static async paginate<ChildClass extends RWSModel<ChildClass>>(
+            this: OpModelType<ChildClass>,             
+            paginationParams: IPaginationParams = { page: 0, per_page: 50 },
+            findParams: FindByType = {},
+        ): Promise<ChildClass[]> {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow(this.name);
+        try {
+            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginationParams);   
+            if (dbData.length) {
+                const instanced: ChildClass[] = [];
+        
+                for (const data of dbData) { 
+                    const inst: ChildClass = new (this as { new(): ChildClass })();
+                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as ChildClass);
+                }
+        
+                return instanced;
+            }
+        
+            return [];
+        } catch (rwsError: Error | any) {
+            console.error(rwsError);
+
+            throw rwsError;
+        }          
+    }
+    
+}

package/src/models/utils/RelationUtils.ts

@@ -0,0 +1,76 @@
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { RWSModel } from '../_model';
+
+export class RelationUtils {
+    static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
+        const relIds: RelOneMetaType<IRWSModel> = {};
+        const relationFields = classFields
+            .filter((item: string) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
+            .map((item: string) => item.split(':').at(-1));        
+    
+        for (const key of relationFields) {  
+            const metadataKey = `Relation:${key}`;
+            const metadata = Reflect.getMetadata(metadataKey, model);                 
+            
+            if (metadata && metadata.promise) {
+                const resolvedMetadata = await metadata.promise;
+                if (!relIds[key]) {
+                    relIds[key] = {
+                        key: resolvedMetadata.key,
+                        required: resolvedMetadata.required,
+                        model: resolvedMetadata.relatedTo,
+                        hydrationField: resolvedMetadata.relationField,
+                        foreignKey: resolvedMetadata.relatedToField
+                    };
+                }
+            }                         
+        } 
+    
+        return relIds;
+    }
+
+    static async getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>> {
+        const relIds: RelManyMetaType<IRWSModel> = {};
+    
+        const inverseFields = classFields
+            .filter((item: string) => item.indexOf('InverseRelation') === 0)
+            .map((item: string) => item.split(':').at(-1));
+                
+        for (const key of inverseFields) {          
+            const metadataKey = `InverseRelation:${key}`;
+            const metadata = Reflect.getMetadata(metadataKey, model);                            
+    
+            if (metadata && metadata.promise) {
+                const resolvedMetadata = await metadata.promise;
+                if (!relIds[key]) {
+                    relIds[key] = {       
+                        key: resolvedMetadata.key,         
+                        inversionModel: resolvedMetadata.inversionModel,
+                        foreignKey: resolvedMetadata.foreignKey                   
+                    };
+                }
+            }                         
+        } 
+    
+        return relIds;
+    }
+
+    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string } } {
+        return {
+            connect: {
+                id: relatedModel.id
+            }
+        };
+    }
+
+    static hasRelation(model: RWSModel<any>, key: string): boolean {
+        // Check if the property exists and is an object with an id property
+        return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
+    }
+
+    static checkRelEnabled(model: RWSModel<any>, key: string): boolean {
+        return Object.keys((model.constructor as any)._RELATIONS).includes(key) && 
+               (model.constructor as any)._RELATIONS[key] === true;
+    }
+}

package/src/models/utils/TimeSeriesUtils.ts

@@ -0,0 +1,38 @@
+import { RWSModel } from "../_model";
+
+export class TimeSeriesUtils {
+    static getTimeSeriesModelFields(model: RWSModel<any>): {[key: string]: {collection: string, hydrationField: string, ids: string[]}} {
+        const timeSeriesIds: {[key: string]: {collection: string, hydrationField: string, ids: string[]}} = {};
+
+        for (const key in model) {
+            if (model.hasOwnProperty(key)) {             
+                const meta = Reflect.getMetadata(`InverseTimeSeries:${key}`, model);            
+                if(meta){
+                    if(!timeSeriesIds[key]){
+                        timeSeriesIds[key] = {
+                            collection: meta.timeSeriesModel,
+                            hydrationField: meta.hydrationField,
+                            ids: model[key]
+                        };
+                    }
+                }                         
+            }
+        } 
+
+        return timeSeriesIds;
+    }
+
+    static checkTimeSeries(constructor: any): boolean {            
+        const data = constructor.prototype as any;
+
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {   
+                if(Reflect.getMetadata(`InverseTimeSeries:${key}`, constructor.prototype)){
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}

package/src/services/DBService.ts

@@ -1,9 +1,10 @@
 import { PrismaClient } from '@prisma/client';
 import { Collection, Db, MongoClient } from 'mongodb';
 import {ITimeSeries} from '../types/ITimeSeries';
-import { IModel } from '../models/_model';
+import { IModel } from '../models/interfaces/IModel';
 import chalk from 'chalk';
 import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { IPaginationParams } from 'src/types/FindParams';
 
 interface IDBClientCreate {
   dbUrl?: string;
@@ -174,7 +175,12 @@ class DBService {
         return;
     }
 
-    async findBy(collection: string, conditions: any, fields: string[] | null = null, ordering: { [fieldName: string]: string } = null, allowRelations: boolean = true): Promise<IModel[]>
+    async findBy(
+        collection: string, 
+        conditions: any, 
+        fields: string[] | null = null, 
+        ordering: { [fieldName: string]: string } = null, 
+        pagination: IPaginationParams = null): Promise<IModel[]>
     {    
         const params: any ={ where: conditions };
 
@@ -189,6 +195,11 @@ class DBService {
             params.orderBy = ordering;
         }
 
+        if(pagination){
+            params.skip = pagination.page * pagination.per_page;
+            params.take = pagination.per_page;
+        }
+
         const retData = await this.getCollectionHandler(collection).findMany(params);        
 
         return retData;
@@ -255,4 +266,4 @@ class DBService {
     }
 }
 
-export { DBService, IDBClientCreate };
+export { DBService, IDBClientCreate };

package/src/types/DbConfigHandler.ts

@@ -1,4 +1,4 @@
-import { OpModelType } from "../models/_model";
+import { OpModelType } from "../models/interfaces/OpModelType";
 
 export interface IDbConfigParams {
     mongo_url?: string;
@@ -8,4 +8,4 @@ export interface IDbConfigParams {
 
 export interface IDbConfigHandler {
     get<K extends keyof IDbConfigParams>(key: K): IDbConfigParams[K];
-}
+}

package/src/types/FindParams.ts

@@ -1,7 +1,13 @@
 export type FindByType = {
-    conditions?: any,    
-    ordering?: { [fieldName: string]: string },
-    fields?: string[],
-    allowRelations?: boolean,
+    conditions?: any  
+    ordering?: { [fieldName: string]: string }
+    fields?: string[]
+    allowRelations?: boolean
     fullData?: boolean
+    pagination?: IPaginationParams
+}
+
+export interface IPaginationParams {
+    page: number,
+    per_page: number
 }