@rws-framework/db 2.1.10 → 2.2.0

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

@@ -0,0 +1,5 @@
+import { OpModelType, RWSModel } from '../_model';
+import { FindByType, IPaginationParams } from '../../types/FindParams';
+export declare class PaginationUtils {
+    static paginate<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, paginationParams?: IPaginationParams, findParams?: FindByType): Promise<ChildClass[]>;
+}

package/dist/models/utils/PaginationUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationUtils = void 0;
+class PaginationUtils {
+    static async paginate(paginationParams = { page: 0, per_page: 50 }, findParams = {}) {
+        var _a, _b, _c, _d, _e;
+        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
+        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
+        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
+        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
+        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : 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 = [];
+                for (const data of dbData) {
+                    const inst = new this();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+}
+exports.PaginationUtils = PaginationUtils;

package/dist/models/utils/RelationUtils copy.d.ts

@@ -0,0 +1,13 @@
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+export declare class RelationUtils {
+    static getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    static getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    static bindRelation(relatedModel: any): {
+        connect: {
+            id: string;
+        };
+    };
+    static hasRelation(model: any, key: string): boolean;
+    static checkRelEnabled(model: any, key: string): boolean;
+}

package/dist/models/utils/RelationUtils copy.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationUtils = void 0;
+class RelationUtils {
+    static async getRelationOneMeta(model, classFields) {
+        const relIds = {};
+        const relationFields = classFields
+            .filter((item) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
+            .map((item) => 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, classFields) {
+        const relIds = {};
+        const inverseFields = classFields
+            .filter((item) => item.indexOf('InverseRelation') === 0)
+            .map((item) => 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) {
+        return {
+            connect: {
+                id: relatedModel.id
+            }
+        };
+    }
+    static hasRelation(model, key) {
+        // 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, key) {
+        return Object.keys(model.constructor._RELATIONS).includes(key) &&
+            model.constructor._RELATIONS[key] === true;
+    }
+}
+exports.RelationUtils = RelationUtils;

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

@@ -0,0 +1,14 @@
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { RWSModel } from '../_model';
+export declare class RelationUtils {
+    static getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    static getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    static bindRelation(relatedModel: RWSModel<any>): {
+        connect: {
+            id: string;
+        };
+    };
+    static hasRelation(model: RWSModel<any>, key: string): boolean;
+    static checkRelEnabled(model: RWSModel<any>, key: string): boolean;
+}

package/dist/models/utils/RelationUtils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationUtils = void 0;
+class RelationUtils {
+    static async getRelationOneMeta(model, classFields) {
+        const relIds = {};
+        const relationFields = classFields
+            .filter((item) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
+            .map((item) => 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, classFields) {
+        const relIds = {};
+        const inverseFields = classFields
+            .filter((item) => item.indexOf('InverseRelation') === 0)
+            .map((item) => 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) {
+        return {
+            connect: {
+                id: relatedModel.id
+            }
+        };
+    }
+    static hasRelation(model, key) {
+        // 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, key) {
+        return Object.keys(model.constructor._RELATIONS).includes(key) &&
+            model.constructor._RELATIONS[key] === true;
+    }
+}
+exports.RelationUtils = RelationUtils;

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

@@ -0,0 +1,11 @@
+import { RWSModel } from "../_model";
+export declare class TimeSeriesUtils {
+    static getTimeSeriesModelFields(model: RWSModel<any>): {
+        [key: string]: {
+            collection: string;
+            hydrationField: string;
+            ids: string[];
+        };
+    };
+    static checkTimeSeries(constructor: any): boolean;
+}

package/dist/models/utils/TimeSeriesUtils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSeriesUtils = void 0;
+class TimeSeriesUtils {
+    static getTimeSeriesModelFields(model) {
+        const timeSeriesIds = {};
+        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) {
+        const data = constructor.prototype;
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (Reflect.getMetadata(`InverseTimeSeries:${key}`, constructor.prototype)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+exports.TimeSeriesUtils = TimeSeriesUtils;

package/dist/services/DBService.d.ts

@@ -1,7 +1,8 @@
 import { Collection } from 'mongodb';
 import { ITimeSeries } from '../types/ITimeSeries';
-import { IModel } from '../models/_model';
+import { IModel } from '../models/interfaces/IModel';
 import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { IPaginationParams } from 'src/types/FindParams';
 interface IDBClientCreate {
     dbUrl?: string;
     dbName?: string;
@@ -26,7 +27,7 @@ declare class DBService {
     delete(collection: string, conditions: any): Promise<void>;
     findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
         [fieldName: string]: string;
-    }, allowRelations?: boolean): Promise<IModel[]>;
+    }, pagination?: IPaginationParams): Promise<IModel[]>;
     collectionExists(collection_name: string): Promise<boolean>;
     createTimeSeriesCollection(collection_name: string): Promise<Collection<ITimeSeries>>;
     private getCollectionHandler;

package/dist/services/DBService.js

@@ -127,7 +127,7 @@ class DBService {
         await this.getCollectionHandler(collection).deleteMany({ where: conditions });
         return;
     }
-    async findBy(collection, conditions, fields = null, ordering = null, allowRelations = true) {
+    async findBy(collection, conditions, fields = null, ordering = null, pagination = null) {
         const params = { where: conditions };
         if (fields) {
             params.select = {};
@@ -138,6 +138,10 @@ class DBService {
         if (ordering) {
             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;
     }

package/dist/types/DbConfigHandler.d.ts

@@ -1,4 +1,4 @@
-import { OpModelType } from "../models/_model";
+import { OpModelType } from "../models/interfaces/OpModelType";
 export interface IDbConfigParams {
     mongo_url?: string;
     mongo_db?: string;

package/dist/types/FindParams.d.ts

@@ -6,4 +6,9 @@ export type FindByType = {
     fields?: string[];
     allowRelations?: boolean;
     fullData?: boolean;
+    pagination?: IPaginationParams;
 };
+export interface IPaginationParams {
+    page: number;
+    per_page: number;
+}

package/package.json

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

package/src/decorators/TrackType.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { OpModelType } from '../models/_model';
+import { OpModelType } from '../models/interfaces/OpModelType';
 
 interface ITrackerOpts{
     required?: boolean,
@@ -53,4 +53,4 @@ function TrackType(type: any, opts: ITrackerOpts | null = null, tags: string[] =
 }
 
 export default TrackType;
-export {IMetaOpts, ITrackerOpts};
+export {IMetaOpts, ITrackerOpts};