@friggframework/core 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.35ee143.0

package/modules/domain/entities/AuthorizationSession.js

@@ -1,131 +0,0 @@
-/**
- * AuthorizationSession Entity
- * Domain entity for multi-step authorization workflows
- *
- * Manages state for authentication flows that require multiple steps,
- * such as OTP verification, multi-factor authentication, or progressive
- * credential collection.
- *
- * @example
- * const session = new AuthorizationSession({
- *     sessionId: '550e8400-e29b-41d4-a716-446655440000',
- *     userId: 'user123',
- *     entityType: 'nagaris',
- *     currentStep: 1,
- *     maxSteps: 2,
- *     stepData: { email: 'user@example.com' },
- *     expiresAt: new Date(Date.now() + 15 * 60 * 1000)
- * });
- */
-class AuthorizationSession {
-    /**
-     * Create an authorization session
-     *
-     * @param {Object} params - Session parameters
-     * @param {string} params.sessionId - Unique session identifier (UUID)
-     * @param {string} params.userId - User ID who initiated the auth flow
-     * @param {string} params.entityType - Type of entity being authorized (module name)
-     * @param {number} [params.currentStep=1] - Current step in the auth flow
-     * @param {number} params.maxSteps - Total number of steps in the flow
-     * @param {Object} [params.stepData={}] - Accumulated data from previous steps
-     * @param {Date} params.expiresAt - Session expiration timestamp
-     * @param {boolean} [params.completed=false] - Whether auth flow is complete
-     * @param {Date} [params.createdAt=new Date()] - Session creation timestamp
-     * @param {Date} [params.updatedAt=new Date()] - Last update timestamp
-     */
-    constructor({
-        sessionId,
-        userId,
-        entityType,
-        currentStep = 1,
-        maxSteps,
-        stepData = {},
-        expiresAt,
-        completed = false,
-        createdAt = new Date(),
-        updatedAt = new Date(),
-    }) {
-        this.sessionId = sessionId;
-        this.userId = userId;
-        this.entityType = entityType;
-        this.currentStep = currentStep;
-        this.maxSteps = maxSteps;
-        this.stepData = stepData;
-        this.expiresAt = expiresAt;
-        this.completed = completed;
-        this.createdAt = createdAt;
-        this.updatedAt = updatedAt;
-
-        this.validate();
-    }
-
-    /**
-     * Validate session state
-     *
-     * @throws {Error} If validation fails
-     */
-    validate() {
-        if (!this.sessionId) {
-            throw new Error('Session ID is required');
-        }
-        if (!this.userId) {
-            throw new Error('User ID is required');
-        }
-        if (!this.entityType) {
-            throw new Error('Entity type is required');
-        }
-        if (this.currentStep < 1) {
-            throw new Error('Step must be >= 1');
-        }
-        if (this.currentStep > this.maxSteps) {
-            throw new Error('Current step cannot exceed max steps');
-        }
-        if (this.expiresAt < new Date()) {
-            throw new Error('Session has expired');
-        }
-    }
-
-    /**
-     * Advance to next step with new data
-     *
-     * @param {Object} newStepData - Data collected from current step
-     * @throws {Error} If session is already completed
-     */
-    advanceStep(newStepData) {
-        if (this.completed) {
-            throw new Error('Cannot advance completed session');
-        }
-
-        this.currentStep += 1;
-        this.stepData = { ...this.stepData, ...newStepData };
-        this.updatedAt = new Date();
-    }
-
-    /**
-     * Mark session as complete
-     */
-    markComplete() {
-        this.completed = true;
-        this.updatedAt = new Date();
-    }
-
-    /**
-     * Check if session has expired
-     *
-     * @returns {boolean} True if session is expired
-     */
-    isExpired() {
-        return this.expiresAt < new Date();
-    }
-
-    /**
-     * Check if session can advance to next step
-     *
-     * @returns {boolean} True if session can advance
-     */
-    canAdvance() {
-        return !this.completed && this.currentStep < this.maxSteps;
-    }
-}
-
-module.exports = { AuthorizationSession };

package/modules/domain/entities/index.js

@@ -1,10 +0,0 @@
-/**
- * Domain Entities Index
- * Export all domain entities for convenient importing
- */
-
-const { AuthorizationSession } = require('./AuthorizationSession');
-
-module.exports = {
-    AuthorizationSession,
-};

package/modules/repositories/authorization-session-repository-factory.js

@@ -1,55 +0,0 @@
-const {
-    AuthorizationSessionRepositoryMongo,
-} = require('./authorization-session-repository-mongo');
-const {
-    AuthorizationSessionRepositoryPostgres,
-} = require('./authorization-session-repository-postgres');
-
-/**
- * Authorization Session Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * Database-specific implementations:
- * - MongoDB: Uses String IDs (ObjectId), TTL index for auto-cleanup
- * - PostgreSQL: Uses Int IDs, manual cleanup via deleteExpired()
- *
- * All repository methods return AuthorizationSession domain entities,
- * ensuring application layer consistency regardless of database type.
- *
- * Environment Configuration:
- * - DB_TYPE=mongodb (default) - Uses MongoDB adapter
- * - DB_TYPE=postgresql - Uses PostgreSQL adapter
- *
- * @example
- * ```javascript
- * const repository = createAuthorizationSessionRepository();
- * const session = await repository.findBySessionId(sessionId);
- * ```
- *
- * @param {Object} [prismaClient] - Optional Prisma client for testing
- * @returns {AuthorizationSessionRepositoryInterface} Configured repository adapter
- * @throws {Error} If DB_TYPE is not supported
- */
-function createAuthorizationSessionRepository(prismaClient) {
-    const dbType = process.env.DB_TYPE || 'mongodb';
-
-    switch (dbType) {
-        case 'mongodb':
-            return new AuthorizationSessionRepositoryMongo(prismaClient);
-
-        case 'postgresql':
-            return new AuthorizationSessionRepositoryPostgres(prismaClient);
-
-        default:
-            throw new Error(
-                `Unsupported DB_TYPE: ${dbType}. Supported values: 'mongodb', 'postgresql'`
-            );
-    }
-}
-
-module.exports = {
-    createAuthorizationSessionRepository,
-    // Export adapters for direct testing
-    AuthorizationSessionRepositoryMongo,
-    AuthorizationSessionRepositoryPostgres,
-};

package/modules/repositories/authorization-session-repository-interface.js

@@ -1,75 +0,0 @@
-/**
- * Authorization Session Repository Interface
- * Abstract base class defining the contract for AuthorizationSession persistence adapters
- *
- * This follows the Port in Hexagonal Architecture:
- * - Domain layer depends on this abstraction
- * - Concrete adapters (MongoDB, PostgreSQL) implement this interface
- * - Use cases receive repositories via dependency injection
- *
- * @abstract
- */
-class AuthorizationSessionRepositoryInterface {
-    /**
-     * Create a new authorization session
-     *
-     * @param {import('../domain/entities/AuthorizationSession').AuthorizationSession} session - Session entity to create
-     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession>} Created session
-     * @abstract
-     */
-    async create(session) {
-        throw new Error('Method create must be implemented by subclass');
-    }
-
-    /**
-     * Find session by session ID
-     *
-     * @param {string} sessionId - Unique session identifier
-     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession|null>} Session entity or null if not found/expired
-     * @abstract
-     */
-    async findBySessionId(sessionId) {
-        throw new Error(
-            'Method findBySessionId must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Find active session for user and entity type
-     * Returns the most recent active (non-completed, non-expired) session
-     *
-     * @param {string} userId - User ID
-     * @param {string} entityType - Entity type (module name)
-     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession|null>} Session entity or null if not found
-     * @abstract
-     */
-    async findActiveSession(userId, entityType) {
-        throw new Error(
-            'Method findActiveSession must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Update existing session
-     *
-     * @param {import('../domain/entities/AuthorizationSession').AuthorizationSession} session - Session entity with updated data
-     * @returns {Promise<import('../domain/entities/AuthorizationSession').AuthorizationSession>} Updated session
-     * @abstract
-     */
-    async update(session) {
-        throw new Error('Method update must be implemented by subclass');
-    }
-
-    /**
-     * Delete expired sessions (cleanup operation)
-     * Should be called periodically to remove old sessions
-     *
-     * @returns {Promise<number>} Number of deleted sessions
-     * @abstract
-     */
-    async deleteExpired() {
-        throw new Error('Method deleteExpired must be implemented by subclass');
-    }
-}
-
-module.exports = { AuthorizationSessionRepositoryInterface };

package/modules/repositories/authorization-session-repository-mongo.js

@@ -1,169 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    AuthorizationSession,
-} = require('../domain/entities/AuthorizationSession');
-const {
-    AuthorizationSessionRepositoryInterface,
-} = require('./authorization-session-repository-interface');
-
-/**
- * MongoDB Authorization Session Repository Adapter
- * Handles AuthorizationSession persistence operations for MongoDB via Prisma
- *
- * MongoDB-specific characteristics:
- * - Uses String IDs (Prisma's default for MongoDB)
- * - TTL index on expiresAt for automatic cleanup
- * - No ID conversion needed (IDs are already strings)
- *
- * Schema Requirements (Prisma):
- * ```prisma
- * model AuthorizationSession {
- *   id          String   @id @default(auto()) @map("_id") @db.ObjectId
- *   sessionId   String   @unique
- *   userId      String
- *   entityType  String
- *   currentStep Int      @default(1)
- *   maxSteps    Int
- *   stepData    Json     @default("{}")
- *   expiresAt   DateTime
- *   completed   Boolean  @default(false)
- *   createdAt   DateTime @default(now())
- *   updatedAt   DateTime @updatedAt
- *
- *   @@index([sessionId])
- *   @@index([userId, entityType])
- *   @@index([expiresAt])
- *   @@index([completed])
- * }
- * ```
- */
-class AuthorizationSessionRepositoryMongo extends AuthorizationSessionRepositoryInterface {
-    constructor(prismaClient = prisma) {
-        super();
-        this.prisma = prismaClient; // Allow injection for testing
-    }
-
-    /**
-     * Create a new authorization session
-     *
-     * @param {AuthorizationSession} session - Session entity to create
-     * @returns {Promise<AuthorizationSession>} Created session entity
-     */
-    async create(session) {
-        const doc = await this.prisma.authorizationSession.create({
-            data: {
-                sessionId: session.sessionId,
-                userId: session.userId,
-                entityType: session.entityType,
-                currentStep: session.currentStep,
-                maxSteps: session.maxSteps,
-                stepData: session.stepData,
-                expiresAt: session.expiresAt,
-                completed: session.completed,
-            },
-        });
-
-        return this._toEntity(doc);
-    }
-
-    /**
-     * Find session by session ID
-     * Excludes expired sessions
-     *
-     * @param {string} sessionId - Unique session identifier
-     * @returns {Promise<AuthorizationSession|null>} Session entity or null
-     */
-    async findBySessionId(sessionId) {
-        const doc = await this.prisma.authorizationSession.findFirst({
-            where: {
-                sessionId,
-                expiresAt: { gt: new Date() },
-            },
-        });
-
-        return doc ? this._toEntity(doc) : null;
-    }
-
-    /**
-     * Find active session for user and entity type
-     * Returns most recent active session
-     *
-     * @param {string} userId - User ID
-     * @param {string} entityType - Entity type (module name)
-     * @returns {Promise<AuthorizationSession|null>} Session entity or null
-     */
-    async findActiveSession(userId, entityType) {
-        const doc = await this.prisma.authorizationSession.findFirst({
-            where: {
-                userId,
-                entityType,
-                completed: false,
-                expiresAt: { gt: new Date() },
-            },
-            orderBy: { createdAt: 'desc' },
-        });
-
-        return doc ? this._toEntity(doc) : null;
-    }
-
-    /**
-     * Update existing session
-     *
-     * @param {AuthorizationSession} session - Session entity with updated data
-     * @returns {Promise<AuthorizationSession>} Updated session entity
-     */
-    async update(session) {
-        const updated = await this.prisma.authorizationSession.update({
-            where: { sessionId: session.sessionId },
-            data: {
-                currentStep: session.currentStep,
-                stepData: session.stepData,
-                completed: session.completed,
-                updatedAt: new Date(),
-            },
-        });
-
-        return this._toEntity(updated);
-    }
-
-    /**
-     * Delete expired sessions (cleanup operation)
-     * Note: MongoDB TTL index handles automatic deletion, but this provides
-     * manual cleanup capability
-     *
-     * @returns {Promise<number>} Number of deleted sessions
-     */
-    async deleteExpired() {
-        const result = await this.prisma.authorizationSession.deleteMany({
-            where: {
-                expiresAt: { lt: new Date() },
-            },
-        });
-
-        return result.count;
-    }
-
-    /**
-     * Convert Prisma document to domain entity
-     *
-     * @private
-     * @param {Object} doc - Prisma document
-     * @returns {AuthorizationSession} Domain entity
-     */
-    _toEntity(doc) {
-        return new AuthorizationSession({
-            sessionId: doc.sessionId,
-            userId: doc.userId,
-            entityType: doc.entityType,
-            currentStep: doc.currentStep,
-            maxSteps: doc.maxSteps,
-            stepData: doc.stepData,
-            expiresAt: doc.expiresAt,
-            completed: doc.completed,
-            createdAt: doc.createdAt,
-            updatedAt: doc.updatedAt,
-        });
-    }
-}
-
-module.exports = { AuthorizationSessionRepositoryMongo };

package/modules/repositories/authorization-session-repository-postgres.js

@@ -1,170 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    AuthorizationSession,
-} = require('../domain/entities/AuthorizationSession');
-const {
-    AuthorizationSessionRepositoryInterface,
-} = require('./authorization-session-repository-interface');
-
-/**
- * PostgreSQL Authorization Session Repository Adapter
- * Handles AuthorizationSession persistence operations for PostgreSQL via Prisma
- *
- * PostgreSQL-specific characteristics:
- * - Uses Int IDs (auto-incrementing)
- * - Indexes on sessionId, userId+entityType, expiresAt, completed
- * - JSON/JSONB support for stepData
- * - No automatic TTL (manual cleanup via deleteExpired)
- *
- * Schema Requirements (Prisma):
- * ```prisma
- * model AuthorizationSession {
- *   id          Int      @id @default(autoincrement())
- *   sessionId   String   @unique
- *   userId      String
- *   entityType  String
- *   currentStep Int      @default(1)
- *   maxSteps    Int
- *   stepData    Json     @default("{}")
- *   expiresAt   DateTime
- *   completed   Boolean  @default(false)
- *   createdAt   DateTime @default(now())
- *   updatedAt   DateTime @updatedAt
- *
- *   @@index([sessionId])
- *   @@index([userId, entityType])
- *   @@index([expiresAt])
- *   @@index([completed])
- * }
- * ```
- */
-class AuthorizationSessionRepositoryPostgres extends AuthorizationSessionRepositoryInterface {
-    constructor(prismaClient = prisma) {
-        super();
-        this.prisma = prismaClient; // Allow injection for testing
-    }
-
-    /**
-     * Create a new authorization session
-     *
-     * @param {AuthorizationSession} session - Session entity to create
-     * @returns {Promise<AuthorizationSession>} Created session entity
-     */
-    async create(session) {
-        const created = await this.prisma.authorizationSession.create({
-            data: {
-                sessionId: session.sessionId,
-                userId: session.userId,
-                entityType: session.entityType,
-                currentStep: session.currentStep,
-                maxSteps: session.maxSteps,
-                stepData: session.stepData,
-                expiresAt: session.expiresAt,
-                completed: session.completed,
-            },
-        });
-
-        return this._toEntity(created);
-    }
-
-    /**
-     * Find session by session ID
-     * Excludes expired sessions
-     *
-     * @param {string} sessionId - Unique session identifier
-     * @returns {Promise<AuthorizationSession|null>} Session entity or null
-     */
-    async findBySessionId(sessionId) {
-        const record = await this.prisma.authorizationSession.findFirst({
-            where: {
-                sessionId,
-                expiresAt: { gt: new Date() },
-            },
-        });
-
-        return record ? this._toEntity(record) : null;
-    }
-
-    /**
-     * Find active session for user and entity type
-     * Returns most recent active session
-     *
-     * @param {string} userId - User ID
-     * @param {string} entityType - Entity type (module name)
-     * @returns {Promise<AuthorizationSession|null>} Session entity or null
-     */
-    async findActiveSession(userId, entityType) {
-        const record = await this.prisma.authorizationSession.findFirst({
-            where: {
-                userId,
-                entityType,
-                completed: false,
-                expiresAt: { gt: new Date() },
-            },
-            orderBy: { createdAt: 'desc' },
-        });
-
-        return record ? this._toEntity(record) : null;
-    }
-
-    /**
-     * Update existing session
-     *
-     * @param {AuthorizationSession} session - Session entity with updated data
-     * @returns {Promise<AuthorizationSession>} Updated session entity
-     */
-    async update(session) {
-        const updated = await this.prisma.authorizationSession.update({
-            where: { sessionId: session.sessionId },
-            data: {
-                currentStep: session.currentStep,
-                stepData: session.stepData,
-                completed: session.completed,
-                updatedAt: new Date(),
-            },
-        });
-
-        return this._toEntity(updated);
-    }
-
-    /**
-     * Delete expired sessions (cleanup operation)
-     * PostgreSQL doesn't have TTL indexes, so this must be called periodically
-     * Recommend running as cron job or scheduled task
-     *
-     * @returns {Promise<number>} Number of deleted sessions
-     */
-    async deleteExpired() {
-        const result = await this.prisma.authorizationSession.deleteMany({
-            where: {
-                expiresAt: { lt: new Date() },
-            },
-        });
-
-        return result.count;
-    }
-
-    /**
-     * Convert Prisma record to domain entity
-     *
-     * @private
-     * @param {Object} record - Prisma record
-     * @returns {AuthorizationSession} Domain entity
-     */
-    _toEntity(record) {
-        return new AuthorizationSession({
-            sessionId: record.sessionId,
-            userId: record.userId,
-            entityType: record.entityType,
-            currentStep: record.currentStep,
-            maxSteps: record.maxSteps,
-            stepData: record.stepData,
-            expiresAt: record.expiresAt,
-            completed: record.completed,
-            createdAt: record.createdAt,
-            updatedAt: record.updatedAt,
-        });
-    }
-}
-
-module.exports = { AuthorizationSessionRepositoryPostgres };

package/modules/use-cases/delete-module-entity.js

@@ -1,23 +0,0 @@
-/**
- * DeleteModuleEntity Use Case
- * Deletes a module entity by its ID
- */
-class DeleteModuleEntity {
-    constructor({ moduleRepository }) {
-        this.moduleRepository = moduleRepository;
-    }
-
-    async execute(entityId) {
-        const entity = await this.moduleRepository.findEntityById(entityId);
-
-        if (!entity) {
-            throw new Error(`Entity not found: ${entityId}`);
-        }
-
-        await this.moduleRepository.deleteEntity(entityId);
-
-        return true;
-    }
-}
-
-module.exports = { DeleteModuleEntity };