@friggframework/core 2.0.0-next.49 → 2.0.0-next.50

package/database/encryption/README.md

@@ -501,8 +501,9 @@ database: {
 # Run encryption tests
 npm test -- database/encryption/
 
-# Tests use explicit database type parameter for testing:
-# createHealthCheckRepository('mongodb')
+# Tests use explicit prismaClient injection:
+# const { prisma } = require('../prisma');
+# const repository = createHealthCheckRepository({ prismaClient: prisma });
 ```
 
 ## Error Handling & Logging

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

@@ -3,25 +3,31 @@ const { HealthCheckRepositoryPostgreSQL } = require('./health-check-repository-p
 const config = require('../config');
 
 /**
- * Health Check Repository Factory
- * Creates the appropriate repository adapter based on database type
+ * Factory function to create a health check repository for the configured database type.
+ * Requires explicit prismaClient injection to support IoC container patterns.
  *
- * Usage:
- * ```javascript
- * const repository = createHealthCheckRepository();
- * ```
+ * @param {Object} options
+ * @param {Object} options.prismaClient - Prisma client instance (required for dependency injection)
+ * @returns {HealthCheckRepositoryInterface} Database-specific health check repository
+ * @throws {Error} If prismaClient is not provided
  *
- * @returns {HealthCheckRepositoryInterface} Configured repository adapter
+ * @example
+ * const { prisma } = require('../prisma');
+ * const repository = createHealthCheckRepository({ prismaClient: prisma });
  */
-function createHealthCheckRepository() {
+function createHealthCheckRepository({ prismaClient } = {}) {
+    if (!prismaClient) {
+        throw new Error('prismaClient is required');
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new HealthCheckRepositoryMongoDB();
+            return new HealthCheckRepositoryMongoDB({ prismaClient });
 
         case 'postgresql':
-            return new HealthCheckRepositoryPostgreSQL();
+            return new HealthCheckRepositoryPostgreSQL({ prismaClient });
 
         default:
             throw new Error(
@@ -32,7 +38,6 @@ function createHealthCheckRepository() {
 
 module.exports = {
     createHealthCheckRepository,
-    // Export adapters for direct testing
     HealthCheckRepositoryMongoDB,
     HealthCheckRepositoryPostgreSQL,
 };

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

@@ -76,9 +76,10 @@ class HealthCheckRepositoryInterface {
     /**
      * Get database connection state
      *
-     * @returns {Object} Connection state info
+     * @returns {Promise<Object>} Connection state info
+     * @abstract
      */
-    getDatabaseConnectionState() {
+    async getDatabaseConnectionState() {
         throw new Error('Method getDatabaseConnectionState must be implemented by subclass');
     }
 }

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

@@ -1,62 +1,78 @@
-const { prisma } = require('../prisma');
 const { mongoose } = require('../mongoose');
 const {
     HealthCheckRepositoryInterface,
 } = require('./health-check-repository-interface');
 
-/**
- * MongoDB-specific Health Check Repository
- *
- * Provides MongoDB-specific database operations for health testing.
- * Uses Mongoose for MongoDB-specific operations (raw access, ping).
- */
 class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
-    constructor() {
+    /**
+     * @param {Object} params
+     * @param {Object} params.prismaClient - Prisma client instance
+     */
+    constructor({ prismaClient }) {
         super();
+        this.prisma = prismaClient;
     }
 
-    getDatabaseConnectionState() {
-        const stateMap = {
-            0: 'disconnected',
-            1: 'connected',
-            2: 'connecting',
-            3: 'disconnecting',
-        };
-        const readyState = mongoose.connection.readyState;
+    /**
+     * @returns {Promise<{readyState: number, stateName: string, isConnected: boolean}>}
+     */
+    async getDatabaseConnectionState() {
+        let isConnected = false;
+        let stateName = 'unknown';
+        
+        try {
+            await this.prisma.$runCommandRaw({ ping: 1 });
+            isConnected = true;
+            stateName = 'connected';
+        } catch (error) {
+            stateName = 'disconnected';
+        }
 
         return {
-            readyState,
-            stateName: stateMap[readyState],
-            isConnected: readyState === 1,
+            readyState: isConnected ? 1 : 0,
+            readyState: isConnected ? 1 : 0,
+            stateName,
+            isConnected,
         };
     }
 
     async pingDatabase(maxTimeMS = 2000) {
         const pingStart = Date.now();
-        await mongoose.connection.db.admin().ping({ maxTimeMS });
+        
+        // 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
+        ]);
+        
+        return Date.now() - pingStart;
+    }
         return Date.now() - pingStart;
     }
 
     async createCredential(credentialData) {
-        // Note: Collection existence is ensured at application startup via
-        // initializeMongoDBSchema() in database/utils/mongodb-schema-init.js
-        // This prevents "Cannot create namespace in multi-document transaction" errors
-        return await prisma.credential.create({
+        return await this.prisma.credential.create({
             data: credentialData,
         });
     }
 
     async findCredentialById(id) {
-        return await prisma.credential.findUnique({
+        return await this.prisma.credential.findUnique({
             where: { id },
         });
     }
 
     /**
-     * Get raw credential from MongoDB bypassing Prisma encryption extension
-     * Uses Mongoose to access raw MongoDB collection
-     * @param {string} id - Credential ID
-     * @returns {Promise<Object|null>} Raw credential from database
+     * @param {string} id
+     * @returns {Promise<Object|null>}
      */
     async getRawCredentialById(id) {
         const { ObjectId } = require('mongodb');
@@ -66,7 +82,7 @@ class HealthCheckRepositoryMongoDB extends HealthCheckRepositoryInterface {
     }
 
     async deleteCredential(id) {
-        await prisma.credential.delete({
+        await this.prisma.credential.delete({
             where: { id },
         });
     }

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

@@ -1,59 +1,67 @@
-const { prisma } = require('../prisma');
 const {
     HealthCheckRepositoryInterface,
 } = require('./health-check-repository-interface');
 
-/**
- * PostgreSQL-specific Health Check Repository
- *
- * Provides PostgreSQL-specific database operations for health testing.
- * Uses Prisma raw queries for PostgreSQL-specific operations.
- */
 class HealthCheckRepositoryPostgreSQL extends HealthCheckRepositoryInterface {
-    constructor() {
+    /**
+     * @param {Object} params
+     * @param {Object} params.prismaClient - Prisma client instance
+     */
+    constructor({ prismaClient }) {
         super();
+        this.prisma = prismaClient;
     }
 
-    getDatabaseConnectionState() {
-        // PostgreSQL connection state via Prisma
-        // Note: Prisma doesn't expose connection state like Mongoose
-        // We check if prisma is connected by attempting a query
+    /**
+     * @returns {Promise<{readyState: number, stateName: string, isConnected: boolean}>}
+     */
+    async getDatabaseConnectionState() {
+        let isConnected = false;
+        let stateName = 'unknown';
+        
+        try {
+            await this.prisma.$queryRaw`SELECT 1`;
+            isConnected = true;
+            stateName = 'connected';
+        } catch (error) {
+            stateName = 'disconnected';
+        }
+
         return {
-            readyState: 1, // Assume connected if Prisma instance exists
-            stateName: 'connected',
-            isConnected: true,
+            readyState: isConnected ? 1 : 0,
+            stateName,
+            isConnected,
         };
     }
 
+    /**
+     * @param {number} maxTimeMS
+     * @returns {Promise<number>} Response time in milliseconds
+     */
     async pingDatabase(maxTimeMS = 2000) {
         const pingStart = Date.now();
-
-        // PostgreSQL ping using SELECT 1
-        await prisma.$queryRaw`SELECT 1`;
-
+        await this.prisma.$queryRaw`SELECT 1`;
         return Date.now() - pingStart;
     }
 
     async createCredential(credentialData) {
-        return await prisma.credential.create({
+        return await this.prisma.credential.create({
             data: credentialData,
         });
     }
 
     async findCredentialById(id) {
-        return await prisma.credential.findUnique({
+        return await this.prisma.credential.findUnique({
             where: { id },
         });
     }
 
     /**
-     * Get raw credential from PostgreSQL bypassing Prisma encryption extension
-     * Uses $queryRaw to access raw PostgreSQL table
-     * @param {string} id - Credential ID
-     * @returns {Promise<Object|null>} Raw credential from database
+     * @param {string} id
+     * @returns {Promise<Object|null>}
      */
     async getRawCredentialById(id) {
-        const results = await prisma.$queryRaw`
+        const results = await this.prisma.$queryRaw`
             SELECT * FROM "Credential" WHERE id = ${id}
         `;
 
@@ -61,12 +69,11 @@ class HealthCheckRepositoryPostgreSQL extends HealthCheckRepositoryInterface {
             return null;
         }
 
-        // Return first result
         return results[0];
     }
 
     async deleteCredential(id) {
-        await prisma.credential.delete({
+        await this.prisma.credential.delete({
             where: { id },
         });
     }

package/database/use-cases/check-database-health-use-case.js

@@ -1,22 +1,17 @@
-/**
- * Use Case for checking database health.
- * Contains business logic for determining database connectivity and health status.
- */
 class CheckDatabaseHealthUseCase {
     /**
      * @param {Object} params
-     * @param {import('../health-check-repository-interface').HealthCheckRepositoryInterface} params.healthCheckRepository
+     * @param {import('../repositories/health-check-repository-interface').HealthCheckRepositoryInterface} params.healthCheckRepository
      */
     constructor({ healthCheckRepository }) {
         this.repository = healthCheckRepository;
     }
 
     /**
-     * Execute database health check
-     * @returns {Promise<Object>} Health check result with status, state, and response time
+     * @returns {Promise<{status: string, state: string, responseTime?: number}>}
      */
     async execute() {
-        const { stateName, isConnected } = this.repository.getDatabaseConnectionState();
+        const { stateName, isConnected } = await this.repository.getDatabaseConnectionState();
 
         const result = {
             status: isConnected ? 'healthy' : 'unhealthy',

package/handlers/routers/health.js

@@ -14,6 +14,7 @@ const {
 const {
     createHealthCheckRepository,
 } = require('../../database/repositories/health-check-repository-factory');
+const { prisma } = require('../../database/prisma');
 const {
     TestEncryptionUseCase,
 } = require('../../database/use-cases/test-encryption-use-case');
@@ -31,7 +32,7 @@ const {
 } = require('../use-cases/check-integrations-health-use-case');
 
 const router = Router();
-const healthCheckRepository = createHealthCheckRepository();
+const healthCheckRepository = createHealthCheckRepository({ prismaClient: prisma });
 
 // Load integrations and create factories just like auth router does
 // This verifies the system can properly load integrations

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0-next.49",
+    "version": "2.0.0-next.50",
     "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-next.49",
-        "@friggframework/prettier-config": "2.0.0-next.49",
-        "@friggframework/test": "2.0.0-next.49",
+        "@friggframework/eslint-config": "2.0.0-next.50",
+        "@friggframework/prettier-config": "2.0.0-next.50",
+        "@friggframework/test": "2.0.0-next.50",
         "@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": "ab5b2d2e5f0a24bc4af6b3dc0ac592c358638bfa"
+    "gitHead": "8a6cfd1c1b42d5c9ec77cb6a2d30a8789fe686a5"
 }