@friggframework/devtools 2.0.0--canary.395.c089c7d.0 → 2.0.0--canary.413.52695f8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.395.c089c7d.0",
+  "version": "2.0.0--canary.413.52695f8.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -9,8 +9,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.395.c089c7d.0",
-    "@friggframework/test": "2.0.0--canary.395.c089c7d.0",
+    "@friggframework/schemas": "2.0.0--canary.413.52695f8.0",
+    "@friggframework/test": "2.0.0--canary.413.52695f8.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -32,8 +32,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.395.c089c7d.0",
-    "@friggframework/prettier-config": "2.0.0--canary.395.c089c7d.0",
+    "@friggframework/eslint-config": "2.0.0--canary.413.52695f8.0",
+    "@friggframework/prettier-config": "2.0.0--canary.413.52695f8.0",
     "prettier": "^2.7.1",
     "serverless": "3.39.0",
     "serverless-dotenv-plugin": "^6.0.0",
@@ -65,5 +65,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c089c7d850dab85bd2b1619d27e67e6761144191"
+  "gitHead": "52695f82fbf27b46b7c7bfac98a611b676c0b0e2"
 }

package/test/auther-definition-tester.js

@@ -0,0 +1,125 @@
+const {
+    Auther,
+    ModuleConstants,
+    createObjectId,
+    connectToDatabase,
+    disconnectFromDatabase,
+} = require('@friggframework/core');
+const { createMockApiObject } = require("./mock-integration");
+
+
+function testAutherDefinition(definition, mocks) {
+    const getModule = async (params) => {
+        const module = await Auther.getInstance({
+            definition,
+            userId: createObjectId(),
+            ...params,
+        });
+        if (mocks.tokenResponse) {
+            mocks.getTokenFrom = async function(code) {
+                await this.setTokens(mocks.tokenResponse);
+                return mocks.tokenResponse
+            }
+            mocks.getTokenFromCode = mocks.getTokenFromCode || mocks.getTokenFrom
+            mocks.getTokenFromCodeBasicAuthHeader = mocks.getTokenFromCodeBasicAuthHeader || mocks.getTokenFrom
+            mocks.getTokenFromClientCredentials = mocks.getTokenFromClientCredentials || mocks.getTokenFrom
+            mocks.getTokenFromUsernamePassword = mocks.getTokenFromUsernamePassword || mocks.getTokenFrom
+        }
+        if (mocks.refreshResponse) {
+            mocks.refreshAccessToken = async function(code) {
+                await this.setTokens(mocks.refreshResponse);
+                return mocks.refreshResponse
+            }
+        }
+        module.api = createMockApiObject(jest, module.api, mocks);
+        return module
+    }
+
+
+    describe(`${definition.moduleName} Module Tests`, () => {
+        let module, authUrl;
+        beforeAll(async () => {
+            await connectToDatabase();
+            module = await getModule();
+        });
+
+        afterAll(async () => {
+            await disconnectFromDatabase();
+        });
+
+        let requirements, authCallbackParams;
+        if (definition.API.requesterType === ModuleConstants.authType.oauth2) {
+            authCallbackParams = mocks.authorizeResponse || mocks.authorizeParams;
+            describe('getAuthorizationRequirements() test', () => {
+                it('should return auth requirements', async () => {
+                    requirements = await module.getAuthorizationRequirements();
+                    expect(requirements).toBeDefined();
+                    expect(requirements.type).toEqual(ModuleConstants.authType.oauth2);
+                    expect(requirements.url).toBeDefined();
+                    authUrl = requirements.url;
+                });
+            });
+        } else if (definition.API.requesterType === ModuleConstants.authType.basic) {
+            // could also confirm authCallbackParams against the auth requirements
+            authCallbackParams = mocks.authorizeParams
+            describe('getAuthorizationRequirements() test', () => {
+                it('should return auth requirements', async () => {
+                    requirements = module.getAuthorizationRequirements();
+                    expect(requirements).toBeDefined();
+                    expect(requirements.type).toEqual(ModuleConstants.authType.basic);
+                });
+            });
+        } else if (definition.API.requesterType === ModuleConstants.authType.apiKey) {
+            // could also confirm authCallbackParams against the auth requirements
+            authCallbackParams = mocks.authorizeParams
+            describe('getAuthorizationRequirements() test', () => {
+                it('should return auth requirements', async () => {
+                    requirements = module.getAuthorizationRequirements();
+                    expect(requirements).toBeDefined();
+                    expect(requirements.type).toEqual(ModuleConstants.authType.apiKey);
+                });
+            });
+        }
+
+        describe('Authorization requests', () => {
+            let firstRes;
+            it('processAuthorizationCallback()', async () => {
+                firstRes = await module.processAuthorizationCallback(authCallbackParams);
+                expect(firstRes).toBeDefined();
+                expect(firstRes.entity_id).toBeDefined();
+                expect(firstRes.credential_id).toBeDefined();
+            });
+            it('retrieves existing entity on subsequent calls', async () => {
+                const res = await module.processAuthorizationCallback(authCallbackParams);
+                expect(res).toEqual(firstRes);
+            });
+        });
+
+        describe('Test credential retrieval and module instantiation', () => {
+            it('retrieve by entity id', async () => {
+                const newModule = await getModule({
+                    userId: module.userId,
+                    entityId: module.entity.id
+                });
+                expect(newModule).toBeDefined();
+                expect(newModule.entity).toBeDefined();
+                expect(newModule.credential).toBeDefined();
+                expect(await newModule.testAuth()).toBeTruthy();
+
+            });
+
+            it('retrieve by credential id', async () => {
+                const newModule = await getModule({
+                    userId: module.userId,
+                    credentialId: module.credential.id
+                });
+                expect(newModule).toBeDefined();
+                expect(newModule.credential).toBeDefined();
+                expect(await newModule.testAuth()).toBeTruthy();
+            });
+        });
+    });
+}
+
+module.exports = { testAutherDefinition }
+

package/test/index.js

@@ -1,9 +1,11 @@
-const { testDefinitionRequiredAuthMethods } = require('./auther-definition-method-tester');
-const { createMockIntegration, createMockApiObject } = require('./mock-integration');
+const {testDefinitionRequiredAuthMethods} = require('./auther-definition-method-tester');
+const {createMockIntegration, createMockApiObject} = require('./mock-integration');
+const { testAutherDefinition } = require('./auther-definition-tester');
 
 
 module.exports = {
     createMockIntegration,
     createMockApiObject,
     testDefinitionRequiredAuthMethods,
+    testAutherDefinition,
 };

package/test/mock-integration.js

@@ -1,4 +1,8 @@
 const {
+    Auther,
+    Credential,
+    Entity,
+    IntegrationFactory,
     createObjectId,
 } = require('@friggframework/core');
 
@@ -7,6 +11,7 @@ async function createMockIntegration(
     userId = null,
     config = { type: IntegrationClass.Definition.name }
 ) {
+    const integrationFactory = new IntegrationFactory([IntegrationClass]);
     userId = userId || createObjectId();
 
     const insertOptions = {
@@ -19,8 +24,10 @@ async function createMockIntegration(
     const entities = [];
     for (const moduleName in IntegrationClass.modules) {
         const ModuleDef = IntegrationClass.Definition.modules[moduleName];
-        // todo: create module using the new architecture
-        const module = {}
+        const module = await Auther.getInstance({
+            definition: ModuleDef,
+            userId: userId,
+        });
         const credential = await module.CredentialModel.findOneAndUpdate(
             user,
             { $set: user },
@@ -44,8 +51,11 @@ async function createMockIntegration(
         );
     }
 
-    // todo: create integration using the new architecture
-    const integration = {}
+    const integration = await integrationFactory.createIntegration(
+        entities,
+        userId,
+        config
+    );
 
     integration.id = integration.record._id;