@friggframework/core 2.0.0-next.41 → 2.0.0-next.42

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

@@ -0,0 +1,250 @@
+//todo: this repository is tightly coupled to the token repository.
+const { prisma } = require('../../database/prisma');
+const {
+    createTokenRepository,
+} = require('../../token/repositories/token-repository-factory');
+const { UserRepositoryInterface } = require('./user-repository-interface');
+
+/**
+ * MongoDB User Repository Adapter
+ * Handles user operations with discriminator pattern support
+ *
+ * MongoDB-specific characteristics:
+ * - Uses String IDs (ObjectId)
+ * - No ID conversion needed (IDs are already strings)
+ * - IndividualUser/OrganizationUser discriminators → User model with type field
+ */
+class UserRepositoryMongo extends UserRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+        this.tokenRepository = createTokenRepository();
+    }
+
+    /**
+     * Get session token from base64 buffer token
+     * Delegates to TokenRepository
+     *
+     * @param {string} token - Base64 buffer token
+     * @returns {Promise<Object>} Session token object with string IDs
+     */
+    async getSessionToken(token) {
+        const jsonToken =
+            this.tokenRepository.getJSONTokenFromBase64BufferToken(token);
+        const sessionToken = await this.tokenRepository.validateAndGetToken(
+            jsonToken
+        );
+        return sessionToken;
+    }
+
+    /**
+     * Find organization user by ID
+     * Replaces: OrganizationUser.findById(userId)
+     *
+     * @param {string} userId - User ID
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findOrganizationUserById(userId) {
+        return await this.prisma.user.findFirst({
+            where: {
+                id: userId,
+                type: 'ORGANIZATION',
+            },
+        });
+    }
+
+    /**
+     * Find individual user by ID
+     * Replaces: IndividualUser.findById(userId)
+     *
+     * @param {string} userId - User ID
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserById(userId) {
+        return await this.prisma.user.findFirst({
+            where: {
+                id: userId,
+                type: 'INDIVIDUAL',
+            },
+        });
+    }
+
+    /**
+     * Create token with expiration
+     * Delegates to TokenRepository
+     *
+     * @param {string} userId - User ID
+     * @param {string} rawToken - Raw unhashed token
+     * @param {number} minutes - Minutes until expiration (default 120)
+     * @returns {Promise<string>} Base64 buffer token
+     */
+    async createToken(userId, rawToken, minutes = 120) {
+        const createdToken = await this.tokenRepository.createTokenWithExpire(
+            userId,
+            rawToken,
+            minutes
+        );
+        return this.tokenRepository.createBase64BufferToken(
+            createdToken,
+            rawToken
+        );
+    }
+
+    /**
+     * Create individual user
+     * Replaces: IndividualUser.create(params)
+     *
+     * @param {Object} params - User creation parameters
+     * @returns {Promise<Object>} Created user object with string IDs
+     */
+    async createIndividualUser(params) {
+        return await this.prisma.user.create({
+            data: {
+                type: 'INDIVIDUAL',
+                email: params.email,
+                username: params.username,
+                hashword: params.hashword,
+                appUserId: params.appUserId,
+                organizationId: params.organization || params.organizationId,
+            },
+        });
+    }
+
+    /**
+     * Create organization user
+     * Replaces: OrganizationUser.create(params)
+     *
+     * @param {Object} params - Organization creation parameters
+     * @returns {Promise<Object>} Created organization object with string IDs
+     */
+    async createOrganizationUser(params) {
+        return await this.prisma.user.create({
+            data: {
+                type: 'ORGANIZATION',
+                appOrgId: params.appOrgId,
+                name: params.name,
+            },
+        });
+    }
+
+    /**
+     * Find individual user by username
+     * Replaces: IndividualUser.findOne({ username })
+     *
+     * @param {string} username - Username to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserByUsername(username) {
+        return await this.prisma.user.findFirst({
+            where: {
+                type: 'INDIVIDUAL',
+                username,
+            },
+        });
+    }
+
+    /**
+     * Find individual user by app user ID
+     * Replaces: IndividualUser.getUserByAppUserId(appUserId)
+     *
+     * @param {string} appUserId - App user ID to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserByAppUserId(appUserId) {
+        return await this.prisma.user.findFirst({
+            where: {
+                type: 'INDIVIDUAL',
+                appUserId,
+            },
+        });
+    }
+
+    /**
+     * Find organization user by app org ID
+     * Replaces: OrganizationUser.getUserByAppOrgId(appOrgId)
+     *
+     * @param {string} appOrgId - App organization ID to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        return await this.prisma.user.findFirst({
+            where: {
+                type: 'ORGANIZATION',
+                appOrgId,
+            },
+        });
+    }
+
+    /**
+     * Find user by ID (any type)
+     * @param {string} userId - User ID
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findUserById(userId) {
+        return await this.prisma.user.findUnique({
+            where: { id: userId },
+        });
+    }
+
+    /**
+     * Find individual user by email
+     * @param {string} email - Email to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserByEmail(email) {
+        return await this.prisma.user.findFirst({
+            where: {
+                type: 'INDIVIDUAL',
+                email,
+            },
+        });
+    }
+
+    /**
+     * Update individual user
+     * @param {string} userId - User ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated user object with string IDs
+     */
+    async updateIndividualUser(userId, updates) {
+        return await this.prisma.user.update({
+            where: { id: userId },
+            data: updates,
+        });
+    }
+
+    /**
+     * Update organization user
+     * @param {string} userId - User ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated user object with string IDs
+     */
+    async updateOrganizationUser(userId, updates) {
+        return await this.prisma.user.update({
+            where: { id: userId },
+            data: updates,
+        });
+    }
+
+    /**
+     * Delete user by ID
+     * @param {string} userId - User ID to delete
+     * @returns {Promise<boolean>} True if deleted successfully
+     */
+    async deleteUser(userId) {
+        try {
+            await this.prisma.user.delete({
+                where: { id: userId },
+            });
+            return true;
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return false;
+            }
+            throw error;
+        }
+    }
+}
+
+module.exports = { UserRepositoryMongo };

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

@@ -0,0 +1,311 @@
+//todo: this repository is tightly coupled to the token repository.
+const { prisma } = require('../../database/prisma');
+const {
+    createTokenRepository,
+} = require('../../token/repositories/token-repository-factory');
+const { UserRepositoryInterface } = require('./user-repository-interface');
+
+/**
+ * PostgreSQL User Repository Adapter
+ * Handles user operations with discriminator pattern support
+ *
+ * PostgreSQL-specific characteristics:
+ * - Uses Int IDs with autoincrement
+ * - Requires ID conversion: String (app layer) ↔ Int (database)
+ * - All returned IDs are converted to strings for application layer consistency
+ */
+class UserRepositoryPostgres extends UserRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+        this.tokenRepository = createTokenRepository();
+    }
+
+    /**
+     * Convert string ID to integer for PostgreSQL queries
+     * @private
+     * @param {string|number|null|undefined} id - ID to convert
+     * @returns {number|null|undefined} Integer ID or null/undefined
+     * @throws {Error} If ID cannot be converted to integer
+     */
+    _convertId(id) {
+        if (id === null || id === undefined) return id;
+        const parsed = parseInt(id, 10);
+        if (isNaN(parsed)) {
+            throw new Error(`Invalid ID: ${id} cannot be converted to integer`);
+        }
+        return parsed;
+    }
+
+    /**
+     * Convert user object IDs to strings
+     * @private
+     * @param {Object|null} user - User object from database
+     * @returns {Object|null} User with string IDs
+     */
+    _convertUserIds(user) {
+        if (!user) return user;
+        return {
+            ...user,
+            id: user.id?.toString(),
+            organizationId: user.organizationId?.toString(),
+        };
+    }
+
+    /**
+     * Get session token from base64 buffer token
+     * Delegates to TokenRepository
+     *
+     * @param {string} token - Base64 buffer token
+     * @returns {Promise<Object>} Session token object with string IDs
+     */
+    async getSessionToken(token) {
+        const jsonToken =
+            this.tokenRepository.getJSONTokenFromBase64BufferToken(token);
+        const sessionToken = await this.tokenRepository.validateAndGetToken(
+            jsonToken
+        );
+        return sessionToken;
+    }
+
+    /**
+     * Find organization user by ID
+     * Replaces: OrganizationUser.findById(userId)
+     *
+     * @param {string} userId - User ID (string from application layer)
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findOrganizationUserById(userId) {
+        const intId = this._convertId(userId);
+        const user = await this.prisma.user.findFirst({
+            where: {
+                id: intId,
+                type: 'ORGANIZATION',
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Find individual user by ID
+     * Replaces: IndividualUser.findById(userId)
+     *
+     * @param {string} userId - User ID (string from application layer)
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserById(userId) {
+        const intId = this._convertId(userId);
+        const user = await this.prisma.user.findFirst({
+            where: {
+                id: intId,
+                type: 'INDIVIDUAL',
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Create token with expiration
+     * Delegates to TokenRepository
+     *
+     * @param {string} userId - User ID (string from application layer)
+     * @param {string} rawToken - Raw unhashed token
+     * @param {number} minutes - Minutes until expiration (default 120)
+     * @returns {Promise<string>} Base64 buffer token
+     */
+    async createToken(userId, rawToken, minutes = 120) {
+        const createdToken = await this.tokenRepository.createTokenWithExpire(
+            userId,
+            rawToken,
+            minutes
+        );
+        return this.tokenRepository.createBase64BufferToken(
+            createdToken,
+            rawToken
+        );
+    }
+
+    /**
+     * Create individual user
+     * Replaces: IndividualUser.create(params)
+     *
+     * @param {Object} params - User creation parameters (with string IDs from application layer)
+     * @returns {Promise<Object>} Created user object with string IDs
+     */
+    async createIndividualUser(params) {
+        const user = await this.prisma.user.create({
+            data: {
+                type: 'INDIVIDUAL',
+                email: params.email,
+                username: params.username,
+                hashword: params.hashword,
+                appUserId: params.appUserId,
+                organizationId: this._convertId(
+                    params.organization || params.organizationId
+                ),
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Create organization user
+     * Replaces: OrganizationUser.create(params)
+     *
+     * @param {Object} params - Organization creation parameters
+     * @returns {Promise<Object>} Created organization object with string IDs
+     */
+    async createOrganizationUser(params) {
+        const user = await this.prisma.user.create({
+            data: {
+                type: 'ORGANIZATION',
+                appOrgId: params.appOrgId,
+                name: params.name,
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Find individual user by username
+     * Replaces: IndividualUser.findOne({ username })
+     *
+     * @param {string} username - Username to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserByUsername(username) {
+        const user = await this.prisma.user.findFirst({
+            where: {
+                type: 'INDIVIDUAL',
+                username,
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Find individual user by app user ID
+     * Replaces: IndividualUser.getUserByAppUserId(appUserId)
+     *
+     * @param {string} appUserId - App user ID to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserByAppUserId(appUserId) {
+        const user = await this.prisma.user.findFirst({
+            where: {
+                type: 'INDIVIDUAL',
+                appUserId,
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Find organization user by app org ID
+     * Replaces: OrganizationUser.getUserByAppOrgId(appOrgId)
+     *
+     * @param {string} appOrgId - App organization ID to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        const user = await this.prisma.user.findFirst({
+            where: {
+                type: 'ORGANIZATION',
+                appOrgId,
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Find user by ID (any type)
+     * @param {string} userId - User ID (string from application layer)
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findUserById(userId) {
+        const intId = this._convertId(userId);
+        const user = await this.prisma.user.findUnique({
+            where: { id: intId },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Find individual user by email
+     * @param {string} email - Email to search for
+     * @returns {Promise<Object|null>} User object with string IDs or null
+     */
+    async findIndividualUserByEmail(email) {
+        const user = await this.prisma.user.findFirst({
+            where: {
+                type: 'INDIVIDUAL',
+                email,
+            },
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Update individual user
+     * @param {string} userId - User ID (string from application layer)
+     * @param {Object} updates - Fields to update (with string IDs from application layer)
+     * @returns {Promise<Object>} Updated user object with string IDs
+     */
+    async updateIndividualUser(userId, updates) {
+        const intId = this._convertId(userId);
+
+        // Convert organizationId if present in updates
+        const data = { ...updates };
+        if (data.organizationId !== undefined) {
+            data.organizationId = this._convertId(data.organizationId);
+        }
+        if (data.organization !== undefined) {
+            data.organizationId = this._convertId(data.organization);
+            delete data.organization;
+        }
+
+        const user = await this.prisma.user.update({
+            where: { id: intId },
+            data,
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Update organization user
+     * @param {string} userId - User ID (string from application layer)
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Updated user object with string IDs
+     */
+    async updateOrganizationUser(userId, updates) {
+        const intId = this._convertId(userId);
+        const user = await this.prisma.user.update({
+            where: { id: intId },
+            data: updates,
+        });
+        return this._convertUserIds(user);
+    }
+
+    /**
+     * Delete user by ID
+     * @param {string} userId - User ID to delete (string from application layer)
+     * @returns {Promise<boolean>} True if deleted successfully
+     */
+    async deleteUser(userId) {
+        try {
+            const intId = this._convertId(userId);
+            await this.prisma.user.delete({
+                where: { id: intId },
+            });
+            return true;
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return false;
+            }
+            throw error;
+        }
+    }
+}
+
+module.exports = { UserRepositoryPostgres };

package/user/tests/doubles/test-user-repository.js

@@ -0,0 +1,72 @@
+const Boom = require('@hapi/boom');
+const { User } = require('../../user');
+
+class TestUserRepository {
+    constructor({ userConfig }) {
+        this.individualUsers = new Map();
+        this.organizationUsers = new Map();
+        this.tokens = new Map();
+        this.userConfig = userConfig;
+    }
+
+    async getSessionToken(token) {
+        return this.tokens.get(token);
+    }
+
+    async findOrganizationUserById(userId) {
+        return this.organizationUsers.get(userId);
+    }
+
+    async findIndividualUserById(userId) {
+        return this.individualUsers.get(userId);
+    }
+
+    async createToken(userId, rawToken, minutes = 120) {
+        const token = `token-for-${userId}-for-${minutes}-mins`;
+        this.tokens.set(token, { user: userId, rawToken });
+        return token;
+    }
+
+    async createIndividualUser(params) {
+        const individualUserData = { id: `individual-${Date.now()}`, ...params };
+        this.individualUsers.set(individualUserData.id, individualUserData);
+        return individualUserData;
+    }
+
+    async createOrganizationUser(params) {
+        const orgUserData = { ...params, id: `org-${Date.now()}` };
+        this.organizationUsers.set(orgUserData.id, orgUserData);
+        return orgUserData;
+    }
+
+    async findIndividualUserByUsername(username) {
+        for (const userDoc of this.individualUsers.values()) {
+            if (userDoc.username === username) {
+                return userDoc;
+            }
+        }
+        return null;
+    }
+
+    async findIndividualUserByAppUserId(appUserId) {
+        if (!appUserId) return null;
+        for (const userDoc of this.individualUsers.values()) {
+            if (userDoc.appUserId === appUserId) {
+                return userDoc;
+            }
+        }
+        return null;
+    }
+
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        if (!appOrgId) return null;
+        for (const userDoc of this.organizationUsers.values()) {
+            if (userDoc.appOrgId === appOrgId) {
+                return userDoc;
+            }
+        }
+        return null;
+    }
+}
+
+module.exports = { TestUserRepository }; 

package/user/tests/use-cases/create-individual-user.test.js

@@ -0,0 +1,24 @@
+const {
+    CreateIndividualUser,
+} = require('../../use-cases/create-individual-user');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+describe('CreateIndividualUser Use Case', () => {
+    it('should create and return an individual user via the repository', async () => {
+        const userConfig = { usePassword: true };
+        const userRepository = new TestUserRepository({ userConfig });
+        const createIndividualUser = new CreateIndividualUser({
+            userRepository,
+            userConfig,
+        });
+
+        const params = {
+            username: 'test-user',
+            password: 'password123',
+        };
+        const user = await createIndividualUser.execute(params);
+
+        expect(user).toBeDefined();
+        expect(user.getIndividualUser().username).toBe(params.username);
+    });
+});

package/user/tests/use-cases/create-organization-user.test.js

@@ -0,0 +1,28 @@
+const {
+    CreateOrganizationUser,
+} = require('../../use-cases/create-organization-user');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+describe('CreateOrganizationUser Use Case', () => {
+    it('should create and return an organization user via the repository', async () => {
+        const userConfig = {
+            primary: 'organization',
+            organizationUserRequired: true,
+            individualUserRequired: false,
+        };
+        const userRepository = new TestUserRepository({ userConfig });
+        const createOrganizationUser = new CreateOrganizationUser({
+            userRepository,
+            userConfig,
+        });
+
+        const params = {
+            name: 'Test Org',
+            appOrgId: 'org-123',
+        };
+        const user = await createOrganizationUser.execute(params);
+
+        expect(user).toBeDefined();
+        expect(user.getOrganizationUser().name).toBe(params.name);
+    });
+}); 

package/user/tests/use-cases/create-token-for-user-id.test.js

@@ -0,0 +1,19 @@
+const {
+    CreateTokenForUserId,
+} = require('../../use-cases/create-token-for-user-id');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+describe('CreateTokenForUserId Use Case', () => {
+    it('should create and return a token via the repository', async () => {
+        const userConfig = {}; // Not used by this use case, but required by the test repo
+        const userRepository = new TestUserRepository({ userConfig });
+        const createTokenForUserId = new CreateTokenForUserId({ userRepository });
+
+        const userId = 'user-123';
+        const token = await createTokenForUserId.execute(userId);
+
+        expect(token).toBeDefined();
+        // The mock token is deterministic, so we can check it
+        expect(token).toContain(`token-for-${userId}`);
+    });
+});