@sedni/cloud_common 1.1.0 → 2.0.0

package/package.json

@@ -1,15 +1,25 @@
 {
     "name": "@sedni/cloud_common",
-    "version": "1.1.0",
+    "version": "2.0.0",
     "description": "Common package for all types, resources and tools of Diamar Cloud",
-    "main": "index.js",
+    "type": "module",
+    "main": "./dist/node-entry.cjs",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "scripts": {
+        "build": "tsup app/index.ts app/node-entry.cjs --format esm,cjs --dts --out-dir dist",
         "test": "cross-env NODE_ENV=internal_test mocha --recursive --exit app/test/*",
         "coverage": "nyc --include 'app/**/*controller.js' mocha",
         "lint": "eslint app/*",
         "lint:fix": "eslint --fix app/*",
         "playground": "node playground.js"
     },
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "require": "./dist/node-entry.cjs"
+        }
+    },
     "author": "Jose Luis Silvestre García",
     "license": "ISC",
     "dependencies": {
@@ -20,6 +30,7 @@
     },
     "devDependencies": {
         "@eslint/js": "^9.32.0",
+        "@types/node": "^24.10.1",
         "chai": "^5.2.1",
         "eslint": "^9.32.0",
         "eslint-plugin-n": "^17.21.0",
@@ -28,6 +39,8 @@
         "nyc": "^17.1.0",
         "proxyquire": "^2.1.3",
         "sinon": "^21.0.0",
-        "supertest": "^7.1.4"
+        "supertest": "^7.1.4",
+        "tsup": "^8.5.0",
+        "typescript": "^5.9.3"
     }
 }

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowJs": true,
+    "checkJs": false,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "app",
+    "strict": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "app/**/*"
+  ]
+}

package/tsconfig.node.json

@@ -0,0 +1,12 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "module": "CommonJS",
+        "outDir": "./dist",
+        "declaration": false
+    },
+    "include": [
+        "app/node-entry.ts",
+        "app/models/**/*.js"
+    ]
+}

package/app/models/Channel.js

@@ -1,73 +0,0 @@
-const mongoose = require("mongoose");
-const mongooseAutopopulate = require("mongoose-autopopulate");
-const mongoosePaginate = require("mongoose-paginate-v2");
-const mongooseAggregatePaginate = require("mongoose-aggregate-paginate-v2");
-
-const channelSchema = new mongoose.Schema({
-    channel_tag: {
-        type: String,
-        required: true,
-    },
-    channel_description: {
-        type: String,
-        required: true,
-    },
-    channel_unit_id: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Unit",
-        required: true,
-        autopopulate: true,
-    },
-    channel_parsed : {
-        type: Object,
-        required: true,
-    },
-    channel_last_bucket_sync: {
-        type: Date,
-        required: false,
-    },
-}, {
-    timestamps: {
-        createdAt: true,
-        updatedAt: true
-    },
-    collection: "channels",
-    toJSON: {
-        transform: function (doc, ret) 
-        {
-            ret.id = ret._id;
-            ret.channel_unit = ret.channel_unit_id;
-            ret.channel_unit_id = ret.channel_unit_id.unit_id;
-            delete ret._id;
-            delete ret.__v;
-        },
-    },
-});
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     INDEXES     /////////////////
- * ///////////////////////////////////////////////
- */
-
-/**
- * Index used primarily for filtering by channel_tag
- */
-channelSchema.index({ "channel_tag" : 1 }, { unique: true });
-
-/**
- * Index used primarily for filtering by channel_description
- */
-channelSchema.index({ "channel_description" : 1 });
-
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     PLUGINS     /////////////////
- * ///////////////////////////////////////////////
- */
-channelSchema.plugin(mongoosePaginate);
-channelSchema.plugin(mongooseAggregatePaginate);
-channelSchema.plugin(mongooseAutopopulate);
-
-module.exports = channelSchema;

package/app/models/ChannelDataBucket.js

@@ -1,321 +0,0 @@
-const mongoose = require("mongoose");
-const mongooseAutopopulate = require("mongoose-autopopulate");
-const mongoosePaginate = require("mongoose-paginate-v2");
-const mongooseAggregatePaginate = require("mongoose-aggregate-paginate-v2");
-
-const dataPointSchema = new mongoose.Schema({
-    timestamp: {
-        type: Number,
-        required: true,
-    },
-    value: {
-        type: Number,
-        required: true,
-    }
-}, {
-    _id: false,
-});
-
-const channeldataBucketSchema = new mongoose.Schema({
-    start_date: {
-        type: Date,
-        required: true,
-        default: Date.now,
-    },
-    end_date: {
-        type: Date,
-        required: true,
-        default: function() 
-        {
-            return new Date(Date.now() + 1000 * 60 * 60); // 1 hour from now
-        }
-    },
-    data : {
-        type: [dataPointSchema],
-        required: true,
-        default: [],
-    },
-    size : {
-        type: Number,
-        required: true,
-        default: 0,
-    },
-    synced : {
-        type: Number,
-        required: true,
-        default: 0,
-    },
-    sum : {
-        type: Number,
-        required: true,
-        default: 0,
-    },
-}, {
-    toJSON: {
-        transform: function (doc, ret) 
-        {
-            ret.id = ret._id;
-            delete ret._id;
-            delete ret.__v;
-            ret.start_date = ret.start_date.getTime();
-            ret.end_date = ret.end_date.getTime();
-            ret.avg = ret.sum / ret.size;
-        },
-    },
-    versionKey: false,
-});
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     INDEXES     /////////////////
- * ///////////////////////////////////////////////
- */
-
-/**
- * Index the start_date and end_date fields for faster queries.
- * The compound index will be used to query the buckets by date range.
- */
-channeldataBucketSchema.index({ start_date: 1, end_date: 1 });
-
-/**
- * Index used to delete old buckets automatically.
- * This function will need to be called to create the TTL index.
- * The index will expire documents after the specified time in seconds.
- * The default is set to one year, but it can be changed by passing the expirationTimeInSeconds parameter.
- */
-const oneYear = 60 * 60 * 24 * 365; // One year in seconds
-channeldataBucketSchema.addTTLIndex = function(ttlField, expirationTimeInSeconds = oneYear)
-{
-    this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
-}
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     PLUGINS     /////////////////
- * ///////////////////////////////////////////////
- */
-channeldataBucketSchema.plugin(mongoosePaginate);
-channeldataBucketSchema.plugin(mongooseAggregatePaginate);
-channeldataBucketSchema.plugin(mongooseAutopopulate);
-
-
-/**
- * ///////////////////////////////////////////////
- * ////////////     FUNCTIONS     ////////////////
- * ///////////////////////////////////////////////
- */
-/**
- * Insert a data point into a specific bucket.
- * 
- * The data point will be inserted into the bucket and the size and sum will be updated.
- * @param {Number} timestamp The timestamp of the data point
- * @param {Number} value The value of the data point
- */
-channeldataBucketSchema.methods.insertDataPoint = async function(timestamp, value)
-{
-    this.data.push({ timestamp: timestamp, value: value });
-    this.size++;
-    this.sum += value;
-    await this.save();
-};
-
-/**
- * Remove data points outside the specified date range within the bucket.
- * 
- * IT WILL NOT SAVE THE BUCKET, YOU NEED TO CALL save() AFTER THIS FUNCTION TO SAVE THE BUCKET
- * @param {Number | Date} start_date The start date of the date range
- * @param {Number | Date} end_date The end date of the date range
-*/
-channeldataBucketSchema.methods.removeDataPointsOutsideDateRange = function(start_date, end_date)
-{
-    start_date = start_date instanceof Date ? start_date.getTime() : start_date;
-    end_date = end_date instanceof Date ? end_date.getTime() : end_date;
-    
-    this.data = this.data.filter(data_point => data_point.timestamp >= start_date && data_point.timestamp < end_date);
-    this.size = this.data.length;
-    this.sum = this.data.reduce((sum, data_point) => sum + data_point.value, 0);
-};
-
-/**
- * Check if the bucket is closed, meaning that it is no longer accepting data points.
- * @param {Number} timestamp The timestamp to check if the bucket is closed
- * @returns {Boolean} True if the bucket is closed, false otherwise
- */
-channeldataBucketSchema.methods.isBucketClosed = function(timestamp = Date.now())
-{
-    return timestamp >= this.end_date.getTime();
-};
-
-/**
- * Insert a data point into the corresponding bucket.
- * 
- * If no bucket exists for the timestamp, it will be created.
- * If a bucket exists for the timestamp, the data point will be inserted into the bucket and the size and sum will be updated.
- * @param {Number} timestamp The timestamp of the data point 
- * @param {Number} value The value of the data point
- * @returns {Object} The bucket that the data point was inserted into
- */
-channeldataBucketSchema.statics.insertDataPoint = async function(timestamp, value)
-{
-    // Truncate the timestamp to the nearest hour
-    const date = new Date(timestamp);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    date.setMilliseconds(0);
-
-    // Upsert the data point
-    const bucket = await this.findOneAndUpdate(
-        { 
-            start_date: date 
-        }, 
-        { 
-            $push: 
-            { 
-                data: 
-                { 
-                    timestamp: timestamp, 
-                    value: value 
-                } 
-            }, 
-
-            $inc: 
-            { 
-                size: 1, 
-                sum: value 
-            }, 
-
-            $set: 
-            { 
-                end_date: new Date(date.getTime() + 1000 * 60 * 60),
-            } 
-        }, 
-        { 
-            upsert: true,
-            new: true
-        }
-    );
-
-    return bucket;
-};
-
-/**
- * Get the last time the data was synced
- * @param {Object} options The options to get the last time the data was synced
- * @param {String} options.channel_tag The channel tag to get the data from
- * @param {Object} options.db The database to get the channel document from 
- * @returns {Number} The last time the data was synced 
- */
-channeldataBucketSchema.statics.lastTimeSynced = async function(options)
-{
-    let last_sync = 0;
-    if(options?.channel_tag && options?.db)
-    {
-        // Get the last time the data was synced
-        const channel = await options.db.collection("channels").findOne({ 
-            channel_tag : options.channel_tag
-        });
-
-        last_sync = channel.channel_last_bucket_sync.getTime();
-    }
-    return last_sync;
-};
-
-/**
- * Get the data that has not been uploaded to the cloud yet
- * @param {Object} options The options to get the data
- * @param {Date | Number} options.last_sync The last time the data was synced, if not provided it will be fetched from the channel document 
- * @param {String} options.channel_tag The channel tag to get the data from, only used if last_sync is not provided
- * @param {Object} options.db The database to get the channel document from, only used if last_sync is not provided
- * @returns {Array} The data that has not been uploaded to the cloud yet
- */
-channeldataBucketSchema.statics.getNotUploadedData = async function(options)
-{
-    // Get the last time the data was synced
-    const last_sync = options?.last_sync ?? await this.lastTimeSynced(options);
-
-    // Get all the buckets that synced is lt size and end_date is gt last_sync
-    const buckets = await this.find({  
-        end_date: { 
-            $gt: new Date(last_sync) 
-        }
-    });
-
-    return buckets;
-};
-
-/**
- * Get the data in the specified date range
- * @param {Date | Number} start_date The start date of the date range
- * @param {Date | Number} end_date The end date of the date range
- * @param {Boolean} plain If true, the data will be returned as an array of data points, otherwise it will be returned as an array of buckets
- * @returns {Array} The data in the specified date range. It will be an array of data points if plain is true, otherwise it will be an array of buckets
- */
-channeldataBucketSchema.statics.getData = async function(start_date, end_date, plain = false)
-{
-    // Truncate the timestamp to the nearest hour
-    const date = new Date(start_date);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    date.setMilliseconds(0);
-
-    // Get the data in the specified date range
-    const data = await this.find({ 
-        start_date: { 
-            $gte: date, 
-            $lt: new Date(end_date) 
-        }
-    });
-
-    if(!data || data.length === 0)
-    {
-        return [];
-    }
-
-    // Remove the data inside the bucket that is not in the specified date range
-    data[0].removeDataPointsOutsideDateRange(start_date, end_date);
-
-    if(data.length > 1)
-    {
-        data[1].removeDataPointsOutsideDateRange(start_date, end_date);
-    }
-
-    return plain ? data.flatMap(bucket => {
-        return bucket.data.map(data_point => {
-            return {
-                timestamp: data_point.timestamp,
-                value: data_point.value
-            };
-        });
-    }) : data;
-};
-
-
-channeldataBucketSchema.statics.upsertBucket = async function(bucket)
-{
-    const date = new Date(bucket.start_date);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    date.setMilliseconds(0);
-
-    const result = await this.updateOne(
-        { 
-            start_date: date 
-        }, 
-        { 
-            $set: 
-            { 
-                data: bucket.data,
-                size: bucket.size,
-                sum: bucket.sum,
-                end_date: new Date(date.getTime() + 1000 * 60 * 60),
-            } 
-        }, 
-        { 
-            upsert: true 
-        }
-    );
-
-    return result;
-};
-
-module.exports = channeldataBucketSchema;

package/app/models/Event.js

@@ -1,90 +0,0 @@
-const mongoose = require("mongoose");
-const mongooseAutopopulate = require("mongoose-autopopulate");
-const mongoosePaginate = require("mongoose-paginate-v2");
-const mongooseAggregatePaginate = require("mongoose-aggregate-paginate-v2");
-const { EventCategories } = require("../types/event.types");
-
-const eventSchema = new mongoose.Schema({
-    event_message: {
-        type: String,
-        required: true
-    },
-    event_source: {
-        type: String,
-        required: true
-    },
-    event_user: {
-        type: String,
-        required: false
-    },
-    event_category: {
-        type: String,
-        required: true,
-        enum: Object.values(EventCategories)
-    },
-    event_type: {
-        type: String,
-        required: true
-    },
-    event_timestamp: {
-        type: Date,
-        default: Date.now,
-    },
-    event_data: {
-        type: Object
-    }
-}, {
-    timestamps: {
-        createdAt: true,
-        updatedAt: false
-    },
-    versionKey: false,
-    toJSON: {
-        transform: function (doc, ret) 
-        {
-            ret.id = ret._id;
-            delete ret._id;
-            delete ret.createdAt;
-            ret.event_timestamp = ret.event_timestamp.getTime();
-        }
-    }
-});
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     INDEXES     /////////////////
- * ///////////////////////////////////////////////
- */
-
-/**
- * Index used primarily for filtering by event_type 
- */
-eventSchema.index({ "event_type" : 1 });
-
-/**
- * Index used primarily for filtering by event_category 
- */
-eventSchema.index({ "event_category" : 1 });
-
-/**
- * Index used to delete old events automatically.
- * This function will need to be called to create the TTL index.
- * The index will expire documents after the specified time in seconds.
- * The default is set to one year, but it can be changed by passing the expirationTimeInSeconds parameter.
- */
-const oneYear = 60 * 60 * 24 * 365; // One year in seconds
-eventSchema.addTTLIndex = function(ttlField, expirationTimeInSeconds = oneYear)
-{
-    this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
-}
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     PLUGINS     /////////////////
- * ///////////////////////////////////////////////
- */
-eventSchema.plugin(mongoosePaginate);
-eventSchema.plugin(mongooseAggregatePaginate);
-eventSchema.plugin(mongooseAutopopulate);
-
-module.exports = eventSchema;

package/app/models/History.js

@@ -1,106 +0,0 @@
-const mongoose = require("mongoose");
-const mongooseAutopopulate = require("mongoose-autopopulate");
-const mongoosePaginate = require("mongoose-paginate-v2");
-const mongooseAggregatePaginate = require("mongoose-aggregate-paginate-v2");
-const { AlarmTypes, AlarmPriorities, CloudAlarmStates, DiamarAlarmStates } = require("../types/alarm.types");
-
-const historySchema = new mongoose.Schema({
-    channel_tag: {
-        type: String,
-        required: true,
-    },
-    alarm_timestamp: {
-        type: Date,
-        required: true,
-        default: Date.now,
-    },
-    alarm_priority: {
-        type: String,
-        required: true,
-        enum: Object.values(AlarmPriorities),
-    },
-    alarm_original_state: {
-        type: String,
-        required: true,
-        enum: Object.values(DiamarAlarmStates),
-    },
-    alarm_state: {
-        type: String,
-        required: true,
-        enum: Object.values(CloudAlarmStates),
-    },
-    alarm_type: {
-        type: String,
-        required: true,
-        enum: Object.values(AlarmTypes),
-    },
-    alarm_value: {
-        type: Number,
-        required: false,
-    },
-    alarm_message: {
-        type: String,
-        required: false,
-    },
-    alarm_data: {
-        type: Object,
-        required: false,
-    },
-}, {
-    timestamps: {
-        createdAt: false,
-        updatedAt: false
-    },
-    versionKey: false,
-    collection: "history",
-    toJSON: {
-        transform: function (doc, ret) 
-        {
-            ret.id = ret._id;
-            delete ret._id;
-            delete ret.__v;
-            ret.alarm_timestamp = new Date(ret.alarm_timestamp).getTime();
-            ret.alarm = {
-                alarm_priority: ret.alarm_priority,
-                alarm_state: ret.alarm_original_state ?? "Inactive",
-                alarm_type: ret.alarm_type,
-                alarm_value: ret.alarm_value === null ? "inf" : `${ret.alarm_value}`,
-                alarm_timestamp: new Date(ret.alarm_timestamp).getTime()
-            };
-        },
-    },
-});
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     INDEXES     /////////////////
- * ///////////////////////////////////////////////
- */
-
-/**
- * Index used primarily for filtering by channel_tag 
- */
-historySchema.index({ "channel_tag" : 1 });
-
-/**
- * Index used to delete old alarms automatically.
- * This function will need to be called to create the TTL index.
- * The index will expire documents after the specified time in seconds.
- * The default is set to one year, but it can be changed by passing the expirationTimeInSeconds parameter.
- */
-const oneYear = 60 * 60 * 24 * 365; // One year in seconds
-historySchema.addTTLIndex = function(ttlField, expirationTimeInSeconds = oneYear)
-{
-    this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
-}
-
-/**
- * ///////////////////////////////////////////////
- * /////////////     PLUGINS     /////////////////
- * ///////////////////////////////////////////////
- */
-historySchema.plugin(mongoosePaginate);
-historySchema.plugin(mongooseAggregatePaginate);
-historySchema.plugin(mongooseAutopopulate);
-
-module.exports = historySchema;