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

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

@@ -58,7 +58,9 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
             return new Map();
         }
 
-        const validIds = credentialIds.filter(id => id !== null && id !== undefined);
+        const validIds = credentialIds.filter(
+            (id) => id !== null && id !== undefined
+        );
 
         if (validIds.length === 0) {
             return new Map();
@@ -118,7 +120,9 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
             where: { userId },
         });
 
-        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialIds = entities
+            .map((e) => e.credentialId)
+            .filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
         return entities.map((e) => ({
@@ -144,7 +148,9 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
             where: { id: { in: entitiesIds } },
         });
 
-        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialIds = entities
+            .map((e) => e.credentialId)
+            .filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
         return entities.map((e) => ({
@@ -174,7 +180,9 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
             },
         });
 
-        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialIds = entities
+            .map((e) => e.credentialId)
+            .filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
         return entities.map((e) => ({
@@ -234,6 +242,31 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         };
     }
 
+    /**
+     * Find entities matching filter criteria
+     * @param {Object} filter - Filter criteria (e.g., { isGlobal: true, moduleName: 'api-name' })
+     * @returns {Promise<Array>} Array of entity objects with string IDs
+     */
+    async findEntitiesBy(filter) {
+        const where = this._convertFilterToWhere(filter);
+        const entities = await this.prisma.entity.findMany({
+            where,
+            include: { credential: true },
+        });
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: e.credential,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            type: e.subType,
+            moduleName: e.moduleName,
+            isGlobal: e.isGlobal,
+        }));
+    }
+
     /**
      * Create a new entity
      * Replaces: Entity.create(entityData)
@@ -399,7 +432,9 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         if (filter.credentialId) where.credentialId = filter.credentialId;
         if (filter.name) where.name = filter.name;
         if (filter.moduleName) where.moduleName = filter.moduleName;
-        if (filter.externalId) where.externalId = this._toString(filter.externalId);
+        if (filter.externalId)
+            where.externalId = this._toString(filter.externalId);
+        if (filter.isGlobal !== undefined) where.isGlobal = filter.isGlobal;
 
         return where;
     }

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

@@ -87,7 +87,9 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
             return new Map();
         }
 
-        const validIds = credentialIds.filter(id => id !== null && id !== undefined);
+        const validIds = credentialIds.filter(
+            (id) => id !== null && id !== undefined
+        );
 
         if (validIds.length === 0) {
             return new Map();
@@ -154,7 +156,9 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
             where: { userId: intUserId },
         });
 
-        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialIds = entities
+            .map((e) => e.credentialId)
+            .filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
         return entities.map((e) => ({
@@ -182,7 +186,9 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
             where: { id: { in: intIds } },
         });
 
-        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialIds = entities
+            .map((e) => e.credentialId)
+            .filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
         return entities.map((e) => ({
@@ -214,7 +220,9 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
             },
         });
 
-        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
+        const credentialIds = entities
+            .map((e) => e.credentialId)
+            .filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
         return entities.map((e) => ({
@@ -275,6 +283,33 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
         };
     }
 
+    /**
+     * Find entities matching filter criteria
+     * Replaces: Entity.find(filter).populate('credential')
+     *
+     * @param {Object} filter - Filter criteria (e.g., { isGlobal: true, type: 'someType', status: 'connected' })
+     * @returns {Promise<Array>} Array of entity objects with string IDs
+     */
+    async findEntitiesBy(filter) {
+        const where = this._convertFilterToWhere(filter);
+        const entities = await this.prisma.entity.findMany({
+            where,
+            include: { credential: true },
+        });
+
+        return entities.map((e) => ({
+            id: e.id.toString(),
+            accountId: e.accountId,
+            credential: this._convertCredentialIds(e.credential),
+            userId: e.userId?.toString(),
+            name: e.name,
+            externalId: e.externalId,
+            type: e.subType,
+            moduleName: e.moduleName,
+            isGlobal: e.isGlobal,
+        }));
+    }
+
     /**
      * Create a new entity
      * Replaces: Entity.create(entityData)
@@ -444,7 +479,9 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
             where.credentialId = this._convertId(filter.credentialId);
         if (filter.name) where.name = filter.name;
         if (filter.moduleName) where.moduleName = filter.moduleName;
-        if (filter.externalId) where.externalId = this._toString(filter.externalId);
+        if (filter.externalId)
+            where.externalId = this._toString(filter.externalId);
+        if (filter.isGlobal !== undefined) where.isGlobal = filter.isGlobal;
 
         return where;
     }

package/modules/repositories/module-repository.js

@@ -172,6 +172,33 @@ class ModuleRepository extends ModuleRepositoryInterface {
         };
     }
 
+    /**
+     * Find entities matching filter criteria
+     * Replaces: Entity.find(filter).populate('credential')
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Array>} Array of entity objects
+     */
+    async findEntitiesBy(filter) {
+        const where = this._convertFilterToWhere(filter);
+        const entities = await this.prisma.entity.findMany({
+            where,
+            include: { credential: true },
+        });
+
+        return entities.map((e) => ({
+            id: e.id,
+            accountId: e.accountId,
+            credential: e.credential,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            type: e.subType,
+            moduleName: e.moduleName,
+            isGlobal: e.isGlobal,
+        }));
+    }
+
     /**
      * Create a new entity
      * Replaces: Entity.create(entityData)
@@ -337,6 +364,7 @@ class ModuleRepository extends ModuleRepositoryInterface {
         if (filter.name) where.name = filter.name;
         if (filter.moduleName) where.moduleName = filter.moduleName;
         if (filter.externalId) where.externalId = filter.externalId;
+        if (filter.isGlobal !== undefined) where.isGlobal = filter.isGlobal;
 
         return where;
     }

package/modules/requester/api-key.js

@@ -2,9 +2,7 @@ const { Requester } = require('./requester');
 const { get } = require('../../assertions');
 const { ModuleConstants } = require('../ModuleConstants');
 
-
 class ApiKeyRequester extends Requester {
-
     static requesterType = ModuleConstants.authType.apiKey;
 
     constructor(params) {

package/modules/requester/basic.js

@@ -3,7 +3,6 @@ const { get } = require('../../assertions');
 const { ModuleConstants } = require('../ModuleConstants');
 
 class BasicAuthRequester extends Requester {
-
     static requesterType = ModuleConstants.authType.basic;
 
     constructor(params) {

package/modules/requester/oauth-2.js

@@ -117,16 +117,6 @@ class OAuth2Requester extends Requester {
         const newRefreshToken = get(params, 'refresh_token', null);
         if (newRefreshToken !== null) {
             this.refresh_token = newRefreshToken;
-        } else {
-            if (this.refresh_token) {
-                console.log(
-                    '[Frigg] No refresh_token in response, preserving existing'
-                );
-            } else {
-                console.log(
-                    '[Frigg] Current refresh_token is null and no new refresh_token in response'
-                );
-            }
         }
         const accessExpiresIn = get(params, 'expires_in', null);
         const refreshExpiresIn = get(
@@ -248,7 +238,6 @@ class OAuth2Requester extends Requester {
                 'Content-Type': 'application/x-www-form-urlencoded',
             },
         };
-        console.log('[Frigg] Refreshing access token with options');
         const response = await this._post(options, false);
         await this.setTokens(response);
         return response;
@@ -296,7 +285,7 @@ class OAuth2Requester extends Requester {
      */
     async refreshAuth() {
         try {
-            console.log('[Frigg] Starting token refresh', {
+            console.log('[OAuth2Requester.refreshAuth] Starting token refresh', {
                 grant_type: this.grant_type,
                 has_refresh_token: !!this.refresh_token,
                 has_client_id: !!this.client_id,
@@ -312,10 +301,10 @@ class OAuth2Requester extends Requester {
             } else {
                 await this.getTokenFromClientCredentials();
             }
-            console.log('[Frigg] Token refresh succeeded');
+            console.log('[OAuth2Requester.refreshAuth] Token refresh succeeded');
             return true;
         } catch (error) {
-            console.error('[Frigg] Token refresh failed', {
+            console.error('[OAuth2Requester.refreshAuth] Token refresh failed', {
                 error_message: error?.message,
                 error_name: error?.name,
                 response_status: error?.response?.status,

package/modules/test/mock-api/definition.js

@@ -1,7 +1,7 @@
 require('dotenv').config();
 const { Api } = require('./api');
 const { get } = require('../../../assertions');
-const config = { name: 'anapi' }
+const config = { name: 'anapi' };
 
 const Definition = {
     API: Api,
@@ -9,7 +9,9 @@ const Definition = {
         url: 'http://localhost:3000/redirect/anapi',
         type: 'oauth2',
     }),
-    getName: function () { return config.name },
+    getName: function () {
+        return config.name;
+    },
     moduleName: config.name,
     modelName: 'AnApi',
     requiredAuthMethods: {
@@ -17,28 +19,31 @@ const Definition = {
             const code = get(params.data, 'code');
             return api.getTokenFromCode(code);
         },
-        getEntityDetails: async function (api, callbackParams, tokenResponse, userId) {
+        getEntityDetails: async function (
+            api,
+            callbackParams,
+            tokenResponse,
+            userId
+        ) {
             const userDetails = await api.getUserDetails();
             return {
                 identifiers: { externalId: userDetails.portalId, userId },
                 details: { name: userDetails.hub_domain },
-            }
+            };
         },
         apiPropertiesToPersist: {
-            credential: [
-                'access_token', 'refresh_token'
-            ],
+            credential: ['access_token', 'refresh_token'],
             entity: [],
         },
         getCredentialDetails: async function (api, userId) {
             const userDetails = await api.getUserDetails();
             return {
                 identifiers: { externalId: userDetails.portalId, userId },
-                details: {}
+                details: {},
             };
         },
         testAuthRequest: async function (api) {
-            return api.getUserDetails()
+            return api.getUserDetails();
         },
     },
     env: {
@@ -46,7 +51,7 @@ const Definition = {
         client_secret: 'test',
         scope: 'test',
         redirect_uri: `http://localhost:3000/redirect/anapi`,
-    }
+    },
 };
 
 module.exports = { Definition };

package/modules/test/mock-api/mocks/hubspot.js

@@ -1,43 +1,43 @@
 const authorizeResponse = {
-    "base": "/redirect/hubspot",
-    "data": {
-        "code": "test-code",
-        "state": "null"
-    }
-}
+    base: '/redirect/hubspot',
+    data: {
+        code: 'test-code',
+        state: 'null',
+    },
+};
 
 const tokenResponse = {
-    "token_type": "bearer",
-    "refresh_token": "test-refresh-token",
-    "access_token": "test-access-token",
-    "expires_in": 1800
-}
+    token_type: 'bearer',
+    refresh_token: 'test-refresh-token',
+    access_token: 'test-access-token',
+    expires_in: 1800,
+};
 
 const userDetailsResponse = {
-    "portalId": 111111111,
-    "timeZone": "US/Eastern",
-    "accountType": "DEVELOPER_TEST",
-    "currency": "USD",
-    "utcOffset": "-05:00",
-    "utcOffsetMilliseconds": -18000000,
-    "token": "test-token",
-    "user": "projectteam@lefthook.co",
-    "hub_domain": "Testing Object Things-dev-44613847.com",
-    "scopes": [
-        "content",
-        "oauth",
-        "crm.objects.contacts.read",
-        "crm.objects.contacts.write",
-        "crm.objects.companies.write",
-        "crm.objects.companies.read",
-        "crm.objects.deals.read",
-        "crm.schemas.deals.read"
+    portalId: 111111111,
+    timeZone: 'US/Eastern',
+    accountType: 'DEVELOPER_TEST',
+    currency: 'USD',
+    utcOffset: '-05:00',
+    utcOffsetMilliseconds: -18000000,
+    token: 'test-token',
+    user: 'projectteam@lefthook.co',
+    hub_domain: 'Testing Object Things-dev-44613847.com',
+    scopes: [
+        'content',
+        'oauth',
+        'crm.objects.contacts.read',
+        'crm.objects.contacts.write',
+        'crm.objects.companies.write',
+        'crm.objects.companies.read',
+        'crm.objects.deals.read',
+        'crm.schemas.deals.read',
     ],
-    "hub_id": 111111111,
-    "app_id": 22222222,
-    "expires_in": 1704,
-    "user_id": 33333333,
-    "token_type": "access"
-}
+    hub_id: 111111111,
+    app_id: 22222222,
+    expires_in: 1704,
+    user_id: 33333333,
+    token_type: 'access',
+};
 
-module.exports = { authorizeResponse, tokenResponse, userDetailsResponse }
+module.exports = { authorizeResponse, tokenResponse, userDetailsResponse };

package/modules/tests/doubles/test-module-factory.js

@@ -1,10 +1,16 @@
 class TestModuleFactory {
-    constructor() { }
+    constructor() {
+        this.moduleRepository = {
+            findEntity: jest.fn().mockResolvedValue(null),
+            findEntitiesBy: jest.fn().mockResolvedValue([]),
+        };
+    }
 
     async getModuleInstance(entityId, userId) {
-        // return minimal stub module with getName and api property
         return {
-            getName() { return 'stubModule'; },
+            getName() {
+                return 'stubModule';
+            },
             api: {},
             entityId,
             userId,
@@ -13,4 +19,4 @@ class TestModuleFactory {
     }
 }
 
-module.exports = { TestModuleFactory }; 
+module.exports = { TestModuleFactory };

package/modules/tests/doubles/test-module-repository.js

@@ -36,4 +36,4 @@ class TestModuleRepository {
     }
 }
 
-module.exports = { TestModuleRepository }; 
+module.exports = { TestModuleRepository };

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

@@ -0,0 +1,23 @@
+/**
+ * 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 };

package/modules/use-cases/get-authorization-requirements.js

@@ -0,0 +1,110 @@
+/**
+ * Get Authorization Requirements Use Case
+ * Business logic for retrieving authorization requirements for a specific step
+ *
+ * Responsibilities:
+ * - Find module definition for entity type
+ * - Determine step count (single vs multi-step)
+ * - Retrieve step-specific requirements (jsonSchema, uiSchema, etc.)
+ * - Return structured requirements for frontend rendering
+ *
+ * Supports both single-step and multi-step modules:
+ * - Single-step: Uses getAuthorizationRequirements() (legacy)
+ * - Multi-step: Uses getAuthRequirementsForStep(step) (new)
+ *
+ * @example
+ * ```javascript
+ * const useCase = new GetAuthorizationRequirementsUseCase({
+ *     moduleDefinitions: [{ moduleName: 'nagaris', definition: NagarisDefinition }]
+ * });
+ *
+ * // Get requirements for step 1
+ * const reqs = await useCase.execute('nagaris', 1);
+ * // Returns: { type: 'email', data: { jsonSchema, uiSchema }, step: 1, totalSteps: 2, isMultiStep: true }
+ *
+ * // Get requirements for step 2
+ * const reqs = await useCase.execute('nagaris', 2);
+ * // Returns: { type: 'otp', data: { jsonSchema, uiSchema }, step: 2, totalSteps: 2, isMultiStep: true }
+ * ```
+ */
+class GetAuthorizationRequirementsUseCase {
+    /**
+     * @param {Object} params - Dependencies
+     * @param {Array<Object>} params.moduleDefinitions - Array of module definitions with structure: { moduleName, definition }
+     */
+    constructor({ moduleDefinitions }) {
+        if (!moduleDefinitions || !Array.isArray(moduleDefinitions)) {
+            throw new Error('moduleDefinitions array is required');
+        }
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Get authorization requirements for a specific step
+     *
+     * @param {string} entityType - Entity type (module name)
+     * @param {number} [step=1] - Step number (1-indexed)
+     * @returns {Promise<Object>} Requirements object with schema and metadata
+     * @throws {Error} If module not found or step invalid
+     */
+    async execute(entityType, step = 1) {
+        // Validate inputs
+        if (!entityType) {
+            throw new Error('entityType is required');
+        }
+        if (!step || step < 1) {
+            throw new Error('step must be >= 1');
+        }
+
+        // Find module definition
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) => def.moduleName === entityType
+        );
+
+        if (!moduleDefinition) {
+            throw new Error(`Module definition not found: ${entityType}`);
+        }
+
+        const ModuleDefinition = moduleDefinition.definition;
+
+        // Determine step count (multi-step vs single-step)
+        const stepCount = ModuleDefinition.getAuthStepCount
+            ? ModuleDefinition.getAuthStepCount()
+            : 1;
+
+        // Validate requested step doesn't exceed max steps
+        if (step > stepCount) {
+            throw new Error(
+                `Step ${step} exceeds maximum steps (${stepCount}) for ${entityType}`
+            );
+        }
+
+        // Get requirements for this specific step
+        let requirements;
+
+        if (ModuleDefinition.getAuthRequirementsForStep) {
+            // Multi-step module - use step-specific method
+            requirements = await ModuleDefinition.getAuthRequirementsForStep(
+                step
+            );
+        } else if (step === 1) {
+            // Single-step module (legacy) - use standard method
+            requirements =
+                await ModuleDefinition.getAuthorizationRequirements();
+        } else {
+            throw new Error(
+                `Module ${entityType} does not support step ${step}`
+            );
+        }
+
+        // Return enriched requirements with metadata
+        return {
+            ...requirements,
+            step,
+            totalSteps: stepCount,
+            isMultiStep: stepCount > 1,
+        };
+    }
+}
+
+module.exports = { GetAuthorizationRequirementsUseCase };

package/modules/use-cases/get-entities-for-user.js

@@ -29,4 +29,4 @@ class GetEntitiesForUser {
     }
 }
 
-module.exports = { GetEntitiesForUser }; 
+module.exports = { GetEntitiesForUser };

package/modules/use-cases/get-entity-options-by-id.js

@@ -20,9 +20,10 @@ class GetEntityOptionsById {
      */
     async execute(entityId, userIdOrUser) {
         // Support both userId (backward compatible) and User object (new pattern)
-        const userId = typeof userIdOrUser === 'object' && userIdOrUser?.getId
-            ? userIdOrUser.getId()
-            : userIdOrUser;
+        const userId =
+            typeof userIdOrUser === 'object' && userIdOrUser?.getId
+                ? userIdOrUser.getId()
+                : userIdOrUser;
 
         const entity = await this.moduleRepository.findEntityById(
             entityId,
@@ -34,9 +35,10 @@ class GetEntityOptionsById {
         }
 
         // Validate entity ownership
-        const isOwned = typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
-            ? userIdOrUser.ownsUserId(entity.userId)
-            : entity.userId?.toString() === userId?.toString();
+        const isOwned =
+            typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
+                ? userIdOrUser.ownsUserId(entity.userId)
+                : entity.userId?.toString() === userId?.toString();
 
         if (!isOwned) {
             throw new Error(

package/modules/use-cases/get-module-entity-by-id.js

@@ -0,0 +1,16 @@
+/**
+ * GetModuleEntityById Use Case
+ * Retrieves a module entity by its ID
+ */
+class GetModuleEntityById {
+    constructor({ moduleRepository }) {
+        this.moduleRepository = moduleRepository;
+    }
+
+    async execute(entityId) {
+        const entity = await this.moduleRepository.findEntityById(entityId);
+        return entity;
+    }
+}
+
+module.exports = { GetModuleEntityById };