@rws-framework/db 2.0.2 → 2.0.4

package/dist/services/DBService.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBService = void 0;
+const client_1 = require("@prisma/client");
+const mongodb_1 = require("mongodb");
+const chalk_1 = __importDefault(require("chalk"));
+class DBService {
+    constructor(configService) {
+        this.configService = configService;
+        this.opts = null;
+        this.connected = false;
+    }
+    connectToDB(opts = null) {
+        if (opts) {
+            this.opts = opts;
+        }
+        else {
+            this.opts = {
+                dbUrl: this.configService.get('mongo_url'),
+                dbName: this.configService.get('mongo_db'),
+            };
+        }
+        if (!this.opts.dbUrl) {
+            console.log(chalk_1.default.red('No database config set in @rws-framework/db'));
+            return;
+        }
+        try {
+            this.client = new client_1.PrismaClient({
+                datasources: {
+                    db: {
+                        url: this.opts.dbUrl
+                    },
+                },
+            });
+            this.connected = true;
+        }
+        catch (e) {
+            console.error(e);
+            throw new Error('PRISMA CONNECTION ERROR');
+        }
+    }
+    async createBaseMongoClient() {
+        var _a;
+        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('mongo_url');
+        const client = new mongodb_1.MongoClient(dbUrl);
+        await client.connect();
+        return client;
+    }
+    async createBaseMongoClientDB() {
+        var _a;
+        const dbName = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbName) || this.configService.get('mongo_db');
+        const client = await this.createBaseMongoClient();
+        return client.db(dbName);
+    }
+    async cloneDatabase(source, target) {
+        const client = await this.createBaseMongoClient();
+        // Source and target DB
+        const sourceDb = client.db(source);
+        const targetDb = client.db(target);
+        // Get all collections from source DB
+        const collections = await sourceDb.listCollections().toArray();
+        // Loop over all collections and copy them to the target DB
+        for (const collection of collections) {
+            const docs = await sourceDb.collection(collection.name).find({}).toArray();
+            await targetDb.collection(collection.name).insertMany(docs);
+        }
+        await client.close();
+    }
+    async watchCollection(collectionName, preRun) {
+        const db = await this.createBaseMongoClientDB();
+        const collection = db.collection(collectionName);
+        const changeStream = collection.watch();
+        return new Promise((resolve) => {
+            changeStream.on('change', (change) => {
+                resolve(change);
+            });
+            preRun();
+        });
+    }
+    async insert(data, collection, isTimeSeries = false) {
+        let result = data;
+        // Insert time-series data outside of the transaction
+        if (isTimeSeries) {
+            const db = await this.createBaseMongoClientDB();
+            const collectionHandler = db.collection(collection);
+            const insert = await collectionHandler.insertOne(data);
+            result = await this.findOneBy(collection, { id: insert.insertedId.toString() });
+            return result;
+        }
+        const prismaCollection = this.getCollectionHandler(collection);
+        result = await prismaCollection.create({ data });
+        return await this.findOneBy(collection, { id: result.id });
+    }
+    async update(data, collection) {
+        const model_id = data.id;
+        delete data['id'];
+        const prismaCollection = this.getCollectionHandler(collection);
+        await prismaCollection.update({
+            where: {
+                id: model_id,
+            },
+            data: data,
+        });
+        return await this.findOneBy(collection, { id: model_id });
+    }
+    async findOneBy(collection, conditions, fields = null, ordering = null, allowRelations = true) {
+        const params = { where: conditions };
+        if (fields) {
+            params.select = {};
+            fields.forEach((fieldName) => {
+                params.select[fieldName] = true;
+            });
+        }
+        if (ordering) {
+            params.orderBy = ordering;
+        }
+        const retData = await this.getCollectionHandler(collection).findFirst(params);
+        return retData;
+    }
+    async delete(collection, conditions) {
+        await this.getCollectionHandler(collection).deleteMany({ where: conditions });
+        return;
+    }
+    async findBy(collection, conditions, fields = null, ordering = null, allowRelations = true) {
+        const params = { where: conditions };
+        if (fields) {
+            params.select = {};
+            fields.forEach((fieldName) => {
+                params.select[fieldName] = true;
+            });
+        }
+        if (ordering) {
+            params.orderBy = ordering;
+        }
+        const retData = await this.getCollectionHandler(collection).findMany(params);
+        return retData;
+    }
+    async collectionExists(collection_name) {
+        var _a;
+        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('mongo_url');
+        const client = new mongodb_1.MongoClient(dbUrl);
+        try {
+            await client.connect();
+            const db = client.db(this.configService.get('mongo_db'));
+            const collections = await db.listCollections().toArray();
+            const existingCollectionNames = collections.map((collection) => collection.name);
+            return existingCollectionNames.includes(collection_name);
+        }
+        catch (error) {
+            console.error('Error connecting to MongoDB:', error);
+            throw error;
+        }
+    }
+    async createTimeSeriesCollection(collection_name) {
+        try {
+            const db = await this.createBaseMongoClientDB();
+            // Create a time series collection
+            const options = {
+                timeseries: {
+                    timeField: 'timestamp', // Replace with your timestamp field
+                    metaField: 'params' // Replace with your metadata field
+                }
+            };
+            await db.createCollection(collection_name, options); // Replace with your collection name
+            return db.collection(collection_name);
+        }
+        catch (error) {
+            console.error('Error connecting to MongoDB:', error);
+            throw error;
+        }
+    }
+    getCollectionHandler(collection) {
+        if (!this.client || !this.connected) {
+            this.connectToDB();
+        }
+        return this.client[collection];
+    }
+    setOpts(opts = null) {
+        this.opts = opts;
+        return this;
+    }
+}
+exports.DBService = DBService;

package/dist/types/DbConfigHandler.d.ts

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

package/dist/types/DbConfigHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/FindParams.d.ts

@@ -0,0 +1,9 @@
+export type FindByType = {
+    conditions?: any;
+    ordering?: {
+        [fieldName: string]: string;
+    };
+    fields?: string[];
+    allowRelations?: boolean;
+    fullData?: boolean;
+};

package/dist/types/FindParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/IRWSModel.d.ts

@@ -0,0 +1,3 @@
+export interface IRWSModel {
+    id?: string;
+}

package/dist/types/IRWSModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ITimeSeries.d.ts

@@ -0,0 +1,6 @@
+export interface ITimeSeries {
+    value: number;
+    timestamp?: Date;
+    params?: any;
+    time_tracker_id?: string;
+}

package/dist/types/ITimeSeries.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {},
   "author": "papablack",
   "license": "ISC",
@@ -20,14 +21,12 @@
     "crypto": "^1.0.1",
     "source-map-support": "^0.5.21",
     "tsconfig-paths": "^4.2.0",
-    "tsconfig-paths-webpack-plugin": "^4.1.0",
-    "webpack": "^5.97.1",    
-    "webpack-cli": "^6.0.1",
-    "webpack-bundle-analyzer": "^4.10.2",
-    "webpack-node-externals": "^3.0.0"
+    "tsconfig-paths-webpack-plugin": "^4.1.0"    
   },
   "devDependencies": {
-    "@types/xml2js": "^0.4.14"
+    "@types/xml2js": "^0.4.14",
+    "typescript": "^5.7.2"
+
   },
   "repository": {
     "type": "git",

package/src/helper/DbHelper.ts

@@ -76,7 +76,7 @@ export class DbHelper {
         }
     }
 
-    static async generateModelSections<T extends unknown>(model: OpModelType<T>): Promise<string> {
+    static async generateModelSections(model: OpModelType<any>): Promise<string> {
         let section = '';
         const modelMetadatas: Record<string, {annotationType: string, metadata: any}> = await RWSModel.getModelAnnotations(model);    
     
@@ -95,7 +95,7 @@ export class DbHelper {
             }
             
             if(annotationType === 'Relation'){
-                const relatedModel = modelMetadata.relatedTo as OpModelType<T>;        
+                const relatedModel = modelMetadata.relatedTo as OpModelType<any>;        
                 // Handle direct relation (many-to-one or one-to-one)
                 section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField}], onDelete: Cascade)\n`;      
                 section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;

package/src/models/_model.ts

@@ -29,6 +29,7 @@ type RelManyMetaType<T extends IRWSModel> = {[key: string]: {key: string, invers
 
 export interface OpModelType<ChildClass> {
     new(data?: any | null): ChildClass;
+    services: IRWSModelServices;
     name: string 
     _collection: string;
     _RELATIONS: {[key: string]: boolean}
@@ -37,8 +38,6 @@ export interface OpModelType<ChildClass> {
     loadModels: () => OpModelType<any>[];
     checkForInclusionWithThrow: (className: string) => void;
     checkForInclusion: (className: string) => boolean;
-    configService?: IDbConfigHandler;
-    dbService?: DBService;
     findOneBy<T extends RWSModel<T>>(
         this: OpModelType<T>,
         findParams: FindByType
@@ -60,14 +59,12 @@ export interface OpModelType<ChildClass> {
     getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
     getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
     getCollection(): string;
+    setServices(services: IRWSModelServices): void;
 }
 
 class RWSModel<ChildClass> implements IModel{
-    static services: IRWSModelServices = {}
-
-    static configService: IDbConfigHandler;
-    static dbService: DBService    
-
+    static services: IRWSModelServices = {};
+    
     [key: string]: any;
     @TrackType(String)
     id: string;
@@ -83,8 +80,8 @@ class RWSModel<ChildClass> implements IModel{
         
         }
 
-        this.dbService = RWSModel.dbService;
-        this.configService = RWSModel.configService;
+        this.dbService = RWSModel.services.dbService;
+        this.configService = RWSModel.services.configService;
 
         if(!data){
             return;    
@@ -99,7 +96,7 @@ class RWSModel<ChildClass> implements IModel{
     
     checkForInclusionWithThrow(): void
     {
-        this.checkForInclusionWithThrow()
+        this.checkForInclusionWithThrow();
     }
 
     static checkForInclusionWithThrow(this: OpModelType<any>, checkModelType: string): void
@@ -117,8 +114,8 @@ class RWSModel<ChildClass> implements IModel{
     static checkForInclusion(this: OpModelType<any>, checkModelType: string): boolean
     {        
         return this.loadModels().find((definedModel: OpModelType<any>) => {
-            return definedModel.name === checkModelType
-        }) !== undefined
+            return definedModel.name === checkModelType;
+        }) !== undefined;
     }
 
     protected _fill(data: any): RWSModel<ChildClass>{
@@ -543,7 +540,7 @@ class RWSModel<ChildClass> implements IModel{
     ){
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
-        return await this.dbService.watchCollection(collection, preRun);
+        return await this.services.dbService.watchCollection(collection, preRun);
     }
 
     public static async findOneBy<ChildClass extends RWSModel<ChildClass>>(
@@ -560,7 +557,7 @@ class RWSModel<ChildClass> implements IModel{
 
         
         const collection = Reflect.get(this, '_collection');        
-        const dbData = await this.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
+        const dbData = await this.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
         
     
         if (dbData) {
@@ -584,7 +581,7 @@ class RWSModel<ChildClass> implements IModel{
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
 
-        const dbData = await this.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
+        const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
     
         if (dbData) {            
             const inst: ChildClass = new (this as { new(): ChildClass })();
@@ -607,7 +604,7 @@ class RWSModel<ChildClass> implements IModel{
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {
-            const dbData = await this.dbService.findBy(collection, conditions, fields, ordering, allowRelations);   
+            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, allowRelations);   
             if (dbData.length) {
                 const instanced: ChildClass[] = [];
         
@@ -633,7 +630,7 @@ class RWSModel<ChildClass> implements IModel{
     ): Promise<void> {
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);         
-        return await this.dbService.delete(collection, conditions);
+        return await this.services.dbService.delete(collection, conditions);
     }
 
     public async delete<ChildClass extends RWSModel<ChildClass>>(): Promise<void> {
@@ -657,7 +654,7 @@ class RWSModel<ChildClass> implements IModel{
 
     static loadModels(): OpModelType<any>[]
     {                        
-        return RWSModel.allModels;
+        return this.allModels || [];
     }
 
     loadModels(): OpModelType<any>[]
@@ -670,8 +667,9 @@ class RWSModel<ChildClass> implements IModel{
         return Object.keys((this as any).constructor._RELATIONS).includes(key) && (this as any).constructor._RELATIONS[key] === true
     }
 
-    public static setServices(services: IRWSModelServices){        
-        RWSModel.services = {...RWSModel.services, ...services};
+    public static setServices(services: IRWSModelServices){
+        this.allModels = services.configService.get('db_models');  
+        this.services = services;
     }
 }
 

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+      "baseUrl": ".",
+      "experimentalDecorators": true,
+      "emitDecoratorMetadata": true,
+      "target": "ES2018",
+      "module": "commonjs",
+      "moduleResolution": "node",
+      "strict": true,
+      "skipLibCheck": true,
+      "esModuleInterop": true,
+      "resolveJsonModule": true,
+      "strictNullChecks": false,
+      "allowSyntheticDefaultImports": true,
+      "sourceMap": false,      
+      "declaration": true,   
+      "outDir": "./dist"       
+    },
+    "include": [
+      "src"    
+    ],
+    "exclude": []
+  }