@rws-framework/db 2.4.0 → 2.4.2

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

@@ -1,11 +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;
-}
+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

@@ -1,35 +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;
+"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,37 +1,37 @@
-import { Collection, Db, MongoClient } from 'mongodb';
-import { ITimeSeries } from '../types/ITimeSeries';
-import { IModel } from '../models/interfaces/IModel';
-import { IDbConfigHandler } from '../types/DbConfigHandler';
-import { IPaginationParams } from 'src/types/FindParams';
-interface IDBClientCreate {
-    dbUrl?: string;
-    dbName?: string;
-}
-declare class DBService {
-    private configService;
-    private client;
-    private opts;
-    private connected;
-    constructor(configService: IDbConfigHandler);
-    private connectToDB;
-    reconnect(opts?: IDBClientCreate): void;
-    static baseClientConstruct(dbUrl: string): MongoClient;
-    createBaseMongoClient(): Promise<MongoClient>;
-    createBaseMongoClientDB(): Promise<[MongoClient, Db]>;
-    cloneDatabase(source: string, target: string): Promise<void>;
-    watchCollection(collectionName: string, preRun: () => void): Promise<any>;
-    insert(data: any, collection: string, isTimeSeries?: boolean): Promise<any>;
-    update(data: any, collection: string): Promise<IModel>;
-    findOneBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
-        [fieldName: string]: string;
-    }, allowRelations?: boolean): Promise<IModel | null>;
-    delete(collection: string, conditions: any): Promise<void>;
-    findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
-        [fieldName: string]: string;
-    }, pagination?: IPaginationParams): Promise<IModel[]>;
-    collectionExists(collection_name: string): Promise<boolean>;
-    createTimeSeriesCollection(collection_name: string): Promise<Collection<ITimeSeries>>;
-    private getCollectionHandler;
-    private setOpts;
-}
-export { DBService, IDBClientCreate };
+import { Collection, Db, MongoClient } from 'mongodb';
+import { ITimeSeries } from '../types/ITimeSeries';
+import { IModel } from '../models/interfaces/IModel';
+import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { IPaginationParams } from '../types/FindParams';
+interface IDBClientCreate {
+    dbUrl?: string;
+    dbName?: string;
+}
+declare class DBService {
+    private configService;
+    private client;
+    private opts;
+    private connected;
+    constructor(configService: IDbConfigHandler);
+    private connectToDB;
+    reconnect(opts?: IDBClientCreate): void;
+    static baseClientConstruct(dbUrl: string): MongoClient;
+    createBaseMongoClient(): Promise<MongoClient>;
+    createBaseMongoClientDB(): Promise<[MongoClient, Db]>;
+    cloneDatabase(source: string, target: string): Promise<void>;
+    watchCollection(collectionName: string, preRun: () => void): Promise<any>;
+    insert(data: any, collection: string, isTimeSeries?: boolean): Promise<any>;
+    update(data: any, collection: string): Promise<IModel>;
+    findOneBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
+        [fieldName: string]: string;
+    }, allowRelations?: boolean): Promise<IModel | null>;
+    delete(collection: string, conditions: any): Promise<void>;
+    findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
+        [fieldName: string]: string;
+    }, pagination?: IPaginationParams): Promise<IModel[]>;
+    collectionExists(collection_name: string): Promise<boolean>;
+    createTimeSeriesCollection(collection_name: string): Promise<Collection<ITimeSeries>>;
+    private getCollectionHandler;
+    private setOpts;
+}
+export { DBService, IDBClientCreate };

package/dist/services/DBService.js

@@ -1,198 +1,198 @@
-"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');
-        }
-    }
-    reconnect(opts = null) {
-        this.connectToDB(opts);
-    }
-    static baseClientConstruct(dbUrl) {
-        const client = new mongodb_1.MongoClient(dbUrl);
-        return client;
-    }
-    async createBaseMongoClient() {
-        var _a;
-        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('mongo_url');
-        const client = DBService.baseClientConstruct(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, 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 [client, 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 [client, 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, pagination = null) {
-        const params = { where: conditions };
-        if (fields) {
-            params.select = {};
-            fields.forEach((fieldName) => {
-                params.select[fieldName] = true;
-            });
-        }
-        if (ordering) {
-            params.orderBy = ordering;
-        }
-        if (pagination) {
-            const perPage = pagination.per_page || 50;
-            params.skip = (pagination.page || 0) * perPage;
-            params.take = perPage;
-        }
-        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 [client, 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;
+"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('db_url'),
+                dbName: this.configService.get('db_name'),
+            };
+        }
+        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');
+        }
+    }
+    reconnect(opts = null) {
+        this.connectToDB(opts);
+    }
+    static baseClientConstruct(dbUrl) {
+        const client = new mongodb_1.MongoClient(dbUrl);
+        return client;
+    }
+    async createBaseMongoClient() {
+        var _a;
+        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('db_url');
+        const client = DBService.baseClientConstruct(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('db_name');
+        const client = await this.createBaseMongoClient();
+        return [client, 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 [client, 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 [client, 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, pagination = null) {
+        const params = { where: conditions };
+        if (fields) {
+            params.select = {};
+            fields.forEach((fieldName) => {
+                params.select[fieldName] = true;
+            });
+        }
+        if (ordering) {
+            params.orderBy = ordering;
+        }
+        if (pagination) {
+            const perPage = pagination.per_page || 50;
+            params.skip = (pagination.page || 0) * perPage;
+            params.take = perPage;
+        }
+        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('db_url');
+        const client = new mongodb_1.MongoClient(dbUrl);
+        try {
+            await client.connect();
+            const db = client.db(this.configService.get('db_name'));
+            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 [client, 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

@@ -1,9 +1,14 @@
-import { OpModelType } from "../models/interfaces/OpModelType";
-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];
-}
+import { OpModelType } from "../models/interfaces/OpModelType";
+export interface IDbConfigParams {
+    db_url?: string;
+    db_name?: string;
+    db_type?: 'mongodb' | 'mysql' | 'sqlite';
+    db_models?: OpModelType<any>[];
+}
+export interface IdGeneratorOptions {
+    useUuid?: boolean;
+    customType?: string;
+}
+export interface IDbConfigHandler {
+    get<K extends keyof IDbConfigParams>(key: K): IDbConfigParams[K];
+}

package/dist/types/DbConfigHandler.js

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

package/dist/types/FindParams.d.ts

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

package/dist/types/FindParams.js

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

package/dist/types/IRWSModel.d.ts

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

package/dist/types/IRWSModel.js

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

package/dist/types/ITimeSeries.d.ts

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