@friggframework/core 2.0.0-next.6 → 2.0.0-next.61

package/application/commands/user-commands.js

@@ -0,0 +1,283 @@
+const {
+    createUserRepository,
+} = require('../../user/repositories/user-repository-factory');
+
+const ERROR_CODE_MAP = {
+    USER_NOT_FOUND: 404,
+    USER_ALREADY_EXISTS: 409,
+    INVALID_USER_DATA: 400,
+};
+
+function mapErrorToResponse(error) {
+    const status = ERROR_CODE_MAP[error?.code] || 500;
+    return {
+        error: status,
+        reason: error?.message,
+        code: error?.code,
+    };
+}
+
+/**
+ * Create user command factory
+ *
+ * NOTE: This is an internal API. Integration developers should use createFriggCommands() instead.
+ *
+ * @returns {Object} User command object with CRUD operations
+ */
+function createUserCommands() {
+    const userRepository = createUserRepository();
+
+    return {
+        /**
+         * Create a new individual user
+         * @param {Object} params
+         * @param {string} params.username - Username (usually email)
+         * @param {string} [params.email] - Email address
+         * @param {string} [params.appUserId] - External application user ID
+         * @param {string} [params.password] - Password (optional)
+         * @returns {Promise<Object>} Created user object
+         */
+        async createUser({ username, email, appUserId, password } = {}) {
+            try {
+                if (!username) {
+                    const error = new Error('username is required');
+                    error.code = 'INVALID_USER_DATA';
+                    throw error;
+                }
+
+                const userData = { username };
+                if (email) userData.email = email;
+                if (appUserId) userData.appUserId = appUserId;
+                if (password) userData.password = password;
+
+                const user = await userRepository.createIndividualUser(
+                    userData
+                );
+
+                return {
+                    id: user.id,
+                    username: user.username,
+                    email: user.email,
+                    appUserId: user.appUserId,
+                };
+            } catch (error) {
+                if (error.code === 11000) {
+                    // Duplicate key error
+                    const duplicateError = new Error(
+                        `User with username '${username}' already exists`
+                    );
+                    duplicateError.code = 'USER_ALREADY_EXISTS';
+                    return mapErrorToResponse(duplicateError);
+                }
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Find a user by their application user ID
+         * @param {string} appUserId - External application user ID
+         * @returns {Promise<Object|null>} User object or null if not found
+         */
+        async findUserByAppUserId(appUserId) {
+            try {
+                if (!appUserId) {
+                    const error = new Error('appUserId is required');
+                    error.code = 'INVALID_USER_DATA';
+                    throw error;
+                }
+
+                const user = await userRepository.findIndividualUserByAppUserId(
+                    appUserId
+                );
+
+                if (!user) {
+                    return null;
+                }
+
+                return {
+                    id: user.id,
+                    username: user.username,
+                    email: user.email,
+                    appUserId: user.appUserId,
+                };
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Find a user by their username
+         * @param {string} username - Username to search for
+         * @returns {Promise<Object|null>} User object or null if not found
+         */
+        async findUserByUsername(username) {
+            try {
+                if (!username) {
+                    const error = new Error('username is required');
+                    error.code = 'INVALID_USER_DATA';
+                    throw error;
+                }
+
+                const user = await userRepository.findIndividualUserByUsername(
+                    username
+                );
+
+                if (!user) {
+                    return null;
+                }
+
+                return {
+                    id: user.id,
+                    username: user.username,
+                    email: user.email,
+                    appUserId: user.appUserId,
+                };
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Find an individual user by their ID
+         * @param {string} userId - Individual user ID to search for
+         * @returns {Promise<Object|null>} Individual user object or null if not found
+         */
+        async findIndividualUserById(userId) {
+            try {
+                if (!userId) {
+                    const error = new Error('userId is required');
+                    error.code = 'INVALID_USER_DATA';
+                    throw error;
+                }
+
+                const user = await userRepository.findIndividualUserById(
+                    userId
+                );
+
+                if (!user) {
+                    return null;
+                }
+
+                return {
+                    id: user._id?.toString() || user.id,
+                    username: user.username,
+                    email: user.email,
+                    appUserId: user.appUserId,
+                };
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Find an organization user by their ID
+         * @param {string} userId - Organization user ID to search for
+         * @returns {Promise<Object|null>} Organization user object or null if not found
+         */
+        async findOrganizationUserById(userId) {
+            try {
+                if (!userId) {
+                    const error = new Error('userId is required');
+                    error.code = 'INVALID_USER_DATA';
+                    throw error;
+                }
+
+                const user = await userRepository.findOrganizationUserById(
+                    userId
+                );
+
+                if (!user) {
+                    return null;
+                }
+
+                return {
+                    id: user.id,
+                    appOrgId: user.appOrgId,
+                    name: user.name,
+                };
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Update a user by ID
+         * @param {string} userId - User ID to update
+         * @param {Object} updates - Fields to update
+         * @returns {Promise<Object>} Updated user object
+         */
+        async updateUser(userId, updates) {
+            try {
+                if (!userId) {
+                    const error = new Error('userId is required');
+                    error.code = 'INVALID_USER_DATA';
+                    throw error;
+                }
+
+                const user = await userRepository.IndividualUser.update(
+                    userId,
+                    updates
+                );
+
+                if (!user) {
+                    const error = new Error(`User ${userId} not found`);
+                    error.code = 'USER_NOT_FOUND';
+                    throw error;
+                }
+
+                return {
+                    id: user._id.toString(),
+                    username: user.username,
+                    email: user.email,
+                    appUserId: user.appUserId,
+                };
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Delete a user by ID
+         *
+         * IMPORTANT: This does NOT automatically cascade delete related records in MongoDB.
+         * Integration developers MUST manually delete related data first:
+         * 1. Delete integrations (via deleteIntegrationById)
+         * 2. Delete entities (via deleteEntityById)
+         * 3. Delete credentials (via deleteCredentialById)
+         * 4. Finally delete user (via deleteUserById)
+         *
+         * @param {string} userId - User ID to delete
+         * @returns {Promise<Object>} Deletion result
+         */
+        async deleteUserById(userId) {
+            try {
+                if (!userId) {
+                    const error = new Error('userId is required');
+                    error.code = 'INVALID_USER_DATA';
+                    throw error;
+                }
+
+                const deleted = await userRepository.deleteUser(userId);
+
+                if (!deleted) {
+                    const error = new Error(`User ${userId} not found`);
+                    error.code = 'USER_NOT_FOUND';
+                    return mapErrorToResponse(error);
+                }
+
+                return {
+                    success: true,
+                    userId,
+                    message: 'User deleted successfully',
+                };
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+    };
+}
+
+module.exports = {
+    createUserCommands,
+    ERROR_CODE_MAP,
+};

package/application/index.js

@@ -0,0 +1,69 @@
+const {
+    createIntegrationCommands,
+    findIntegrationContextByExternalEntityId,
+} = require('./commands/integration-commands');
+const { createUserCommands } = require('./commands/user-commands');
+const { createEntityCommands } = require('./commands/entity-commands');
+const {
+    createCredentialCommands,
+} = require('./commands/credential-commands');
+
+/**
+ * Create a unified command factory with all CRUD operations
+ *
+ * This is the main entry point for integration developers to access all
+ * database operations without directly touching Mongoose models.
+ *
+ * @param {Object} params
+ * @param {Object} params.integrationClass - Integration class (required)
+ * @returns {Object} Unified commands object with all CRUD operations
+ *
+ * @example
+ * const commands = createFriggCommands({ integrationClass: MyIntegration });
+ * const user = await commands.createUser({ username: 'user@example.com' });
+ * const credential = await commands.createCredential({ userId: user.id, ... });
+ */
+function createFriggCommands({ integrationClass }) {
+    // All commands use Frigg's default repositories and use cases
+    const integrationCommands = createIntegrationCommands({ integrationClass });
+
+    const userCommands = createUserCommands();
+
+    const entityCommands = createEntityCommands();
+
+    const credentialCommands = createCredentialCommands();
+
+    return {
+        // Integration commands
+        ...integrationCommands,
+
+        // User commands
+        ...userCommands,
+
+        // Entity commands
+        ...entityCommands,
+
+        // Credential commands
+        ...credentialCommands,
+    };
+}
+
+module.exports = {
+    // Unified factory
+    createFriggCommands,
+
+    // Individual factories
+    createIntegrationCommands,
+    createUserCommands,
+    createEntityCommands,
+    createCredentialCommands,
+
+    // Legacy standalone function
+    findIntegrationContextByExternalEntityId,
+
+    // Deprecated - use createFriggCommands instead
+    integrationCommands: {
+        create: createIntegrationCommands,
+        findIntegrationContextByExternalEntityId,
+    },
+};