@friggframework/core 2.0.0--canary.545.dba001a.0 → 2.0.0--canary.545.c40eca4.0

package/handlers/routers/admin.js

@@ -25,17 +25,41 @@ const {
 } = require('../../user/use-cases/create-token-for-user-id');
 const { DeleteUser } = require('../../user/use-cases/delete-user');
 
-// Initialize repositories and use cases
-const { userConfig } = loadAppDefinition();
-const userRepository = createUserRepository({ userConfig });
-const moduleRepository = createModuleRepository();
-
-// Use cases
-const getModuleEntityById = new GetModuleEntityById({ moduleRepository });
-const updateModuleEntity = new UpdateModuleEntity({ moduleRepository });
-const deleteModuleEntity = new DeleteModuleEntity({ moduleRepository });
-const createTokenForUserId = new CreateTokenForUserId({ userRepository });
-const deleteUser = new DeleteUser({ userRepository });
+// Lazy-initialized repositories and use cases (deferred until first request)
+let _userRepository,
+    _moduleRepository,
+    _getModuleEntityById,
+    _updateModuleEntity,
+    _deleteModuleEntity,
+    _createTokenForUserId,
+    _deleteUser;
+
+function ensureInitialized() {
+    if (!_userRepository) {
+        const { userConfig } = loadAppDefinition();
+        _userRepository = createUserRepository({ userConfig });
+        _moduleRepository = createModuleRepository();
+        _getModuleEntityById = new GetModuleEntityById({
+            moduleRepository: _moduleRepository,
+        });
+        _updateModuleEntity = new UpdateModuleEntity({
+            moduleRepository: _moduleRepository,
+        });
+        _deleteModuleEntity = new DeleteModuleEntity({
+            moduleRepository: _moduleRepository,
+        });
+        _createTokenForUserId = new CreateTokenForUserId({
+            userRepository: _userRepository,
+        });
+        _deleteUser = new DeleteUser({ userRepository: _userRepository });
+    }
+}
+
+// Lazy initialization middleware — runs once on first request
+router.use((req, res, next) => {
+    ensureInitialized();
+    next();
+});
 
 // Debug logging
 router.use((req, res, next) => {
@@ -72,14 +96,14 @@ router.get(
         sort[sortBy] = sortOrder === 'desc' ? -1 : 1;
 
         // Use repository to get users
-        const users = await userRepository.findAllUsers({
+        const users = await _userRepository.findAllUsers({
             skip,
             limit: parseInt(limit),
             sort,
             excludeFields: ['-hashword'], // Exclude password hash
         });
 
-        const totalCount = await userRepository.countUsers();
+        const totalCount = await _userRepository.countUsers();
 
         res.json({
             users,
@@ -122,7 +146,7 @@ router.get(
         sort[sortBy] = sortOrder === 'desc' ? -1 : 1;
 
         // Use repository to search users
-        const users = await userRepository.searchUsers({
+        const users = await _userRepository.searchUsers({
             query: q,
             skip,
             limit: parseInt(limit),
@@ -130,7 +154,7 @@ router.get(
             excludeFields: ['-hashword'],
         });
 
-        const totalCount = await userRepository.countUsersBySearchQuery(q);
+        const totalCount = await _userRepository.countUsersBySearchQuery(q);
 
         res.json({
             users,
@@ -175,7 +199,7 @@ router.post(
         }
 
         // Check if user already exists
-        const existingUser = await userRepository.findIndividualUserByUsername(
+        const existingUser = await _userRepository.findIndividualUserByUsername(
             username
         );
         if (existingUser) {
@@ -185,7 +209,7 @@ router.post(
             });
         }
 
-        const existingEmail = await userRepository.findIndividualUserByEmail(
+        const existingEmail = await _userRepository.findIndividualUserByEmail(
             email
         );
         if (existingEmail) {
@@ -210,7 +234,7 @@ router.post(
         if (appUserId) userData.appUserId = appUserId;
         if (organizationId) userData.organizationId = organizationId;
 
-        const user = await userRepository.createIndividualUser(userData);
+        const user = await _userRepository.createIndividualUser(userData);
 
         // Remove sensitive fields
         const userObj = user.toObject ? user.toObject() : user;
@@ -232,7 +256,7 @@ router.get(
     catchAsyncError(async (req, res) => {
         const { userId } = req.params;
 
-        const user = await userRepository.findUserById(userId);
+        const user = await _userRepository.findUserById(userId);
 
         if (!user) {
             return res.status(404).json({
@@ -261,7 +285,7 @@ router.post(
         const { expiresInMinutes = 120 } = req.body;
 
         // Find the user
-        const user = await userRepository.findUserById(userId);
+        const user = await _userRepository.findUserById(userId);
 
         if (!user) {
             return res.status(404).json({
@@ -271,7 +295,7 @@ router.post(
         }
 
         // Generate token without password verification
-        const token = await createTokenForUserId.execute(
+        const token = await _createTokenForUserId.execute(
             userId,
             expiresInMinutes
         );
@@ -295,7 +319,7 @@ router.delete(
         const { userId } = req.params;
 
         // Execute delete user use case
-        await deleteUser.execute(userId);
+        await _deleteUser.execute(userId);
 
         res.status(204).send();
     })
@@ -318,7 +342,7 @@ router.get(
         if (type) query.type = type;
         if (status) query.status = status;
 
-        const entities = await moduleRepository.findEntitiesBy(query);
+        const entities = await _moduleRepository.findEntitiesBy(query);
 
         res.json({ entities });
     })
@@ -333,7 +357,7 @@ router.get(
     catchAsyncError(async (req, res) => {
         const { entityId } = req.params;
 
-        const entity = await getModuleEntityById.execute(entityId);
+        const entity = await _getModuleEntityById.execute(entityId);
 
         if (!entity || !entity.isGlobal) {
             return res.status(404).json({
@@ -363,7 +387,7 @@ router.post(
         }
 
         // Create entity with isGlobal flag
-        const entity = await moduleRepository.createEntity({
+        const entity = await _moduleRepository.createEntity({
             ...entityData,
             type,
             isGlobal: true,
@@ -383,7 +407,7 @@ router.put(
     catchAsyncError(async (req, res) => {
         const { entityId } = req.params;
 
-        const entity = await updateModuleEntity.execute(entityId, req.body);
+        const entity = await _updateModuleEntity.execute(entityId, req.body);
 
         if (!entity) {
             return res.status(404).json({
@@ -405,7 +429,7 @@ router.delete(
     catchAsyncError(async (req, res) => {
         const { entityId } = req.params;
 
-        await deleteModuleEntity.execute(entityId);
+        await _deleteModuleEntity.execute(entityId);
 
         res.status(204).send();
     })
@@ -420,7 +444,7 @@ router.post(
     catchAsyncError(async (req, res) => {
         const { entityId } = req.params;
 
-        const entity = await getModuleEntityById.execute(entityId);
+        const entity = await _getModuleEntityById.execute(entityId);
 
         if (!entity || !entity.isGlobal) {
             return res.status(404).json({

package/handlers/routers/auth.js

@@ -3,34 +3,55 @@ const { createAppHandler } = require('./../app-handler-helpers');
 const { requireLoggedInUser } = require('./middleware/requireLoggedInUser');
 const { loadAppDefinition } = require('../app-definition-loader');
 
-const router = createIntegrationRouter();
+let _router;
+let _handler;
 
-router.route('/api/integrations/redirect/:appId').get((req, res) => {
-    res.redirect(
-        `${process.env.FRONTEND_URI}/redirect/${
-            req.params.appId
-        }?${new URLSearchParams(req.query)}`
-    );
-});
+function ensureRouter() {
+    if (!_router) {
+        _router = createIntegrationRouter();
 
-// Integration settings endpoint
-router
-    .route('/config/integration-settings')
-    .get(requireLoggedInUser, (req, res) => {
-        const appDefinition = loadAppDefinition();
+        _router
+            .route('/api/integrations/redirect/:appId')
+            .get((req, res) => {
+                res.redirect(
+                    `${process.env.FRONTEND_URI}/redirect/${
+                        req.params.appId
+                    }?${new URLSearchParams(req.query)}`
+                );
+            });
 
-        const settings = {
-            autoProvisioningEnabled:
-                appDefinition.integration?.autoProvisioningEnabled ?? true,
-            credentialReuseStrategy:
-                appDefinition.integration?.credentialReuseStrategy ?? 'shared',
-            allowUserManagedEntities:
-                appDefinition.integration?.allowUserManagedEntities ?? true,
-        };
+        // Integration settings endpoint
+        _router
+            .route('/config/integration-settings')
+            .get(requireLoggedInUser, (req, res) => {
+                const appDefinition = loadAppDefinition();
 
-        res.json(settings);
-    });
+                const settings = {
+                    autoProvisioningEnabled:
+                        appDefinition.integration
+                            ?.autoProvisioningEnabled ?? true,
+                    credentialReuseStrategy:
+                        appDefinition.integration
+                            ?.credentialReuseStrategy ?? 'shared',
+                    allowUserManagedEntities:
+                        appDefinition.integration
+                            ?.allowUserManagedEntities ?? true,
+                };
 
-const handler = createAppHandler('HTTP Event: Auth', router);
+                res.json(settings);
+            });
+    }
+    return _router;
+}
 
-module.exports = { handler, router };
+module.exports = {
+    get router() {
+        return ensureRouter();
+    },
+    get handler() {
+        if (!_handler) {
+            _handler = createAppHandler('HTTP Event: Auth', ensureRouter());
+        }
+        return _handler;
+    },
+};

package/handlers/routers/health.js

@@ -29,49 +29,58 @@ const {
 } = require('../use-cases/check-integrations-health-use-case');
 
 const router = Router();
-const healthCheckRepository = createHealthCheckRepository({
-    prismaClient: prisma,
-});
 
-// Load integrations and create factories just like auth router does
-// This verifies the system can properly load integrations
-let moduleFactory, integrationClasses;
-try {
-    const appDef = loadAppDefinition();
-    integrationClasses = appDef.integrations || [];
+// Lazy-initialized use cases (deferred until first request)
+let _checkDatabaseHealthUseCase,
+    _checkEncryptionHealthUseCase,
+    _checkExternalApisHealthUseCase,
+    _checkIntegrationsHealthUseCase;
 
-    const moduleRepository = createModuleRepository();
-    const moduleDefinitions =
-        getModulesDefinitionFromIntegrationClasses(integrationClasses);
+function ensureInitialized() {
+    if (!_checkDatabaseHealthUseCase) {
+        const healthCheckRepository = createHealthCheckRepository({
+            prismaClient: prisma,
+        });
 
-    moduleFactory = new ModuleFactory({
-        moduleRepository,
-        moduleDefinitions,
-    });
-} catch (error) {
-    console.error(
-        'Failed to load integrations for health check:',
-        error.message
-    );
-    // Factories will be undefined, health check will report unhealthy
-    moduleFactory = undefined;
-    integrationClasses = [];
-}
+        let moduleFactory, integrationClasses;
+        try {
+            const appDef = loadAppDefinition();
+            integrationClasses = appDef.integrations || [];
+
+            const moduleRepository = createModuleRepository();
+            const moduleDefinitions =
+                getModulesDefinitionFromIntegrationClasses(integrationClasses);
+
+            moduleFactory = new ModuleFactory({
+                moduleRepository,
+                moduleDefinitions,
+            });
+        } catch (error) {
+            console.error(
+                'Failed to load integrations for health check:',
+                error.message
+            );
+            moduleFactory = undefined;
+            integrationClasses = [];
+        }
 
-const testEncryptionUseCase = new TestEncryptionUseCase({
-    healthCheckRepository,
-});
-const checkDatabaseHealthUseCase = new CheckDatabaseHealthUseCase({
-    healthCheckRepository,
-});
-const checkEncryptionHealthUseCase = new CheckEncryptionHealthUseCase({
-    testEncryptionUseCase,
-});
-const checkExternalApisHealthUseCase = new CheckExternalApisHealthUseCase();
-const checkIntegrationsHealthUseCase = new CheckIntegrationsHealthUseCase({
-    moduleFactory,
-    integrationClasses,
-});
+        const testEncryptionUseCase = new TestEncryptionUseCase({
+            healthCheckRepository,
+        });
+        _checkDatabaseHealthUseCase = new CheckDatabaseHealthUseCase({
+            healthCheckRepository,
+        });
+        _checkEncryptionHealthUseCase = new CheckEncryptionHealthUseCase({
+            testEncryptionUseCase,
+        });
+        _checkExternalApisHealthUseCase =
+            new CheckExternalApisHealthUseCase();
+        _checkIntegrationsHealthUseCase = new CheckIntegrationsHealthUseCase({
+            moduleFactory,
+            integrationClasses,
+        });
+    }
+}
 
 const validateApiKey = (req, res, next) => {
     const apiKey = req.headers['x-frigg-health-api-key'];
@@ -132,6 +141,7 @@ router.get('/health', async (_req, res) => {
 });
 
 router.get('/health/detailed', async (_req, res) => {
+    ensureInitialized();
     console.log('Starting detailed health check');
     const startTime = Date.now();
 
@@ -197,7 +207,7 @@ router.get('/health/detailed', async (_req, res) => {
     }
 
     try {
-        response.checks.database = await checkDatabaseHealthUseCase.execute();
+        response.checks.database = await _checkDatabaseHealthUseCase.execute();
         if (response.checks.database.status === 'unhealthy') {
             response.status = 'unhealthy';
         }
@@ -213,7 +223,7 @@ router.get('/health/detailed', async (_req, res) => {
 
     try {
         response.checks.encryption =
-            await checkEncryptionHealthUseCase.execute();
+            await _checkEncryptionHealthUseCase.execute();
         if (response.checks.encryption.status === 'unhealthy') {
             response.status = 'unhealthy';
         }
@@ -229,7 +239,7 @@ router.get('/health/detailed', async (_req, res) => {
 
     try {
         const { apiStatuses, allReachable } =
-            await checkExternalApisHealthUseCase.execute();
+            await _checkExternalApisHealthUseCase.execute();
         response.checks.externalApis = apiStatuses;
         if (!allReachable) {
             response.status = 'unhealthy';
@@ -248,7 +258,7 @@ router.get('/health/detailed', async (_req, res) => {
     }
 
     try {
-        response.checks.integrations = checkIntegrationsHealthUseCase.execute();
+        response.checks.integrations = _checkIntegrationsHealthUseCase.execute();
         console.log(
             'Integrations check completed:',
             response.checks.integrations
@@ -283,10 +293,11 @@ router.get('/health/live', (_req, res) => {
 });
 
 router.get('/health/ready', async (_req, res) => {
-    const dbHealth = await checkDatabaseHealthUseCase.execute();
+    ensureInitialized();
+    const dbHealth = await _checkDatabaseHealthUseCase.execute();
     const isDbReady = dbHealth.status === 'healthy';
 
-    const integrationsHealth = checkIntegrationsHealthUseCase.execute();
+    const integrationsHealth = _checkIntegrationsHealthUseCase.execute();
     const areModulesReady = integrationsHealth.modules.count > 0;
 
     const isReady = isDbReady && areModulesReady;

package/handlers/routers/integration-defined-routers.js

@@ -3,43 +3,54 @@ const { loadAppDefinition } = require('../app-definition-loader');
 const { Router } = require('express');
 const { loadRouterFromObject } = require('../backend-utils');
 
-const handlers = {};
-const { integrations: integrationClasses } = loadAppDefinition();
+let _handlers;
 
-//todo: this should be in a use case class
-for (const IntegrationClass of integrationClasses) {
-    const router = Router();
-    const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
+function ensureHandlers() {
+    if (!_handlers) {
+        _handlers = {};
+        const { integrations: integrationClasses } = loadAppDefinition();
 
-    console.log(
-        `\n│ Configuring routes for ${IntegrationClass.Definition.name} Integration:`
-    );
+        //todo: this should be in a use case class
+        for (const IntegrationClass of integrationClasses) {
+            const router = Router();
+            const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
 
-    for (const routeDef of IntegrationClass.Definition.routes) {
-        if (typeof routeDef === 'function') {
-            router.use(basePath, routeDef(IntegrationClass));
-            console.log(`│ ANY ${basePath}/* (function handler)`);
-        } else if (typeof routeDef === 'object') {
-            router.use(
-                basePath,
-                loadRouterFromObject(IntegrationClass, routeDef)
+            console.log(
+                `\n│ Configuring routes for ${IntegrationClass.Definition.name} Integration:`
             );
-            const method = (routeDef.method || 'ANY').toUpperCase();
-            const fullPath = `${basePath}${routeDef.path}`;
-            console.log(`│ ${method} ${fullPath}`);
-        } else if (routeDef instanceof express.Router) {
-            router.use(basePath, routeDef);
-            console.log(`│ ANY ${basePath}/* (express router)`);
+
+            for (const routeDef of IntegrationClass.Definition.routes) {
+                if (typeof routeDef === 'function') {
+                    router.use(basePath, routeDef(IntegrationClass));
+                    console.log(`│ ANY ${basePath}/* (function handler)`);
+                } else if (typeof routeDef === 'object') {
+                    router.use(
+                        basePath,
+                        loadRouterFromObject(IntegrationClass, routeDef)
+                    );
+                    const method = (routeDef.method || 'ANY').toUpperCase();
+                    const fullPath = `${basePath}${routeDef.path}`;
+                    console.log(`│ ${method} ${fullPath}`);
+                } else if (routeDef instanceof express.Router) {
+                    router.use(basePath, routeDef);
+                    console.log(`│ ANY ${basePath}/* (express router)`);
+                }
+            }
+            console.log('│');
+
+            _handlers[`${IntegrationClass.Definition.name}`] = {
+                handler: createAppHandler(
+                    `HTTP Event: ${IntegrationClass.Definition.name}`,
+                    router
+                ),
+            };
         }
     }
-    console.log('│');
-
-    handlers[`${IntegrationClass.Definition.name}`] = {
-        handler: createAppHandler(
-            `HTTP Event: ${IntegrationClass.Definition.name}`,
-            router
-        ),
-    };
+    return _handlers;
 }
 
-module.exports = { handlers };
+module.exports = {
+    get handlers() {
+        return ensureHandlers();
+    },
+};

package/handlers/routers/integration-webhook-routers.js

@@ -5,73 +5,84 @@ const {
     IntegrationEventDispatcher,
 } = require('../integration-event-dispatcher');
 
-const handlers = {};
-const { integrations: integrationClasses } = loadAppDefinition();
+let _handlers;
 
-for (const IntegrationClass of integrationClasses) {
-    const webhookConfig = IntegrationClass.Definition.webhooks;
+function ensureHandlers() {
+    if (!_handlers) {
+        _handlers = {};
+        const { integrations: integrationClasses } = loadAppDefinition();
 
-    // Skip if webhooks not enabled
-    if (
-        !webhookConfig ||
-        (typeof webhookConfig === 'object' && !webhookConfig.enabled)
-    ) {
-        continue;
-    }
+        for (const IntegrationClass of integrationClasses) {
+            const webhookConfig = IntegrationClass.Definition.webhooks;
 
-    const router = Router();
-    const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
+            // Skip if webhooks not enabled
+            if (
+                !webhookConfig ||
+                (typeof webhookConfig === 'object' && !webhookConfig.enabled)
+            ) {
+                continue;
+            }
 
-    console.log(
-        `\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`
-    );
+            const router = Router();
+            const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
 
-    // General webhook route (no integration ID)
-    router.post(basePath, async (req, res, next) => {
-        try {
-            const integrationInstance = new IntegrationClass();
-            const dispatcher = new IntegrationEventDispatcher(
-                integrationInstance
+            console.log(
+                `\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`
             );
-            await dispatcher.dispatchHttp({
-                event: 'WEBHOOK_RECEIVED',
-                req,
-                res,
-                next,
+
+            // General webhook route (no integration ID)
+            router.post(basePath, async (req, res, next) => {
+                try {
+                    const integrationInstance = new IntegrationClass();
+                    const dispatcher = new IntegrationEventDispatcher(
+                        integrationInstance
+                    );
+                    await dispatcher.dispatchHttp({
+                        event: 'WEBHOOK_RECEIVED',
+                        req,
+                        res,
+                        next,
+                    });
+                } catch (error) {
+                    next(error);
+                }
             });
-        } catch (error) {
-            next(error);
-        }
-    });
-    console.log(`│ POST ${basePath}`);
+            console.log(`│ POST ${basePath}`);
 
-    // Integration-specific webhook route (with integration ID)
-    router.post(`${basePath}/:integrationId`, async (req, res, next) => {
-        try {
-            const integrationInstance = new IntegrationClass();
-            const dispatcher = new IntegrationEventDispatcher(
-                integrationInstance
-            );
-            await dispatcher.dispatchHttp({
-                event: 'WEBHOOK_RECEIVED',
-                req,
-                res,
-                next,
+            // Integration-specific webhook route (with integration ID)
+            router.post(`${basePath}/:integrationId`, async (req, res, next) => {
+                try {
+                    const integrationInstance = new IntegrationClass();
+                    const dispatcher = new IntegrationEventDispatcher(
+                        integrationInstance
+                    );
+                    await dispatcher.dispatchHttp({
+                        event: 'WEBHOOK_RECEIVED',
+                        req,
+                        res,
+                        next,
+                    });
+                } catch (error) {
+                    next(error);
+                }
             });
-        } catch (error) {
-            next(error);
-        }
-    });
-    console.log(`│ POST ${basePath}/:integrationId`);
-    console.log('│');
+            console.log(`│ POST ${basePath}/:integrationId`);
+            console.log('│');
 
-    handlers[`${IntegrationClass.Definition.name}Webhook`] = {
-        handler: createAppHandler(
-            `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
-            router,
-            false // shouldUseDatabase = false
-        ),
-    };
+            _handlers[`${IntegrationClass.Definition.name}Webhook`] = {
+                handler: createAppHandler(
+                    `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
+                    router,
+                    false // shouldUseDatabase = false
+                ),
+            };
+        }
+    }
+    return _handlers;
 }
 
-module.exports = { handlers };
+module.exports = {
+    get handlers() {
+        return ensureHandlers();
+    },
+};

package/handlers/routers/user.js

@@ -15,17 +15,33 @@ const catchAsyncError = require('express-async-handler');
 const { loadAppDefinition } = require('../app-definition-loader');
 
 const router = express();
-const { userConfig } = loadAppDefinition();
-const userRepository = createUserRepository();
-const createIndividualUser = new CreateIndividualUser({
-    userRepository,
-    userConfig,
-});
-const loginUser = new LoginUser({
-    userRepository,
-    userConfig,
+
+// Lazy-initialized repositories and use cases (deferred until first request)
+let _userRepository, _createIndividualUser, _loginUser, _createTokenForUserId;
+
+function ensureInitialized() {
+    if (!_userRepository) {
+        const { userConfig } = loadAppDefinition();
+        _userRepository = createUserRepository();
+        _createIndividualUser = new CreateIndividualUser({
+            userRepository: _userRepository,
+            userConfig,
+        });
+        _loginUser = new LoginUser({
+            userRepository: _userRepository,
+            userConfig,
+        });
+        _createTokenForUserId = new CreateTokenForUserId({
+            userRepository: _userRepository,
+        });
+    }
+}
+
+// Lazy initialization middleware — runs once on first request
+router.use((req, res, next) => {
+    ensureInitialized();
+    next();
 });
-const createTokenForUserId = new CreateTokenForUserId({ userRepository });
 
 // define the login endpoint
 router.route('/user/login').post(
@@ -34,8 +50,8 @@ router.route('/user/login').post(
             'username',
             'password',
         ]);
-        const user = await loginUser.execute({ username, password });
-        const token = await createTokenForUserId.execute(user.getId(), 120);
+        const user = await _loginUser.execute({ username, password });
+        const token = await _createTokenForUserId.execute(user.getId(), 120);
         res.status(201);
         res.json({ token });
     })
@@ -48,11 +64,11 @@ router.route('/user/create').post(
             'password',
         ]);
 
-        const user = await createIndividualUser.execute({
+        const user = await _createIndividualUser.execute({
             username,
             password,
         });
-        const token = await createTokenForUserId.execute(user.getId(), 120);
+        const token = await _createTokenForUserId.execute(user.getId(), 120);
         res.status(201);
         res.json({ token });
     })

package/handlers/routers/websocket.js

@@ -3,7 +3,15 @@ const {
     createWebsocketConnectionRepository,
 } = require('../../database/websocket-connection-repository-factory');
 
-const websocketConnectionRepository = createWebsocketConnectionRepository();
+let _websocketConnectionRepository;
+
+function getRepository() {
+    if (!_websocketConnectionRepository) {
+        _websocketConnectionRepository =
+            createWebsocketConnectionRepository();
+    }
+    return _websocketConnectionRepository;
+}
 
 const handleWebSocketConnection = async (event, context) => {
     // Handle different WebSocket events
@@ -12,7 +20,7 @@ const handleWebSocketConnection = async (event, context) => {
             // Handle new connection
             try {
                 const connectionId = event.requestContext.connectionId;
-                await websocketConnectionRepository.createConnection(
+                await getRepository().createConnection(
                     connectionId
                 );
                 console.log(`Stored new connection: ${connectionId}`);
@@ -26,7 +34,7 @@ const handleWebSocketConnection = async (event, context) => {
             // Handle disconnection
             try {
                 const connectionId = event.requestContext.connectionId;
-                await websocketConnectionRepository.deleteConnection(
+                await getRepository().deleteConnection(
                     connectionId
                 );
                 console.log(`Removed connection: ${connectionId}`);

package/handlers/workers/integration-defined-workers.js

@@ -2,26 +2,37 @@ const { createHandler } = require('@friggframework/core');
 const { loadAppDefinition } = require('../app-definition-loader');
 const { createQueueWorker } = require('../backend-utils');
 
-const handlers = {};
-const { integrations: integrationClasses } = loadAppDefinition();
+let _handlers;
 
-integrationClasses.forEach((IntegrationClass) => {
-    const defaultQueueWorker = createQueueWorker(IntegrationClass);
+function ensureHandlers() {
+    if (!_handlers) {
+        _handlers = {};
+        const { integrations: integrationClasses } = loadAppDefinition();
 
-    handlers[`${IntegrationClass.Definition.name}`] = {
-        queueWorker: createHandler({
-            eventName: `Queue Worker for ${IntegrationClass.Definition.name}`,
-            isUserFacingResponse: false,
-            method: async (event, context) => {
-                const worker = new defaultQueueWorker();
-                await worker.run(event, context);
-                return {
-                    message: 'Successfully processed the Generic Queue Worker',
-                    input: event,
-                };
-            },
-        }),
-    };
-});
+        integrationClasses.forEach((IntegrationClass) => {
+            const defaultQueueWorker = createQueueWorker(IntegrationClass);
 
-module.exports = { handlers };
+            _handlers[`${IntegrationClass.Definition.name}`] = {
+                queueWorker: createHandler({
+                    eventName: `Queue Worker for ${IntegrationClass.Definition.name}`,
+                    isUserFacingResponse: false,
+                    method: async (event, context) => {
+                        const worker = new defaultQueueWorker();
+                        await worker.run(event, context);
+                        return {
+                            message: 'Successfully processed the Generic Queue Worker',
+                            input: event,
+                        };
+                    },
+                }),
+            };
+        });
+    }
+    return _handlers;
+}
+
+module.exports = {
+    get handlers() {
+        return ensureHandlers();
+    },
+};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.545.dba001a.0",
+    "version": "2.0.0--canary.545.c40eca4.0",
     "dependencies": {
         "@hapi/boom": "^10.0.1",
         "bcryptjs": "^2.4.3",
@@ -35,9 +35,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.545.dba001a.0",
-        "@friggframework/prettier-config": "2.0.0--canary.545.dba001a.0",
-        "@friggframework/test": "2.0.0--canary.545.dba001a.0",
+        "@friggframework/eslint-config": "2.0.0--canary.545.c40eca4.0",
+        "@friggframework/prettier-config": "2.0.0--canary.545.c40eca4.0",
+        "@friggframework/test": "2.0.0--canary.545.c40eca4.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -78,5 +78,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "dba001affb699d55b0684fa236af8a5f67ddf852"
+    "gitHead": "c40eca49e72472f0499b24ce709a655a7503727b"
 }