@friggframework/core 2.0.0--canary.490.856adab.0 → 2.0.0--canary.490.d8be1b9.0

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

@@ -0,0 +1,73 @@
+const { ObjectId } = require('mongodb');
+const { getNativeMongoClient } = require('../mongodb-native-client');
+const { EncryptedCollection } = require('../encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../encryption/field-encryption-service');
+const { getEncryptedFields } = require('../encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { HealthCheckRepositoryInterface } = require('./health-check-repository-interface');
+
+class HealthCheckRepositoryDocumentDB extends HealthCheckRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        this.nativeClient = nativeClient;
+        
+        const collection = nativeClient.collection('Credential');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'Credential');
+    }
+
+    async getDatabaseConnectionState() {
+        let isConnected = false;
+        let stateName = 'unknown';
+        
+        try {
+            await this.nativeClient.runCommand({ ping: 1 });
+            isConnected = true;
+            stateName = 'connected';
+        } catch (error) {
+            stateName = 'disconnected';
+        }
+
+        return {
+            readyState: isConnected ? 1 : 0,
+            stateName,
+            isConnected,
+        };
+    }
+
+    async pingDatabase(maxTimeMS = 2000) {
+        const pingStart = Date.now();
+        await this.nativeClient.runCommand({ ping: 1 });
+        return Date.now() - pingStart;
+    }
+
+    async createCredential(credentialData) {
+        const result = await this.collection.insertOne(credentialData);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async findCredentialById(id) {
+        return await this.collection.findOne({ _id: new ObjectId(id) });
+    }
+
+    async getRawCredentialById(id) {
+        const rawCollection = this.nativeClient.collection('Credential');
+        return await rawCollection.findOne({ _id: new ObjectId(id) });
+    }
+
+    async deleteCredentialById(id) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(id) });
+        return result.deletedCount > 0;
+    }
+}
+
+module.exports = { HealthCheckRepositoryDocumentDB };
+

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

@@ -1,5 +1,7 @@
 const { HealthCheckRepositoryMongoDB } = require('./health-check-repository-mongodb');
 const { HealthCheckRepositoryPostgreSQL } = require('./health-check-repository-postgres');
+const { HealthCheckRepositoryDocumentDB } = require('./health-check-repository-documentdb');
+const { isDocumentDB } = require('../utils/documentdb-compatibility');
 const config = require('../config');
 
 /**
@@ -16,6 +18,10 @@ const config = require('../config');
  * const repository = createHealthCheckRepository({ prismaClient: prisma });
  */
 function createHealthCheckRepository({ prismaClient } = {}) {
+    if (isDocumentDB()) {
+        return new HealthCheckRepositoryDocumentDB();
+    }
+
     if (!prismaClient) {
         throw new Error('prismaClient is required');
     }
@@ -40,4 +46,5 @@ module.exports = {
     createHealthCheckRepository,
     HealthCheckRepositoryMongoDB,
     HealthCheckRepositoryPostgreSQL,
+    HealthCheckRepositoryDocumentDB,
 };

package/integrations/repositories/integration-mapping-repository-documentdb.js

@@ -0,0 +1,60 @@
+const { ObjectId } = require('mongodb');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { IntegrationMappingRepositoryInterface } = require('./integration-mapping-repository-interface');
+
+class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('IntegrationMapping');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'IntegrationMapping');
+    }
+
+    async findMappingById(mappingId) {
+        return await this.collection.findOne({ _id: new ObjectId(mappingId) });
+    }
+
+    async findMappingsByIntegrationId(integrationId) {
+        return await this.collection.find({ integrationId });
+    }
+
+    async createMapping(mappingData) {
+        const doc = {
+            ...mappingData,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async updateMapping(mappingId, updates) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(mappingId) },
+            { $set: { ...updates, updatedAt: new Date() } }
+        );
+
+        return await this.findMappingById(mappingId);
+    }
+
+    async deleteMapping(mappingId) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(mappingId) });
+        return result.deletedCount > 0;
+    }
+}
+
+module.exports = { IntegrationMappingRepositoryDocumentDB };
+

package/integrations/repositories/integration-mapping-repository-factory.js

@@ -1,9 +1,7 @@
-const {
-    IntegrationMappingRepositoryMongo,
-} = require('./integration-mapping-repository-mongo');
-const {
-    IntegrationMappingRepositoryPostgres,
-} = require('./integration-mapping-repository-postgres');
+const { IntegrationMappingRepositoryMongo } = require('./integration-mapping-repository-mongo');
+const { IntegrationMappingRepositoryPostgres } = require('./integration-mapping-repository-postgres');
+const { IntegrationMappingRepositoryDocumentDB } = require('./integration-mapping-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 /**
@@ -26,6 +24,10 @@ const config = require('../../database/config');
  * @returns {IntegrationMappingRepositoryInterface} Configured repository adapter
  */
 function createIntegrationMappingRepository() {
+    if (isDocumentDB()) {
+        return new IntegrationMappingRepositoryDocumentDB();
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
@@ -44,7 +46,7 @@ function createIntegrationMappingRepository() {
 
 module.exports = {
     createIntegrationMappingRepository,
-    // Export adapters for direct testing
     IntegrationMappingRepositoryMongo,
     IntegrationMappingRepositoryPostgres,
+    IntegrationMappingRepositoryDocumentDB,
 };

package/integrations/repositories/integration-repository-documentdb.js

@@ -0,0 +1,103 @@
+const { ObjectId } = require('mongodb');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { IntegrationRepositoryInterface } = require('./integration-repository-interface');
+
+class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('Integration');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'Integration');
+    }
+
+    async findIntegrationById(id) {
+        return await this.collection.findOne({ _id: new ObjectId(id) });
+    }
+
+    async findIntegrationByUserId(userId) {
+        const integrations = await this.collection.find({ userId });
+        return integrations[0] || null;
+    }
+
+    async findIntegrationsByUserId(userId) {
+        return await this.collection.find({ userId });
+    }
+
+    async findIntegrationByName(name) {
+        return await this.collection.findOne({ name });
+    }
+
+    async createIntegration(entities, userId, config) {
+        const entityIds = Array.isArray(entities) 
+            ? entities.map(e => e.id || e._id?.toString() || e)
+            : [entities.id || entities._id?.toString() || entities];
+
+        const doc = {
+            userId,
+            entityIds,
+            config: config || {},
+            status: 'active',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async updateIntegrationStatus(integrationId, status) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(integrationId) },
+            { $set: { status, updatedAt: new Date() } }
+        );
+
+        return await this.findIntegrationById(integrationId);
+    }
+
+    async updateIntegrationMessages(integrationId, incomingMessages, outgoingMessages) {
+        const update = { updatedAt: new Date() };
+        
+        if (incomingMessages !== undefined) {
+            update.incomingMessages = incomingMessages;
+        }
+        if (outgoingMessages !== undefined) {
+            update.outgoingMessages = outgoingMessages;
+        }
+
+        await this.collection.updateOne(
+            { _id: new ObjectId(integrationId) },
+            { $set: update }
+        );
+
+        return await this.findIntegrationById(integrationId);
+    }
+
+    async updateIntegrationConfig(integrationId, config) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(integrationId) },
+            { $set: { config, updatedAt: new Date() } }
+        );
+
+        return await this.findIntegrationById(integrationId);
+    }
+
+    async deleteIntegrationById(integrationId) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(integrationId) });
+        return result.deletedCount > 0;
+    }
+}
+
+module.exports = { IntegrationRepositoryDocumentDB };
+

package/integrations/repositories/integration-repository-factory.js

@@ -1,5 +1,7 @@
 const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
 const { IntegrationRepositoryPostgres } = require('./integration-repository-postgres');
+const { IntegrationRepositoryDocumentDB } = require('./integration-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 /**
@@ -20,6 +22,10 @@ const config = require('../../database/config');
  * @throws {Error} If database type is not supported
  */
 function createIntegrationRepository() {
+    if (isDocumentDB()) {
+        return new IntegrationRepositoryDocumentDB();
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
@@ -38,7 +44,7 @@ function createIntegrationRepository() {
 
 module.exports = {
     createIntegrationRepository,
-    // Export adapters for direct testing
     IntegrationRepositoryMongo,
     IntegrationRepositoryPostgres,
+    IntegrationRepositoryDocumentDB,
 };

package/integrations/repositories/process-repository-documentdb.js

@@ -0,0 +1,61 @@
+const { ObjectId } = require('mongodb');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { ProcessRepositoryInterface } = require('./process-repository-interface');
+
+class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('Process');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'Process');
+    }
+
+    async createProcess(processData) {
+        const doc = {
+            ...processData,
+            status: processData.status || 'pending',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async findProcessById(processId) {
+        return await this.collection.findOne({ _id: new ObjectId(processId) });
+    }
+
+    async findProcessesByUserId(userId) {
+        return await this.collection.find({ userId });
+    }
+
+    async updateProcess(processId, updates) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(processId) },
+            { $set: { ...updates, updatedAt: new Date() } }
+        );
+
+        return await this.findProcessById(processId);
+    }
+
+    async deleteProcess(processId) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(processId) });
+        return result.deletedCount > 0;
+    }
+}
+
+module.exports = { ProcessRepositoryDocumentDB };
+

package/integrations/repositories/process-repository-factory.js

@@ -1,5 +1,7 @@
 const { ProcessRepositoryMongo } = require('./process-repository-mongo');
 const { ProcessRepositoryPostgres } = require('./process-repository-postgres');
+const { ProcessRepositoryDocumentDB } = require('./process-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 /**
@@ -21,6 +23,10 @@ const config = require('../../database/config');
  * @throws {Error} If database type is not supported
  */
 function createProcessRepository() {
+    if (isDocumentDB()) {
+        return new ProcessRepositoryDocumentDB();
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
@@ -39,8 +45,8 @@ function createProcessRepository() {
 
 module.exports = {
     createProcessRepository,
-    // Export adapters for direct testing
     ProcessRepositoryMongo,
     ProcessRepositoryPostgres,
+    ProcessRepositoryDocumentDB,
 };
 

package/modules/repositories/module-repository-documentdb.js

@@ -0,0 +1,82 @@
+const { ObjectId } = require('mongodb');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { ModuleRepositoryInterface } = require('./module-repository-interface');
+
+class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('Entity');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'Entity');
+    }
+
+    async findEntityById(entityId) {
+        return await this.collection.findOne({ _id: new ObjectId(entityId) });
+    }
+
+    async findEntitiesByUserId(userId) {
+        return await this.collection.find({ userId });
+    }
+
+    async findEntitiesByIds(entitiesIds) {
+        const objectIds = entitiesIds.map(id => new ObjectId(id));
+        return await this.collection.find({ _id: { $in: objectIds } });
+    }
+
+    async findEntitiesByUserIdAndModuleName(userId, moduleName) {
+        return await this.collection.find({ userId, moduleName });
+    }
+
+    async findEntity(filter) {
+        return await this.collection.findOne(filter);
+    }
+
+    async createEntity(entityData) {
+        const doc = {
+            ...entityData,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async updateEntity(entityId, updates) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(entityId) },
+            { $set: { ...updates, updatedAt: new Date() } }
+        );
+
+        return await this.findEntityById(entityId);
+    }
+
+    async unsetCredential(entityId) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(entityId) },
+            { $unset: { credential: '' }, $set: { updatedAt: new Date() } }
+        );
+
+        return await this.findEntityById(entityId);
+    }
+
+    async deleteEntity(entityId) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(entityId) });
+        return result.deletedCount > 0;
+    }
+}
+
+module.exports = { ModuleRepositoryDocumentDB };
+

package/modules/repositories/module-repository-factory.js

@@ -1,14 +1,14 @@
 const { ModuleRepositoryMongo } = require('./module-repository-mongo');
 const { ModuleRepositoryPostgres } = require('./module-repository-postgres');
+const { ModuleRepositoryDocumentDB } = require('./module-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
-/**
- * Module Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * @returns {ModuleRepositoryInterface} Configured repository adapter
- */
 function createModuleRepository() {
+    if (isDocumentDB()) {
+        return new ModuleRepositoryDocumentDB();
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
@@ -27,7 +27,7 @@ function createModuleRepository() {
 
 module.exports = {
     createModuleRepository,
-    // Export adapters for direct testing
     ModuleRepositoryMongo,
     ModuleRepositoryPostgres,
+    ModuleRepositoryDocumentDB,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.490.856adab.0",
+    "version": "2.0.0--canary.490.d8be1b9.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.490.856adab.0",
-        "@friggframework/prettier-config": "2.0.0--canary.490.856adab.0",
-        "@friggframework/test": "2.0.0--canary.490.856adab.0",
+        "@friggframework/eslint-config": "2.0.0--canary.490.d8be1b9.0",
+        "@friggframework/prettier-config": "2.0.0--canary.490.d8be1b9.0",
+        "@friggframework/test": "2.0.0--canary.490.d8be1b9.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": "856adabfc4df93bda01d7fc9a81f13ea1959cde0"
+    "gitHead": "d8be1b9d24b459e074d7f39344386e843987625e"
 }

package/syncs/repositories/sync-repository-documentdb.js

@@ -0,0 +1,62 @@
+const { ObjectId } = require('mongodb');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { SyncRepositoryInterface } = require('./sync-repository-interface');
+
+class SyncRepositoryDocumentDB extends SyncRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('Sync');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'Sync');
+    }
+
+    async getSyncObject(name, dataIdentifier, entity) {
+        const entityId = entity?.id || entity?._id?.toString() || entity;
+        
+        return await this.collection.findOne({
+            name,
+            dataIdentifier,
+            entityId,
+        });
+    }
+
+    async createSync(syncData) {
+        const doc = {
+            ...syncData,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async updateSync(syncId, updates) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(syncId) },
+            { $set: { ...updates, updatedAt: new Date() } }
+        );
+
+        return await this.collection.findOne({ _id: new ObjectId(syncId) });
+    }
+
+    async deleteSync(syncId) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(syncId) });
+        return result.deletedCount > 0;
+    }
+}
+
+module.exports = { SyncRepositoryDocumentDB };
+

package/syncs/repositories/sync-repository-factory.js

@@ -1,19 +1,14 @@
 const { SyncRepositoryMongo } = require('./sync-repository-mongo');
 const { SyncRepositoryPostgres } = require('./sync-repository-postgres');
+const { SyncRepositoryDocumentDB } = require('./sync-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
-/**
- * Sync Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * Usage:
- * ```javascript
- * const repository = createSyncRepository();
- * ```
- *
- * @returns {SyncRepositoryInterface} Configured repository adapter
- */
 function createSyncRepository() {
+    if (isDocumentDB()) {
+        return new SyncRepositoryDocumentDB();
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
@@ -32,7 +27,7 @@ function createSyncRepository() {
 
 module.exports = {
     createSyncRepository,
-    // Export adapters for direct testing
     SyncRepositoryMongo,
     SyncRepositoryPostgres,
+    SyncRepositoryDocumentDB,
 };

package/token/repositories/token-repository-documentdb.js

@@ -0,0 +1,91 @@
+const { ObjectId } = require('mongodb');
+const bcrypt = require('bcryptjs');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { TokenRepositoryInterface } = require('./token-repository-interface');
+
+const BCRYPT_ROUNDS = 10;
+
+class TokenRepositoryDocumentDB extends TokenRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('Token');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'Token');
+    }
+
+    async createTokenWithExpire(userId, rawToken, minutes) {
+        const hashedToken = await bcrypt.hash(rawToken, BCRYPT_ROUNDS);
+        const expiresAt = new Date(Date.now() + minutes * 60 * 1000);
+
+        const doc = {
+            userId,
+            token: hashedToken,
+            expiresAt,
+            createdAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        const token = await this.collection.findOne({ _id: result.insertedId });
+        
+        return Buffer.from(JSON.stringify({ 
+            tokenId: token._id.toString(), 
+            rawToken 
+        })).toString('base64');
+    }
+
+    async validateAndGetToken(tokenObj) {
+        const token = await this.collection.findOne({ _id: new ObjectId(tokenObj.tokenId) });
+        
+        if (!token) {
+            return null;
+        }
+
+        if (new Date() > new Date(token.expiresAt)) {
+            await this.deleteToken(tokenObj.tokenId);
+            return null;
+        }
+
+        const isValid = await bcrypt.compare(tokenObj.rawToken, token.token);
+        return isValid ? token : null;
+    }
+
+    async findTokenById(tokenId) {
+        return await this.collection.findOne({ _id: new ObjectId(tokenId) });
+    }
+
+    async findTokensByUserId(userId) {
+        return await this.collection.find({ userId });
+    }
+
+    async deleteToken(tokenId) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(tokenId) });
+        return result.deletedCount > 0;
+    }
+
+    async deleteExpiredTokens() {
+        const result = await this.collection.deleteMany({ 
+            expiresAt: { $lt: new Date() } 
+        });
+        return result.deletedCount;
+    }
+
+    async deleteTokensByUserId(userId) {
+        const result = await this.collection.deleteMany({ userId });
+        return result.deletedCount;
+    }
+}
+
+module.exports = { TokenRepositoryDocumentDB };
+

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

@@ -1,14 +1,14 @@
 const { TokenRepositoryMongo } = require('./token-repository-mongo');
 const { TokenRepositoryPostgres } = require('./token-repository-postgres');
+const { TokenRepositoryDocumentDB } = require('./token-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
-/**
- * Token Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * @returns {TokenRepositoryInterface} Configured repository adapter
- */
 function createTokenRepository() {
+    if (isDocumentDB()) {
+        return new TokenRepositoryDocumentDB();
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
@@ -27,7 +27,7 @@ function createTokenRepository() {
 
 module.exports = {
     createTokenRepository,
-    // Export adapters for direct testing
     TokenRepositoryMongo,
     TokenRepositoryPostgres,
+    TokenRepositoryDocumentDB,
 };

package/user/repositories/user-repository-documentdb.js

@@ -0,0 +1,148 @@
+const { ObjectId } = require('mongodb');
+const bcrypt = require('bcryptjs');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { UserRepositoryInterface } = require('./user-repository-interface');
+const { createTokenRepository } = require('../../token/repositories/token-repository-factory');
+
+const BCRYPT_ROUNDS = 10;
+
+class UserRepositoryDocumentDB extends UserRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('User');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'User');
+        this.tokenRepository = createTokenRepository();
+    }
+
+    async getSessionToken(token) {
+        return await this.tokenRepository.getSessionToken(token);
+    }
+
+    async findUserById(userId) {
+        return await this.collection.findOne({ _id: new ObjectId(userId) });
+    }
+
+    async findIndividualUserById(userId) {
+        return await this.collection.findOne({ 
+            _id: new ObjectId(userId),
+            type: 'individual',
+        });
+    }
+
+    async findOrganizationUserById(userId) {
+        return await this.collection.findOne({
+            _id: new ObjectId(userId),
+            type: 'organization',
+        });
+    }
+
+    async findIndividualUserByUsername(username) {
+        return await this.collection.findOne({
+            username,
+            type: 'individual',
+        });
+    }
+
+    async findIndividualUserByEmail(email) {
+        return await this.collection.findOne({
+            email,
+            type: 'individual',
+        });
+    }
+
+    async findIndividualUserByAppUserId(appUserId) {
+        return await this.collection.findOne({
+            appUserId,
+            type: 'individual',
+        });
+    }
+
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        return await this.collection.findOne({
+            appOrgId,
+            type: 'organization',
+        });
+    }
+
+    async createIndividualUser(params) {
+        const { username, email, password, appUserId } = params;
+
+        const hashedPassword = await bcrypt.hash(password, BCRYPT_ROUNDS);
+
+        const doc = {
+            type: 'individual',
+            username,
+            email,
+            hashword: hashedPassword,
+            appUserId: appUserId || null,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async createOrganizationUser(params) {
+        const { name, appOrgId } = params;
+
+        const doc = {
+            type: 'organization',
+            name,
+            appOrgId: appOrgId || null,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async updateIndividualUser(userId, updates) {
+        if (updates.password) {
+            updates.hashword = await bcrypt.hash(updates.password, BCRYPT_ROUNDS);
+            delete updates.password;
+        }
+
+        await this.collection.updateOne(
+            { _id: new ObjectId(userId), type: 'individual' },
+            { $set: { ...updates, updatedAt: new Date() } }
+        );
+
+        return await this.findIndividualUserById(userId);
+    }
+
+    async updateOrganizationUser(userId, updates) {
+        await this.collection.updateOne(
+            { _id: new ObjectId(userId), type: 'organization' },
+            { $set: { ...updates, updatedAt: new Date() } }
+        );
+
+        return await this.findOrganizationUserById(userId);
+    }
+
+    async deleteUser(userId) {
+        const result = await this.collection.deleteOne({ _id: new ObjectId(userId) });
+        return result.deletedCount > 0;
+    }
+
+    async createToken(userId, rawToken, minutes = 120) {
+        return await this.tokenRepository.createTokenWithExpire(userId, rawToken, minutes);
+    }
+}
+
+module.exports = { UserRepositoryDocumentDB };
+

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

@@ -1,5 +1,7 @@
 const { UserRepositoryMongo } = require('./user-repository-mongo');
 const { UserRepositoryPostgres } = require('./user-repository-postgres');
+const { UserRepositoryDocumentDB } = require('./user-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const databaseConfig = require('../../database/config');
 
 /**
@@ -22,6 +24,10 @@ const databaseConfig = require('../../database/config');
  * @returns {UserRepositoryInterface} Configured repository adapter
  */
 function createUserRepository() {
+    if (isDocumentDB()) {
+        return new UserRepositoryDocumentDB();
+    }
+
     const dbType = databaseConfig.DB_TYPE;
 
     switch (dbType) {
@@ -40,7 +46,7 @@ function createUserRepository() {
 
 module.exports = {
     createUserRepository,
-    // Export adapters for direct testing
     UserRepositoryMongo,
     UserRepositoryPostgres,
+    UserRepositoryDocumentDB,
 };

package/websocket/repositories/websocket-connection-repository-documentdb.js

@@ -0,0 +1,64 @@
+const { ObjectId } = require('mongodb');
+const { getNativeMongoClient } = require('../../database/mongodb-native-client');
+const { EncryptedCollection } = require('../../database/encrypted-collection-wrapper');
+const { FieldEncryptionService } = require('../../database/encryption/field-encryption-service');
+const { getEncryptedFields } = require('../../database/encryption/encryption-schema-registry');
+const { Cryptor } = require('../../encrypt/Cryptor');
+const { WebsocketConnectionRepositoryInterface } = require('./websocket-connection-repository-interface');
+
+class WebsocketConnectionRepositoryDocumentDB extends WebsocketConnectionRepositoryInterface {
+    constructor() {
+        super();
+        
+        const nativeClient = getNativeMongoClient();
+        const collection = nativeClient.collection('WebsocketConnection');
+        
+        const cryptor = new Cryptor({ shouldUseAws: !!process.env.KMS_KEY_ARN });
+        const encryptionService = new FieldEncryptionService({
+            cryptor,
+            schema: { getEncryptedFields },
+        });
+        
+        this.collection = new EncryptedCollection(collection, encryptionService, 'WebsocketConnection');
+    }
+
+    async createConnection(connectionData) {
+        const doc = {
+            ...connectionData,
+            active: true,
+            createdAt: new Date(),
+        };
+
+        const result = await this.collection.insertOne(doc);
+        return await this.collection.findOne({ _id: result.insertedId });
+    }
+
+    async findActiveConnectionsByUserId(userId) {
+        return await this.collection.find({ userId, active: true });
+    }
+
+    async findConnectionById(connectionId) {
+        return await this.collection.findOne({ _id: new ObjectId(connectionId) });
+    }
+
+    async findConnectionByConnectionId(connectionId) {
+        return await this.collection.findOne({ connectionId });
+    }
+
+    async deactivateConnection(connectionId) {
+        await this.collection.updateOne(
+            { connectionId },
+            { $set: { active: false } }
+        );
+
+        return await this.findConnectionByConnectionId(connectionId);
+    }
+
+    async deleteConnection(connectionId) {
+        const result = await this.collection.deleteOne({ connectionId });
+        return result.deletedCount > 0;
+    }
+}
+
+module.exports = { WebsocketConnectionRepositoryDocumentDB };
+

package/websocket/repositories/websocket-connection-repository-factory.js

@@ -1,18 +1,14 @@
-const {
-    WebsocketConnectionRepositoryMongo,
-} = require('./websocket-connection-repository-mongo');
-const {
-    WebsocketConnectionRepositoryPostgres,
-} = require('./websocket-connection-repository-postgres');
+const { WebsocketConnectionRepositoryMongo } = require('./websocket-connection-repository-mongo');
+const { WebsocketConnectionRepositoryPostgres } = require('./websocket-connection-repository-postgres');
+const { WebsocketConnectionRepositoryDocumentDB } = require('./websocket-connection-repository-documentdb');
+const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
-/**
- * Websocket Connection Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * @returns {WebsocketConnectionRepositoryInterface} Configured repository adapter
- */
 function createWebsocketConnectionRepository() {
+    if (isDocumentDB()) {
+        return new WebsocketConnectionRepositoryDocumentDB();
+    }
+
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
@@ -31,7 +27,7 @@ function createWebsocketConnectionRepository() {
 
 module.exports = {
     createWebsocketConnectionRepository,
-    // Export adapters for direct testing
     WebsocketConnectionRepositoryMongo,
     WebsocketConnectionRepositoryPostgres,
+    WebsocketConnectionRepositoryDocumentDB,
 };