@rws-framework/db 2.2.5 → 2.2.6

package/dist/helper/DbHelper.js

@@ -9,7 +9,6 @@ const chalk_1 = __importDefault(require("chalk"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const _model_1 = require("../models/_model");
-const TimeSeriesModel_1 = __importDefault(require("../models/core/TimeSeriesModel"));
 const log = console.log;
 const workspaceRoot = console_1.rwsPath.findRootWorkspacePath();
 const moduleDir = path_1.default.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
@@ -30,15 +29,15 @@ class DbHelper {
                 const modelSection = await DbHelper.generateModelSections(model);
                 template += '\n\n' + modelSection;
                 log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
-                if (_model_1.RWSModel.isSubclass(model, TimeSeriesModel_1.default)) {
-                    dbService.collectionExists(model._collection).then((exists) => {
-                        if (exists) {
-                            return;
-                        }
-                        log(chalk_1.default.green('[RWS Init]') + ` creating TimeSeries type collection from ${model} model`);
-                        dbService.createTimeSeriesCollection(model._collection);
-                    });
-                }
+                // if(RWSModel.isSubclass(model as any, TimeSeriesModel)){    
+                //     dbService.collectionExists(model._collection).then((exists: boolean) => {
+                //         if (exists){
+                //             return;
+                //         }
+                //         log(chalk.green('[RWS Init]') + ` creating TimeSeries type collection from ${model} model`);
+                //         dbService.createTimeSeriesCollection(model._collection);    
+                //     });
+                // }
             }
             const schemaDir = path_1.default.join(moduleDir, 'prisma');
             const schemaPath = path_1.default.join(schemaDir, 'schema.prisma');

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { DBService } from "./services/DBService";
 import { RWSModel, OpModelType } from "./models/_model";
-import TimeSeriesModel from './models/core/TimeSeriesModel';
 import { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts } from './decorators';
 import { DbHelper } from './helper/DbHelper';
 import { FieldsHelper } from './helper/FieldsHelper';
@@ -10,4 +9,4 @@ import type { IDbConfigHandler } from './types/DbConfigHandler';
 import type { IRWSModel } from './types/IRWSModel';
 import { RWSCollection, IRWSCollectionMeta, IRWSCollectionOpts } from "./decorators/RWSCollection";
 export type { IRWSCollectionMeta, IRWSCollectionOpts, IRWSModel, IMetaOpts, OpModelType, IDbConfigHandler, ITimeSeries, };
-export { RWSModel, RWSCollection, DBService, FindByType, TimeSeriesModel, InverseRelation, Relation, TrackType, InverseTimeSeries, DbHelper, FieldsHelper };
+export { RWSModel, RWSCollection, DBService, FindByType, InverseRelation, Relation, TrackType, InverseTimeSeries, DbHelper, FieldsHelper };

package/dist/index.js

@@ -1,15 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldsHelper = exports.DbHelper = exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = exports.TimeSeriesModel = exports.DBService = exports.RWSCollection = exports.RWSModel = void 0;
+exports.FieldsHelper = exports.DbHelper = exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = exports.DBService = exports.RWSCollection = exports.RWSModel = void 0;
 const DBService_1 = require("./services/DBService");
 Object.defineProperty(exports, "DBService", { enumerable: true, get: function () { return DBService_1.DBService; } });
 const _model_1 = require("./models/_model");
 Object.defineProperty(exports, "RWSModel", { enumerable: true, get: function () { return _model_1.RWSModel; } });
-const TimeSeriesModel_1 = __importDefault(require("./models/core/TimeSeriesModel"));
-exports.TimeSeriesModel = TimeSeriesModel_1.default;
+// import TimeSeriesModel from './models/core/TimeSeriesModel';
 const decorators_1 = require("./decorators");
 Object.defineProperty(exports, "InverseRelation", { enumerable: true, get: function () { return decorators_1.InverseRelation; } });
 Object.defineProperty(exports, "Relation", { enumerable: true, get: function () { return decorators_1.Relation; } });

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

@@ -3,7 +3,7 @@ import { IRWSModelServices } from '../interfaces/IRWSModelServices';
 import { OpModelType } from '../interfaces/OpModelType';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { DBService } from '../../services/DBService';
-declare class RWSModel<ChildClass> implements IModel {
+declare class RWSModel<T> implements IModel {
     static services: IRWSModelServices;
     [key: string]: any;
     id: string;
@@ -17,20 +17,20 @@ declare class RWSModel<ChildClass> implements IModel {
     static checkForInclusionWithThrow(this: OpModelType<any>, checkModelType: string): void;
     checkForInclusion(): boolean;
     static checkForInclusion(this: OpModelType<any>, checkModelType: string): boolean;
-    protected _fill(data: any): RWSModel<ChildClass>;
+    protected _fill(data: any): RWSModel<T>;
     protected hasRelation(key: string): boolean;
     protected bindRelation(key: string, relatedModel: RWSModel<any>): {
         connect: {
             id: string;
         };
     };
-    _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean): Promise<ChildClass>;
+    _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean): Promise<T>;
     private getModelScalarFields;
     private getRelationOneMeta;
     static getRelationOneMeta(model: any, classFields: string[]): Promise<import("..").RelOneMetaType<import("../..").IRWSModel>>;
     private getRelationManyMeta;
     static getRelationManyMeta(model: any, classFields: string[]): Promise<import("..").RelManyMetaType<import("../..").IRWSModel>>;
-    static paginate<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<any>, pageParams: IPaginationParams, findParams?: FindByType): Promise<RWSModel<ChildClass>[]>;
+    static paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams: IPaginationParams, findParams?: FindByType): Promise<T[]>;
     toMongo(): Promise<any>;
     getCollection(): string | null;
     static getCollection(): string | null;
@@ -49,12 +49,12 @@ declare class RWSModel<ChildClass> implements IModel {
     isDbVariable(variable: string): Promise<boolean>;
     static checkDbVariable(constructor: any, variable: string): Promise<boolean>;
     sanitizeDBData(data: any): any;
-    static watchCollection<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, preRun: () => void): Promise<any>;
-    static findOneBy<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, findParams?: FindByType): Promise<ChildClass | null>;
-    static find<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<ChildClass | null>;
-    static findBy<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, findParams?: FindByType): Promise<ChildClass[]>;
-    static delete<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, conditions: any): Promise<void>;
-    delete<ChildClass extends RWSModel<ChildClass>>(): Promise<void>;
+    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 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>;
     static create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
     static loadModels(): OpModelType<any>[];
     loadModels(): OpModelType<any>[];

package/dist/models/core/RWSModel.js

@@ -8,18 +8,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RWSModel = void 0;
 const decorators_1 = require("../../decorators");
 const FieldsHelper_1 = require("../../helper/FieldsHelper");
 const RelationUtils_1 = require("../utils/RelationUtils");
-const PaginationUtils_1 = require("../utils/PaginationUtils");
 const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
 const ModelUtils_1 = require("../utils/ModelUtils");
-const TimeSeriesModel_1 = __importDefault(require("./TimeSeriesModel"));
 class RWSModel {
     constructor(data) {
         if (!this.getCollection()) {
@@ -38,7 +33,10 @@ class RWSModel {
         }
     }
     checkForInclusionWithThrow() {
-        this.checkForInclusionWithThrow();
+        const constructor = this.constructor;
+        if (!constructor.checkForInclusion(constructor.name)) {
+            throw new Error('Model undefined: ' + constructor.name);
+        }
     }
     static checkForInclusionWithThrow(checkModelType) {
         if (!this.checkForInclusion(this.name)) {
@@ -46,7 +44,8 @@ class RWSModel {
         }
     }
     checkForInclusion() {
-        return this.checkForInclusion();
+        const constructor = this.constructor;
+        return constructor.checkForInclusion(constructor.name);
     }
     static checkForInclusion(checkModelType) {
         return this.loadModels().find((definedModel) => {
@@ -172,8 +171,31 @@ class RWSModel {
     static async getRelationManyMeta(model, classFields) {
         return RelationUtils_1.RelationUtils.getRelationManyMeta(model, classFields);
     }
-    static paginate(pageParams, findParams) {
-        return PaginationUtils_1.PaginationUtils.paginate.bind(this)(pageParams, findParams);
+    static async paginate(paginateParams, 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, paginateParams);
+            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;
+        }
     }
     async toMongo() {
         const data = {};
@@ -218,7 +240,7 @@ class RWSModel {
         }
         else {
             this.preCreate();
-            const isTimeSeries = this instanceof TimeSeriesModel_1.default;
+            const isTimeSeries = false; //this instanceof timeSeriesModel;
             updatedModelData = await this.dbService.insert(data, this.getCollection(), isTimeSeries);
             await this._asyncFill(updatedModelData);
             this.postCreate();

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

@@ -1,7 +1 @@
-import { RWSModel } from './RWSModel';
-export default class TimeSeriesModel<T> extends RWSModel<T> {
-    value: number;
-    timestamp: Date;
-    params: any;
-    constructor(data?: any);
-}
+export {};

package/dist/models/core/TimeSeriesModel.js

@@ -1,34 +1,14 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const RWSModel_1 = require("./RWSModel");
-const decorators_1 = require("../../decorators");
-class TimeSeriesModel extends RWSModel_1.RWSModel {
-    constructor(data) {
-        super(data);
-        if (!this.timestamp) {
-            this.timestamp = new Date();
-        }
-    }
-}
-exports.default = TimeSeriesModel;
-__decorate([
-    (0, decorators_1.TrackType)(Number),
-    __metadata("design:type", Number)
-], TimeSeriesModel.prototype, "value", void 0);
-__decorate([
-    (0, decorators_1.TrackType)(Date),
-    __metadata("design:type", Date)
-], TimeSeriesModel.prototype, "timestamp", void 0);
-__decorate([
-    (0, decorators_1.TrackType)(Object),
-    __metadata("design:type", Object)
-], TimeSeriesModel.prototype, "params", void 0);
+// export default class TimeSeriesModel<T> extends RWSModel<T> {
+//     @TrackType(Number) value: number;
+//     @TrackType(Date) timestamp: Date;
+//     @TrackType(Object)
+//     params: any;
+//     constructor(data?: any) {    
+//         super(data);
+//         if(!this.timestamp) {
+//             this.timestamp = new Date();
+//         }
+//     }
+// }

package/dist/models/index.d.ts

@@ -3,6 +3,5 @@ import { IRWSModelServices } from './interfaces/IRWSModelServices';
 import { OpModelType } from './interfaces/OpModelType';
 import { RelationBindType, RelOneMetaType, RelManyMetaType } from './types/RelationTypes';
 import { RWSModel } from './core/RWSModel';
-import TimeSeriesModel from './core/TimeSeriesModel';
 import { TrackType, IMetaOpts } from '../decorators';
-export { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, RWSModel, TimeSeriesModel, TrackType, IMetaOpts };
+export { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, RWSModel, TrackType, IMetaOpts };

package/dist/models/index.js

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrackType = exports.TimeSeriesModel = exports.RWSModel = void 0;
+exports.TrackType = exports.RWSModel = void 0;
 const RWSModel_1 = require("./core/RWSModel");
 Object.defineProperty(exports, "RWSModel", { enumerable: true, get: function () { return RWSModel_1.RWSModel; } });
-const TimeSeriesModel_1 = __importDefault(require("./core/TimeSeriesModel"));
-exports.TimeSeriesModel = TimeSeriesModel_1.default;
+// import TimeSeriesModel from './core/TimeSeriesModel';
 const decorators_1 = require("../decorators");
 Object.defineProperty(exports, "TrackType", { enumerable: true, get: function () { return decorators_1.TrackType; } });

package/dist/models/interfaces/OpModelType.d.ts

@@ -3,9 +3,9 @@ import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { IRWSModelServices } from './IRWSModelServices';
 import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
 import { DBService } from '../../services/DBService';
-type RWSModel<T> = any;
-export interface OpModelType<ChildClass> {
-    new (data?: any | null): ChildClass;
+import type { RWSModel } from '../core/RWSModel';
+export interface OpModelType<T> {
+    new (data?: any | null): T;
     services: IRWSModelServices;
     name: string;
     _collection: string;
@@ -17,16 +17,15 @@ export interface OpModelType<ChildClass> {
     loadModels: () => OpModelType<any>[];
     checkForInclusionWithThrow: (className: string) => void;
     checkForInclusion: (className: string) => boolean;
-    findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams: FindByType): Promise<T | null>;
+    findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
     find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
-    findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams: FindByType): Promise<T[]>;
+    findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
     paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
-    delete<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, conditions: any): Promise<void>;
-    create<T extends RWSModel<T>>(this: OpModelType<T>, data: T): Promise<T>;
+    delete<T extends RWSModel<T>>(this: OpModelType<T>, conditions: any): Promise<void>;
+    create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
     getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
     getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
     getCollection(): string;
     getDb(): DBService;
     setServices(services: IRWSModelServices): void;
 }
-export {};

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

@@ -1,5 +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[]>;
+    static paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginationParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
 }

package/dist/services/DBService.js

@@ -139,8 +139,9 @@ class DBService {
             params.orderBy = ordering;
         }
         if (pagination) {
-            params.skip = pagination.page * pagination.per_page;
-            params.take = pagination.per_page;
+            const perPage = pagination.per_page || 50;
+            params.skip = pagination.page * perPage;
+            params.take = perPage;
         }
         const retData = await this.getCollectionHandler(collection).findMany(params);
         return retData;

package/dist/types/FindParams.d.ts

@@ -10,5 +10,5 @@ export type FindByType = {
 };
 export interface IPaginationParams {
     page: number;
-    per_page: number;
+    per_page?: number;
 }

package/package.json

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

package/src/helper/DbHelper.ts

@@ -5,7 +5,7 @@ import fs from 'fs';
 
 import { IDbConfigHandler } from '../types/DbConfigHandler';
 import { IMetaOpts, OpModelType, RWSModel } from '../models/_model';
-import TimeSeriesModel from '../models/core/TimeSeriesModel';
+// import TimeSeriesModel from '../models/core/TimeSeriesModel';
 import { DBService } from '../services/DBService';
 import { IRelationOpts } from '../decorators/Relation';
 import { InverseRelationOpts } from '../decorators/InverseRelation';
@@ -40,17 +40,17 @@ export class DbHelper {
 
                 log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
             
-                if(RWSModel.isSubclass(model as any, TimeSeriesModel)){    
-                    dbService.collectionExists(model._collection).then((exists: boolean) => {
-                        if (exists){
-                            return;
-                        }
+                // if(RWSModel.isSubclass(model as any, TimeSeriesModel)){    
+                //     dbService.collectionExists(model._collection).then((exists: boolean) => {
+                //         if (exists){
+                //             return;
+                //         }
 
-                        log(chalk.green('[RWS Init]') + ` creating TimeSeries type collection from ${model} model`);
+                //         log(chalk.green('[RWS Init]') + ` creating TimeSeries type collection from ${model} model`);
 
-                        dbService.createTimeSeriesCollection(model._collection);    
-                    });
-                }
+                //         dbService.createTimeSeriesCollection(model._collection);    
+                //     });
+                // }
             }
 
             const schemaDir = path.join(moduleDir, 'prisma');

package/src/index.ts

@@ -1,6 +1,6 @@
 import { DBService } from "./services/DBService";
 import { RWSModel, OpModelType } from "./models/_model";
-import TimeSeriesModel from './models/core/TimeSeriesModel';
+// import TimeSeriesModel from './models/core/TimeSeriesModel';
 import { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts } from './decorators';
 
 import { DbHelper } from './helper/DbHelper';
@@ -28,7 +28,7 @@ export {
    DBService,
 
    FindByType, 
-   TimeSeriesModel,   
+   // TimeSeriesModel,   
 
    InverseRelation, Relation, TrackType, InverseTimeSeries,
 

package/src/models/core/RWSModel.ts

@@ -5,14 +5,13 @@ import { TrackType, IMetaOpts } from '../../decorators';
 import { FieldsHelper } from '../../helper/FieldsHelper';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { RelationUtils } from '../utils/RelationUtils';
-import { PaginationUtils } from '../utils/PaginationUtils';
 
 import { TimeSeriesUtils } from '../utils/TimeSeriesUtils';
 import { ModelUtils } from '../utils/ModelUtils';
-import timeSeriesModel from './TimeSeriesModel';      
+// import timeSeriesModel from './TimeSeriesModel';      
 import { DBService } from '../../services/DBService';
 
-class RWSModel<ChildClass> implements IModel {
+class RWSModel<T> implements IModel {
     static services: IRWSModelServices = {};
     
     [key: string]: any;
@@ -44,7 +43,10 @@ class RWSModel<ChildClass> implements IModel {
     }    
     
     checkForInclusionWithThrow(): void {
-        this.checkForInclusionWithThrow();
+        const constructor = this.constructor as OpModelType<any>;
+        if(!constructor.checkForInclusion(constructor.name)){
+            throw new Error('Model undefined: ' + constructor.name);
+        }
     }
 
     static checkForInclusionWithThrow(this: OpModelType<any>, checkModelType: string): void {
@@ -54,7 +56,8 @@ class RWSModel<ChildClass> implements IModel {
     }
 
     checkForInclusion(): boolean {                
-        return this.checkForInclusion();        
+        const constructor = this.constructor as OpModelType<any>;
+        return constructor.checkForInclusion(constructor.name);        
     }
 
     static checkForInclusion(this: OpModelType<any>, checkModelType: string): boolean {        
@@ -63,7 +66,7 @@ class RWSModel<ChildClass> implements IModel {
         }) !== undefined;
     }
 
-    protected _fill(data: any): RWSModel<ChildClass> {
+    protected _fill(data: any): RWSModel<T> {
         for (const key in data) {
             if (data.hasOwnProperty(key)) {   
               
@@ -90,7 +93,7 @@ class RWSModel<ChildClass> implements IModel {
         return RelationUtils.bindRelation(relatedModel);
     }
 
-    public async _asyncFill(data: any, fullDataMode = false, allowRelations = true): Promise<ChildClass> {
+    public async _asyncFill(data: any, fullDataMode = false, allowRelations = true): Promise<T> {
         const collections_to_models: {[key: string]: any} = {};           
         const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(this);
     
@@ -191,10 +194,10 @@ class RWSModel<ChildClass> implements IModel {
             }       
         }     
     
-        return this as any as ChildClass;
+        return this as any as T;
     }    
 
-    private getModelScalarFields(model: RWSModel<ChildClass>): string[] {
+    private getModelScalarFields(model: RWSModel<T>): string[] {
         return ModelUtils.getModelScalarFields(model);
     }
 
@@ -214,8 +217,38 @@ class RWSModel<ChildClass> implements IModel {
         return RelationUtils.getRelationManyMeta(model, classFields);
     }
 
-    static paginate<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<any>,pageParams: IPaginationParams, findParams?: FindByType): Promise<RWSModel<ChildClass>[]> {
-        return PaginationUtils.paginate.bind(this)(pageParams, findParams);
+    public static async paginate<T extends RWSModel<T>>(
+        this: OpModelType<T>,  
+        paginateParams: IPaginationParams,  
+        findParams?: FindByType
+    ): Promise<T[]> {
+        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, paginateParams);   
+            if (dbData.length) {
+                const instanced: T[] = [];
+        
+                for (const data of dbData) { 
+                    const inst: T = new (this as { new(): T })();
+                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
+                }
+        
+                return instanced;
+            }
+        
+            return [];
+        } catch (rwsError: Error | any) {
+            console.error(rwsError);
+
+            throw rwsError;
+        }                 
     }
 
     public async toMongo(): Promise<any> {
@@ -274,7 +307,7 @@ class RWSModel<ChildClass> implements IModel {
         } else {
             this.preCreate();      
       
-            const isTimeSeries = this instanceof timeSeriesModel;
+            const isTimeSeries = false;//this instanceof timeSeriesModel;
 
             updatedModelData = await this.dbService.insert(data, this.getCollection(), isTimeSeries);      
 
@@ -339,8 +372,8 @@ class RWSModel<ChildClass> implements IModel {
         return sanitizedData;
     }
 
-    public static async watchCollection<ChildClass extends RWSModel<ChildClass>>(
-        this: OpModelType<ChildClass>, 
+    public static async watchCollection<T extends RWSModel<T>>(
+        this: OpModelType<T>, 
         preRun: () => void
     ){
         const collection = Reflect.get(this, '_collection');
@@ -348,10 +381,10 @@ class RWSModel<ChildClass> implements IModel {
         return await this.services.dbService.watchCollection(collection, preRun);
     }
 
-    public static async findOneBy<ChildClass extends RWSModel<ChildClass>>(
-        this: OpModelType<ChildClass>,
+    public static async findOneBy<T extends RWSModel<T>>(
+        this: OpModelType<T>,
         findParams?: FindByType
-    ): Promise<ChildClass | null> {
+    ): Promise<T | null> {
         const conditions = findParams?.conditions ?? {};
         const ordering = findParams?.ordering ?? null;
         const fields = findParams?.fields ?? null;
@@ -366,18 +399,18 @@ class RWSModel<ChildClass> implements IModel {
         
     
         if (dbData) {
-            const inst: ChildClass = new (this as { new(): ChildClass })();
+            const inst: T = new (this as { new(): T })();
             return await inst._asyncFill(dbData, fullData, allowRelations);
         }
     
         return null;
     }
 
-    public static async find<ChildClass extends RWSModel<ChildClass>>(
-        this: OpModelType<ChildClass>,
+    public static async find<T extends RWSModel<T>>(
+        this: OpModelType<T>,
         id: string,        
         findParams: Omit<FindByType, 'conditions'> = null
-    ): Promise<ChildClass | null> {        
+    ): Promise<T | null> {        
         const ordering = findParams?.ordering ?? null;
         const fields = findParams?.fields ?? null;
         const allowRelations = findParams?.allowRelations ?? true;          
@@ -389,17 +422,17 @@ class RWSModel<ChildClass> implements IModel {
         const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
     
         if (dbData) {            
-            const inst: ChildClass = new (this as { new(): ChildClass })();
+            const inst: T = new (this as { new(): T })();
             return await inst._asyncFill(dbData, fullData, allowRelations);
         }
     
         return null;
     }   
     
-    public static async findBy<ChildClass extends RWSModel<ChildClass>>(
-        this: OpModelType<ChildClass>,    
+    public static async findBy<T extends RWSModel<T>>(
+        this: OpModelType<T>,    
         findParams?: FindByType
-    ): Promise<ChildClass[]> {
+    ): Promise<T[]> {
         const conditions = findParams?.conditions ?? {};
         const ordering = findParams?.ordering ?? null;
         const fields = findParams?.fields ?? null;
@@ -411,11 +444,11 @@ class RWSModel<ChildClass> implements IModel {
         try {
             const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering);   
             if (dbData.length) {
-                const instanced: ChildClass[] = [];
+                const instanced: T[] = [];
         
                 for (const data of dbData) { 
-                    const inst: ChildClass = new (this as { new(): ChildClass })();
-                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as ChildClass);
+                    const inst: T = new (this as { new(): T })();
+                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
                 }
         
                 return instanced;
@@ -429,8 +462,8 @@ class RWSModel<ChildClass> implements IModel {
         }                 
     }
 
-    public static async delete<ChildClass extends RWSModel<ChildClass>>(
-        this: OpModelType<ChildClass>,
+    public static async delete<T extends RWSModel<T>>(
+        this: OpModelType<T>,
         conditions: any
     ): Promise<void> {
         const collection = Reflect.get(this, '_collection');
@@ -438,7 +471,7 @@ class RWSModel<ChildClass> implements IModel {
         return await this.services.dbService.delete(collection, conditions);
     }
 
-    public async delete<ChildClass extends RWSModel<ChildClass>>(): Promise<void> {
+    public async delete<T extends RWSModel<T>>(): Promise<void> {
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow();
         return await this.dbService.delete(collection, {

package/src/models/core/TimeSeriesModel.ts

@@ -1,19 +1,19 @@
 import { RWSModel } from './RWSModel';
 import { TrackType } from '../../decorators';
 
-export default class TimeSeriesModel<T> extends RWSModel<T> {
-    @TrackType(Number) value: number;
+// export default class TimeSeriesModel<T> extends RWSModel<T> {
+//     @TrackType(Number) value: number;
 
-    @TrackType(Date) timestamp: Date;
+//     @TrackType(Date) timestamp: Date;
     
-    @TrackType(Object)
-    params: any;
+//     @TrackType(Object)
+//     params: any;
 
-    constructor(data?: any) {    
-        super(data);
+//     constructor(data?: any) {    
+//         super(data);
 
-        if(!this.timestamp) {
-            this.timestamp = new Date();
-        }
-    }
-}
+//         if(!this.timestamp) {
+//             this.timestamp = new Date();
+//         }
+//     }
+// }

package/src/models/index.ts

@@ -3,7 +3,7 @@ import { IRWSModelServices } from './interfaces/IRWSModelServices';
 import { OpModelType } from './interfaces/OpModelType';
 import { RelationBindType, RelOneMetaType, RelManyMetaType } from './types/RelationTypes';
 import { RWSModel } from './core/RWSModel';
-import TimeSeriesModel from './core/TimeSeriesModel';
+// import TimeSeriesModel from './core/TimeSeriesModel';
 import { TrackType, IMetaOpts } from '../decorators';
 
 export {
@@ -14,7 +14,7 @@ export {
     RelOneMetaType,
     RelManyMetaType,
     RWSModel,
-    TimeSeriesModel,
+    // TimeSeriesModel,
     TrackType,
     IMetaOpts
 };

package/src/models/interfaces/OpModelType.ts

@@ -4,11 +4,11 @@ import { IRWSModelServices } from './IRWSModelServices';
 import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
 import { DBService } from '../../services/DBService';
 
-// Forward declaration to avoid circular dependency
-type RWSModel<T> = any;
+// Reference to the RWSModel class to avoid circular dependency
+import type { RWSModel } from '../core/RWSModel';
 
-export interface OpModelType<ChildClass> {
-    new(data?: any | null): ChildClass;
+export interface OpModelType<T> {
+    new(data?: any | null): T;
     services: IRWSModelServices;
     name: string;
     _collection: string;
@@ -20,7 +20,7 @@ export interface OpModelType<ChildClass> {
     checkForInclusion: (className: string) => boolean;
     findOneBy<T extends RWSModel<T>>(
         this: OpModelType<T>,
-        findParams: FindByType
+        findParams?: FindByType
     ): Promise<T | null>;
     find<T extends RWSModel<T>>(
         this: OpModelType<T>,
@@ -29,18 +29,18 @@ export interface OpModelType<ChildClass> {
     ): Promise<T | null>;
     findBy<T extends RWSModel<T>>(
         this: OpModelType<T>,    
-        findParams: FindByType
+        findParams?: FindByType
     ): Promise<T[]>;
     paginate<T extends RWSModel<T>>(
         this: OpModelType<T>,    
         paginateParams?: IPaginationParams,
         findParams?: FindByType
     ): Promise<T[]>;
-    delete<ChildClass extends RWSModel<ChildClass>>(
-        this: OpModelType<ChildClass>,
+    delete<T extends RWSModel<T>>(
+        this: OpModelType<T>,
         conditions: any
     ): Promise<void>;
-    create<T extends RWSModel<T>>(this: OpModelType<T>, data: T): Promise<T>;
+    create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
     getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
     getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
     getCollection(): string;

package/src/models/utils/PaginationUtils.ts

@@ -5,11 +5,11 @@ import { FindByType, IPaginationParams } from '../../types/FindParams';
 
 export class PaginationUtils {
 
-    public static async paginate<ChildClass extends RWSModel<ChildClass>>(
-            this: OpModelType<ChildClass>,             
+    public static async paginate<T extends RWSModel<T>>(
+            this: OpModelType<T>,             
             paginationParams: IPaginationParams = { page: 0, per_page: 50 },
             findParams: FindByType = {},
-        ): Promise<ChildClass[]> {
+        ): Promise<T[]> {
         const conditions = findParams?.conditions ?? {};
         const ordering = findParams?.ordering ?? null;
         const fields = findParams?.fields ?? null;
@@ -21,11 +21,11 @@ export class PaginationUtils {
         try {
             const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginationParams);   
             if (dbData.length) {
-                const instanced: ChildClass[] = [];
+                const instanced: T[] = [];
         
                 for (const data of dbData) { 
-                    const inst: ChildClass = new (this as { new(): ChildClass })();
-                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as ChildClass);
+                    const inst: T = new (this as { new(): T })();
+                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
                 }
         
                 return instanced;

package/src/services/DBService.ts

@@ -196,8 +196,9 @@ class DBService {
         }
 
         if(pagination){
-            params.skip = pagination.page * pagination.per_page;
-            params.take = pagination.per_page;
+            const perPage = pagination.per_page || 50;
+            params.skip = pagination.page * perPage;
+            params.take = perPage;
         }
 
         const retData = await this.getCollectionHandler(collection).findMany(params);        

package/src/types/FindParams.ts

@@ -9,5 +9,5 @@ export type FindByType = {
 
 export interface IPaginationParams {
     page: number,
-    per_page: number
-}
+    per_page?: number
+}