@friggframework/core 2.0.0-next.70 → 2.0.0-next.72

package/assertions/index.js

@@ -6,10 +6,7 @@ const {
     getArrayParamAndVerifyParamType,
     getAndVerifyType,
 } = require('./get');
-const { expectShallowEqualDbObject } = require('./is-equal');
-
 module.exports = {
-    expectShallowEqualDbObject,
     get,
     getAll,
     verifyType,

package/core/create-handler.js

@@ -29,7 +29,7 @@ const createHandler = (optionByName = {}) => {
             // If enabled (i.e. if SECRET_ARN is set in process.env) Fetch secrets from AWS Secrets Manager, and set them as environment variables.
             await secretsToEnv();
 
-            // Helps mongoose reuse the connection.  Lowers response times.
+            // Helps reuse the database connection.  Lowers response times.
             context.callbackWaitsForEmptyEventLoop = false;
 
             // Run the Lambda

package/database/index.js

@@ -1,65 +1,25 @@
-//todo: probably most of this file content can be removed
-
 /**
  * Database Module Index
- * Exports Mongoose models and connection utilities
+ * Exports Prisma client, connection utilities, and repositories
  *
  * Note: Frigg uses the Repository pattern for data access.
- * Models are not meant to be used directly - use repositories instead:
+ * Use repositories for data operations:
  * - SyncRepository (syncs/sync-repository.js)
  * - IntegrationRepository (integrations/integration-repository.js)
  * - CredentialRepository (credential/credential-repository.js)
  * etc.
  */
 
-// Lazy-load mongoose to avoid importing mongodb when using PostgreSQL only
-let _mongoose = null;
-let _IndividualUser = null;
-let _OrganizationUser = null;
-let _UserModel = null;
-let _WebsocketConnection = null;
-
-// Prisma exports (always available)
-const { prisma } = require('./prisma');
+const { prisma, connectPrisma, disconnectPrisma } = require('./prisma');
 const { TokenRepository } = require('../token/repositories/token-repository');
 const {
     WebsocketConnectionRepository,
 } = require('../websocket/repositories/websocket-connection-repository');
 
 module.exports = {
-    // Lazy-loaded mongoose exports (only load when accessed)
-    get mongoose() {
-        if (!_mongoose) {
-            _mongoose = require('./mongoose').mongoose;
-        }
-        return _mongoose;
-    },
-    get IndividualUser() {
-        if (!_IndividualUser) {
-            _IndividualUser = require('./models/IndividualUser').IndividualUser;
-        }
-        return _IndividualUser;
-    },
-    get OrganizationUser() {
-        if (!_OrganizationUser) {
-            _OrganizationUser = require('./models/OrganizationUser').OrganizationUser;
-        }
-        return _OrganizationUser;
-    },
-    get UserModel() {
-        if (!_UserModel) {
-            _UserModel = require('./models/UserModel').UserModel;
-        }
-        return _UserModel;
-    },
-    get WebsocketConnection() {
-        if (!_WebsocketConnection) {
-            _WebsocketConnection = require('./models/WebsocketConnection').WebsocketConnection;
-        }
-        return _WebsocketConnection;
-    },
-    // Prisma (always available)
     prisma,
+    connectPrisma,
+    disconnectPrisma,
     TokenRepository,
     WebsocketConnectionRepository,
 };

package/database/repositories/health-check-repository-documentdb.js

@@ -49,17 +49,21 @@ class HealthCheckRepositoryDocumentDB extends HealthCheckRepositoryInterface {
      */
     async pingDatabase(maxTimeMS = 2000) {
         const pingStart = Date.now();
+        let timeoutId;
 
-        const timeoutPromise = new Promise((_, reject) =>
-            setTimeout(() => reject(new Error('Database ping timeout')), maxTimeMS)
-        );
-
-        await Promise.race([
-            this.prisma.$runCommandRaw({ ping: 1 }),
-            timeoutPromise,
-        ]);
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => reject(new Error('Database ping timeout')), maxTimeMS);
+        });
 
-        return Date.now() - pingStart;
+        try {
+            await Promise.race([
+                this.prisma.$runCommandRaw({ ping: 1 }),
+                timeoutPromise,
+            ]);
+            return Date.now() - pingStart;
+        } finally {
+            clearTimeout(timeoutId);
+        }
     }
 
     async createCredential(credentialData) {

package/database/repositories/health-check-repository-mongodb.js

@@ -1,4 +1,3 @@
-const { mongoose } = require('../mongoose');
 const {
     HealthCheckRepositoryInterface,
 } = require('./health-check-repository-interface');
@@ -19,7 +18,7 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
     async getDatabaseConnectionState() {
         let isConnected = false;
         let stateName = 'unknown';
-        
+
         try {
             await this.prisma.$runCommandRaw({ ping: 1 });
             isConnected = true;
@@ -29,7 +28,6 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
         }
 
         return {
-            readyState: isConnected ? 1 : 0,
             readyState: isConnected ? 1 : 0,
             stateName,
             isConnected,
@@ -38,22 +36,21 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
 
     async pingDatabase(maxTimeMS = 2000) {
         const pingStart = Date.now();
-        
-        // Create a timeout promise that rejects after maxTimeMS
-        const timeoutPromise = new Promise((_, reject) => 
-            setTimeout(() => reject(new Error('Database ping timeout')), maxTimeMS)
-        );
-        
-        // Race between the database ping and the timeout
-        await Promise.race([
-            prisma.$queryRaw`SELECT 1`.catch(() => {
-                // For MongoDB, use runCommandRaw instead
-                return prisma.$runCommandRaw({ ping: 1 });
-            }),
-            timeoutPromise
-        ]);
+        let timeoutId;
+
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => reject(new Error('Database ping timeout')), maxTimeMS);
+        });
 
-        return Date.now() - pingStart;
+        try {
+            await Promise.race([
+                this.prisma.$runCommandRaw({ ping: 1 }),
+                timeoutPromise
+            ]);
+            return Date.now() - pingStart;
+        } finally {
+            clearTimeout(timeoutId);
+        }
     }
 
     async createCredential(credentialData) {
@@ -69,14 +66,17 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
     }
 
     /**
+     * Get raw credential from database bypassing Prisma encryption extension.
+     * Uses findRaw() to query MongoDB directly.
      * @param {string} id
      * @returns {Promise<Object|null>}
      */
     async getRawCredentialById(id) {
-        const { ObjectId } = require('mongodb');
-        return await mongoose.connection.db
-            .collection('Credential')
-            .findOne({ _id: new ObjectId(id) });
+        if (!id) return null;
+        const results = await this.prisma.credential.findRaw({
+            filter: { _id: { $oid: id } },
+        });
+        return results[0] || null;
     }
 
     async deleteCredential(id) {

package/database/utils/mongodb-collection-utils.js

@@ -5,11 +5,13 @@
  * handling the constraint that collections cannot be created inside
  * multi-document transactions.
  *
+ * Uses Prisma's $runCommandRaw to execute MongoDB admin commands.
+ *
  * @see https://github.com/prisma/prisma/issues/8305
  * @see https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations
  */
 
-const { mongoose } = require('../mongoose');
+const { prisma } = require('../prisma');
 
 /**
  * Ensures a MongoDB collection exists
@@ -30,20 +32,19 @@ const { mongoose } = require('../mongoose');
  */
 async function ensureCollectionExists(collectionName) {
     try {
-        const collections = await mongoose.connection.db
-            .listCollections({ name: collectionName })
-            .toArray();
+        const result = await prisma.$runCommandRaw({
+            listCollections: 1,
+            filter: { name: collectionName },
+        });
+
+        const collections = result.cursor?.firstBatch || [];
 
         if (collections.length === 0) {
-            // Collection doesn't exist, create it outside of any transaction
-            await mongoose.connection.db.createCollection(collectionName);
+            await prisma.$runCommandRaw({ create: collectionName });
             console.log(`Created MongoDB collection: ${collectionName}`);
         }
     } catch (error) {
-        // Collection might already exist due to race condition, or other error
-        // Log warning but don't fail - let subsequent operations handle errors
         if (error.codeName === 'NamespaceExists') {
-            // This is expected in race conditions, silently continue
             return;
         }
         console.warn(`Error ensuring collection ${collectionName} exists:`, error.message);
@@ -73,10 +74,12 @@ async function ensureCollectionsExist(collectionNames) {
  */
 async function collectionExists(collectionName) {
     try {
-        const collections = await mongoose.connection.db
-            .listCollections({ name: collectionName })
-            .toArray();
+        const result = await prisma.$runCommandRaw({
+            listCollections: 1,
+            filter: { name: collectionName },
+        });
 
+        const collections = result.cursor?.firstBatch || [];
         return collections.length > 0;
     } catch (error) {
         console.error(`Error checking if collection ${collectionName} exists:`, error.message);

package/database/utils/mongodb-schema-init.js

@@ -16,7 +16,7 @@
  * @see https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations
  */
 
-const { mongoose } = require('../mongoose');
+const { prisma } = require('../prisma');
 const { ensureCollectionsExist } = require('./mongodb-collection-utils');
 const { getCollectionsFromSchemaSync } = require('./prisma-schema-parser');
 const config = require('../config');
@@ -53,8 +53,10 @@ async function initializeMongoDBSchema() {
         return;
     }
 
-    // Check if database is connected
-    if (mongoose.connection.readyState !== 1) {
+    // Verify database connectivity via Prisma ping
+    try {
+        await prisma.$runCommandRaw({ ping: 1 });
+    } catch (error) {
         throw new Error(
             'Cannot initialize MongoDB schema - database not connected. ' +
             'Call connectPrisma() before initializeMongoDBSchema()'

package/handlers/app-handler-helpers.js

@@ -32,6 +32,7 @@ const createApp = (applyMiddleware) => {
             flushDebugLog(boomError);
             res.status(statusCode).json({ error: 'Internal Server Error' });
         } else {
+            console.warn(`[Frigg] ${req.method} ${req.path} -> ${statusCode}: ${err.message}`);
             res.status(statusCode).json({ error: err.message });
         }
     });

package/index.js

@@ -1,5 +1,4 @@
 const {
-    expectShallowEqualDbObject,
     get,
     getAll,
     verifyType,
@@ -14,17 +13,9 @@ const {
     createHandler,
 } = require('./core/index');
 const {
-    mongoose,
-    connectToDatabase,
-    disconnectFromDatabase,
-    createObjectId,
-    IndividualUser,
-    OrganizationUser,
-    State,
-    Token,
-    UserModel,
-    WebsocketConnection,
     prisma,
+    connectPrisma,
+    disconnectPrisma,
     TokenRepository,
     WebsocketConnectionRepository,
 } = require('./database/index');
@@ -95,13 +86,10 @@ const {
 const application = require('./application');
 const utils = require('./utils');
 
-// const {Sync } = require('./syncs/model');
-
 const { QueuerUtil } = require('./queues');
 
 module.exports = {
     // assertions
-    expectShallowEqualDbObject,
     get,
     getAll,
     verifyType,
@@ -116,17 +104,9 @@ module.exports = {
     createHandler,
 
     // database
-    mongoose,
-    connectToDatabase,
-    disconnectFromDatabase,
-    createObjectId,
-    IndividualUser,
-    OrganizationUser,
-    State,
-    Token,
-    UserModel,
-    WebsocketConnection,
     prisma,
+    connectPrisma,
+    disconnectPrisma,
     TokenRepository,
     WebsocketConnectionRepository,
     createUserRepository,

package/modules/index.js

@@ -1,4 +1,3 @@
-const { Entity } = require('./entity');
 const { ApiKeyRequester } = require('./requester/api-key');
 const { BasicAuthRequester } = require('./requester/basic');
 const { OAuth2Requester } = require('./requester/oauth-2');
@@ -7,7 +6,6 @@ const { ModuleConstants } = require('./ModuleConstants');
 const { ModuleFactory } = require('./module-factory');
 
 module.exports = {
-    Entity,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,

package/modules/module.js

@@ -42,7 +42,9 @@ class Module extends Delegate {
         const apiParams = {
             ...this.definition.env,
             delegate: this,
-            ...(this.credential?.data ? this.apiParamsFromCredential(this.credential.data) : {}), // Handle case when credential is undefined
+            ...(this.credential?.data
+                ? this.apiParamsFromCredential(this.credential.data)
+                : {}), // Handle case when credential is undefined
             ...this.apiParamsFromEntity(this.entity),
         };
         this.api = new this.apiClass(apiParams);
@@ -100,10 +102,15 @@ class Module extends Delegate {
             this.api,
             this.userId
         );
-        Object.assign(
-            credentialDetails.details,
-            this.apiParamsFromCredential(this.api)
-        );
+        const apiParams = this.apiParamsFromCredential(this.api);
+
+        if (!apiParams.refresh_token && this.api.isRefreshable) {
+            console.warn(
+                `[Frigg] No refresh_token in apiParams for module ${this.name}.`
+            );
+        }
+
+        Object.assign(credentialDetails.details, apiParams);
         credentialDetails.details.authIsValid = true;
 
         const persisted = await this.credentialRepository.upsertCredential(

package/modules/requester/oauth-2.js

@@ -30,7 +30,6 @@ const { ModuleConstants } = require('../ModuleConstants');
  * await api.getTokenFromClientCredentials();
  */
 class OAuth2Requester extends Requester {
-
     static requesterType = ModuleConstants.authType.oauth2;
 
     /**
@@ -118,6 +117,16 @@ class OAuth2Requester extends Requester {
         const newRefreshToken = get(params, 'refresh_token', null);
         if (newRefreshToken !== null) {
             this.refresh_token = newRefreshToken;
+        } else {
+            if (this.refresh_token) {
+                console.log(
+                    '[Frigg] No refresh_token in response, preserving existing'
+                );
+            } else {
+                console.log(
+                    '[Frigg] Current refresh_token is null and no new refresh_token in response'
+                );
+            }
         }
         const accessExpiresIn = get(params, 'expires_in', null);
         const refreshExpiresIn = get(
@@ -128,7 +137,9 @@ class OAuth2Requester extends Requester {
 
         this.accessTokenExpire = new Date(Date.now() + accessExpiresIn * 1000);
         if (refreshExpiresIn !== null) {
-            this.refreshTokenExpire = new Date(Date.now() + refreshExpiresIn * 1000);
+            this.refreshTokenExpire = new Date(
+                Date.now() + refreshExpiresIn * 1000
+            );
         }
 
         await this.notify(this.DLGT_TOKEN_UPDATE);
@@ -237,6 +248,7 @@ class OAuth2Requester extends Requester {
                 'Content-Type': 'application/x-www-form-urlencoded',
             },
         };
+        console.log('[Frigg] Refreshing access token with options');
         const response = await this._post(options, false);
         await this.setTokens(response);
         return response;
@@ -284,7 +296,7 @@ class OAuth2Requester extends Requester {
      */
     async refreshAuth() {
         try {
-            console.log('[OAuth2Requester.refreshAuth] Starting token refresh', {
+            console.log('[Frigg] Starting token refresh', {
                 grant_type: this.grant_type,
                 has_refresh_token: !!this.refresh_token,
                 has_client_id: !!this.client_id,
@@ -300,10 +312,10 @@ class OAuth2Requester extends Requester {
             } else {
                 await this.getTokenFromClientCredentials();
             }
-            console.log('[OAuth2Requester.refreshAuth] Token refresh succeeded');
+            console.log('[Frigg] Token refresh succeeded');
             return true;
         } catch (error) {
-            console.error('[OAuth2Requester.refreshAuth] Token refresh failed', {
+            console.error('[Frigg] Token refresh failed', {
                 error_message: error?.message,
                 error_name: error?.name,
                 response_status: error?.response?.status,

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0-next.70",
+    "version": "2.0.0-next.72",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
         "@aws-sdk/client-lambda": "^3.714.0",
+        "@aws-sdk/client-scheduler": "^3.1002.0",
         "@aws-sdk/client-sqs": "^3.588.0",
         "@hapi/boom": "^10.0.1",
         "bcryptjs": "^2.4.3",
@@ -20,7 +21,7 @@
         "fs-extra": "^11.2.0",
         "lodash": "4.17.21",
         "lodash.get": "^4.4.2",
-        "mongoose": "6.11.6",
+        "mongodb": "^4.17.0",
         "node-fetch": "^2.6.7",
         "serverless-http": "^2.7.0",
         "uuid": "^9.0.1"
@@ -38,9 +39,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0-next.70",
-        "@friggframework/prettier-config": "2.0.0-next.70",
-        "@friggframework/test": "2.0.0-next.70",
+        "@friggframework/eslint-config": "2.0.0-next.72",
+        "@friggframework/prettier-config": "2.0.0-next.72",
+        "@friggframework/test": "2.0.0-next.72",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +81,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "dee1112300e01813e68b2598c3a722d1a31e1677"
+    "gitHead": "d655a19777f535775f2f67b5f17511eb438b300b"
 }

package/syncs/manager.js

@@ -1,6 +1,6 @@
 const _ = require('lodash');
 const moment = require('moment');
-const mongoose = require('mongoose');
+const { ObjectId } = require('mongodb');
 const SyncObject = require('./sync');
 const { debug } = require('packages/logs');
 const { get } = require('../assertions');
@@ -314,7 +314,7 @@ class SyncManager {
 
     async createSyncDBObject(objArr, entities) {
         const entityIds = entities.map(
-            (ent) => ({ $elemMatch: { $eq: mongoose.Types.ObjectId(ent) } })
+            (ent) => ({ $elemMatch: { $eq: new ObjectId(ent) } })
             // return {"$elemMatch": {"$eq": ent}};
         );
         const dataIdentifiers = [];

package/types/associations/index.d.ts

@@ -1,20 +1,3 @@
-declare module "@friggframework/associations/model" {
-  import { Model } from "mongoose";
-
-  export class Association extends Model {
-    integrationId: string;
-    name: string;
-    type: string;
-    primaryObject: string;
-    objects: {
-      entityId: string;
-      objectType: string;
-      objId: string;
-      metadata?: object;
-    }[];
-  }
-}
-
 declare module "@friggframework/associations/association" {
   export default class Association implements IFriggAssociation {
     data: any;

package/types/database/index.d.ts

@@ -1,3 +1,11 @@
-declare module "@friggframework/database/mongo" {
-  export function connectToDatabase(): Promise<void>;
+declare module "@friggframework/database" {
+  export const prisma: any;
+  export function connectPrisma(): Promise<any>;
+  export function disconnectPrisma(): Promise<void>;
+  export class TokenRepository {
+    constructor(params: { prismaClient: any });
+  }
+  export class WebsocketConnectionRepository {
+    constructor(params: { prismaClient: any });
+  }
 }

package/types/encrypt/index.d.ts

@@ -1,5 +1,7 @@
 declare module "@friggframework/encrypt" {
-  import { Schema } from "mongoose";
-
-  export function Encrypt(schema: Schema, options: any): void;
+  export class Cryptor {
+    constructor(params: { shouldUseAws?: boolean });
+    encrypt(plaintext: string): Promise<string>;
+    decrypt(ciphertext: string): Promise<string>;
+  }
 }

package/types/integrations/index.d.ts

@@ -1,8 +1,7 @@
 declare module "@friggframework/integrations" {
   import { Delegate, IFriggDelegate } from "@friggframework/core";
-  import { Model } from "mongoose";
 
-  export class Integration extends Model {
+  export interface Integration {
     entities: any[];
     userId: string;
     status: string; // IntegrationStatus

package/types/module-plugin/index.d.ts

@@ -1,20 +1,22 @@
 declare module "@friggframework/module-plugin" {
-  import { Model } from "mongoose";
   import { Delegate, IFriggDelegate } from "@friggframework/core";
 
-  export class Credential extends Model {
-    userId: string;
-    authIsValid: boolean;
-    externalId: string;
+  export interface Credential {
+    id?: string;
+    userId?: string;
+    authIsValid?: boolean;
+    externalId?: string;
+    data?: any;
   }
 
-  interface IFriggEntityManager { }
-
-  export class Entity extends Model {
-    credentialId: string;
-    userId: string;
-    name: string;
-    externalId: string;
+  export interface Entity {
+    id?: string;
+    credentialId?: string;
+    userId?: string;
+    name?: string;
+    moduleName?: string;
+    externalId?: string;
+    data?: any;
   }
 
   export type MappedEntity = Entity & { id: string; type: any };

package/types/syncs/index.d.ts

@@ -1,18 +1,3 @@
-declare module "@friggframework/syncs/model" {
-  import { Model } from "mongoose";
-
-  export class Sync extends Model {
-    entities: any[];
-    hash: string;
-    name: string;
-    dataIdentifiers: {
-      entity: any;
-      id: object;
-      hash: string;
-    }[];
-  }
-}
-
 declare module "@friggframework/syncs/manager" {
   import Sync from "@friggframework/syncs/sync";
 

package/assertions/is-equal.js

@@ -1,17 +0,0 @@
-const expectShallowEqualDbObject = (modelObject, compareObject) => {
-    for (const key in compareObject) {
-        let objVal = modelObject[key];
-
-        if (objVal instanceof Date) {
-            objVal = objVal.toISOString();
-        } else if (objVal instanceof mongoose.Types.ObjectId) {
-            objVal = objVal._id.toString();
-        }
-
-        expect(compareObject[key]).toBe(objVal);
-    }
-};
-
-// TODO not sure how much this is needed, but could rewrite with _.isEqualWith for deep equality with custom checks.
-
-module.exports = { expectShallowEqualDbObject };

package/associations/model.js

@@ -1,54 +0,0 @@
-const mongoose = require("mongoose");
-
-const schema = new mongoose.Schema({
-  integration: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Integration",
-    required: true,
-  },
-  name: { type: String, required: true },
-  type: {
-    type: String,
-    enum: ["ONE_TO_MANY", "ONE_TO_ONE", "MANY_TO_ONE"],
-    required: true,
-  },
-  primaryObject: { type: String, required: true },
-  objects: [
-    {
-      entity: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Entity",
-        required: true,
-      },
-      objectType: { type: String, required: true },
-      objId: { type: String, required: true },
-      metadata: { type: Object, required: false },
-    },
-  ],
-});
-
-schema.statics({
-  addAssociation: async function (id, object) {
-    return this.update({ _id: id }, { $push: { objects: object } });
-  },
-  findAssociation: async function (name, dataIdentifierHash) {
-    const syncList = await this.list({
-      name: name,
-      "dataIdentifiers.hash": dataIdentifierHash,
-    });
-
-    if (syncList.length === 1) {
-      return syncList[0];
-    } else if (syncList.length === 0) {
-      return null;
-    } else {
-      throw new Error(
-        `there are multiple sync objects with the name ${name}, for entities [${entities}]`
-      );
-    }
-  },
-});
-
-const Association =
-  mongoose.models.Association || mongoose.model("Association", schema);
-module.exports = { Association };

package/database/models/IndividualUser.js

@@ -1,76 +0,0 @@
-const { mongoose } = require('../mongoose');
-const bcrypt = require('bcryptjs');
-const { UserModel: Parent } = require('./UserModel');
-
-const collectionName = 'IndividualUser';
-
-const schema = new mongoose.Schema({
-    email: { type: String },
-    username: { type: String, unique: true },
-    hashword: { type: String },
-    appUserId: { type: String },
-    organizationUser: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-});
-
-schema.pre('save', async function () {
-    if (this.hashword) {
-        this.hashword = await bcrypt.hashSync(
-            this.hashword,
-            parseInt(this.schema.statics.decimals)
-        )
-    }
-})
-
-schema.static({
-    decimals: 10,
-    update: async function (id, options) {
-        if ('password' in options) {
-            options.hashword = await bcrypt.hashSync(
-                options.password,
-                parseInt(this.decimals)
-            );
-            delete options.password;
-        }
-        return this.findOneAndUpdate(
-            {_id: id},
-            options,
-            {new: true, useFindAndModify: true}
-        );
-    },
-    getUserByUsername: async function (username) {
-        let getByUser;
-        try{
-            getByUser = await this.find({username});
-        } catch (e) {
-            console.log('oops')
-        }
-
-        if (getByUser.length > 1) {
-            throw new Error(
-                'Unique username or email? Please reach out to our developers'
-            );
-        }
-
-        if (getByUser.length === 1) {
-            return getByUser[0];
-        }
-    },
-    getUserByAppUserId: async function (appUserId) {
-        const getByUser = await this.find({ appUserId });
-
-        if (getByUser.length > 1) {
-            throw new Error(
-                'Supposedly using a unique appUserId? Please reach out to our developers'
-            );
-        }
-
-
-        if (getByUser.length === 1) {
-            return getByUser[0];
-        }
-    }
-})
-
-const IndividualUser = Parent.discriminators?.IndividualUser || Parent.discriminator(collectionName, schema);
-
-module.exports = {IndividualUser};

package/database/models/OrganizationUser.js

@@ -1,29 +0,0 @@
-const { mongoose } = require('../mongoose');
-const { UserModel: Parent } = require('./UserModel');
-
-const collectionName = 'OrganizationUser';
-
-const schema = new mongoose.Schema({
-    appOrgId: { type: String, required: true, unique: true },
-    name: { type: String },
-});
-
-schema.static({
-    getUserByAppOrgId: async function (appOrgId) {
-        const getByUser = await this.find({ appOrgId });
-
-        if (getByUser.length > 1) {
-            throw new Error(
-                'Supposedly using a unique appOrgId? Please reach out to our developers'
-            );
-        }
-
-        if (getByUser.length === 1) {
-            return getByUser[0];
-        }
-    }
-})
-
-const OrganizationUser = Parent.discriminators?.OrganizationUser || Parent.discriminator(collectionName, schema);
-
-module.exports = {OrganizationUser};

package/database/models/UserModel.js

@@ -1,7 +0,0 @@
-const { mongoose } = require('../mongoose');
-
-const schema = new mongoose.Schema({}, {timestamps: true})
-
-const UserModel = mongoose.models.User || mongoose.model('User',schema)
-
-module.exports = { UserModel: UserModel };

package/database/models/WebsocketConnection.js

@@ -1,55 +0,0 @@
-const { mongoose } = require('../mongoose');
-const {
-    ApiGatewayManagementApiClient,
-    PostToConnectionCommand,
-} = require('@aws-sdk/client-apigatewaymanagementapi');
-
-const schema = new mongoose.Schema({
-    connectionId: { type: mongoose.Schema.Types.String },
-});
-
-// Add a static method to get active connections
-schema.statics.getActiveConnections = async function () {
-    try {
-        // Return empty array if websockets are not configured
-        if (!process.env.WEBSOCKET_API_ENDPOINT) {
-            return [];
-        }
-
-        const connections = await this.find({}, 'connectionId');
-        return connections.map((conn) => ({
-            connectionId: conn.connectionId,
-            send: async (data) => {
-                const apigwManagementApi = new ApiGatewayManagementApiClient({
-                    endpoint: process.env.WEBSOCKET_API_ENDPOINT,
-                });
-
-                try {
-                    const command = new PostToConnectionCommand({
-                        ConnectionId: conn.connectionId,
-                        Data: JSON.stringify(data),
-                    });
-                    await apigwManagementApi.send(command);
-                } catch (error) {
-                    if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
-                        console.log(`Stale connection ${conn.connectionId}`);
-                        await this.deleteOne({
-                            connectionId: conn.connectionId,
-                        });
-                    } else {
-                        throw error;
-                    }
-                }
-            },
-        }));
-    } catch (error) {
-        console.error('Error getting active connections:', error);
-        throw error;
-    }
-};
-
-const WebsocketConnection =
-    mongoose.models.WebsocketConnection ||
-    mongoose.model('WebsocketConnection', schema);
-
-module.exports = { WebsocketConnection };

package/database/models/readme.md

@@ -1 +0,0 @@
-// todo: we need to get rid of this entire models folder

package/database/mongoose.js

@@ -1,5 +0,0 @@
-const mongoose = require('mongoose');
-mongoose.set('strictQuery', false);
-module.exports = {
-    mongoose
-}

package/database/repositories/health-check-repository.js

@@ -1,108 +0,0 @@
-const { prisma } = require('../prisma');
-const { mongoose } = require('../mongoose');
-const {
-    HealthCheckRepositoryInterface,
-} = require('./health-check-repository-interface');
-
-/**
- * Repository for Health Check database operations.
- * Provides atomic database operations for health testing.
- *
- * Follows DDD/Hexagonal Architecture:
- * - Infrastructure Layer (this repository)
- * - Pure database operations only, no business logic
- * - Used by Application Layer (Use Cases)
- *
- * Works identically for both MongoDB and PostgreSQL:
- * - Uses Prisma for database operations
- * - Encryption happens transparently via Prisma extension
- * - Both MongoDB and PostgreSQL use same Prisma API
- *
- * Migration from Mongoose to Prisma:
- * - Replaced Mongoose models with Prisma client
- * - Uses Credential model for encryption testing
- * - Maintains same method signatures for compatibility
- */
-class HealthCheckRepository extends HealthCheckRepositoryInterface {
-    constructor() {
-        super();
-    }
-
-    /**
-     * Get database connection state
-     * @returns {Object} Object with readyState, stateName, and isConnected
-     */
-    getDatabaseConnectionState() {
-        const stateMap = {
-            0: 'disconnected',
-            1: 'connected',
-            2: 'connecting',
-            3: 'disconnecting',
-        };
-        const readyState = mongoose.connection.readyState;
-
-        return {
-            readyState,
-            stateName: stateMap[readyState],
-            isConnected: readyState === 1,
-        };
-    }
-
-    /**
-     * Ping the database to verify connectivity
-     * @param {number} maxTimeMS - Maximum time to wait for ping response
-     * @returns {Promise<number>} Response time in milliseconds
-     * @throws {Error} If database is not connected or ping fails
-     */
-    async pingDatabase(maxTimeMS = 2000) {
-        const pingStart = Date.now();
-        await mongoose.connection.db.admin().ping({ maxTimeMS });
-        return Date.now() - pingStart;
-    }
-
-    /**
-     * Create a test credential for encryption testing
-     * @param {Object} credentialData - Credential data to create
-     * @returns {Promise<Object>} Created credential
-     */
-    async createCredential(credentialData) {
-        return await prisma.credential.create({
-            data: credentialData,
-        });
-    }
-
-    /**
-     * Find a credential by ID
-     * @param {string} id - Credential ID
-     * @returns {Promise<Object|null>} Found credential or null
-     */
-    async findCredentialById(id) {
-        return await prisma.credential.findUnique({
-            where: { id },
-        });
-    }
-
-    /**
-     * Get raw credential from database bypassing Prisma encryption extension
-     * @param {string} id - Credential ID
-     * @returns {Promise<Object|null>} Raw credential from database
-     */
-    async getRawCredentialById(id) {
-        return await mongoose.connection.db
-            .collection('credentials')
-            .findOne({ _id: id });
-    }
-
-    /**
-     * Delete a credential by ID
-     * @param {string} id - Credential ID
-     * @returns {Promise<void>}
-     */
-    async deleteCredential(id) {
-        await prisma.credential.delete({
-            where: { id },
-        });
-    }
-}
-
-module.exports = { HealthCheckRepository };

package/encrypt/test-encrypt.js

@@ -1,105 +0,0 @@
-const { mongoose } = require('../database/mongoose');
-const crypto = require('crypto');
-
-const hexPattern = /^[a-f0-9]+$/i; // match hex strings of length >= 1
-
-// Test that an encrypted secret value appears to have valid values (without actually decrypting it).
-function expectValidSecret(secret) {
-    const parts = secret.split(':');
-    const keyId = Buffer.from(parts[0], 'base64').toString();
-    const iv = parts[1];
-    const encryptedText = parts[2];
-    const encryptedKey = Buffer.from(parts[3], 'base64').toString();
-
-    expect(iv).toHaveLength(32);
-    expect(iv).toMatch(hexPattern);
-    expect(encryptedText).toHaveLength(14);
-    expect(encryptedText).toMatch(hexPattern);
-
-    // Keys from AWS start with Karn and have a different format.
-    if (keyId.startsWith('arn:aws')) {
-        expect(keyId).toBe(
-            `arn:aws:kms:us-east-1:000000000000:key/${process.env.KMS_KEY_ARN}`
-        );
-        // The length here is a sanity check.  Seems they are always within this range.
-        expect(encryptedKey.length).toBeGreaterThanOrEqual(85);
-        expect(encryptedKey.length).toBeLessThanOrEqual(140);
-    } else {
-        const { AES_KEY_ID, DEPRECATED_AES_KEY_ID } = process.env;
-        expect([AES_KEY_ID, DEPRECATED_AES_KEY_ID]).toContain(keyId);
-
-        const encryptedKeyParts = encryptedKey.split(':');
-        const iv2 = encryptedKeyParts[0];
-        const encryptedKeyPart = encryptedKeyParts[1];
-
-        expect(iv2).toHaveLength(32);
-        expect(iv2).toMatch(hexPattern);
-        expect(encryptedKeyPart).toHaveLength(64);
-        expect(encryptedKeyPart).toMatch(hexPattern);
-    }
-}
-
-// Load and validate a raw test document compared to a Mongoose document object.
-async function expectValidRawDoc(Model, doc) {
-    const rawDoc = await expectValidRawDocById(Model, doc._id);
-
-    expect(rawDoc.notSecret.toString()).toBe(doc.notSecret.toString());
-    expect(rawDoc).not.toHaveProperty('secret', doc.secret);
-
-    return rawDoc;
-}
-
-// Load and validate a raw test document by ID.
-async function expectValidRawDocById(Model, _id) {
-    const rawDoc = await Model.collection.findOne({ _id });
-
-    expect(rawDoc).toHaveProperty('notSecret');
-    expect(rawDoc).toHaveProperty('secret');
-    expectValidSecret(rawDoc.secret);
-
-    return rawDoc;
-}
-
-// Create a clean test model, so that the plug-in can be reinitialized.
-function createModel() {
-    const randomHex = crypto.randomBytes(16).toString('hex');
-    const schema = new mongoose.Schema({
-        secret: { type: String, lhEncrypt: true },
-        notSecret: { type: mongoose.Schema.Types.ObjectId },
-        'deeply.nested.secret': { type: String, lhEncrypt: true },
-    });
-
-    schema.plugin(Encrypt);
-
-    const Model = mongoose.model(`EncryptTest_${randomHex}`, schema);
-    return { schema, Model };
-}
-
-// Save and validate a test doc.
-async function saveTestDocument(Model) {
-    const notSecret = new mongoose.Types.ObjectId();
-    const secret = 'abcdefg';
-    const doc = new Model({ notSecret, secret });
-
-    expect(doc).toHaveProperty('notSecret');
-    expect(doc.notSecret.toString()).toBe(notSecret.toString());
-    expect(doc).toHaveProperty('secret');
-    expect(doc.secret).toBe(secret);
-
-    await doc.save();
-
-    expect(doc).toHaveProperty('notSecret');
-    expect(doc.notSecret.toString()).toBe(notSecret.toString());
-    expect(doc).toHaveProperty('secret');
-    expect(doc.secret).toBe(secret);
-
-    return { doc, secret, notSecret };
-}
-
-module.exports = {
-    expectValidSecret,
-    expectValidRawDoc,
-    expectValidRawDocById,
-    createModel,
-    saveTestDocument,
-};

package/modules/entity.js

@@ -1,46 +0,0 @@
-const { mongoose } = require('../database/mongoose');
-const schema = new mongoose.Schema(
-    {
-        credential: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Credential',
-            required: false,
-        },
-        user: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User',
-            required: false,
-        },
-        name: { type: String },
-        moduleName: { type: String },
-        externalId: { type: String },
-    },
-    { timestamps: true }
-);
-
-schema.static({
-    findByUserId: async function (userId) {
-        const entities = await this.find({ user: userId });
-        if (entities.length === 0) {
-            return null;
-        } else if (entities.length === 1) {
-            return entities[0];
-        } else {
-            throw new Error('multiple entities with same userId');
-        }
-    },
-    findAllByUserId(userId) {
-        return this.find({ user: userId });
-    },
-    upsert: async function (filter, obj) {
-        return this.findOneAndUpdate(filter, obj, {
-            new: true,
-            upsert: true,
-            setDefaultsOnInsert: true,
-        });
-    },
-});
-
-const Entity = mongoose.models.Entity || mongoose.model('Entity', schema);
-
-module.exports = { Entity };

package/syncs/model.js

@@ -1,62 +0,0 @@
-const mongoose = require("mongoose");
-
-const schema = new mongoose.Schema({
-  entities: [
-    { type: mongoose.Schema.Types.ObjectId, ref: "Entity", required: true },
-  ],
-  hash: { type: String, required: true },
-  name: { type: String, required: true },
-  dataIdentifiers: [
-    {
-      entity: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Entity",
-        required: true,
-      },
-      id: { type: Object, required: true },
-      hash: { type: String, required: true },
-    },
-  ],
-});
-
-schema.statics({
-  getSyncObject: async function (name, dataIdentifier, entity) {
-    // const syncList = await this.list({name:name,entities: {"$in": entities}, "entityIds.idHash":entityIdHash });
-    const syncList = await this.find({
-      name: name,
-      dataIdentifiers: { $elemMatch: { id: dataIdentifier, entity } },
-    });
-
-    if (syncList.length === 1) {
-      return syncList[0];
-    } else if (syncList.length === 0) {
-      return null;
-    } else {
-      throw new Error(
-        `There are multiple sync objects with the name ${name}, for entities [${syncList[0].entities}] [${syncList[1].entities}]`
-      );
-    }
-  },
-
-  addDataIdentifier: async function (id, dataIdentifier) {
-    return await this.update(
-      { _id: id },
-      {},
-      { dataIdentifiers: dataIdentifier }
-    );
-  },
-
-  getEntityObjIdForEntityIdFromObject: function (syncObj, entityId) {
-    for (let dataIdentifier of syncObj.dataIdentifiers) {
-      if (dataIdentifier.entity.toString() === entityId) {
-        return dataIdentifier.id;
-      }
-    }
-    throw new Error(
-      `Sync object does not have DataIdentifier for entityId: ${entityId}`
-    );
-  },
-});
-
-const Sync = mongoose.models.Sync || mongoose.model("Sync", schema);
-module.exports = { Sync };