@justair/justair-library 4.7.21 → 4.7.22

package/src/models/tests/monitorRequests.test.js

@@ -1,46 +1,46 @@
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import MonitorRequests from '../monitorRequests.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create monitor request and fetch it from the database', async () => {
-  const monitorRequestData = {
-    monitorOwnerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorOwnerOrg
-    monitorOwnerOrgName: 'Organization A',
-    monitorSharerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorSharerOrg
-    monitorSharerOrgName: 'Organization B',
-    monitorList: [
-      mongoose.Types.ObjectId(), // Generate a new ObjectId for each monitor in the list
-      mongoose.Types.ObjectId(),
-    ],
-    status: 'Requested',
-  };
-
-  // Create a new monitor request document
-  const createdMonitorRequest = await MonitorRequests.create(monitorRequestData);
-
-  // Fetch the monitor request from the database
-  const fetchedMonitorRequest = await MonitorRequests.findById(createdMonitorRequest._id);
-
-  expect(fetchedMonitorRequest).toMatchObject(monitorRequestData);
-});
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import MonitorRequests from '../monitorRequests.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create monitor request and fetch it from the database', async () => {
+  const monitorRequestData = {
+    monitorOwnerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorOwnerOrg
+    monitorOwnerOrgName: 'Organization A',
+    monitorSharerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorSharerOrg
+    monitorSharerOrgName: 'Organization B',
+    monitorList: [
+      mongoose.Types.ObjectId(), // Generate a new ObjectId for each monitor in the list
+      mongoose.Types.ObjectId(),
+    ],
+    status: 'Requested',
+  };
+
+  // Create a new monitor request document
+  const createdMonitorRequest = await MonitorRequests.create(monitorRequestData);
+
+  // Fetch the monitor request from the database
+  const fetchedMonitorRequest = await MonitorRequests.findById(createdMonitorRequest._id);
+
+  expect(fetchedMonitorRequest).toMatchObject(monitorRequestData);
+});

package/src/models/tests/monitors.test.js

@@ -1,62 +1,62 @@
-import { Decimal128 } from 'bson';
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import Monitors from '../monitors.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create monitor and fetch it from the database', async () => {
-  const monitorData = {
-    monitorCode: 'ABC123',
-    monitorSupplier: 'clarity',
-    monitorIdFromSupplier: '123456',
-    measurementUpdate: new Date(),
-    monitorProperties: {
-      property1: 'value1',
-      property2: 'value2',
-    },
-    isPrivate: false,
-    monitorState: 'Collocation',
-    sponsor: mongoose.Types.ObjectId(), // Generate a new ObjectId for sponsor
-    sponsorName: 'Organization A',
-    monitorLatitude: 37.7749,
-    monitorLongitude: -122.4194,
-    location: {
-      city: 'San Francisco',
-      country: 'United States',
-    },
-    context: ['School'],
-    colocationDate: new Date(),
-    parameters: ['NO2', 'PM2.5', 'Temperature'],
-    latestPM2_5: Decimal128.fromString('10.5'), // Use Decimal128 for decimal values
-    latestAQI_PM2_5: 75,
-    isActive: true,
-  };
-
-  // Create a new monitor document
-  const createdMonitor = await Monitors.create(monitorData);
-
-  // Fetch the monitor from the database
-  const fetchedMonitor = await Monitors.findById(createdMonitor._id);
-
-  expect(fetchedMonitor).toMatchObject(monitorData);
-});
+import { Decimal128 } from 'bson';
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Monitors from '../monitors.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create monitor and fetch it from the database', async () => {
+  const monitorData = {
+    monitorCode: 'ABC123',
+    monitorSupplier: 'clarity',
+    monitorIdFromSupplier: '123456',
+    measurementUpdate: new Date(),
+    monitorProperties: {
+      property1: 'value1',
+      property2: 'value2',
+    },
+    isPrivate: false,
+    monitorState: 'Collocation',
+    sponsor: mongoose.Types.ObjectId(), // Generate a new ObjectId for sponsor
+    sponsorName: 'Organization A',
+    monitorLatitude: 37.7749,
+    monitorLongitude: -122.4194,
+    location: {
+      city: 'San Francisco',
+      country: 'United States',
+    },
+    context: ['School'],
+    colocationDate: new Date(),
+    parameters: ['NO2', 'PM2.5', 'Temperature'],
+    latestPM2_5: Decimal128.fromString('10.5'), // Use Decimal128 for decimal values
+    latestAQI_PM2_5: 75,
+    isActive: true,
+  };
+
+  // Create a new monitor document
+  const createdMonitor = await Monitors.create(monitorData);
+
+  // Fetch the monitor from the database
+  const fetchedMonitor = await Monitors.findById(createdMonitor._id);
+
+  expect(fetchedMonitor).toMatchObject(monitorData);
+});

package/src/models/tests/organizations.test.js

@@ -1,51 +1,51 @@
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import Organizations from '../organizations.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create organization and fetch it from the database', async () => {
-  const organizationData = {
-    name: 'Acme Corp',
-    website: 'https://www.example.com',
-    location: {
-      city: 'San Francisco',
-      country: 'United States',
-    },
-    authorized: false,
-    orgAPIKey: [{ key: 'ABC123' }],
-    orgCode: 'ACME123',
-    orgDescription: 'A sample organization',
-    orgLogo: 'https://www.example.com/logo.png',
-    connectedMonitors: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each connected monitor
-    communityMessages: [{ message: 'Welcome to our community!' }],
-    isActive: true,
-  };
-
-  // Create a new organization document
-  const createdOrganization = await Organizations.create(organizationData);
-
-  // Fetch the organization from the database
-  const fetchedOrganization = await Organizations.findById(createdOrganization._id);
-
-  expect(fetchedOrganization).toMatchObject(organizationData);
-});
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Organizations from '../organizations.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create organization and fetch it from the database', async () => {
+  const organizationData = {
+    name: 'Acme Corp',
+    website: 'https://www.example.com',
+    location: {
+      city: 'San Francisco',
+      country: 'United States',
+    },
+    authorized: false,
+    orgAPIKey: [{ key: 'ABC123' }],
+    orgCode: 'ACME123',
+    orgDescription: 'A sample organization',
+    orgLogo: 'https://www.example.com/logo.png',
+    connectedMonitors: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each connected monitor
+    communityMessages: [{ message: 'Welcome to our community!' }],
+    isActive: true,
+  };
+
+  // Create a new organization document
+  const createdOrganization = await Organizations.create(organizationData);
+
+  // Fetch the organization from the database
+  const fetchedOrganization = await Organizations.findById(createdOrganization._id);
+
+  expect(fetchedOrganization).toMatchObject(organizationData);
+});

package/src/models/tests/users.test.js

@@ -1,54 +1,54 @@
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import Users from '../users.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create user and fetch it from the database', async () => {
-  const userData = {
-    name: 'John Doe',
-    phone: '1234567890',
-    email: 'john.doe@example.com',
-    zipCode: '12345',
-    location: {
-      city: 'San Francisco',
-      country: 'United States',
-    },
-    organizations: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each organization
-    alertPhone: '9876543210',
-    alertCount: 0,
-    subscribedMonitors: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each subscribed monitor
-    currentAlertMode: 'Good',
-    latestAlerts: [{ message: 'Alert 1' }],
-    optInPhone: true,
-    optInEmail: true,
-    isActive: true,
-  };
-
-  // Create a new user document
-  const createdUser = await Users.create(userData);
-
-  // Fetch the user from the database
-  const fetchedUser = await Users.findById(createdUser._id);
-
-  expect(fetchedUser).toMatchObject(userData);
-});
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Users from '../users.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create user and fetch it from the database', async () => {
+  const userData = {
+    name: 'John Doe',
+    phone: '1234567890',
+    email: 'john.doe@example.com',
+    zipCode: '12345',
+    location: {
+      city: 'San Francisco',
+      country: 'United States',
+    },
+    organizations: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each organization
+    alertPhone: '9876543210',
+    alertCount: 0,
+    subscribedMonitors: [mongoose.Types.ObjectId()], // Generate a new ObjectId for each subscribed monitor
+    currentAlertMode: 'Good',
+    latestAlerts: [{ message: 'Alert 1' }],
+    optInPhone: true,
+    optInEmail: true,
+    isActive: true,
+  };
+
+  // Create a new user document
+  const createdUser = await Users.create(userData);
+
+  // Fetch the user from the database
+  const fetchedUser = await Users.findById(createdUser._id);
+
+  expect(fetchedUser).toMatchObject(userData);
+});

package/src/models/usageMetrics.js

@@ -1,28 +1,28 @@
-import mongoose, { Schema } from "mongoose";
-
-const requestSchema = new Schema(
-  {
-    endpoint: String,
-    count: Number,
-  },
-  { timestamps: true }
-);
-
-const usageMetricsSchema = mongoose.Schema(
-  {
-    apiKeyId: { type: mongoose.Schema.Types.ObjectId, ref: "ApiKey" },
-    endpoint: String,
-    response: {
-      sizeInMB: Number,
-      sizeInKB: Number, 
-    }
-    
-  },
-  { timestamps: true }
-);
-
-const UsageMetrics = mongoose.model("UsageMetrics", usageMetricsSchema);
-
-export { usageMetricsSchema, UsageMetrics };
-
-
+import mongoose, { Schema } from "mongoose";
+
+const requestSchema = new Schema(
+  {
+    endpoint: String,
+    count: Number,
+  },
+  { timestamps: true }
+);
+
+const usageMetricsSchema = mongoose.Schema(
+  {
+    apiKeyId: { type: mongoose.Schema.Types.ObjectId, ref: "ApiKey" },
+    endpoint: String,
+    response: {
+      sizeInMB: Number,
+      sizeInKB: Number, 
+    }
+    
+  },
+  { timestamps: true }
+);
+
+const UsageMetrics = mongoose.model("UsageMetrics", usageMetricsSchema);
+
+export { usageMetricsSchema, UsageMetrics };
+
+

package/src/models/users.js

@@ -1,55 +1,55 @@
-import mongoose from "mongoose";
-
-const usersSchema = mongoose.Schema(
-  {
-    name: String,
-    phone: String,
-    email: String,
-    zipCode: String,
-    location: [Object],
-    organizations: [{ type: mongoose.Types.ObjectId, ref: "Organizations" }],
-    alertPhone: String,
-    alertCount: { type: Number, default: 0 },
-    subscribedMonitors: [{ type: mongoose.Types.ObjectId, ref: "Monitors" }],
-    currentAlertMode: {
-      type: String,
-      enum: [
-        "Good",
-        "Unhealthy",
-        "Moderate",
-        "Unhealthy for SG",
-        "Very Unhealthy",
-        "Hazardous",
-      ],
-      default: "Good",
-    },
-    latestAlerts: [Object],
-    optInPhone: { type: Boolean, default: true },
-    optInEmail: { type: Boolean, default: false },
-    isActive: { type: Boolean, default: true },
-    hasOnboarded: { type: Boolean, default: false },
-    isSharingLocation: { type: Boolean, default: false },
-    toolTips: Object,
-    alertPreferenceLevel: {
-      type: String,
-      enum: [
-        "Good",
-        "Moderate",
-        "Unhealthy for SG",
-        "Unhealthy",
-        "Very Unhealthy",
-        "Hazardous",
-      ],
-      default: "Good",
-    },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-usersSchema.index({ phone: 1 });
-
-const Users = mongoose.model("Users", usersSchema);
-
-export { usersSchema, Users };
+import mongoose from "mongoose";
+
+const usersSchema = mongoose.Schema(
+  {
+    name: String,
+    phone: String,
+    email: String,
+    zipCode: String,
+    location: [Object],
+    organizations: [{ type: mongoose.Types.ObjectId, ref: "Organizations" }],
+    alertPhone: String,
+    alertCount: { type: Number, default: 0 },
+    subscribedMonitors: [{ type: mongoose.Types.ObjectId, ref: "Monitors" }],
+    currentAlertMode: {
+      type: String,
+      enum: [
+        "Good",
+        "Unhealthy",
+        "Moderate",
+        "Unhealthy for SG",
+        "Very Unhealthy",
+        "Hazardous",
+      ],
+      default: "Good",
+    },
+    latestAlerts: [Object],
+    optInPhone: { type: Boolean, default: true },
+    optInEmail: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    hasOnboarded: { type: Boolean, default: false },
+    isSharingLocation: { type: Boolean, default: false },
+    toolTips: Object,
+    alertPreferenceLevel: {
+      type: String,
+      enum: [
+        "Good",
+        "Moderate",
+        "Unhealthy for SG",
+        "Unhealthy",
+        "Very Unhealthy",
+        "Hazardous",
+      ],
+      default: "Good",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+usersSchema.index({ phone: 1 });
+
+const Users = mongoose.model("Users", usersSchema);
+
+export { usersSchema, Users };

package/tsconfig.json

@@ -1,11 +1,11 @@
-{
-    "include": ["src/**/*"],
-    "compilerOptions": {
-      "allowJs": true,
-      // Generate d.ts files
-      "declaration": true,
-      "emitDeclarationOnly": true,
-      "outDir": "dist",
-      "declarationMap": true
-    }
+{
+    "include": ["src/**/*"],
+    "compilerOptions": {
+      "allowJs": true,
+      // Generate d.ts files
+      "declaration": true,
+      "emitDeclarationOnly": true,
+      "outDir": "dist",
+      "declarationMap": true
+    }
 }