@friggframework/core 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

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

@@ -0,0 +1,169 @@
+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

@@ -0,0 +1,170 @@
+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/repositories/module-repository-documentdb.js

@@ -9,7 +9,9 @@ const {
     deleteOne,
 } = require('../../database/documentdb-utils');
 const { ModuleRepositoryInterface } = require('./module-repository-interface');
-const { DocumentDBEncryptionService } = require('../../database/documentdb-encryption-service');
+const {
+    DocumentDBEncryptionService,
+} = require('../../database/documentdb-encryption-service');
 
 /**
  * Module/Entity repository for DocumentDB.
@@ -50,16 +52,34 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
         }
         const filter = { userId: objectId };
         const docs = await findMany(this.prisma, 'Entity', filter);
-        const credentialMap = await this._fetchCredentialsBulk(docs.map((doc) => doc.credentialId));
-        return docs.map((doc) => this._mapEntity(doc, credentialMap.get(fromObjectId(doc.credentialId)) || null));
+        const credentialMap = await this._fetchCredentialsBulk(
+            docs.map((doc) => doc.credentialId)
+        );
+        return docs.map((doc) =>
+            this._mapEntity(
+                doc,
+                credentialMap.get(fromObjectId(doc.credentialId)) || null
+            )
+        );
     }
 
     async findEntitiesByIds(entitiesIds) {
-        const ids = (entitiesIds || []).map((id) => toObjectId(id)).filter(Boolean);
+        const ids = (entitiesIds || [])
+            .map((id) => toObjectId(id))
+            .filter(Boolean);
         if (ids.length === 0) return [];
-        const docs = await findMany(this.prisma, 'Entity', { _id: { $in: ids } });
-        const credentialMap = await this._fetchCredentialsBulk(docs.map((doc) => doc.credentialId));
-        return docs.map((doc) => this._mapEntity(doc, credentialMap.get(fromObjectId(doc.credentialId)) || null));
+        const docs = await findMany(this.prisma, 'Entity', {
+            _id: { $in: ids },
+        });
+        const credentialMap = await this._fetchCredentialsBulk(
+            docs.map((doc) => doc.credentialId)
+        );
+        return docs.map((doc) =>
+            this._mapEntity(
+                doc,
+                credentialMap.get(fromObjectId(doc.credentialId)) || null
+            )
+        );
     }
 
     async findEntitiesByUserIdAndModuleName(userId, moduleName) {
@@ -72,8 +92,15 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
             moduleName,
         };
         const docs = await findMany(this.prisma, 'Entity', filter);
-        const credentialMap = await this._fetchCredentialsBulk(docs.map((doc) => doc.credentialId));
-        return docs.map((doc) => this._mapEntity(doc, credentialMap.get(fromObjectId(doc.credentialId)) || null));
+        const credentialMap = await this._fetchCredentialsBulk(
+            docs.map((doc) => doc.credentialId)
+        );
+        return docs.map((doc) =>
+            this._mapEntity(
+                doc,
+                credentialMap.get(fromObjectId(doc.credentialId)) || null
+            )
+        );
     }
 
     async unsetCredential(entityId) {
@@ -174,7 +201,9 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
     async deleteEntity(entityId) {
         const objectId = toObjectId(entityId);
         if (!objectId) return false;
-        const result = await deleteOne(this.prisma, 'Entity', { _id: objectId });
+        const result = await deleteOne(this.prisma, 'Entity', {
+            _id: objectId,
+        });
         const deleted = result?.n ?? 0;
         return deleted > 0;
     }
@@ -190,13 +219,17 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
 
             // Use raw findOne to bypass Prisma encryption extension
             const rawCredential = await findOne(this.prisma, 'Credential', {
-                _id: objectId
+                _id: objectId,
             });
 
             if (!rawCredential) return null;
 
             // Decrypt sensitive fields using service
-            const decryptedCredential = await this.encryptionService.decryptFields('Credential', rawCredential);
+            const decryptedCredential =
+                await this.encryptionService.decryptFields(
+                    'Credential',
+                    rawCredential
+                );
 
             // Return in same format
             const credential = {
@@ -206,12 +239,15 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
                 authIsValid: decryptedCredential.authIsValid ?? null,
                 createdAt: decryptedCredential.createdAt,
                 updatedAt: decryptedCredential.updatedAt,
-                data: decryptedCredential.data
+                data: decryptedCredential.data,
             };
 
             return this._convertCredentialIds(credential);
         } catch (error) {
-            console.error(`Failed to fetch/decrypt credential ${id}:`, error.message);
+            console.error(
+                `Failed to fetch/decrypt credential ${id}:`,
+                error.message
+            );
             // Return null instead of throwing to allow graceful degradation
             // This repository is read-only (doesn't create/update credentials)
             // Entities can still be loaded even if their credential is corrupted/unreadable
@@ -229,45 +265,55 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
 
         try {
             // Convert string IDs to ObjectIds for bulk query
-            const objectIds = ids.map(id => toObjectId(id)).filter(Boolean);
+            const objectIds = ids.map((id) => toObjectId(id)).filter(Boolean);
             if (objectIds.length === 0) return new Map();
 
             // Use raw findMany to bypass Prisma encryption extension
             const rawCredentials = await findMany(this.prisma, 'Credential', {
-                _id: { $in: objectIds }
+                _id: { $in: objectIds },
             });
 
             // Decrypt all credentials in parallel
-            const decryptionPromises = rawCredentials.map(async (rawCredential) => {
-                try {
-                    // Decrypt sensitive fields using service
-                    const decryptedCredential = await this.encryptionService.decryptFields('Credential', rawCredential);
-
-                    // Build credential object in same format as Prisma would return
-                    const credential = {
-                        id: fromObjectId(decryptedCredential._id),
-                        userId: fromObjectId(decryptedCredential.userId),
-                        externalId: decryptedCredential.externalId ?? null,
-                        authIsValid: decryptedCredential.authIsValid ?? null,
-                        createdAt: decryptedCredential.createdAt,
-                        updatedAt: decryptedCredential.updatedAt,
-                        data: decryptedCredential.data
-                    };
-
-                    return this._convertCredentialIds(credential);
-                } catch (error) {
-                    const credId = fromObjectId(rawCredential._id);
-                    console.error(`Failed to decrypt credential ${credId}:`, error.message);
-                    return null;
+            const decryptionPromises = rawCredentials.map(
+                async (rawCredential) => {
+                    try {
+                        // Decrypt sensitive fields using service
+                        const decryptedCredential =
+                            await this.encryptionService.decryptFields(
+                                'Credential',
+                                rawCredential
+                            );
+
+                        // Build credential object in same format as Prisma would return
+                        const credential = {
+                            id: fromObjectId(decryptedCredential._id),
+                            userId: fromObjectId(decryptedCredential.userId),
+                            externalId: decryptedCredential.externalId ?? null,
+                            authIsValid:
+                                decryptedCredential.authIsValid ?? null,
+                            createdAt: decryptedCredential.createdAt,
+                            updatedAt: decryptedCredential.updatedAt,
+                            data: decryptedCredential.data,
+                        };
+
+                        return this._convertCredentialIds(credential);
+                    } catch (error) {
+                        const credId = fromObjectId(rawCredential._id);
+                        console.error(
+                            `Failed to decrypt credential ${credId}:`,
+                            error.message
+                        );
+                        return null;
+                    }
                 }
-            });
+            );
 
             // Wait for all decryptions to complete
             const decryptedCredentials = await Promise.all(decryptionPromises);
 
             // Build Map from results, filtering out nulls
             const map = new Map();
-            decryptedCredentials.forEach(credential => {
+            decryptedCredentials.forEach((credential) => {
                 if (credential) {
                     map.set(credential.id, credential);
                 }
@@ -308,12 +354,15 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
             if (userObj) query.userId = userObj;
         }
         if (filter.credential || filter.credentialId) {
-            const credObj = toObjectId(filter.credential || filter.credentialId);
+            const credObj = toObjectId(
+                filter.credential || filter.credentialId
+            );
             if (credObj) query.credentialId = credObj;
         }
         if (filter.name) query.name = filter.name;
         if (filter.moduleName) query.moduleName = filter.moduleName;
         if (filter.externalId) query.externalId = filter.externalId;
+        if (filter.isGlobal !== undefined) query.isGlobal = filter.isGlobal;
         return query;
     }
 
@@ -332,4 +381,3 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
 }
 
 module.exports = { ModuleRepositoryDocumentDB };
-

package/modules/repositories/module-repository-factory.js

@@ -1,8 +1,4 @@
-const { ModuleRepositoryMongo } = require('./module-repository-mongo');
 const { ModuleRepositoryPostgres } = require('./module-repository-postgres');
-const {
-    ModuleRepositoryDocumentDB,
-} = require('./module-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -16,12 +12,14 @@ function createModuleRepository() {
 
     switch (dbType) {
         case 'mongodb':
+            const { ModuleRepositoryMongo } = require('./module-repository-mongo');
             return new ModuleRepositoryMongo();
 
         case 'postgresql':
             return new ModuleRepositoryPostgres();
 
         case 'documentdb':
+            const { ModuleRepositoryDocumentDB } = require('./module-repository-documentdb');
             return new ModuleRepositoryDocumentDB();
 
         default:
@@ -34,7 +32,7 @@ function createModuleRepository() {
 module.exports = {
     createModuleRepository,
     // Export adapters for direct testing
-    ModuleRepositoryMongo,
+    get ModuleRepositoryMongo() { return require('./module-repository-mongo').ModuleRepositoryMongo; },
     ModuleRepositoryPostgres,
-    ModuleRepositoryDocumentDB,
+    get ModuleRepositoryDocumentDB() { return require('./module-repository-documentdb').ModuleRepositoryDocumentDB; },
 };

package/modules/repositories/module-repository-interface.js

@@ -91,6 +91,19 @@ class ModuleRepositoryInterface {
         throw new Error('Method findEntity must be implemented by subclass');
     }
 
+    /**
+     * Find entities matching filter criteria
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Array>} Array of entity objects
+     * @abstract
+     */
+    async findEntitiesBy(filter) {
+        throw new Error(
+            'Method findEntitiesBy must be implemented by subclass'
+        );
+    }
+
     /**
      * Create a new entity
      *