Ironclad updates and sub type

api-module-library/ironclad/manager.js

@@ -9,6 +9,7 @@ const {
 } = require('@friggframework/module-plugin');
 const AuthFields = require('./authFields');
 const Config = require('./defaultConfig.json');
+const { flushDebugLog } = require('@friggframework/logs');
 
 class Manager extends ModuleManager {
     static Entity = Entity;
@@ -32,11 +33,8 @@ class Manager extends ModuleManager {
             instance.credential = await Credential.findById(
                 instance.entity.credential
             );
-            managerParams.apiKey = instance.credential.apiKey;
-        } else if (params.credentialId) {
-            instance.credential = await Credential.findById(
-                params.credentialId
-            );
+            if (instance.credential.subdomain)
+                managerParams.subdomain = instance.credential.subdomain;
             managerParams.apiKey = instance.credential.apiKey;
         }
         instance.api = await new Api(managerParams);
@@ -58,13 +56,24 @@ class Manager extends ModuleManager {
     async processAuthorizationCallback(params) {
         const apiKey = get(params.data, 'apiKey', null);
         const subdomain = get(params.data, 'subdomain', null);
+        const subType = get(params.data, 'subType', null);
+        this.userId = this.userId || get(params, 'userId');
         this.api = new Api({ apiKey, subdomain });
+        const authRes = await this.testAuth();
+        if (!authRes) throw new Error('Auth Error');
+
+        // Grab identifying information if available.
+        // Currently not available in the Ironclad API
 
         await this.findOrCreateCredential({
             apiKey,
+            subType,
+            subdomain,
         });
         await this.findOrCreateEntity({
             apiKey,
+            subType,
+            subdomain,
         });
         return {
             credential_id: this.credential.id,
@@ -74,17 +83,23 @@ class Manager extends ModuleManager {
     }
 
     async findOrCreateCredential(params) {
-        const apiKey = get(params.data, 'apiKey', null);
+        const apiKey = get(params, 'apiKey', null);
+        const subdomain = get(params, 'subdomain', null);
+        const subType = get(params, 'subType', null);
 
         const search = await Entity.find({
             user: this.userId,
             apiKey,
+            subType,
+            subdomain,
         });
 
         if (search.length === 0) {
             const createObj = {
                 user: this.userId,
                 apiKey,
+                subType,
+                subdomain,
             };
             this.credential = await Credential.create(createObj);
         } else if (search.length === 1) {
@@ -100,16 +115,19 @@ class Manager extends ModuleManager {
     async findOrCreateEntity(params) {
         const apiKey = get(params.data, 'apiKey', null);
         const name = get(params, 'name', null);
+        const subType = get(params, 'subType', null);
 
         const search = await Entity.find({
             user: this.userId,
             externalId: apiKey,
+            subType,
         });
         if (search.length === 0) {
             const createObj = {
                 credential: this.credential.id,
                 user: this.userId,
                 name,
+                subType,
                 externalId: apiKey,
             };
             this.entity = await Entity.create(createObj);
@@ -121,6 +139,15 @@ class Manager extends ModuleManager {
         }
     }
 
+    async testAuth() {
+        let validAuth = false;
+        try {
+            if (await this.api.listWebhooks()) validAuth = true;
+        } catch (e) {
+            flushDebugLog(e);
+        }
+        return validAuth;
+    }
     async deauthorize() {
         this.api = new Api();
 

api-module-library/ironclad/test/manager.test.js

@@ -1,6 +1,7 @@
 const Manager = require('../manager');
 const mongoose = require('mongoose');
 const config = require('../defaultConfig.json');
+const { expect } = require('chai');
 require('dotenv').config();
 
 describe(`Should fully test the ${config.label} Manager`, () => {
@@ -19,9 +20,74 @@ describe(`Should fully test the ${config.label} Manager`, () => {
         await mongoose.disconnect();
     });
 
-    it('should return auth requirements', async () => {
+    it('getAuthorizationRequirements() should return auth requirements', async () => {
         const requirements = await manager.getAuthorizationRequirements();
         expect(requirements).exists;
-        expect(requirements.type).toEqual('apiKey');
+        expect(requirements.type).to.equal('apiKey');
+    });
+    describe('processAuthorizationCallback()', () => {
+        it('should return client', async () => {
+            const authRes = await manager.processAuthorizationCallback({
+                data: {
+                    apiKey: process.env.IRONCLAD_API_KEY,
+                    subdomain: process.env.IRONCLAD_SUBDOMAIN,
+                },
+            });
+            expect(authRes).exists;
+            expect(authRes).to.have.property('entity_id');
+            expect(authRes).to.have.property('credential_id');
+            expect(authRes).to.have.property('type');
+        });
+        it('should error if incorrect auth data', async () => {
+            try {
+                const authRes = await manager.processAuthorizationCallback({
+                    data: {
+                        apiKey: 'bad',
+                        subdomain: process.env.IRONCLAD_SUBDOMAIN,
+                    },
+                });
+                expect(authRes).to.not.exist;
+            } catch (e) {
+                expect(e.message).to.contain('Auth Error');
+            }
+        });
+        it('should return store subType', async () => {
+            const authRes = await manager.processAuthorizationCallback({
+                data: {
+                    apiKey: process.env.IRONCLAD_API_KEY,
+                    subdomain: process.env.IRONCLAD_SUBDOMAIN,
+                    subType: process.env.IRONCLAD_SUBTYPE,
+                },
+            });
+            expect(authRes).exists;
+            expect(authRes).to.have.property('entity_id');
+            expect(authRes).to.have.property('credential_id');
+            expect(authRes).to.have.property('type');
+        });
+        it('should return distinguish between subTypes', async () => {
+            const authRes = await manager.processAuthorizationCallback({
+                data: {
+                    apiKey: process.env.IRONCLAD_API_KEY,
+                    subdomain: process.env.IRONCLAD_SUBDOMAIN,
+                    subType: process.env.IRONCLAD_SUBTYPE,
+                },
+            });
+            expect(authRes).exists;
+            expect(authRes).to.have.property('entity_id');
+            expect(authRes).to.have.property('credential_id');
+            expect(authRes).to.have.property('type');
+            const secondAuthRes = await manager.processAuthorizationCallback({
+                data: {
+                    apiKey: process.env.IRONCLAD_API_KEY,
+                    subdomain: process.env.IRONCLAD_SUBDOMAIN,
+                    subType: 'fresh',
+                },
+            });
+            expect(secondAuthRes).exists;
+            expect(secondAuthRes).to.have.property('entity_id');
+            expect(secondAuthRes).to.have.property('credential_id');
+            expect(secondAuthRes).to.have.property('type');
+            expect(secondAuthRes.entity_id).to.not.equal(authRes.entity_id);
+        });
     });
 });

packages/module-plugin/credential.js

@@ -8,6 +8,7 @@ const schema = new mongoose.Schema(
             ref: 'User',
             required: true,
         },
+        subType: { type: String },
         auth_is_valid: { type: Boolean },
         externalId: { type: String }, // Used for lookups, identifying the owner of the credential
     },

packages/module-plugin/entity.js

@@ -7,6 +7,7 @@ const schema = new mongoose.Schema(
             ref: 'Credential',
             required: false,
         },
+        subType: { type: String },
         user: {
             type: mongoose.Schema.Types.ObjectId,
             ref: 'User',