@friggframework/core 2.0.0--canary.490.dfd8df5.0 → 2.0.0--canary.490.1d4d68c.0

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

@@ -1,7 +1,5 @@
-const { CredentialRepositoryMongo } = require('./credential-repository-mongo');
+const { CredentialRepositoryMongoDBNative } = require('./credential-repository-mongodb-native');
 const { CredentialRepositoryPostgres } = require('./credential-repository-postgres');
-const { CredentialRepositoryDocumentDB } = require('./credential-repository-documentdb');
-const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 /**
@@ -9,12 +7,15 @@ const config = require('../../database/config');
  * Creates the appropriate repository adapter based on database type
  *
  * Database-specific implementations:
- * - MongoDB: Uses String IDs (ObjectId), no conversion needed
- * - PostgreSQL: Uses Int IDs, converts String ↔ Int
+ * - MongoDB/DocumentDB: Uses native MongoDB driver (String IDs/ObjectId), no conversion needed
+ * - PostgreSQL: Uses Prisma with Int IDs, converts String ↔ Int
  *
  * All repository methods return String IDs regardless of database type,
  * ensuring application layer consistency.
  *
+ * MongoDB/DocumentDB: Uses native driver to avoid Prisma $$REMOVE operator issues
+ * PostgreSQL: Uses Prisma (no $$REMOVE issues)
+ *
  * Usage:
  * ```javascript
  * const repository = createCredentialRepository();
@@ -23,29 +24,26 @@ const config = require('../../database/config');
  * @returns {CredentialRepositoryInterface} Configured repository adapter
  */
 function createCredentialRepository() {
-    if (isDocumentDB()) {
-        return new CredentialRepositoryDocumentDB();
-    }
-
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new CredentialRepositoryMongo();
+        case 'documentdb':
+            // Both MongoDB and DocumentDB use native driver
+            return new CredentialRepositoryMongoDBNative();
 
         case 'postgresql':
             return new CredentialRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createCredentialRepository,
-    CredentialRepositoryMongo,
+    CredentialRepositoryMongoDBNative,
     CredentialRepositoryPostgres,
-    CredentialRepositoryDocumentDB,
 };

package/credential/repositories/{credential-repository-documentdb.js → credential-repository-mongodb-native.js}

@@ -1,11 +1,11 @@
 const { ObjectId } = require('mongodb');
-const { BaseRepositoryDocumentDB } = require('../../database/repositories/base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('../../database/repositories/base-repository-documentdb');
 const { CredentialRepositoryInterface } = require('./credential-repository-interface');
 
-class CredentialRepositoryDocumentDB extends CredentialRepositoryInterface {
+class CredentialRepositoryMongoDBNative extends CredentialRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('Credential', 'Credential');
+        this._base = new BaseRepositoryMongoDBNative('Credential', 'Credential');
     }
 
     get collection() {
@@ -129,5 +129,5 @@ class CredentialRepositoryDocumentDB extends CredentialRepositoryInterface {
     }
 }
 
-module.exports = { CredentialRepositoryDocumentDB };
+module.exports = { CredentialRepositoryMongoDBNative };
 

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

@@ -1,50 +1,27 @@
-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');
-
-/**
- * Factory function to create a health check repository for the configured database type.
- * Requires explicit prismaClient injection to support IoC container patterns.
- *
- * @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
- *
- * @example
- * const { prisma } = require('../prisma');
- * const repository = createHealthCheckRepository({ prismaClient: prisma });
- */
-function createHealthCheckRepository({ prismaClient } = {}) {
-    if (isDocumentDB()) {
-        return new HealthCheckRepositoryDocumentDB();
-    }
-
-    if (!prismaClient) {
-        throw new Error('prismaClient is required');
-    }
+const { HealthCheckRepositoryMongoDBNative } = require('./health-check-repository-mongodb-native');
+const { HealthCheckRepositoryPostgres } = require('./health-check-repository-postgres');
+const config = require('../../database/config');
 
+function createHealthCheckRepository() {
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new HealthCheckRepositoryMongoDB({ prismaClient });
+        case 'documentdb':
+            return new HealthCheckRepositoryMongoDBNative();
 
         case 'postgresql':
-            return new HealthCheckRepositoryPostgreSQL({ prismaClient });
+            return new HealthCheckRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createHealthCheckRepository,
-    HealthCheckRepositoryMongoDB,
-    HealthCheckRepositoryPostgreSQL,
-    HealthCheckRepositoryDocumentDB,
+    HealthCheckRepositoryMongoDBNative,
+    HealthCheckRepositoryPostgres,
 };

package/database/repositories/{health-check-repository-documentdb.js → health-check-repository-mongodb-native.js}

@@ -1,12 +1,12 @@
 const { ObjectId } = require('mongodb');
 const { getNativeMongoClient } = require('../mongodb-native-client');
-const { BaseRepositoryDocumentDB } = require('./base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('./base-repository-documentdb');
 const { HealthCheckRepositoryInterface } = require('./health-check-repository-interface');
 
-class HealthCheckRepositoryDocumentDB extends HealthCheckRepositoryInterface {
+class HealthCheckRepositoryMongoDBNative extends HealthCheckRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('Credential', 'Credential');
+        this._base = new BaseRepositoryMongoDBNative('Credential', 'Credential');
         this.nativeClient = getNativeMongoClient();
     }
 
@@ -59,5 +59,5 @@ class HealthCheckRepositoryDocumentDB extends HealthCheckRepositoryInterface {
     }
 }
 
-module.exports = { HealthCheckRepositoryDocumentDB };
+module.exports = { HealthCheckRepositoryMongoDBNative };
 

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

@@ -1,52 +1,27 @@
-const { IntegrationMappingRepositoryMongo } = require('./integration-mapping-repository-mongo');
+const { IntegrationMappingRepositoryMongoDBNative } = require('./integration-mapping-repository-mongodb-native');
 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');
 
-/**
- * Integration Mapping Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * Database-specific implementations:
- * - MongoDB: Uses String IDs (ObjectId), no conversion needed
- * - PostgreSQL: Uses Int IDs, converts String ↔ Int
- *
- * All repository methods return String IDs regardless of database type,
- * ensuring application layer consistency.
- *
- * Usage:
- * ```javascript
- * const repository = createIntegrationMappingRepository();
- * const mapping = await repository.findMappingBy(integrationId, sourceId);
- * ```
- *
- * @returns {IntegrationMappingRepositoryInterface} Configured repository adapter
- */
 function createIntegrationMappingRepository() {
-    if (isDocumentDB()) {
-        return new IntegrationMappingRepositoryDocumentDB();
-    }
-
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new IntegrationMappingRepositoryMongo();
+        case 'documentdb':
+            return new IntegrationMappingRepositoryMongoDBNative();
 
         case 'postgresql':
             return new IntegrationMappingRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createIntegrationMappingRepository,
-    IntegrationMappingRepositoryMongo,
+    IntegrationMappingRepositoryMongoDBNative,
     IntegrationMappingRepositoryPostgres,
-    IntegrationMappingRepositoryDocumentDB,
 };

package/integrations/repositories/{integration-mapping-repository-documentdb.js → integration-mapping-repository-mongodb-native.js}

@@ -1,11 +1,11 @@
 const { ObjectId } = require('mongodb');
-const { BaseRepositoryDocumentDB } = require('../../database/repositories/base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('../../database/repositories/base-repository-documentdb');
 const { IntegrationMappingRepositoryInterface } = require('./integration-mapping-repository-interface');
 
-class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
+class IntegrationMappingRepositoryMongoDBNative extends IntegrationMappingRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('IntegrationMapping', 'IntegrationMapping');
+        this._base = new BaseRepositoryMongoDBNative('IntegrationMapping', 'IntegrationMapping');
     }
 
     get collection() {
@@ -46,5 +46,5 @@ class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositor
     }
 }
 
-module.exports = { IntegrationMappingRepositoryDocumentDB };
+module.exports = { IntegrationMappingRepositoryMongoDBNative };
 

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

@@ -1,7 +1,5 @@
-const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
+const { IntegrationRepositoryMongoDBNative } = require('./integration-repository-mongodb-native');
 const { IntegrationRepositoryPostgres } = require('./integration-repository-postgres');
-const { IntegrationRepositoryDocumentDB } = require('./integration-repository-documentdb');
-const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 /**
@@ -10,9 +8,12 @@ const config = require('../../database/config');
  *
  * This implements the Factory pattern for Hexagonal Architecture:
  * - Reads database type from app definition (backend/index.js)
- * - Returns correct adapter (MongoDB or PostgreSQL)
+ * - Returns correct adapter (MongoDB Native Driver or Prisma for PostgreSQL)
  * - Provides clear error for unsupported databases
  *
+ * MongoDB/MongoDBNative: Uses native MongoDB driver (avoids Prisma $$REMOVE operator issues)
+ * PostgreSQL: Uses Prisma (no $$REMOVE issues)
+ *
  * Usage:
  * ```javascript
  * const repository = createIntegrationRepository();
@@ -22,29 +23,27 @@ 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) {
         case 'mongodb':
-            return new IntegrationRepositoryMongo();
+        case 'documentdb':
+        case 'mongodb-native':
+            // Both MongoDB and MongoDBNative use native driver
+            return new IntegrationRepositoryMongoDBNative();
 
         case 'postgresql':
             return new IntegrationRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'mongodb-native', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createIntegrationRepository,
-    IntegrationRepositoryMongo,
+    IntegrationRepositoryMongoDBNative,
     IntegrationRepositoryPostgres,
-    IntegrationRepositoryDocumentDB,
 };

package/integrations/repositories/{integration-repository-documentdb.js → integration-repository-mongodb-native.js}

@@ -1,11 +1,19 @@
 const { ObjectId } = require('mongodb');
-const { BaseRepositoryDocumentDB } = require('../../database/repositories/base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('../../database/repositories/base-repository-documentdb');
 const { IntegrationRepositoryInterface } = require('./integration-repository-interface');
 
-class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
+/**
+ * MongoDB Native Driver Repository for Integration
+ * 
+ * Uses native MongoDB driver instead of Prisma to avoid $$REMOVE operator issues.
+ * Works with both MongoDB and MongoDBNative.
+ * 
+ * Architecture: Hexagonal (Adapter layer)
+ */
+class IntegrationRepositoryMongoDBNative extends IntegrationRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('Integration', 'Integration');
+        this._base = new BaseRepositoryMongoDBNative('Integration', 'Integration');
     }
 
     get collection() {
@@ -89,5 +97,5 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     }
 }
 
-module.exports = { IntegrationRepositoryDocumentDB };
+module.exports = { IntegrationRepositoryMongoDBNative };
 

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

@@ -1,52 +1,27 @@
-const { ProcessRepositoryMongo } = require('./process-repository-mongo');
+const { ProcessRepositoryMongoDBNative } = require('./process-repository-mongodb-native');
 const { ProcessRepositoryPostgres } = require('./process-repository-postgres');
-const { ProcessRepositoryDocumentDB } = require('./process-repository-documentdb');
-const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
-/**
- * Process Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * This implements the Factory pattern for Hexagonal Architecture:
- * - Reads database type from app definition (backend/index.js)
- * - Returns correct adapter (MongoDB or PostgreSQL)
- * - Provides clear error for unsupported databases
- *
- * Usage:
- * ```javascript
- * const repository = createProcessRepository();
- * await repository.create({ userId, integrationId, name, type, state });
- * ```
- *
- * @returns {ProcessRepositoryInterface} Configured repository adapter
- * @throws {Error} If database type is not supported
- */
 function createProcessRepository() {
-    if (isDocumentDB()) {
-        return new ProcessRepositoryDocumentDB();
-    }
-
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new ProcessRepositoryMongo();
+        case 'documentdb':
+            return new ProcessRepositoryMongoDBNative();
 
         case 'postgresql':
             return new ProcessRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createProcessRepository,
-    ProcessRepositoryMongo,
+    ProcessRepositoryMongoDBNative,
     ProcessRepositoryPostgres,
-    ProcessRepositoryDocumentDB,
 };
-

package/integrations/repositories/{process-repository-documentdb.js → process-repository-mongodb-native.js}

@@ -1,11 +1,11 @@
 const { ObjectId } = require('mongodb');
-const { BaseRepositoryDocumentDB } = require('../../database/repositories/base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('../../database/repositories/base-repository-documentdb');
 const { ProcessRepositoryInterface } = require('./process-repository-interface');
 
-class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
+class ProcessRepositoryMongoDBNative extends ProcessRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('Process', 'Process');
+        this._base = new BaseRepositoryMongoDBNative('Process', 'Process');
     }
 
     get collection() {
@@ -47,5 +47,5 @@ class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
     }
 }
 
-module.exports = { ProcessRepositoryDocumentDB };
+module.exports = { ProcessRepositoryMongoDBNative };
 

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

@@ -1,33 +1,27 @@
-const { ModuleRepositoryMongo } = require('./module-repository-mongo');
+const { ModuleRepositoryMongoDBNative } = require('./module-repository-mongodb-native');
 const { ModuleRepositoryPostgres } = require('./module-repository-postgres');
-const { ModuleRepositoryDocumentDB } = require('./module-repository-documentdb');
-const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 function createModuleRepository() {
-    if (isDocumentDB()) {
-        return new ModuleRepositoryDocumentDB();
-    }
-
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new ModuleRepositoryMongo();
+        case 'documentdb':
+            return new ModuleRepositoryMongoDBNative();
 
         case 'postgresql':
             return new ModuleRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createModuleRepository,
-    ModuleRepositoryMongo,
+    ModuleRepositoryMongoDBNative,
     ModuleRepositoryPostgres,
-    ModuleRepositoryDocumentDB,
 };

package/modules/repositories/{module-repository-documentdb.js → module-repository-mongodb-native.js}

@@ -1,11 +1,11 @@
 const { ObjectId } = require('mongodb');
-const { BaseRepositoryDocumentDB } = require('../../database/repositories/base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('../../database/repositories/base-repository-documentdb');
 const { ModuleRepositoryInterface } = require('./module-repository-interface');
 
-class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
+class ModuleRepositoryMongoDBNative extends ModuleRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('Entity', 'Entity');
+        this._base = new BaseRepositoryMongoDBNative('Entity', 'Entity');
     }
 
     get collection() {
@@ -68,5 +68,5 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
     }
 }
 
-module.exports = { ModuleRepositoryDocumentDB };
+module.exports = { ModuleRepositoryMongoDBNative };
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.490.dfd8df5.0",
+    "version": "2.0.0--canary.490.1d4d68c.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.dfd8df5.0",
-        "@friggframework/prettier-config": "2.0.0--canary.490.dfd8df5.0",
-        "@friggframework/test": "2.0.0--canary.490.dfd8df5.0",
+        "@friggframework/eslint-config": "2.0.0--canary.490.1d4d68c.0",
+        "@friggframework/prettier-config": "2.0.0--canary.490.1d4d68c.0",
+        "@friggframework/test": "2.0.0--canary.490.1d4d68c.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": "dfd8df51792994e68efdcfe2aaf4725c10da74ca"
+    "gitHead": "1d4d68ca55433804a888e3b897fc3bfcd91cd0ba"
 }

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

@@ -1,33 +1,27 @@
-const { SyncRepositoryMongo } = require('./sync-repository-mongo');
+const { SyncRepositoryMongoDBNative } = require('./sync-repository-mongodb-native');
 const { SyncRepositoryPostgres } = require('./sync-repository-postgres');
-const { SyncRepositoryDocumentDB } = require('./sync-repository-documentdb');
-const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 function createSyncRepository() {
-    if (isDocumentDB()) {
-        return new SyncRepositoryDocumentDB();
-    }
-
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new SyncRepositoryMongo();
+        case 'documentdb':
+            return new SyncRepositoryMongoDBNative();
 
         case 'postgresql':
             return new SyncRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createSyncRepository,
-    SyncRepositoryMongo,
+    SyncRepositoryMongoDBNative,
     SyncRepositoryPostgres,
-    SyncRepositoryDocumentDB,
 };

package/syncs/repositories/{sync-repository-documentdb.js → sync-repository-mongodb-native.js}

@@ -1,11 +1,11 @@
 const { ObjectId } = require('mongodb');
-const { BaseRepositoryDocumentDB } = require('../../database/repositories/base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('../../database/repositories/base-repository-documentdb');
 const { SyncRepositoryInterface } = require('./sync-repository-interface');
 
-class SyncRepositoryDocumentDB extends SyncRepositoryInterface {
+class SyncRepositoryMongoDBNative extends SyncRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('Sync', 'Sync');
+        this._base = new BaseRepositoryMongoDBNative('Sync', 'Sync');
     }
 
     get collection() {
@@ -48,5 +48,5 @@ class SyncRepositoryDocumentDB extends SyncRepositoryInterface {
     }
 }
 
-module.exports = { SyncRepositoryDocumentDB };
+module.exports = { SyncRepositoryMongoDBNative };
 

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

@@ -1,33 +1,27 @@
-const { TokenRepositoryMongo } = require('./token-repository-mongo');
+const { TokenRepositoryMongoDBNative } = require('./token-repository-mongodb-native');
 const { TokenRepositoryPostgres } = require('./token-repository-postgres');
-const { TokenRepositoryDocumentDB } = require('./token-repository-documentdb');
-const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
 const config = require('../../database/config');
 
 function createTokenRepository() {
-    if (isDocumentDB()) {
-        return new TokenRepositoryDocumentDB();
-    }
-
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new TokenRepositoryMongo();
+        case 'documentdb':
+            return new TokenRepositoryMongoDBNative();
 
         case 'postgresql':
             return new TokenRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createTokenRepository,
-    TokenRepositoryMongo,
+    TokenRepositoryMongoDBNative,
     TokenRepositoryPostgres,
-    TokenRepositoryDocumentDB,
 };

package/token/repositories/{token-repository-documentdb.js → token-repository-mongodb-native.js}

@@ -1,14 +1,14 @@
 const { ObjectId } = require('mongodb');
 const bcrypt = require('bcryptjs');
-const { BaseRepositoryDocumentDB } = require('../../database/repositories/base-repository-documentdb');
+const { BaseRepositoryMongoDBNative } = require('../../database/repositories/base-repository-documentdb');
 const { TokenRepositoryInterface } = require('./token-repository-interface');
 
 const BCRYPT_ROUNDS = 10;
 
-class TokenRepositoryDocumentDB extends TokenRepositoryInterface {
+class TokenRepositoryMongoDBNative extends TokenRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('Token', 'Token');
+        this._base = new BaseRepositoryMongoDBNative('Token', 'Token');
     }
 
     get collection() {
@@ -77,5 +77,5 @@ class TokenRepositoryDocumentDB extends TokenRepositoryInterface {
     }
 }
 
-module.exports = { TokenRepositoryDocumentDB };
+module.exports = { TokenRepositoryMongoDBNative };