@justair/justair-library 6.14.0 → 7.0.0

package/dist/models/userNotifications.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userNotifications.d.ts","sourceRoot":"","sources":["../../src/models/userNotifications.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuBE;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAwE;AAgBxE,6EAGE;AAOF,kFAGE;AAQF,iFAGE;AAGF,4EAGE;qBA1GmB,UAAU"}
+{"version":3,"file":"userNotifications.d.ts","sourceRoot":"","sources":["../../src/models/userNotifications.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuBE;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwE;AAgBxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGE;AAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGE;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGE;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAGE;qBA1GmB,UAAU"}

package/dist/models/users.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../src/models/users.js"],"names":[],"mappings":"AA2CA,8BAiFE;AA+BF,wBAAmD;AAnJnD,iDAA4D;AAC5D,6CAAmD;AAUnD,4DAsBC"}
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../src/models/users.js"],"names":[],"mappings":"AA2CA,8BAiFE;AA8BF,wBAAmD;AAlJnD,iDAA4D;AAC5D,6CAAmD;AAUnD,4DAsBC"}

package/dist/modules/audit/schema.d.ts

@@ -8,314 +8,241 @@
  *   action (what)  ├─► AuditLog doc ──► compliance queries (by actor / action / target)
  *   resource (tgt) ┘
  */
-export const auditLogSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+export const auditLogSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
     timestamps: true;
 }, {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}>> & mongoose.FlatRecord<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, Omit<mongoose.DefaultSchemaOptions, "timestamps"> & {
+    timestamps: true;
+}> & Omit<{
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}> & {
+} & mongoose.DefaultTimestampProps & {
     _id: mongoose.Types.ObjectId;
-}>;
-export const AuditLog: mongoose.Model<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
 } & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, unknown, {
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}, {}, {}, {}, mongoose.Document<unknown, {}, {
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export const AuditLog: mongoose.Model<{
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}> & {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+} & mongoose.DefaultTimestampProps, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, {
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-} & {
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, {
+    timestamps: true;
+}> & Omit<{
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: mongoose.Types.ObjectId;
+        email?: string;
+        orgId?: mongoose.Types.ObjectId;
+    };
+    resource?: {
+        id?: any;
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+} & mongoose.DefaultTimestampProps & {
     _id: mongoose.Types.ObjectId;
-}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+} & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
     timestamps: true;
 }, {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: mongoose.Types.ObjectId;
+        email?: string;
+        orgId?: mongoose.Types.ObjectId;
+    };
+    resource?: {
+        id?: any;
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, Omit<mongoose.DefaultSchemaOptions, "timestamps"> & {
+    timestamps: true;
+}> & Omit<{
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: mongoose.Types.ObjectId;
+        email?: string;
+        orgId?: mongoose.Types.ObjectId;
+    };
+    resource?: {
+        id?: any;
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
 } & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, unknown, {
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}>> & mongoose.FlatRecord<{
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>, {
     action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
     outcome: "success" | "failure";
     metadata?: any;
     actor?: {
-        adminId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        adminId?: mongoose.Types.ObjectId;
         email?: string;
-        orgId?: {
-            prototype?: mongoose.Types.ObjectId;
-            cacheHexString?: unknown;
-            generate?: {};
-            createFromTime?: {};
-            createFromHexString?: {};
-            createFromBase64?: {};
-            isValid?: {};
-        };
+        orgId?: mongoose.Types.ObjectId;
     };
     resource?: {
+        id?: any;
         type?: string;
     };
     reason?: string;
     requestId?: string;
-}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     _id: mongoose.Types.ObjectId;
-}>>;
+} & {
+    __v: number;
+}>;
 import mongoose from 'mongoose';
 //# sourceMappingURL=schema.d.ts.map

package/dist/modules/audit/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/audit/schema.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqBE;AAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA4D;qBAzCvC,UAAU"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/audit/schema.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqBE;AAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA4D;qBAzCvC,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "6.14.0",
+  "version": "7.0.0",
   "description": "JustAir Internal Library",
   "main": "src/index.js",
   "type": "module",
@@ -33,12 +33,17 @@
   ],
   "author": "Britney Epps",
   "license": "ISC",
+  "engines": {
+    "node": ">=20.19.0"
+  },
   "dependencies": {
     "jose": "^5.10.0",
-    "mongoose": "^7.8.3",
     "nanoid": "^5.1.6",
     "winston": "^3.10.0"
   },
+  "peerDependencies": {
+    "mongoose": "^9.0.0"
+  },
   "jest": {
     "testEnvironment": "node",
     "transform": {},
@@ -49,6 +54,7 @@
     "@types/node": "^16.0.0",
     "jest": "^29",
     "mongodb-memory-server": "^11.2.0",
+    "mongoose": "^9.0.0",
     "jest-environment-node": "^29",
     "ts-node": "^10.0.0",
     "typescript": "^5.3.2"

package/src/config/db.js

@@ -3,11 +3,15 @@ import mongoose from "mongoose";
 class Database {
   static instances = new Map(); // Store multiple instances by connection key
 
-  constructor({ CONNECTION_URL, database }) {
+  constructor({ CONNECTION_URL, database, options = {} }) {
     this.CONNECTION_URL = CONNECTION_URL;
     this.database = database;
     this.connectionKey = `${CONNECTION_URL}:${database}`;
     this.isConnected = false;
+    // Per-instance mongoose connect options, merged over the defaults in
+    // connect(). Lets local/test targets disable TLS and JA-1781 pass
+    // Queryable Encryption options without another interface change.
+    this.options = options;
   }
 
   async connect() {
@@ -40,6 +44,7 @@ class Database {
         authSource: "admin",
         ssl: true,
         dbName: this.database,
+        ...this.options,
       });
 
       this.isConnected = true;

package/src/config/tests/db.test.js

@@ -0,0 +1,46 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Database from '../db.js';
+
+let mongoServer;
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+});
+
+afterAll(async () => {
+  if (mongoose.connection.readyState === 1) {
+    await mongoose.disconnect();
+  }
+  await mongoServer.stop();
+});
+
+// JA-878: Database is the platform-wide connection choke point. These smoke
+// tests pin connect/disconnect behavior under the mongoose 9 / driver 7 pair.
+test('connects and disconnects cleanly', async () => {
+  const db = new Database({
+    CONNECTION_URL: mongoServer.getUri(),
+    database: 'ja878-smoke',
+    options: { ssl: false, authSource: undefined },
+  });
+
+  await db.connect();
+  expect(db.isConnected).toBe(true);
+  expect(mongoose.connection.readyState).toBe(1);
+  expect(Database.getCurrentDatabase()).toBe('ja878-smoke');
+
+  await db.disconnect();
+  expect(db.isConnected).toBe(false);
+  expect(mongoose.connection.readyState).toBe(0);
+});
+
+test('bad URI rejects with a clear error instead of hanging', async () => {
+  const db = new Database({
+    CONNECTION_URL: 'mongodb://127.0.0.1:1/unreachable',
+    database: 'nope',
+    options: { ssl: false, authSource: undefined, serverSelectionTimeoutMS: 2000, connectTimeoutMS: 2000 },
+  });
+
+  await expect(db.connect()).rejects.toThrow();
+  expect(db.isConnected).toBe(false);
+});

package/src/models/organizations.js

@@ -162,12 +162,10 @@ organizationsSchema.methods.setRateLimitProperties = function () {
   });
 };
 
-organizationsSchema.pre("save", function (next) {
+organizationsSchema.pre("save", function () {
   if (this.isModified("orgAPIKey")) {
     this.setRateLimitProperties();
   }
-
-  next();
 });
 
 // Name-based sorting index