@friggframework/core 2.0.0--canary.397.b7e1978.0 → 2.0.0--canary.397.3862908.0

package/handlers/backend-utils.js

@@ -2,8 +2,10 @@ const { Router } = require('express');
 const { Worker } = require('@friggframework/core');
 const { loadAppDefinition } = require('./app-definition-loader');
 const { IntegrationRepository } = require('../integrations/integration-repository');
-const { ModuleService } = require('../modules/module-service');
+const { ModuleFactory } = require('../modules/module-factory');
 const { GetIntegrationInstance } = require('../integrations/use-cases/get-integration-instance');
+const { getModulesDefinitionFromIntegrationClasses } = require('../integrations/utils/map-integration-dto');
+const { ModuleRepository } = require('../modules/module-repository');
 
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
     const router = Router();
@@ -42,12 +44,16 @@ const createQueueWorker = (integrationClass) => {
                 } else {
                     const { integrations: integrationClasses } = loadAppDefinition();
                     const integrationRepository = new IntegrationRepository();
-                    const moduleService = new ModuleService();
+                    const moduleRepository = new ModuleRepository();
+                    const moduleFactory = new ModuleFactory({
+                        moduleRepository,
+                        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+                    });
 
                     const getIntegrationInstance = new GetIntegrationInstance({
                         integrationRepository,
                         integrationClasses,
-                        moduleService,
+                        moduleFactory,
                     });
 
                     // todo: are we going to have the userId available here?

package/integrations/integration-router.js

@@ -8,7 +8,7 @@ const { GetIntegrationsForUser } = require('./use-cases/get-integrations-for-use
 const { CredentialRepository } = require('../credential/credential-repository');
 const { GetCredentialForUser } = require('../credential/use-cases/get-credential-for-user');
 const { CreateIntegration } = require('./use-cases/create-integration');
-const { ModuleService } = require('../modules/module-service');
+const { ModuleFactory } = require('../modules/module-factory');
 const { ModuleRepository } = require('../modules/module-repository');
 const { GetEntitiesForUser } = require('../modules/use-cases/get-entities-for-user');
 const { loadAppDefinition } = require('../handlers/app-definition-loader');
@@ -36,7 +36,7 @@ function createIntegrationRouter(params) {
     const integrationRepository = new IntegrationRepository();
     const credentialRepository = new CredentialRepository();
 
-    const moduleService = new ModuleService({
+    const moduleFactory = new ModuleFactory({
         moduleRepository,
         moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
@@ -48,7 +48,7 @@ function createIntegrationRouter(params) {
     const getIntegrationsForUser = new GetIntegrationsForUser({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
         moduleRepository,
     });
 
@@ -59,7 +59,7 @@ function createIntegrationRouter(params) {
     const createIntegration = new CreateIntegration({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
     });
 
     const getEntitiesForUser = new GetEntitiesForUser({
@@ -70,13 +70,13 @@ function createIntegrationRouter(params) {
     const getIntegrationInstance = new GetIntegrationInstance({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
     });
 
     const updateIntegration = new UpdateIntegration({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
     });
 
     const getModuleInstanceFromType = new GetModuleInstanceFromType({

package/integrations/integration.js

@@ -119,7 +119,7 @@ class Integration {
             // -----------------------------------------------------------------
             // Inject the real Module instances (with credentials) so that any
             // behaviour code accessing `this.<moduleName>.api` hits the
-            // correctly authenticated requester created by ModuleService.
+            // correctly authenticated requester created by ModuleFactory.
             // -----------------------------------------------------------------
             for (const mod of this._moduleInstances) {
                 const key = typeof mod.getName === 'function' ? mod.getName() : mod.name;

package/integrations/test/integration-base.test.js

@@ -2,10 +2,10 @@ const _ = require('lodash');
 const { mongoose } = require('../../database/mongoose');
 const { expect } = require('chai');
 const { IntegrationBase } = require("../integration-base");
-const {Credential} = require('../../module-plugin/credential');
-const {Entity} = require('../../module-plugin/entity');
+const { Credential } = require('../../module-plugin/credential');
+const { Entity } = require('../../module-plugin/entity');
 const { IntegrationMapping } = require('../integration-mapping')
-const {IntegrationModel} = require("../integration-model");
+const { IntegrationModel } = require("../integration-model");
 
 describe(`Should fully test the IntegrationBase Class`, () => {
     let integrationRecord;
@@ -93,15 +93,15 @@ describe(`Should fully test the IntegrationBase Class`, () => {
     describe('upsertIntegrationMapping()', () => {
         it('should throw error if sourceId is null', async () => {
             try {
-                await integration.upsertMapping( null, {});
+                await integration.upsertMapping(null, {});
                 fail('should have thrown error')
-            } catch(err) {
+            } catch (err) {
                 expect(err.message).to.contain('sourceId must be set');
             }
         });
 
         it('should return for empty mapping', async () => {
-            const mapping = await integration.upsertMapping( 'validId2', {});
+            const mapping = await integration.upsertMapping('validId2', {});
             expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
                 integration: integrationRecord._id,
                 sourceId: 'validId2',

package/integrations/tests/doubles/dummy-integration-class.js

@@ -0,0 +1,11 @@
+const { IntegrationBase } = require('../../integration-base');
+
+class DummyIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'dummy',
+        version: '1.0.0',
+        modules: {},
+    };
+}
+
+module.exports = { DummyIntegration }; 

package/integrations/tests/doubles/test-integration-repository.js

@@ -0,0 +1,52 @@
+const { v4: uuid } = require('uuid');
+
+class TestIntegrationRepository {
+    constructor() {
+        this.store = new Map();
+    }
+
+    async createIntegration(entities, userId, config) {
+        const id = uuid();
+        const record = {
+            id,
+            entitiesIds: entities,
+            userId,
+            config,
+            version: '0.0.0',
+            status: 'NEW',
+            messages: {},
+        };
+        this.store.set(id, record);
+        return record;
+    }
+
+    async findIntegrationById(id) {
+        const rec = this.store.get(id);
+        if (!rec) return null;
+        return rec;
+    }
+
+    async findIntegrationsByUserId(userId) {
+        return Array.from(this.store.values()).filter(r => r.userId === userId);
+    }
+
+    async updateIntegrationMessages(id, type, title, body, timestamp) {
+        const rec = this.store.get(id);
+        if (!rec) return false;
+        if (!rec.messages[type]) rec.messages[type] = [];
+        rec.messages[type].push({ title, message: body, timestamp });
+        return true;
+    }
+
+    async deleteIntegrationById(id) {
+        return this.store.delete(id);
+    }
+
+    async updateIntegrationStatus(id, status) {
+        const rec = this.store.get(id);
+        if (rec) rec.status = status;
+        return true;
+    }
+}
+
+module.exports = { TestIntegrationRepository }; 

package/integrations/tests/use-cases/create-integration.test.js

@@ -0,0 +1,27 @@
+const { CreateIntegration } = require('../../use-cases/create-integration');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('CreateIntegration Use-Case', () => {
+    it('creates an integration and returns DTO', async () => {
+        const integrationRepository = new TestIntegrationRepository();
+        const moduleFactory = new TestModuleFactory();
+
+        const useCase = new CreateIntegration({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+
+        const entities = ['entity-1'];
+        const userId = 'user-1';
+        const config = { type: 'dummy', foo: 'bar' };
+
+        const dto = await useCase.execute(entities, userId, config);
+
+        expect(dto.id).toBeDefined();
+        expect(dto.config).toEqual(config);
+        expect(dto.userId).toBe(userId);
+    });
+}); 

package/integrations/tests/use-cases/delete-integration-for-user.test.js

@@ -0,0 +1,20 @@
+const { DeleteIntegrationForUser } = require('../../use-cases/delete-integration-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('DeleteIntegrationForUser', () => {
+    it('deletes integration', async () => {
+        const repo = new TestIntegrationRepository();
+        const record = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+        const useCase = new DeleteIntegrationForUser({
+            integrationRepository: repo,
+            integrationClasses: [DummyIntegration],
+        });
+
+        await useCase.execute(record.id, 'user-1');
+
+        const found = await repo.findIntegrationById(record.id);
+        expect(found).toBeNull();
+    });
+}); 

package/integrations/tests/use-cases/get-integration-for-user.test.js

@@ -0,0 +1,29 @@
+const { GetIntegrationForUser } = require('../../use-cases/get-integration-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+
+describe('GetIntegrationForUser', () => {
+    it('returns integration dto', async () => {
+        const iRepo = new TestIntegrationRepository();
+        const mRepo = new TestModuleRepository();
+        const mFactory = new TestModuleFactory();
+
+        const entity = { id: 'entity-1' };
+        mRepo.addEntity(entity);
+
+        const record = await iRepo.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+        const useCase = new GetIntegrationForUser({
+            integrationRepository: iRepo,
+            integrationClasses: [DummyIntegration],
+            moduleFactory: mFactory,
+            moduleRepository: mRepo,
+        });
+
+        const dto = await useCase.execute(record.id, 'user-1');
+        expect(dto.id).toBe(record.id);
+    });
+}); 

package/integrations/tests/use-cases/get-integration-instance.test.js

@@ -0,0 +1,26 @@
+const { GetIntegrationInstance } = require('../../use-cases/get-integration-instance');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetIntegrationInstance Use-Case', () => {
+    it('returns hydrated integration instance', async () => {
+        const integrationRepository = new TestIntegrationRepository();
+        const moduleFactory = new TestModuleFactory();
+
+        // first create record directly via repo
+        const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+        const useCase = new GetIntegrationInstance({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+
+        const instance = await useCase.execute(record.id, 'user-1');
+
+        expect(instance.id).toBe(record.id);
+        expect(instance.getConfig().type).toBe('dummy');
+        expect(instance.entities).toEqual(record.entitiesIds);
+    });
+}); 

package/integrations/tests/use-cases/get-integrations-for-user.test.js

@@ -0,0 +1,30 @@
+const { GetIntegrationsForUser } = require('../../use-cases/get-integrations-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetIntegrationsForUser', () => {
+    it('returns integrations dto list', async () => {
+        const integrationRepo = new TestIntegrationRepository();
+        const moduleRepo = new TestModuleRepository();
+        const moduleFactory = new TestModuleFactory();
+
+        // setup entity and module repo
+        const entity = { id: 'entity-1' };
+        moduleRepo.addEntity(entity);
+
+        await integrationRepo.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+        const useCase = new GetIntegrationsForUser({
+            integrationRepository: integrationRepo,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+            moduleRepository: moduleRepo,
+        });
+
+        const list = await useCase.execute('user-1');
+        expect(list.length).toBe(1);
+        expect(list[0].config.type).toBe('dummy');
+    });
+}); 

package/integrations/tests/use-cases/get-possible-integrations.test.js

@@ -0,0 +1,12 @@
+const { GetPossibleIntegrations } = require('../../use-cases/get-possible-integrations');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetPossibleIntegrations', () => {
+    it('returns option details array', async () => {
+        const useCase = new GetPossibleIntegrations({ integrationClasses: [DummyIntegration] });
+        const res = await useCase.execute();
+        expect(Array.isArray(res)).toBe(true);
+        expect(res.length).toBe(1);
+        expect(res[0].display).toBeDefined();
+    });
+}); 

package/integrations/tests/use-cases/update-integration-messages.test.js

@@ -0,0 +1,15 @@
+const { UpdateIntegrationMessages } = require('../../use-cases/update-integration-messages');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+
+describe('UpdateIntegrationMessages', () => {
+    it('adds message', async () => {
+        const repo = new TestIntegrationRepository();
+        const rec = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+        const useCase = new UpdateIntegrationMessages({ integrationRepository: repo });
+        await useCase.execute(rec.id, 'errors', 'title', 'body', Date.now());
+
+        const fetched = await repo.findIntegrationById(rec.id);
+        expect(fetched.messages.errors.length).toBe(1);
+    });
+}); 

package/integrations/tests/use-cases/update-integration.test.js

@@ -0,0 +1,24 @@
+const { UpdateIntegration } = require('../../use-cases/update-integration');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('UpdateIntegration', () => {
+    it('calls on update and returns dto', async () => {
+        const repo = new TestIntegrationRepository();
+        const mf = new TestModuleFactory();
+
+        const record = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
+
+        const useCase = new UpdateIntegration({
+            integrationRepository: repo,
+            integrationClasses: [DummyIntegration],
+            moduleFactory: mf,
+        });
+
+        const newConfig = { type: 'dummy', foo: 'baz' };
+        const dto = await useCase.execute(record.id, 'user-1', newConfig);
+
+        expect(dto.config.foo).toBe('baz');
+    });
+}); 

package/integrations/use-cases/create-integration.js

@@ -6,12 +6,12 @@ class CreateIntegration {
      * @param {Object} params
      * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository
      * @param {import('../integration-classes').IntegrationClasses} params.integrationClasses
-     * @param {import('../../modules/module-service').ModuleService} params.moduleService
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory
      */
-    constructor({ integrationRepository, integrationClasses, moduleService }) {
+    constructor({ integrationRepository, integrationClasses, moduleFactory }) {
         this.integrationRepository = integrationRepository;
         this.integrationClasses = integrationClasses;
-        this.moduleService = moduleService;
+        this.moduleFactory = moduleFactory;
     }
 
     async execute(entities, userId, config) {
@@ -28,7 +28,7 @@ class CreateIntegration {
 
         const modules = [];
         for (const entityId of integrationRecord.entitiesIds) {
-            const moduleInstance = await this.moduleService.getModuleInstance(
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
                 entityId,
                 integrationRecord.userId
             );

package/integrations/use-cases/get-integration-for-user.js

@@ -2,14 +2,14 @@ const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
 class GetIntegrationForUser {
-    constructor({ integrationRepository, integrationClasses, moduleService, moduleRepository }) {
+    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
 
         /**
          * @type {import('../integration-repository').IntegrationRepository}
          */
         this.integrationRepository = integrationRepository;
         this.integrationClasses = integrationClasses;
-        this.moduleService = moduleService;
+        this.moduleFactory = moduleFactory;
         this.moduleRepository = moduleRepository;
     }
 
@@ -36,7 +36,7 @@ class GetIntegrationForUser {
 
         const modules = [];
         for (const entity of entities) {
-            const moduleInstance = await this.moduleService.getModuleInstance(
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
                 entity._id,
                 integrationRecord.user
             );

package/integrations/use-cases/get-integration-instance.js

@@ -8,16 +8,16 @@ class GetIntegrationInstance {
      * @param {Object} params
      * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data access
      * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
-     * @param {import('../module-plugin/module-service').ModuleService} params.moduleService - Service for module instantiation and management
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management
      */
     constructor({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
     }) {
         this.integrationRepository = integrationRepository;
         this.integrationClasses = integrationClasses;
-        this.moduleService = moduleService;
+        this.moduleFactory = moduleFactory;
     }
 
     async execute(integrationId, userId) {
@@ -44,7 +44,7 @@ class GetIntegrationInstance {
 
         const modules = [];
         for (const entityId of integrationRecord.entitiesIds) {
-            const moduleInstance = await this.moduleService.getModuleInstance(
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
                 entityId,
                 integrationRecord.userId
             );

package/integrations/use-cases/get-integrations-for-user.js

@@ -2,14 +2,14 @@ const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
 class GetIntegrationsForUser {
-    constructor({ integrationRepository, integrationClasses, moduleService, moduleRepository }) {
+    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
 
         /**
          * @type {import('../integration-repository').IntegrationRepository}
          */
         this.integrationRepository = integrationRepository;
         this.integrationClasses = integrationClasses;
-        this.moduleService = moduleService;
+        this.moduleFactory = moduleFactory;
         this.moduleRepository = moduleRepository;
     }
 
@@ -31,7 +31,7 @@ class GetIntegrationsForUser {
 
             const modules = [];
             for (const entity of entities) {
-                const moduleInstance = await this.moduleService.getModuleInstance(
+                const moduleInstance = await this.moduleFactory.getModuleInstance(
                     entity.id,
                     integrationRecord.userId
                 );

package/integrations/use-cases/update-integration.js

@@ -10,16 +10,16 @@ class UpdateIntegration {
      * @param {Object} params
      * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data access
      * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
-     * @param {import('../module-plugin/module-service').ModuleService} params.moduleService - Service for module instantiation and management
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management
      */
     constructor({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
     }) {
         this.integrationRepository = integrationRepository;
         this.integrationClasses = integrationClasses;
-        this.moduleService = moduleService;
+        this.moduleFactory = moduleFactory;
     }
 
     async execute(integrationId, userId, config) {
@@ -49,7 +49,7 @@ class UpdateIntegration {
         // 3. Load modules based on entity references
         const modules = [];
         for (const entityId of integrationRecord.entitiesIds) {
-            const moduleInstance = await this.moduleService.getModuleInstance(
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
                 entityId,
                 integrationRecord.userId
             );

package/modules/{module-service.js → module-factory.js}

@@ -1,6 +1,11 @@
 const { Module } = require('./module');
 
-class ModuleService {
+/**
+ * Acts as a factory for fully-hydrated domain Module instances.
+ * Provides methods to retrieve and construct Module objects with their associated
+ * entity and definition.
+ */
+class ModuleFactory {
     /**
      * @param {Object} params - Configuration parameters.
      * @param {import('./module-repository').ModuleRepository} params.moduleRepository - Repository for module data operations.
@@ -46,4 +51,4 @@ class ModuleService {
     }
 }
 
-module.exports = { ModuleService }; 
+module.exports = { ModuleFactory };

package/modules/module-repository.js

@@ -19,26 +19,6 @@ class ModuleRepository {
         };
     }
 
-    async findEntitiesByIds(entitiesIds) {
-        const entitiesRecords = await Entity.find({ _id: { $in: entitiesIds } }, '', { lean: true }).populate('credential');
-
-        // todo: this is a workaround needed while we create an integration with the same entity twice
-        if (entitiesRecords.length !== entitiesIds.length && entitiesIds[0] !== entitiesIds[1]) {
-            throw new Error(`Some entities not found`);
-        }
-
-        return entitiesRecords.map(e => ({
-            id: e._id,
-            accountId: e.accountId,
-            credential: e.credential,
-            userId: e.user.toString(),
-            name: e.name,
-            externalId: e.externalId,
-            type: e.__t,
-            moduleName: e.moduleName,
-        }));
-    }
-
     async findEntitiesByUserId(userId) {
         const entitiesRecords = await Entity.find(
             { user: userId },
@@ -84,7 +64,8 @@ class ModuleRepository {
      * @returns {Promise<import('mongoose').UpdateWriteOpResult>}
      */
     async unsetCredential(entityId) {
-        return Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
+        const result = await Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
+        return result.acknowledged;
     }
 }
 

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

@@ -0,0 +1,16 @@
+class TestModuleFactory {
+    constructor() { }
+
+    async getModuleInstance(entityId, userId) {
+        // return minimal stub module with getName and api property
+        return {
+            getName() { return 'stubModule'; },
+            api: {},
+            entityId,
+            userId,
+            testAuth: async () => true,
+        };
+    }
+}
+
+module.exports = { TestModuleFactory }; 

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

@@ -0,0 +1,19 @@
+class TestModuleRepository {
+    constructor() {
+        this.entities = new Map();
+    }
+
+    addEntity(entity) {
+        this.entities.set(entity.id, entity);
+    }
+
+    async findEntityById(id) {
+        return this.entities.get(id);
+    }
+
+    async findEntitiesByIds(ids) {
+        return ids.map((id) => this.entities.get(id));
+    }
+}
+
+module.exports = { TestModuleRepository }; 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.397.b7e1978.0",
+  "version": "2.0.0--canary.397.3862908.0",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
     "aws-sdk": "^2.1200.0",
@@ -22,9 +22,9 @@
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.397.b7e1978.0",
-    "@friggframework/prettier-config": "2.0.0--canary.397.b7e1978.0",
-    "@friggframework/test": "2.0.0--canary.397.b7e1978.0",
+    "@friggframework/eslint-config": "2.0.0--canary.397.3862908.0",
+    "@friggframework/prettier-config": "2.0.0--canary.397.3862908.0",
+    "@friggframework/test": "2.0.0--canary.397.3862908.0",
     "@types/lodash": "4.17.15",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "chai": "^4.3.6",
@@ -53,5 +53,5 @@
   },
   "homepage": "https://github.com/friggframework/frigg#readme",
   "description": "",
-  "gitHead": "b7e197879d90d5bd782c5299aa55f312eb7d4b63"
+  "gitHead": "3862908989603188a6c3a404d456f4349c84e54b"
 }