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

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

@@ -1,52 +1,27 @@
-const { UserRepositoryMongo } = require('./user-repository-mongo');
+const { UserRepositoryMongoDBNative } = require('./user-repository-mongodb-native');
 const { UserRepositoryPostgres } = require('./user-repository-postgres');
-const { UserRepositoryDocumentDB } = require('./user-repository-documentdb');
-const { isDocumentDB } = require('../../database/utils/documentdb-compatibility');
-const databaseConfig = require('../../database/config');
+const config = require('../../database/config');
 
-/**
- * User 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 = createUserRepository();
- * const user = await repository.findUserById(id); // ID is string
- * ```
- *
- * @returns {UserRepositoryInterface} Configured repository adapter
- */
 function createUserRepository() {
-    if (isDocumentDB()) {
-        return new UserRepositoryDocumentDB();
-    }
-
-    const dbType = databaseConfig.DB_TYPE;
+    const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new UserRepositoryMongo();
+        case 'documentdb':
+            return new UserRepositoryMongoDBNative();
 
         case 'postgresql':
             return new UserRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported DB_TYPE: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createUserRepository,
-    UserRepositoryMongo,
+    UserRepositoryMongoDBNative,
     UserRepositoryPostgres,
-    UserRepositoryDocumentDB,
 };

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

@@ -1,15 +1,15 @@
 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 { UserRepositoryInterface } = require('./user-repository-interface');
 const { createTokenRepository } = require('../../token/repositories/token-repository-factory');
 
 const BCRYPT_ROUNDS = 10;
 
-class UserRepositoryDocumentDB extends UserRepositoryInterface {
+class UserRepositoryMongoDBNative extends UserRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('User', 'User');
+        this._base = new BaseRepositoryMongoDBNative('User', 'User');
         this.tokenRepository = createTokenRepository();
     }
 
@@ -134,5 +134,5 @@ class UserRepositoryDocumentDB extends UserRepositoryInterface {
     }
 }
 
-module.exports = { UserRepositoryDocumentDB };
+module.exports = { UserRepositoryMongoDBNative };
 

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

@@ -1,33 +1,27 @@
-const { WebsocketConnectionRepositoryMongo } = require('./websocket-connection-repository-mongo');
+const { WebsocketConnectionRepositoryMongoDBNative } = require('./websocket-connection-repository-mongodb-native');
 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');
 
 function createWebsocketConnectionRepository() {
-    if (isDocumentDB()) {
-        return new WebsocketConnectionRepositoryDocumentDB();
-    }
-
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new WebsocketConnectionRepositoryMongo();
+        case 'documentdb':
+            return new WebsocketConnectionRepositoryMongoDBNative();
 
         case 'postgresql':
             return new WebsocketConnectionRepositoryPostgres();
 
         default:
             throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
             );
     }
 }
 
 module.exports = {
     createWebsocketConnectionRepository,
-    WebsocketConnectionRepositoryMongo,
+    WebsocketConnectionRepositoryMongoDBNative,
     WebsocketConnectionRepositoryPostgres,
-    WebsocketConnectionRepositoryDocumentDB,
 };

package/websocket/repositories/{websocket-connection-repository-documentdb.js → websocket-connection-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 { WebsocketConnectionRepositoryInterface } = require('./websocket-connection-repository-interface');
 
-class WebsocketConnectionRepositoryDocumentDB extends WebsocketConnectionRepositoryInterface {
+class WebsocketConnectionRepositoryMongoDBNative extends WebsocketConnectionRepositoryInterface {
     constructor() {
         super();
-        this._base = new BaseRepositoryDocumentDB('WebsocketConnection', 'WebsocketConnection');
+        this._base = new BaseRepositoryMongoDBNative('WebsocketConnection', 'WebsocketConnection');
     }
 
     get collection() {
@@ -50,5 +50,5 @@ class WebsocketConnectionRepositoryDocumentDB extends WebsocketConnectionReposit
     }
 }
 
-module.exports = { WebsocketConnectionRepositoryDocumentDB };
+module.exports = { WebsocketConnectionRepositoryMongoDBNative };
 

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

@@ -1,311 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    CredentialRepositoryInterface,
-} = require('./credential-repository-interface');
-const { BaseRepositoryMongoDB } = require('../../database/repositories/base-repository-mongodb');
-
-/**
- * MongoDB Credential Repository Adapter
- * Handles OAuth credentials and API tokens persistence with MongoDB
- *
- * MongoDB-specific characteristics:
- * - Uses String IDs (ObjectId)
- * - No ID conversion needed (IDs are already strings)
- * - Dynamic schema support via JSON field
- */
-class CredentialRepositoryMongo extends CredentialRepositoryInterface {
-    constructor() {
-        super();
-        
-        // Use MongoDB base repository for DocumentDB compatibility
-        const mongoBase = new BaseRepositoryMongoDB({ prismaClient: prisma });
-        this.prisma = mongoBase.prisma;
-    }
-
-    /**
-     * Find credential by ID
-     * Replaces: Credential.findById(id)
-     *
-     * @param {string} id - Credential ID
-     * @returns {Promise<Object|null>} Credential object or null
-     */
-    async findCredentialById(id) {
-        const credential = await this.prisma.credential.findUnique({
-            where: { id },
-        });
-
-        if (!credential) {
-            return null;
-        }
-
-        // Extract data from JSON field
-        const data = credential.data || {};
-
-        return {
-            _id: credential.id,
-            id: credential.id,
-            user: credential.userId,
-            userId: credential.userId,
-            externalId: credential.externalId,
-            authIsValid: credential.authIsValid,
-            ...data, // Spread OAuth tokens from JSON field
-        };
-    }
-
-    /**
-     * Update authentication status
-     * Replaces: Credential.updateOne({ _id: credentialId }, { $set: { authIsValid } })
-     *
-     * @param {string} credentialId - Credential ID
-     * @param {boolean} authIsValid - Authentication validity status
-     * @returns {Promise<Object>} Update result
-     */
-    async updateAuthenticationStatus(credentialId, authIsValid) {
-        await this.prisma.credential.update({
-            where: { id: credentialId },
-            data: { authIsValid },
-        });
-
-        return { acknowledged: true, modifiedCount: 1 };
-    }
-
-    /**
-     * Permanently remove a credential document
-     * Replaces: Credential.deleteOne({ _id: credentialId })
-     *
-     * @param {string} credentialId - Credential ID
-     * @returns {Promise<Object>} Deletion result
-     */
-    async deleteCredentialById(credentialId) {
-        try {
-            await this.prisma.credential.delete({
-                where: { id: credentialId },
-            });
-            return { acknowledged: true, deletedCount: 1 };
-        } catch (error) {
-            if (error.code === 'P2025') {
-                // Record not found
-                return { acknowledged: true, deletedCount: 0 };
-            }
-            throw error;
-        }
-    }
-
-    /**
-     * Create or update credential matching identifiers
-     * Replaces: Credential.findOneAndUpdate(query, update, { upsert: true })
-     *
-     * @param {{identifiers: Object, details: Object}} credentialDetails
-     * @returns {Promise<Object>} The persisted credential
-     */
-    async upsertCredential(credentialDetails) {
-        const { identifiers, details } = credentialDetails;
-        if (!identifiers)
-            throw new Error('identifiers required to upsert credential');
-
-        if (!identifiers.user && !identifiers.userId) {
-            throw new Error('user or userId required in identifiers');
-        }
-        if (!identifiers.externalId) {
-            throw new Error(
-                'externalId required in identifiers to prevent credential collision. ' +
-                'When multiple credentials exist for the same user, both userId and externalId ' +
-                'are needed to uniquely identify which credential to update.'
-            );
-        }
-
-        // Build where clause from identifiers
-        const where = this._convertIdentifiersToWhere(identifiers);
-
-        // Separate schema fields from dynamic OAuth data
-        const {
-            user,
-            userId,
-            externalId,
-            authIsValid,
-            
-            ...oauthData
-        } = details;
-
-        // Find existing credential
-        const existing = await this.prisma.credential.findFirst({ where });
-
-        if (existing) {
-            // Update existing - merge OAuth data into existing data JSON
-            const mergedData = { ...(existing.data || {}), ...oauthData };
-
-            const updated = await this.prisma.credential.update({
-                where: { id: existing.id },
-                data: {
-                    userId: userId || user || existing.userId,
-                    externalId:
-                        externalId !== undefined
-                            ? externalId
-                            : existing.externalId,
-                    authIsValid:
-                        authIsValid !== undefined
-                            ? authIsValid
-                            : existing.authIsValid,
-                    data: mergedData,
-                },
-            });
-
-            return {
-                id: updated.id,
-                externalId: updated.externalId,
-                userId: updated.userId,
-                authIsValid: updated.authIsValid,
-                ...(updated.data || {}),
-            };
-        }
-
-        // Create new credential
-        // DocumentDB compatibility handled by BaseRepositoryMongoDB wrapper
-        const created = await this.prisma.credential.create({
-            data: {
-                userId: userId || user,
-                externalId,
-                authIsValid: authIsValid,
-                data: oauthData,
-            },
-        });
-
-        return {
-            id: created.id,
-            externalId: created.externalId,
-            userId: created.userId,
-            authIsValid: created.authIsValid,
-            ...(created.data || {}),
-        };
-    }
-
-    /**
-     * Find a credential by filter criteria
-     * Replaces: Credential.findOne(query)
-     *
-     * @param {Object} filter
-     * @param {string} [filter.userId] - User ID
-     * @param {string} [filter.externalId] - External ID
-     * @param {string} [filter.credentialId] - Credential ID
-     * @returns {Promise<Object|null>} Credential object or null if not found
-     */
-    async findCredential(filter) {
-        const where = this._convertFilterToWhere(filter);
-
-        const credential = await this.prisma.credential.findFirst({
-            where,
-        });
-
-        if (!credential) {
-            return null;
-        }
-
-        const data = credential.data || {};
-
-        return {
-            id: credential.id,
-            userId: credential.userId,
-            externalId: credential.externalId,
-            authIsValid: credential.authIsValid,
-            access_token: data.access_token,
-            refresh_token: data.refresh_token,
-            domain: data.domain,
-            ...data,
-        };
-    }
-
-    /**
-     * Update a credential by ID
-     * Replaces: Credential.findByIdAndUpdate(credentialId, { $set: updates })
-     *
-     * @param {string} credentialId - Credential ID
-     * @param {Object} updates - Fields to update
-     * @returns {Promise<Object|null>} Updated credential object or null if not found
-     */
-    async updateCredential(credentialId, updates) {
-        // Get existing credential to merge OAuth data
-        const existing = await this.prisma.credential.findUnique({
-            where: { id: credentialId },
-        });
-
-        if (!existing) {
-            return null;
-        }
-
-        // Separate schema fields from OAuth data
-        const {
-            user,
-            userId,
-            externalId,
-            authIsValid,
-            
-            ...oauthData
-        } = updates;
-
-        // Merge OAuth data with existing
-        const mergedData = { ...(existing.data || {}), ...oauthData };
-
-        const updated = await this.prisma.credential.update({
-            where: { id: credentialId },
-            data: {
-                userId: userId || user || existing.userId,
-                externalId:
-                    externalId !== undefined ? externalId : existing.externalId,
-                authIsValid:
-                    authIsValid !== undefined ? authIsValid : existing.authIsValid,
-                data: mergedData,
-            },
-        });
-
-        const data = updated.data || {};
-
-        return {
-            id: updated.id,
-            userId: updated.userId,
-            externalId: updated.externalId,
-            authIsValid: updated.authIsValid,
-            access_token: data.access_token,
-            refresh_token: data.refresh_token,
-            domain: data.domain,
-            ...data,
-        };
-    }
-
-    /**
-     * Convert identifiers to Prisma where clause
-     * @private
-     * @param {Object} identifiers - Identifier fields
-     * @returns {Object} Prisma where clause
-     */
-    _convertIdentifiersToWhere(identifiers) {
-        const where = {};
-
-        if (identifiers._id) where.id = identifiers._id;
-        if (identifiers.id) where.id = identifiers.id;
-        if (identifiers.user) where.userId = identifiers.user;
-        if (identifiers.userId) where.userId = identifiers.userId;
-        if (identifiers.externalId) where.externalId = identifiers.externalId;
-
-        return where;
-    }
-
-    /**
-     * Convert filter to Prisma where clause
-     * @private
-     * @param {Object} filter - Filter criteria
-     * @returns {Object} Prisma where clause
-     */
-    _convertFilterToWhere(filter) {
-        const where = {};
-
-        if (filter.credentialId) where.id = filter.credentialId;
-        if (filter.id) where.id = filter.id;
-        if (filter.user) where.userId = filter.user;
-        if (filter.userId) where.userId = filter.userId;
-        if (filter.externalId) where.externalId = filter.externalId;
-
-        return where;
-    }
-}
-
-module.exports = { CredentialRepositoryMongo };

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

@@ -1,165 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    IntegrationMappingRepositoryInterface,
-} = require('./integration-mapping-repository-interface');
-const { BaseRepositoryMongoDB } = require('../../database/repositories/base-repository-mongodb');
-
-/**
- * MongoDB Integration Mapping Repository Adapter
- * Handles persistence of integration mappings used for data transformation
- *
- * MongoDB-specific characteristics:
- * - Uses String IDs (ObjectId)
- * - No ID conversion needed (IDs are already strings)
- * - mapping data stored in JSON field
- */
-class IntegrationMappingRepositoryMongo extends IntegrationMappingRepositoryInterface {
-    constructor() {
-        super();
-        
-        // Use MongoDB base repository for DocumentDB compatibility
-        const mongoBase = new BaseRepositoryMongoDB({ prismaClient: prisma });
-        this.prisma = mongoBase.prisma;
-    }
-
-    /**
-     * Convert any value to string (handles null/undefined)
-     * @private
-     * @param {*} value - Value to convert
-     * @returns {string|null|undefined} String value or null/undefined
-     */
-    _toString(value) {
-        if (value === null || value === undefined) return value;
-        return String(value);
-    }
-
-    /**
-     * Find mapping by integration ID and source ID
-     * Replaces: IntegrationMapping.findBy(integrationId, sourceId)
-     *
-     * @param {string} integrationId - The integration ID
-     * @param {string} sourceId - The source ID for lookup
-     * @returns {Promise<Object|null>} The mapping object with string IDs or null
-     */
-    async findMappingBy(integrationId, sourceId) {
-        return await this.prisma.integrationMapping.findFirst({
-            where: {
-                integrationId,
-                sourceId: this._toString(sourceId),
-            },
-        });
-    }
-
-    /**
-     * Create or update a mapping
-     * Replaces: IntegrationMapping.upsert(integrationId, sourceId, mapping)
-     *
-     * @param {string} integrationId - The integration ID
-     * @param {string} sourceId - The source ID for lookup
-     * @param {Object} mapping - The mapping data
-     * @returns {Promise<Object>} The created or updated mapping document with string IDs
-     */
-    async upsertMapping(integrationId, sourceId, mapping) {
-        return await this.prisma.integrationMapping.upsert({
-            where: {
-                integrationId_sourceId: {
-                    integrationId,
-                    sourceId: this._toString(sourceId),
-                },
-            },
-            update: {
-                mapping,
-            },
-            create: {
-                integrationId,
-                sourceId: this._toString(sourceId),
-                mapping,
-            },
-        });
-    }
-
-    /**
-     * Find all mappings for an integration
-     * Replaces: IntegrationMapping.find({ integration: integrationId })
-     *
-     * @param {string} integrationId - The integration ID
-     * @returns {Promise<Array>} Array of mapping documents with string IDs
-     */
-    async findMappingsByIntegration(integrationId) {
-        return await this.prisma.integrationMapping.findMany({
-            where: { integrationId },
-        });
-    }
-
-    /**
-     * Delete a mapping by integration and source ID
-     * Replaces: IntegrationMapping.deleteOne({ integration, sourceId })
-     *
-     * @param {string} integrationId - The integration ID
-     * @param {string} sourceId - The source ID
-     * @returns {Promise<Object>} The deletion result
-     */
-    async deleteMapping(integrationId, sourceId) {
-        try {
-            await this.prisma.integrationMapping.delete({
-                where: {
-                    integrationId_sourceId: {
-                        integrationId,
-                        sourceId: this._toString(sourceId),
-                    },
-                },
-            });
-            return { acknowledged: true, deletedCount: 1 };
-        } catch (error) {
-            if (error.code === 'P2025') {
-                // Record not found
-                return { acknowledged: true, deletedCount: 0 };
-            }
-            throw error;
-        }
-    }
-
-    /**
-     * Delete all mappings for an integration
-     * Replaces: IntegrationMapping.deleteMany({ integration: integrationId })
-     *
-     * @param {string} integrationId - The integration ID
-     * @returns {Promise<Object>} The deletion result
-     */
-    async deleteMappingsByIntegration(integrationId) {
-        const result = await this.prisma.integrationMapping.deleteMany({
-            where: { integrationId },
-        });
-
-        return {
-            acknowledged: true,
-            deletedCount: result.count,
-        };
-    }
-
-    /**
-     * Find mapping by ID
-     * @param {string} id - Mapping ID
-     * @returns {Promise<Object|null>} Mapping object with string IDs or null
-     */
-    async findMappingById(id) {
-        return await this.prisma.integrationMapping.findUnique({
-            where: { id },
-        });
-    }
-
-    /**
-     * Update mapping by ID
-     * @param {string} id - Mapping ID
-     * @param {Object} updates - Fields to update
-     * @returns {Promise<Object>} Updated mapping object with string IDs
-     */
-    async updateMapping(id, updates) {
-        return await this.prisma.integrationMapping.update({
-            where: { id },
-            data: updates,
-        });
-    }
-}
-
-module.exports = { IntegrationMappingRepositoryMongo };