@rws-framework/db 2.1.11 → 2.2.1

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.11",
+  "version": "2.2.1",
   "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};

package/src/models/_model.ts

@@ -1,28 +1,31 @@
-import {DBService, IDBClientCreate} from '../services/DBService';
-import { IRWSModel } from '../types/IRWSModel';
-import { IDbConfigHandler } from '../types/DbConfigHandler';
-
-import {TrackType, IMetaOpts } from '../decorators';
-import { FieldsHelper } from '../helper/FieldsHelper';
-import { FindByType } from '../types/FindParams';
-
-interface IModel{
-    [key: string]: any;
-    id: string | null;
-    save: () => void;
-    getCollection: () => string | null;
-    configService?: IDbConfigHandler;
-    dbService?: DBService;
-}
-
-interface IRWSModelServices {
-    configService?: IDbConfigHandler
-    dbService?: DBService
-}
-
-type RelationBindType = {
-    connect: { id: string }
+/**
+ * @deprecated This file is deprecated. Import from 'models' directory instead.
+ */
+
+import {
+    IModel,
+    IRWSModelServices,
+    OpModelType,
+    RelationBindType,
+    RelOneMetaType,
+    RelManyMetaType,
+    RWSModel,
+    TrackType,
+    IMetaOpts
+} from './index';
+
+export {
+    IModel,
+    IRWSModelServices,
+    OpModelType,
+    RelationBindType,
+    RelOneMetaType,
+    RelManyMetaType,
+    RWSModel,
+    TrackType,
+    IMetaOpts
 };
+<<<<<<< HEAD
 
 type RelOneMetaType<T extends IRWSModel> = {[key: string]: {required: boolean, key?: string, model: OpModelType<T>, hydrationField: string, foreignKey: string}};
 type RelManyMetaType<T extends IRWSModel> = {[key: string]: {key: string, inversionModel: OpModelType<T>, foreignKey: string}};
@@ -674,3 +677,5 @@ class RWSModel<ChildClass> implements IModel{
 export { IModel, TrackType, IMetaOpts, RWSModel };
 
 
+=======
+>>>>>>> 7c50786 (v2.2.0)