@friggframework/core 2.0.0--canary.498.336977b.0 → 2.0.0--canary.498.82efe90.0

package/database/index.js

@@ -12,13 +12,14 @@
  * etc.
  */
 
-const { mongoose } = require('./mongoose');
-const { IndividualUser } = require('./models/IndividualUser');
-const { OrganizationUser } = require('./models/OrganizationUser');
-const { UserModel } = require('./models/UserModel');
-const { WebsocketConnection } = require('./models/WebsocketConnection');
+// 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
+// Prisma exports (always available)
 const { prisma } = require('./prisma');
 const { TokenRepository } = require('../token/repositories/token-repository');
 const {
@@ -26,12 +27,38 @@ const {
 } = require('../websocket/repositories/websocket-connection-repository');
 
 module.exports = {
-    mongoose,
-    IndividualUser,
-    OrganizationUser,
-    UserModel,
-    WebsocketConnection,
-    // Prisma
+    // 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,
     TokenRepository,
     WebsocketConnectionRepository,

package/handlers/backend-utils.js

@@ -71,6 +71,8 @@ const createModuleFactoryWithDefinitions = (
 };
 
 const loadIntegrationForWebhook = async (integrationId) => {
+    console.log(`[loadIntegrationForWebhook] Loading integration ${integrationId}`);
+
     const { loadAppDefinition } = require('./app-definition-loader');
     const { integrations: integrationClasses } = loadAppDefinition();
 
@@ -92,13 +94,21 @@ const loadIntegrationForWebhook = async (integrationId) => {
         integrationId
     );
 
-    return await getIntegrationInstance.execute(
+    console.log(`[loadIntegrationForWebhook] Found integration record - userId: ${integrationRecord?.userId}, status: ${integrationRecord?.status}`);
+
+    const instance = await getIntegrationInstance.execute(
         integrationId,
         integrationRecord.userId
     );
+
+    console.log(`[loadIntegrationForWebhook] Instance created - has entities: ${!!instance.entities}, has config: ${!!instance.config}`);
+
+    return instance;
 };
 
 const loadIntegrationForProcess = async (processId, integrationClass) => {
+    console.log(`[loadIntegrationForProcess] Loading integration for processId: ${processId}`);
+
     const { processRepository, integrationRepository, moduleRepository } =
         initializeRepositories();
 
@@ -122,31 +132,45 @@ const loadIntegrationForProcess = async (processId, integrationClass) => {
         throw new Error(`Process not found: ${processId}`);
     }
 
-    return await getIntegrationInstance.execute(
+    console.log(`[loadIntegrationForProcess] Found process - integrationId: ${process.integrationId}, userId: ${process.userId}`);
+
+    const instance = await getIntegrationInstance.execute(
         process.integrationId,
         process.userId
     );
+
+    console.log(`[loadIntegrationForProcess] Instance created - has entities: ${!!instance.entities}, has config: ${!!instance.config}`);
+    console.log(`[loadIntegrationForProcess] Entity keys: ${Object.keys(instance.entities || {}).join(', ')}`);
+
+    return instance;
 };
 
 const createQueueWorker = (integrationClass) => {
     class QueueWorker extends Worker {
         async _run(params, context) {
             try {
+                console.log(`[QueueWorker] Event: ${params.event}, Data keys: ${Object.keys(params.data || {}).join(', ')}`);
+                console.log(`[QueueWorker] processId: ${params.data?.processId}, integrationId: ${params.data?.integrationId}`);
+
                 let integrationInstance;
-                
+
                 // Prioritize processId first (for sync handler compatibility),
                 // then integrationId (for ANY event type that needs hydration),
                 // fallback to unhydrated instance
                 if (params.data?.processId) {
+                    console.log(`[QueueWorker] Hydrating via processId: ${params.data.processId}`);
                     integrationInstance = await loadIntegrationForProcess(
                         params.data.processId,
                         integrationClass
                     );
                 } else if (params.data?.integrationId) {
+                    console.log(`[QueueWorker] Hydrating via integrationId: ${params.data.integrationId}`);
                     integrationInstance = await loadIntegrationForWebhook(
                         params.data.integrationId
                     );
+                    console.log(`[QueueWorker] Hydration complete - userId: ${integrationInstance.userId}, config keys: ${Object.keys(integrationInstance.config || {}).join(', ')}`);
                 } else {
+                    console.log(`[QueueWorker] No processId or integrationId - creating unhydrated instance`);
                     // Instantiates a DRY integration class without database records.
                     // There will be cases where we need to use helpers that the api modules can export.
                     // Like for HubSpot, the answer is to do a reverse lookup for the integration by the entity external ID (HubSpot Portal ID),

package/integrations/integration-base.js

@@ -153,6 +153,9 @@ class IntegrationBase {
      * @param {Array} [payload.modules]
      */
     setIntegrationRecord(payload = {}) {
+        console.log(`[setIntegrationRecord] Called with payload keys: ${Object.keys(payload).join(', ')}`);
+        console.log(`[setIntegrationRecord] payload.modules length: ${payload.modules?.length || 0}`);
+
         if (!payload || Object.keys(payload).length === 0) {
             throw new Error('setIntegrationRecord requires integration data');
         }
@@ -160,6 +163,8 @@ class IntegrationBase {
         const integrationRecord = payload.record;
         const integrationModules = payload.modules ?? [];
 
+        console.log(`[setIntegrationRecord] integrationModules length: ${integrationModules.length}`);
+
         if (!integrationRecord) {
             throw new Error('Integration record not provided');
         }
@@ -175,7 +180,9 @@ class IntegrationBase {
         this.version = version;
         this.messages = messages || { errors: [], warnings: [] };
 
+        console.log(`[setIntegrationRecord] About to call _appendModules with ${integrationModules.length} modules`);
         this.modules = this._appendModules(integrationModules);
+        console.log(`[setIntegrationRecord] After _appendModules, this.modules keys: ${Object.keys(this.modules).join(', ')}`);
 
         this.record = {
             id: this.id,
@@ -188,6 +195,7 @@ class IntegrationBase {
         };
 
         this._isHydrated = Boolean(this.id);
+        console.log(`[setIntegrationRecord] Hydrated: ${this._isHydrated}`);
         return this;
     }
 
@@ -214,41 +222,57 @@ class IntegrationBase {
      * @returns {Object} The modules object
      */
     _appendModules(integrationModules) {
+        console.log(`[_appendModules] Called with ${integrationModules?.length || 0} modules`);
+        console.log(`[_appendModules] Definition.modules exists: ${!!this.constructor.Definition?.modules}`);
+
         const modules = {};
-        
+
         // Build reverse mapping: definition.getName() → referenceKey
         // e.g., 'quo-attio' → 'quo', 'attio' → 'attio'
         const moduleNameToKey = {};
         if (this.constructor.Definition?.modules) {
+            console.log(`[_appendModules] Definition.modules keys: ${Object.keys(this.constructor.Definition.modules).join(', ')}`);
             for (const [key, moduleConfig] of Object.entries(this.constructor.Definition.modules)) {
                 const definition = moduleConfig.definition;
                 if (definition) {
                     // Use getName() if available, fallback to moduleName
-                    const definitionName = typeof definition.getName === 'function' 
-                        ? definition.getName() 
+                    const definitionName = typeof definition.getName === 'function'
+                        ? definition.getName()
                         : definition.moduleName;
                     if (definitionName) {
+                        console.log(`[_appendModules] Mapping: ${definitionName} → ${key}`);
                         moduleNameToKey[definitionName] = key;
                     }
                 }
             }
         }
-        
+
+        console.log(`[_appendModules] Built mapping: ${JSON.stringify(moduleNameToKey)}`);
+
         for (const module of integrationModules) {
             const moduleName =
                 typeof module.getName === 'function'
                     ? module.getName()
                     : module.name;
-            
+
+            console.log(`[_appendModules] Processing module with name: ${moduleName}`);
+
             // Use the reference key from Definition.modules if available,
             // otherwise fall back to moduleName
             const key = moduleNameToKey[moduleName] || moduleName;
-            
+
+            console.log(`[_appendModules] Resolved key: ${key}`);
+
             if (key) {
                 modules[key] = module;
                 this[key] = module;
+                console.log(`[_appendModules] Attached module to this.${key}`);
             }
         }
+
+        console.log(`[_appendModules] Returning modules object with keys: ${Object.keys(modules).join(', ')}`);
+        console.log(`[_appendModules] this.entities after attachment: ${Object.keys(this.entities || {}).join(', ')}`);
+
         return modules;
     }
 

package/integrations/use-cases/get-integration-instance.js

@@ -27,6 +27,8 @@ class GetIntegrationInstance {
      * @throws {Error} When integration is not found, doesn't belong to user, or integration class is not found.
      */
     async execute(integrationId, userId) {
+        console.log(`[GetIntegrationInstance] Loading integration ${integrationId} for user ${userId}`);
+
         const integrationRecord =
             await this.integrationRepository.findIntegrationById(integrationId);
 
@@ -36,6 +38,8 @@ class GetIntegrationInstance {
             );
         }
 
+        console.log(`[GetIntegrationInstance] Found integration record - type: ${integrationRecord.config?.type}, entitiesIds: ${JSON.stringify(integrationRecord.entitiesIds)}`);
+
         const integrationClass = this.integrationClasses.find(
             (integrationClass) =>
                 integrationClass.Definition.name ===
@@ -54,15 +58,21 @@ class GetIntegrationInstance {
             );
         }
 
+        console.log(`[GetIntegrationInstance] Loading ${integrationRecord.entitiesIds?.length || 0} entities/modules`);
+
         const modules = [];
         for (const entityId of integrationRecord.entitiesIds) {
+            console.log(`[GetIntegrationInstance] Loading module for entity ${entityId}`);
             const moduleInstance = await this.moduleFactory.getModuleInstance(
                 entityId,
                 integrationRecord.userId
             );
+            console.log(`[GetIntegrationInstance] Module loaded - type: ${moduleInstance.constructor.name}`);
             modules.push(moduleInstance);
         }
 
+        console.log(`[GetIntegrationInstance] Loaded ${modules.length} modules total`);
+
         const integrationInstance = new integrationClass({
             id: integrationRecord.id,
             userId: integrationRecord.userId,

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.498.336977b.0",
+    "version": "2.0.0--canary.498.82efe90.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -38,9 +38,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.498.336977b.0",
-        "@friggframework/prettier-config": "2.0.0--canary.498.336977b.0",
-        "@friggframework/test": "2.0.0--canary.498.336977b.0",
+        "@friggframework/eslint-config": "2.0.0--canary.498.82efe90.0",
+        "@friggframework/prettier-config": "2.0.0--canary.498.82efe90.0",
+        "@friggframework/test": "2.0.0--canary.498.82efe90.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "336977bb0e30f823cbeac47d635858073337ff14"
+    "gitHead": "82efe90fa2bee64b1407052191ae8d06307d8106"
 }