@friggframework/core 2.0.0-next.5 → 2.0.0-next.51

package/token/repositories/token-repository.js

@@ -0,0 +1,219 @@
+const { prisma } = require('../../database/prisma');
+const bcrypt = require('bcryptjs');
+const { TokenRepositoryInterface } = require('./token-repository-interface');
+
+const BCRYPT_ROUNDS = 10;
+
+/**
+ * Prisma-based Token Repository
+ * Handles persistence of authentication tokens with bcrypt hashing
+ *
+ * Works identically for both MongoDB and PostgreSQL:
+ * - MongoDB: String IDs with @db.ObjectId
+ * - PostgreSQL: Integer IDs with auto-increment
+ * - Both use same query patterns (no many-to-many differences)
+ *
+ * Migration from Mongoose:
+ * - Constructor injection of Prisma client
+ * - Static methods → Instance methods
+ * - Token.createTokenWithExpire() → createTokenWithExpire()
+ * - Token.validateAndGetTokenFromJSONToken() → validateAndGetToken()
+ * - Bcrypt hashing handled in repository layer
+ */
+class TokenRepository extends TokenRepositoryInterface {
+    constructor(prismaClient = prisma) {
+        super();
+        this.prisma = prismaClient; // Allow injection for testing
+    }
+
+    /**
+     * Create a token with expiration
+     * Replaces: Token.createTokenWithExpire(userId, rawToken, minutes)
+     *
+     * @param {string} userId - The user ID
+     * @param {string} rawToken - The raw (unhashed) token string
+     * @param {number} minutes - Minutes until expiration
+     * @returns {Promise<Object>} The created token record
+     */
+    async createTokenWithExpire(userId, rawToken, minutes) {
+        // Hash the token with bcrypt
+        const tokenHash = await bcrypt.hash(rawToken, BCRYPT_ROUNDS);
+
+        // Calculate expiration time
+        const expires = new Date(Date.now() + minutes * 60000);
+
+        return await this.prisma.token.create({
+            data: {
+                token: tokenHash,
+                expires,
+                userId,
+            },
+        });
+    }
+
+    /**
+     * Validate and retrieve token from JSON token object
+     * Replaces: Token.validateAndGetTokenFromJSONToken(tokenObj)
+     *
+     * @param {Object} tokenObj - Object with id and token properties
+     * @returns {Promise<Object>} The validated token record
+     * @throws {Error} If token is invalid, expired, or doesn't exist
+     */
+    async validateAndGetToken(tokenObj) {
+        const sessionToken = await this.prisma.token.findUnique({
+            where: { id: tokenObj.id },
+        });
+
+        if (!sessionToken) {
+            throw new Error('Invalid Token: Token does not exist');
+        }
+
+        // Verify token hash matches
+        const isValid = await bcrypt.compare(
+            tokenObj.token,
+            sessionToken.token
+        );
+        if (!isValid) {
+            throw new Error('Invalid Token: Token does not match');
+        }
+
+        // Check if token is expired
+        if (
+            sessionToken.expires &&
+            new Date(sessionToken.expires) < new Date()
+        ) {
+            throw new Error('Invalid Token: Token is expired');
+        }
+
+        return sessionToken;
+    }
+
+    /**
+     * Find a token by ID
+     * Replaces: Token.findById(tokenId)
+     *
+     * @param {string} tokenId - The token ID
+     * @returns {Promise<Object|null>} The token record or null
+     */
+    async findTokenById(tokenId) {
+        return await this.prisma.token.findUnique({
+            where: { id: tokenId },
+        });
+    }
+
+    /**
+     * Find tokens by user ID
+     * Replaces: Token.find({ user: userId })
+     *
+     * @param {string} userId - The user ID
+     * @returns {Promise<Array>} Array of token records
+     */
+    async findTokensByUserId(userId) {
+        return await this.prisma.token.findMany({
+            where: { userId },
+        });
+    }
+
+    /**
+     * Delete a token by ID
+     * Replaces: Token.deleteOne({ _id: tokenId })
+     *
+     * @param {string} tokenId - The token ID
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteToken(tokenId) {
+        try {
+            await this.prisma.token.delete({
+                where: { id: tokenId },
+            });
+            return { acknowledged: true, deletedCount: 1 };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return { acknowledged: true, deletedCount: 0 };
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Delete expired tokens
+     * Replaces: Token.deleteMany({ expires: { $lt: new Date() } })
+     *
+     * @returns {Promise<Object>} The deletion result with count
+     */
+    async deleteExpiredTokens() {
+        const result = await this.prisma.token.deleteMany({
+            where: {
+                expires: {
+                    lt: new Date(),
+                },
+            },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Delete all tokens for a user
+     * Replaces: Token.deleteMany({ user: userId })
+     *
+     * @param {string} userId - The user ID
+     * @returns {Promise<Object>} The deletion result
+     */
+    async deleteTokensByUserId(userId) {
+        const result = await this.prisma.token.deleteMany({
+            where: { userId },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+
+    /**
+     * Create JSON token string from token object and raw token
+     * Replaces: Token.createJSONToken(token, rawToken)
+     *
+     * @param {Object} token - The token record
+     * @param {string} rawToken - The raw token string
+     * @returns {string} JSON string with id and token
+     */
+    createJSONToken(token, rawToken) {
+        return JSON.stringify({
+            id: token.id,
+            token: rawToken,
+        });
+    }
+
+    /**
+     * Create base64 encoded buffer token
+     * Replaces: Token.createBase64BufferToken(token, rawToken)
+     *
+     * @param {Object} token - The token record
+     * @param {string} rawToken - The raw token string
+     * @returns {string} Base64 encoded token
+     */
+    createBase64BufferToken(token, rawToken) {
+        const jsonVal = this.createJSONToken(token, rawToken);
+        return Buffer.from(jsonVal).toString('base64');
+    }
+
+    /**
+     * Parse JSON token from base64 buffer
+     * Replaces: Token.getJSONTokenFromBase64BufferToken(buffer)
+     *
+     * @param {string} buffer - Base64 encoded token string
+     * @returns {Object} Parsed token object with id and token
+     */
+    getJSONTokenFromBase64BufferToken(buffer) {
+        const tokenStr = Buffer.from(buffer.trim(), 'base64').toString('ascii');
+        return JSON.parse(tokenStr);
+    }
+}
+
+module.exports = { TokenRepository };

package/types/core/index.d.ts

@@ -1,5 +1,5 @@
 declare module "@friggframework/core" {
-  import { SQS } from "aws-sdk";
+  import type { SendMessageCommandInput } from "@aws-sdk/client-sqs";
 
   export class Delegate implements IFriggDelegate {
     delegate: any;
@@ -50,5 +50,5 @@ declare module "@friggframework/core" {
     QueueOwnerAWSAccountId?: string;
   };
 
-  type SendSQSMessageParams = SQS.SendMessageRequest;
+  type SendSQSMessageParams = SendMessageCommandInput;
 }

package/types/integrations/index.d.ts

@@ -1,7 +1,6 @@
 declare module "@friggframework/integrations" {
   import { Delegate, IFriggDelegate } from "@friggframework/core";
   import { Model } from "mongoose";
-  import { EntityManager } from "@friggframework/module-plugin";
 
   export class Integration extends Model {
     entities: any[];
@@ -19,8 +18,7 @@ declare module "@friggframework/integrations" {
 
   export class IntegrationManager
     extends Delegate
-    implements IFriggIntegrationManager
-  {
+    implements IFriggIntegrationManager {
     integration: Integration;
     primaryInstance: any;
     targetInstance: any;
@@ -56,7 +54,6 @@ declare module "@friggframework/integrations" {
       entities: { id: string; user: any },
       userId: string,
       config: any,
-      EntityManager: EntityManager
     ): Promise<any>;
 
     static getFormattedIntegration(
@@ -116,8 +113,7 @@ declare module "@friggframework/integrations" {
   }
 
   export class IntegrationConfigManager
-    implements IFriggIntegrationConfigManager
-  {
+    implements IFriggIntegrationConfigManager {
     options: IntegrationOptions[];
     primary: any;
 

package/types/module-plugin/index.d.ts

@@ -4,72 +4,21 @@ declare module "@friggframework/module-plugin" {
 
   export class Credential extends Model {
     userId: string;
-    auth_is_valid: boolean;
-    subType: string;
+    authIsValid: boolean;
     externalId: string;
   }
 
-  export class EntityManager implements IFriggEntityManager {
-    static primaryEntityClass: any;
-    static entityManagerClasses: any[];
-    static entityTypes: string[];
-    static getEntitiesForUser(userId: string): Promise<any[]>;
-    static checkIsValidType(entityType: string): boolean;
-    static getEntityManagerClass(entityType?: string): any;
-
-    static getEntityManagerInstanceFromEntityId(
-      entityId: string,
-      userId: string
-    ): Promise<any>;
-  }
-
-  interface IFriggEntityManager {}
+  interface IFriggEntityManager { }
 
   export class Entity extends Model {
     credentialId: string;
-    subType: string;
     userId: string;
     name: string;
     externalId: string;
   }
 
   export type MappedEntity = Entity & { id: string; type: any };
-  export class ModuleManager extends Delegate implements IFriggModuleManager {
-    static Entity: Entity;
-    static Credential: Credential;
-
-    constructor(params: { userId: string });
 
-    static getName(): any;
-    static getInstance(params: any): Promise<any>;
-    static getEntitiesForUserId(userId: string): Promise<MappedEntity[]>;
-
-    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    findOrCreateEntity(params: any): Promise<any>;
-    getAllSyncObjects(SyncClass: any): Promise<any>;
-    getAuthorizationRequirements(params: any): Promise<any>;
-    getEntityId(): Promise<string>;
-    getEntityOptions(): Promise<any>;
-    markCredentialsInvalid(): Promise<Credential>;
-    processAuthorizationCallback(params: any): Promise<any>;
-    testAuth(params: any): Promise<any>;
-    validateAuthorizationRequirements(): Promise<boolean>;
-  }
-
-  interface IFriggModuleManager extends IFriggDelegate {
-    getEntityId(): Promise<string>;
-    validateAuthorizationRequirements(): Promise<boolean>;
-    getAuthorizationRequirements(params: any): Promise<any>;
-    testAuth(params: any): Promise<any>;
-    processAuthorizationCallback(params: any): Promise<any>;
-    getEntityOptions(): Promise<any>;
-    findOrCreateEntity(params: any): Promise<any>;
-    getAllSyncObjects(SyncClass: any): Promise<any>;
-    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    markCredentialsInvalid(): Promise<Credential>;
-  }
 
   export class Requester implements IFriggRequester {
     DLGT_INVALID_AUTH: string;
@@ -138,8 +87,7 @@ declare module "@friggframework/module-plugin" {
 
   export class ApiKeyRequester
     extends Requester
-    implements IFriggApiKeyRequester
-  {
+    implements IFriggApiKeyRequester {
     API_KEY_NAME: string;
     API_KEY_VALUE: any;
 
@@ -160,8 +108,7 @@ declare module "@friggframework/module-plugin" {
 
   export class BasicAuthRequester
     extends Requester
-    implements IFriggBasicAuthRequester
-  {
+    implements IFriggBasicAuthRequester {
     password: string;
     username: string;
 
@@ -189,8 +136,7 @@ declare module "@friggframework/module-plugin" {
 
   export class OAuth2Requester
     extends Requester
-    implements IFriggOAuth2Requester
-  {
+    implements IFriggOAuth2Requester {
     DLGT_TOKEN_DEAUTHORIZED: string;
     DLGT_TOKEN_UPDATE: string;
     accessTokenExpire: any;

package/types/syncs/index.d.ts

@@ -28,7 +28,6 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
-      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
     createSyncDBObject(objArr: any[], entities: any[]): Promise<any>;
@@ -50,7 +49,6 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
-      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
   }

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

@@ -0,0 +1,46 @@
+const { UserRepositoryMongo } = require('./user-repository-mongo');
+const { UserRepositoryPostgres } = require('./user-repository-postgres');
+const databaseConfig = 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() {
+    const dbType = databaseConfig.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new UserRepositoryMongo();
+
+        case 'postgresql':
+            return new UserRepositoryPostgres();
+
+        default:
+            throw new Error(
+                `Unsupported DB_TYPE: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createUserRepository,
+    // Export adapters for direct testing
+    UserRepositoryMongo,
+    UserRepositoryPostgres,
+};

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

@@ -0,0 +1,198 @@
+/**
+ * User Repository Interface
+ * Abstract base class defining the contract for user persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * Note: Currently, User model has identical structure across MongoDB and PostgreSQL,
+ * so UserRepository serves both. This interface exists for consistency and
+ * future-proofing if database-specific implementations become needed.
+ *
+ * @abstract
+ */
+class UserRepositoryInterface {
+    /**
+     * Get session token from base64 buffer token
+     *
+     * @param {string} token - Base64 buffer token
+     * @returns {Promise<Object>} Session token object
+     * @abstract
+     */
+    async getSessionToken(token) {
+        throw new Error(
+            'Method getSessionToken must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find organization user by ID
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<Object|null>} User object or null
+     * @abstract
+     */
+    async findOrganizationUserById(userId) {
+        throw new Error(
+            'Method findOrganizationUserById must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find individual user by ID
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<Object|null>} User object or null
+     * @abstract
+     */
+    async findIndividualUserById(userId) {
+        throw new Error(
+            'Method findIndividualUserById must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Create token with expiration
+     *
+     * @param {string|number} userId - User ID
+     * @param {string} rawToken - Raw unhashed token
+     * @param {number} minutes - Minutes until expiration (default 120)
+     * @returns {Promise<string>} Base64 buffer token
+     * @abstract
+     */
+    async createToken(userId, rawToken, minutes = 120) {
+        throw new Error('Method createToken must be implemented by subclass');
+    }
+
+    /**
+     * Create individual user
+     *
+     * @param {Object} params - User creation parameters
+     * @returns {Promise<Object>} Created user object
+     * @abstract
+     */
+    async createIndividualUser(params) {
+        throw new Error(
+            'Method createIndividualUser must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Create organization user
+     *
+     * @param {Object} params - Organization creation parameters
+     * @returns {Promise<Object>} Created organization object
+     * @abstract
+     */
+    async createOrganizationUser(params) {
+        throw new Error(
+            'Method createOrganizationUser must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find individual user by username
+     *
+     * @param {string} username - Username to search for
+     * @returns {Promise<Object|null>} User object or null
+     * @abstract
+     */
+    async findIndividualUserByUsername(username) {
+        throw new Error(
+            'Method findIndividualUserByUsername must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find individual user by app user ID
+     *
+     * @param {string} appUserId - App user ID to search for
+     * @returns {Promise<Object|null>} User object or null
+     * @abstract
+     */
+    async findIndividualUserByAppUserId(appUserId) {
+        throw new Error(
+            'Method findIndividualUserByAppUserId must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find organization user by app org ID
+     *
+     * @param {string} appOrgId - App organization ID to search for
+     * @returns {Promise<Object|null>} User object or null
+     * @abstract
+     */
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        throw new Error(
+            'Method findOrganizationUserByAppOrgId must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find user by ID (any type)
+     *
+     * @param {string|number} userId - User ID
+     * @returns {Promise<Object|null>} User object or null
+     * @abstract
+     */
+    async findUserById(userId) {
+        throw new Error('Method findUserById must be implemented by subclass');
+    }
+
+    /**
+     * Find individual user by email
+     *
+     * @param {string} email - Email to search for
+     * @returns {Promise<Object|null>} User object or null
+     * @abstract
+     */
+    async findIndividualUserByEmail(email) {
+        throw new Error(
+            'Method findIndividualUserByEmail must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Update individual user
+     *
+     * @param {string|number} userId - User ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated user object
+     * @abstract
+     */
+    async updateIndividualUser(userId, updates) {
+        throw new Error(
+            'Method updateIndividualUser must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Update organization user
+     *
+     * @param {string|number} userId - User ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated user object
+     * @abstract
+     */
+    async updateOrganizationUser(userId, updates) {
+        throw new Error(
+            'Method updateOrganizationUser must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Delete user by ID
+     *
+     * @param {string|number} userId - User ID to delete
+     * @returns {Promise<boolean>} True if deleted successfully
+     * @abstract
+     */
+    async deleteUser(userId) {
+        throw new Error('Method deleteUser must be implemented by subclass');
+    }
+}
+
+module.exports = { UserRepositoryInterface };