@friggframework/core 2.0.0--canary.395.e3c5038.0 → 2.0.0--canary.395.f03dc2b.0

package/application/commands/integration-commands.test.js

@@ -1,3 +1,10 @@
+jest.mock('../../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
 const mockFindExecute = jest.fn();
 
 jest.mock('../../integrations/use-cases/find-integration-context-by-external-entity-id', () => {

package/application/commands/user-commands.js

@@ -25,7 +25,7 @@ function mapErrorToResponse(error) {
  * @returns {Object} User command object with CRUD operations
  */
 function createUserCommands() {
-    const userRepository = createUserRepository({ userConfig: {} });
+    const userRepository = createUserRepository();
 
     return {
         /**

package/credential/repositories/credential-repository-factory.js

@@ -2,6 +2,7 @@ const { CredentialRepositoryMongo } = require('./credential-repository-mongo');
 const {
     CredentialRepositoryPostgres,
 } = require('./credential-repository-postgres');
+const config = require('../../database/config');
 
 /**
  * Credential Repository Factory
@@ -17,25 +18,23 @@ const {
  * Usage:
  * ```javascript
  * const repository = createCredentialRepository();
- * const credential = await repository.findCredentialById(id); // ID is string
  * ```
  *
- * @param {Object} [prismaClient] - Optional Prisma client for testing
  * @returns {CredentialRepositoryInterface} Configured repository adapter
  */
-function createCredentialRepository(prismaClient) {
-    const dbType = process.env.DB_TYPE || 'mongodb';
+function createCredentialRepository() {
+    const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new CredentialRepositoryMongo(prismaClient);
+            return new CredentialRepositoryMongo();
 
         case 'postgresql':
-            return new CredentialRepositoryPostgres(prismaClient);
+            return new CredentialRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported DB_TYPE: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
             );
     }
 }

package/credential/repositories/credential-repository-mongo.js

@@ -13,9 +13,9 @@ const {
  * - Dynamic schema support via JSON field
  */
 class CredentialRepositoryMongo extends CredentialRepositoryInterface {
-    constructor(prismaClient = prisma) {
+    constructor() {
         super();
-        this.prisma = prismaClient; // Allow injection for testing
+        this.prisma = prisma;
     }
 
     /**

package/credential/repositories/credential-repository-postgres.js

@@ -13,9 +13,9 @@ const {
  * - All returned IDs are converted to strings for application layer consistency
  */
 class CredentialRepositoryPostgres extends CredentialRepositoryInterface {
-    constructor(prismaClient = prisma) {
+    constructor() {
         super();
-        this.prisma = prismaClient; // Allow injection for testing
+        this.prisma = prisma;
     }
 
     /**

package/database/config.js

@@ -4,11 +4,82 @@
  */
 
 /**
- * Database type selection
- * Currently only 'mongodb' is supported, but this will enable multi-database support
- * @type {'mongodb'|'postgresql'|'mysql'}
+ * Determines database type from app definition
+ * Reads backend/index.js Definition.database configuration
+ *
+ * @returns {'mongodb'|'postgresql'} Database type
+ * @throws {Error} If database type cannot be determined or app definition missing
  */
-const DB_TYPE = process.env.DB_TYPE || 'mongodb';
+function getDatabaseType() {
+    try {
+        const path = require('node:path');
+        const fs = require('node:fs');
+        const { findNearestBackendPackageJson } = require('../utils');
+
+        let backendIndexPath;
+        let database;
+        const backendPackagePath = findNearestBackendPackageJson();
+
+        if (!backendPackagePath) {
+            throw new Error(
+                '[Frigg] Cannot find backend package.json. ' +
+                'Ensure backend/package.json exists in your project.'
+            );
+        }
+
+        const backendDir = path.dirname(backendPackagePath);
+        backendIndexPath = path.join(backendDir, 'index.js');
+
+        if (!fs.existsSync(backendIndexPath)) {
+            throw new Error(
+                `[Frigg] Backend index.js not found at ${backendIndexPath}. ` +
+                'Ensure backend/index.js exists with a Definition export.'
+            );
+        }
+
+        const backendModule = require(backendIndexPath);
+        database = backendModule?.Definition?.database;
+
+        if (!database) {
+            throw new Error(
+                '[Frigg] App definition missing database configuration. ' +
+                `Add database: { postgres: { enable: true } } (or mongoDB/documentDB) to ${backendIndexPath}`
+            );
+        }
+
+        // Determine database type from enabled database
+        // Priority order: postgres > mongoDB > documentDB
+        if (database.postgres?.enable === true) {
+            return 'postgresql';
+        }
+        if (database.mongoDB?.enable === true) {
+            return 'mongodb';
+        }
+        if (database.documentDB?.enable === true) {
+            return 'mongodb'; // DocumentDB is MongoDB-compatible
+        }
+
+        throw new Error(
+            '[Frigg] No database enabled in app definition. ' +
+            'Set one of: database.postgres.enable, database.mongoDB.enable, or database.documentDB.enable to true'
+        );
+    } catch (error) {
+        // Re-throw with context if it's our error
+        if (error.message.includes('[Frigg]')) {
+            throw error;
+        }
+        // Wrap unexpected errors
+        throw new Error(
+            `[Frigg] Failed to determine database type: ${error.message}`
+        );
+    }
+}
+
+/**
+ * Cached database type (lazy evaluation)
+ * @type {'mongodb'|'postgresql'|null}
+ */
+let cachedDbType = null;
 
 /**
  * Enable Prisma debug logging
@@ -24,7 +95,23 @@ const PRISMA_LOG_LEVEL = process.env.PRISMA_LOG_LEVEL || 'error,warn';
 const PRISMA_QUERY_LOGGING = process.env.PRISMA_QUERY_LOGGING === 'true';
 
 module.exports = {
-    DB_TYPE,
+    getDatabaseType, // Export for testing and direct use
     PRISMA_LOG_LEVEL,
     PRISMA_QUERY_LOGGING,
-};
+};
+
+/**
+ * Lazy-evaluated database type determined from app definition
+ * Only evaluates when accessed, preventing module load failures in test environments
+ * @type {'mongodb'|'postgresql'}
+ */
+Object.defineProperty(module.exports, 'DB_TYPE', {
+    get() {
+        if (cachedDbType === null) {
+            cachedDbType = getDatabaseType();
+        }
+        return cachedDbType;
+    },
+    enumerable: true,
+    configurable: true
+});

package/database/encryption/README.md

@@ -41,7 +41,34 @@ External Systems (AWS KMS, Database)
 
 ## Configuration
 
-### App Definition
+### Database Selection
+
+Database type is configured in `backend/index.js` app definition:
+
+```javascript
+const appDefinition = {
+    database: {
+        mongoDB: {
+            enable: true,    // Use MongoDB
+        },
+        documentDB: {
+            enable: false,   // Use DocumentDB (MongoDB-compatible)
+            tlsCAFile: './security/global-bundle.pem',
+        },
+        postgres: {
+            enable: false,   // Use PostgreSQL
+        },
+    },
+    // ... other config
+};
+```
+
+**Important**: Only enable ONE database at a time. The framework will use the first enabled database in this priority order:
+1. PostgreSQL (`postgres.enable = true`)
+2. MongoDB (`mongoDB.enable = true`)
+3. DocumentDB (`documentDB.enable = true`)
+
+### Encryption Configuration
 
 In `backend/index.js`:
 
@@ -371,14 +398,79 @@ npm test -- database/encryption/
 
 ### Integration Tests
 
+Database type is determined from your app definition in `backend/index.js`:
+
+```javascript
+// backend/index.js
+database: {
+    mongoDB: { enable: true },   // For MongoDB tests
+    postgres: { enable: false }
+}
+```
+
 ```bash
-# Test with MongoDB
-DB_TYPE=mongodb npm test -- database/encryption/
+# Run encryption tests
+npm test -- database/encryption/
+
+# Tests use explicit database type parameter for testing:
+# createHealthCheckRepository('mongodb')
+```
+
+## Error Handling & Logging
+
+### Error Handling Strategy
+
+The encryption system uses **fail-fast error handling**:
+
+- **Encryption failures**: Throw errors immediately (don't save corrupted/unencrypted sensitive data)
+- **Decryption failures**: Throw errors immediately (prevents exposing invalid data)
+- **Configuration errors**: Warn and disable encryption (graceful degradation for development)
+- **Validation errors**: Throw errors on startup (catch issues before production)
 
-# Test with PostgreSQL
-DB_TYPE=postgresql npm test -- database/encryption/
+**Why fail-fast?**
+- Security-critical operations must not silently fail
+- Better to expose issues during development than risk data breaches
+- Prevents inconsistent database state (partially encrypted data)
+
+### Logging Configuration
+
+Configure log verbosity with `FRIGG_LOG_LEVEL`:
+
+```bash
+# Production (minimal logging)
+FRIGG_LOG_LEVEL=WARN
+
+# Development (detailed logging)
+FRIGG_LOG_LEVEL=DEBUG
+
+# Default
+FRIGG_LOG_LEVEL=INFO
 ```
 
+**Log Levels:**
+- `DEBUG`: Detailed encryption operations (includes schema loading, key checks)
+- `INFO`: High-level status (encryption enabled/disabled, custom schema registration)
+- `WARN`: Configuration issues (missing keys, bypassed encryption)
+- `ERROR`: Operation failures (encryption/decryption errors)
+
+**Production Safety:**
+- Sensitive data automatically sanitized in logs
+- Long base64 strings truncated (prevents key leakage)
+- Stack traces omitted in production (`STAGE=production`)
+- Key IDs never logged
+
+### Performance Optimizations
+
+**Parallel field encryption:**
+- Multiple fields encrypted concurrently using `Promise.all()`
+- Significantly faster for models with many encrypted fields
+- Example: 3 fields encrypted in ~30ms vs ~90ms (3x speedup)
+
+**Deep cloning:**
+- Uses native `structuredClone()` on Node.js 17+ (2-5x faster)
+- Falls back to custom implementation for compatibility
+- No external dependencies required
+
 ## Troubleshooting
 
 ### Encryption Not Working