@friggframework/devtools 2.0.0--canary.397.fe6d7a2.0 → 2.0.0--canary.405.45825cd.0

package/infrastructure/create-frigg-infrastructure.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const fs = require('fs-extra');
 const { composeServerlessDefinition } = require('./serverless-template');
+
 const { findNearestBackendPackageJson } = require('@friggframework/core');
 
 function createFriggInfrastructure() {
@@ -18,7 +19,14 @@ function createFriggInfrastructure() {
     const backend = require(backendFilePath);
     const appDefinition = backend.Definition;
 
-    const definition = composeServerlessDefinition(appDefinition);
+    // const serverlessTemplate = require(path.resolve(
+    //     __dirname,
+    //     './serverless-template.js'
+    // ));
+    const definition = composeServerlessDefinition(
+        appDefinition,
+        backend.IntegrationFactory
+    );
 
     return {
         ...definition,

package/infrastructure/serverless-template.js

@@ -102,7 +102,325 @@ const modifyHandlerPaths = (functions) => {
     return modifiedFunctions;
 };
 
+// Helper function to create VPC infrastructure resources
+const createVPCInfrastructure = (AppDefinition) => {
+    const vpcResources = {
+        // VPC
+        FriggVPC: {
+            Type: 'AWS::EC2::VPC',
+            Properties: {
+                CidrBlock: AppDefinition.vpc.cidrBlock || '10.0.0.0/16',
+                EnableDnsHostnames: true,
+                EnableDnsSupport: true,
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-vpc' }
+                ]
+            }
+        },
+
+        // Internet Gateway
+        FriggInternetGateway: {
+            Type: 'AWS::EC2::InternetGateway',
+            Properties: {
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-igw' }
+                ]
+            }
+        },
+
+        // Attach Internet Gateway to VPC
+        FriggVPCGatewayAttachment: {
+            Type: 'AWS::EC2::VPCGatewayAttachment',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                InternetGatewayId: { Ref: 'FriggInternetGateway' }
+            }
+        },
+
+        // Public Subnet for NAT Gateway
+        FriggPublicSubnet: {
+            Type: 'AWS::EC2::Subnet',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                CidrBlock: '10.0.1.0/24',
+                AvailabilityZone: { 'Fn::Select': [0, { 'Fn::GetAZs': '' }] },
+                MapPublicIpOnLaunch: true,
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-public-subnet' }
+                ]
+            }
+        },
+
+        // Private Subnet 1 for Lambda
+        FriggPrivateSubnet1: {
+            Type: 'AWS::EC2::Subnet',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                CidrBlock: '10.0.2.0/24',
+                AvailabilityZone: { 'Fn::Select': [0, { 'Fn::GetAZs': '' }] },
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-private-subnet-1' }
+                ]
+            }
+        },
+
+        // Private Subnet 2 for Lambda (different AZ for redundancy)
+        FriggPrivateSubnet2: {
+            Type: 'AWS::EC2::Subnet',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                CidrBlock: '10.0.3.0/24',
+                AvailabilityZone: { 'Fn::Select': [1, { 'Fn::GetAZs': '' }] },
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-private-subnet-2' }
+                ]
+            }
+        },
+
+        // Elastic IP for NAT Gateway
+        FriggNATGatewayEIP: {
+            Type: 'AWS::EC2::EIP',
+            Properties: {
+                Domain: 'vpc',
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-nat-eip' }
+                ]
+            },
+            DependsOn: 'FriggVPCGatewayAttachment'
+        },
+
+        // NAT Gateway for private subnet internet access
+        FriggNATGateway: {
+            Type: 'AWS::EC2::NatGateway',
+            Properties: {
+                AllocationId: { 'Fn::GetAtt': ['FriggNATGatewayEIP', 'AllocationId'] },
+                SubnetId: { Ref: 'FriggPublicSubnet' },
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-nat-gateway' }
+                ]
+            }
+        },
+
+        // Public Route Table
+        FriggPublicRouteTable: {
+            Type: 'AWS::EC2::RouteTable',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-public-rt' }
+                ]
+            }
+        },
+
+        // Public Route to Internet Gateway
+        FriggPublicRoute: {
+            Type: 'AWS::EC2::Route',
+            Properties: {
+                RouteTableId: { Ref: 'FriggPublicRouteTable' },
+                DestinationCidrBlock: '0.0.0.0/0',
+                GatewayId: { Ref: 'FriggInternetGateway' }
+            },
+            DependsOn: 'FriggVPCGatewayAttachment'
+        },
+
+        // Associate Public Subnet with Public Route Table
+        FriggPublicSubnetRouteTableAssociation: {
+            Type: 'AWS::EC2::SubnetRouteTableAssociation',
+            Properties: {
+                SubnetId: { Ref: 'FriggPublicSubnet' },
+                RouteTableId: { Ref: 'FriggPublicRouteTable' }
+            }
+        },
+
+        // Private Route Table
+        FriggPrivateRouteTable: {
+            Type: 'AWS::EC2::RouteTable',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-private-rt' }
+                ]
+            }
+        },
+
+        // Private Route to NAT Gateway
+        FriggPrivateRoute: {
+            Type: 'AWS::EC2::Route',
+            Properties: {
+                RouteTableId: { Ref: 'FriggPrivateRouteTable' },
+                DestinationCidrBlock: '0.0.0.0/0',
+                NatGatewayId: { Ref: 'FriggNATGateway' }
+            }
+        },
+
+        // Associate Private Subnet 1 with Private Route Table
+        FriggPrivateSubnet1RouteTableAssociation: {
+            Type: 'AWS::EC2::SubnetRouteTableAssociation',
+            Properties: {
+                SubnetId: { Ref: 'FriggPrivateSubnet1' },
+                RouteTableId: { Ref: 'FriggPrivateRouteTable' }
+            }
+        },
+
+        // Associate Private Subnet 2 with Private Route Table
+        FriggPrivateSubnet2RouteTableAssociation: {
+            Type: 'AWS::EC2::SubnetRouteTableAssociation',
+            Properties: {
+                SubnetId: { Ref: 'FriggPrivateSubnet2' },
+                RouteTableId: { Ref: 'FriggPrivateRouteTable' }
+            }
+        },
+
+        // Security Group for Lambda functions
+        FriggLambdaSecurityGroup: {
+            Type: 'AWS::EC2::SecurityGroup',
+            Properties: {
+                GroupDescription: 'Security group for Frigg Lambda functions',
+                VpcId: { Ref: 'FriggVPC' },
+                SecurityGroupEgress: [
+                    {
+                        IpProtocol: 'tcp',
+                        FromPort: 443,
+                        ToPort: 443,
+                        CidrIp: '0.0.0.0/0',
+                        Description: 'HTTPS outbound'
+                    },
+                    {
+                        IpProtocol: 'tcp',
+                        FromPort: 80,
+                        ToPort: 80,
+                        CidrIp: '0.0.0.0/0',
+                        Description: 'HTTP outbound'
+                    },
+                     {
+                         IpProtocol: 'tcp',
+                         FromPort: 27017,
+                         ToPort: 27017,
+                         CidrIp: '0.0.0.0/0',
+                         Description: 'MongoDB Atlas TLS outbound'
+                     },
+                    {
+                        IpProtocol: 'tcp',
+                        FromPort: 53,
+                        ToPort: 53,
+                        CidrIp: '0.0.0.0/0',
+                        Description: 'DNS TCP'
+                    },
+                    {
+                        IpProtocol: 'udp',
+                        FromPort: 53,
+                        ToPort: 53,
+                        CidrIp: '0.0.0.0/0',
+                        Description: 'DNS UDP'
+                    }
+                ],
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-lambda-sg' }
+                ]
+            }
+        }
+    };
+
+    // Add VPC Endpoints for cost optimization
+    if (AppDefinition.vpc.enableVPCEndpoints !== false) {
+        // S3 Gateway Endpoint (free)
+        vpcResources.FriggS3VPCEndpoint = {
+            Type: 'AWS::EC2::VPCEndpoint',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                ServiceName: 'com.amazonaws.${self:provider.region}.s3',
+                VpcEndpointType: 'Gateway',
+                RouteTableIds: [
+                    { Ref: 'FriggPrivateRouteTable' }
+                ]
+            }
+        };
+
+        // DynamoDB Gateway Endpoint (free)
+        vpcResources.FriggDynamoDBVPCEndpoint = {
+            Type: 'AWS::EC2::VPCEndpoint',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                ServiceName: 'com.amazonaws.${self:provider.region}.dynamodb',
+                VpcEndpointType: 'Gateway',
+                RouteTableIds: [
+                    { Ref: 'FriggPrivateRouteTable' }
+                ]
+            }
+        };
+
+        // KMS Interface Endpoint (paid, but useful if using KMS)
+        if (AppDefinition.encryption?.useDefaultKMSForFieldLevelEncryption === true) {
+            vpcResources.FriggKMSVPCEndpoint = {
+                Type: 'AWS::EC2::VPCEndpoint',
+                Properties: {
+                    VpcId: { Ref: 'FriggVPC' },
+                    ServiceName: 'com.amazonaws.${self:provider.region}.kms',
+                    VpcEndpointType: 'Interface',
+                    SubnetIds: [
+                        { Ref: 'FriggPrivateSubnet1' },
+                        { Ref: 'FriggPrivateSubnet2' }
+                    ],
+                    SecurityGroupIds: [
+                        { Ref: 'FriggVPCEndpointSecurityGroup' }
+                    ],
+                    PrivateDnsEnabled: true
+                }
+            };
+        }
+
+        // Secrets Manager Interface Endpoint (paid, but useful for secrets)
+        vpcResources.FriggSecretsManagerVPCEndpoint = {
+            Type: 'AWS::EC2::VPCEndpoint',
+            Properties: {
+                VpcId: { Ref: 'FriggVPC' },
+                ServiceName: 'com.amazonaws.${self:provider.region}.secretsmanager',
+                VpcEndpointType: 'Interface',
+                SubnetIds: [
+                    { Ref: 'FriggPrivateSubnet1' },
+                    { Ref: 'FriggPrivateSubnet2' }
+                ],
+                SecurityGroupIds: [
+                    { Ref: 'FriggVPCEndpointSecurityGroup' }
+                ],
+                PrivateDnsEnabled: true
+            }
+        };
+
+        // Security Group for VPC Endpoints
+        vpcResources.FriggVPCEndpointSecurityGroup = {
+            Type: 'AWS::EC2::SecurityGroup',
+            Properties: {
+                GroupDescription: 'Security group for Frigg VPC Endpoints',
+                VpcId: { Ref: 'FriggVPC' },
+                SecurityGroupIngress: [
+                    {
+                        IpProtocol: 'tcp',
+                        FromPort: 443,
+                        ToPort: 443,
+                        SourceSecurityGroupId: { Ref: 'FriggLambdaSecurityGroup' },
+                        Description: 'HTTPS from Lambda'
+                    }
+                ],
+                Tags: [
+                    { Key: 'Name', Value: '${self:service}-${self:provider.stage}-vpc-endpoint-sg' }
+                ]
+            }
+        };
+    }
+
+    return vpcResources;
+};
+
 const composeServerlessDefinition = (AppDefinition) => {
+    // Define CORS configuration to be used across all endpoints
+    const corsConfig = {
+        origin: '*',
+        headers: '*',
+        methods: ['ANY'],
+        allowCredentials: true,
+    };
+    
     const definition = {
         frameworkVersion: '>=3.17.0',
         service: AppDefinition.name || 'create-frigg-app',
@@ -207,21 +525,21 @@ const composeServerlessDefinition = (AppDefinition) => {
                         http: {
                             path: '/api/integrations',
                             method: 'ANY',
-                            cors: true,
+                            cors: corsConfig,
                         },
                     },
                     {
                         http: {
                             path: '/api/integrations/{proxy+}',
                             method: 'ANY',
-                            cors: true,
+                            cors: corsConfig,
                         },
                     },
                     {
                         http: {
                             path: '/api/authorize',
                             method: 'ANY',
-                            cors: true,
+                            cors: corsConfig,
                         },
                     },
                 ],
@@ -233,7 +551,26 @@ const composeServerlessDefinition = (AppDefinition) => {
                         http: {
                             path: '/user/{proxy+}',
                             method: 'ANY',
-                            cors: true,
+                            cors: corsConfig,
+                        },
+                    },
+                ],
+            },
+            health: {
+                handler: 'node_modules/@friggframework/core/handlers/routers/health.handler',
+                events: [
+                    {
+                        http: {
+                            path: '/health',
+                            method: 'GET',
+                            cors: corsConfig,
+                        },
+                    },
+                    {
+                        http: {
+                            path: '/health/{proxy+}',
+                            method: 'GET',
+                            cors: corsConfig,
                         },
                     },
                 ],
@@ -329,28 +666,154 @@ const composeServerlessDefinition = (AppDefinition) => {
         },
     };
 
+    // Configure BASE_URL based on custom domain or API Gateway
+    if (process.env.CUSTOM_DOMAIN) {
+        
+        // Configure custom domain
+        definition.custom.customDomain = {
+            domainName: process.env.CUSTOM_DOMAIN,
+            basePath: process.env.CUSTOM_BASE_PATH || '',
+            stage: '${self:provider.stage}',
+            createRoute53Record: process.env.CREATE_ROUTE53_RECORD !== 'false', // Default true
+            certificateName: process.env.CERTIFICATE_NAME || process.env.CUSTOM_DOMAIN,
+            endpointType: process.env.ENDPOINT_TYPE || 'edge', // edge, regional, or private
+            securityPolicy: process.env.SECURITY_POLICY || 'tls_1_2',
+            apiType: 'rest',
+            autoDomain: process.env.AUTO_DOMAIN === 'true', // Auto create domain if it doesn't exist
+        };
+        
+        // Set BASE_URL to custom domain
+        definition.provider.environment.BASE_URL = `https://${process.env.CUSTOM_DOMAIN}`;
+    } else {
+        // Default BASE_URL using API Gateway generated URL
+        definition.provider.environment.BASE_URL = {
+            'Fn::Join': [
+                '',
+                [
+                    'https://',
+                    { Ref: 'ApiGatewayRestApi' },
+                    '.execute-api.',
+                    { Ref: 'AWS::Region' },
+                    '.amazonaws.com/',
+                    '${self:provider.stage}',
+                ],
+            ],
+        };
+    }
+    
+    // REDIRECT_PATH is required for OAuth integrations
+    if (!process.env.REDIRECT_PATH) {
+        throw new Error(
+            'REDIRECT_PATH environment variable is required. ' +
+            'Please set REDIRECT_PATH in your .env file (e.g., REDIRECT_PATH=/oauth/callback)'
+        );
+    }
+    
+    // Set REDIRECT_URI based on domain configuration
+    if (process.env.CUSTOM_DOMAIN) {
+        definition.provider.environment.REDIRECT_URI = `https://${process.env.CUSTOM_DOMAIN}${process.env.REDIRECT_PATH}`;
+    } else {
+        definition.provider.environment.REDIRECT_URI = {
+            'Fn::Join': [
+                '',
+                [
+                    'https://',
+                    { Ref: 'ApiGatewayRestApi' },
+                    '.execute-api.',
+                    { Ref: 'AWS::Region' },
+                    '.amazonaws.com/',
+                    '${self:provider.stage}',
+                    process.env.REDIRECT_PATH,
+                ],
+            ],
+        };
+    }
+    
+    // Add REDIRECT_URI to CloudFormation outputs
+    definition.resources.Outputs = {
+        RedirectURI: {
+            Description: 'OAuth Redirect URI to register with providers',
+            Value: definition.provider.environment.REDIRECT_URI,
+        },
+    };
+
     // KMS Configuration based on App Definition
     if (AppDefinition.encryption?.useDefaultKMSForFieldLevelEncryption === true) {
-        // Add KMS IAM permissions
+        // Provision a dedicated KMS key and wire it automatically
+        definition.resources.Resources.FriggKMSKey = {
+            Type: 'AWS::KMS::Key',
+            Properties: {
+                EnableKeyRotation: true,
+                KeyPolicy: {
+                    Version: '2012-10-17',
+                    Statement: [
+                        {
+                            Sid: 'AllowRootAccountAdmin',
+                            Effect: 'Allow',
+                            Principal: { AWS: { 'Fn::Sub': 'arn:aws:iam::${AWS::AccountId}:root' } },
+                            Action: 'kms:*',
+                            Resource: '*'
+                        }
+                    ]
+                }
+            }
+        };
+
         definition.provider.iamRoleStatements.push({
             Effect: 'Allow',
-            Action: [
-                'kms:GenerateDataKey',
-                'kms:Decrypt'
-            ],
-            Resource: ['${self:custom.kmsGrants.kmsKeyId}']
+            Action: ['kms:GenerateDataKey', 'kms:Decrypt'],
+            Resource: [{ 'Fn::GetAtt': ['FriggKMSKey', 'Arn'] }]
         });
 
-        // Add KMS_KEY_ARN environment variable for Frigg Encrypt module
-        definition.provider.environment.KMS_KEY_ARN = '${self:custom.kmsGrants.kmsKeyId}';
+        definition.provider.environment.KMS_KEY_ARN = { 'Fn::GetAtt': ['FriggKMSKey', 'Arn'] };
 
-        // Add serverless-kms-grants plugin
         definition.plugins.push('serverless-kms-grants');
+        definition.custom.kmsGrants = { kmsKeyId: { 'Fn::GetAtt': ['FriggKMSKey', 'Arn'] } };
+    }
 
-        // Configure KMS grants with default key
-        definition.custom.kmsGrants = {
-            kmsKeyId: '*'
-        };
+    // VPC Configuration based on App Definition
+    if (AppDefinition.vpc?.enable === true) {
+        // Create VPC config from App Definition or use auto-created resources
+        const vpcConfig = {};
+
+        if (AppDefinition.vpc.securityGroupIds) {
+            // User provided custom security groups
+            vpcConfig.securityGroupIds = AppDefinition.vpc.securityGroupIds;
+        } else {
+            // Use auto-created security group
+            vpcConfig.securityGroupIds = [{ Ref: 'FriggLambdaSecurityGroup' }];
+        }
+
+        if (AppDefinition.vpc.subnetIds) {
+            // User provided custom subnets
+            vpcConfig.subnetIds = AppDefinition.vpc.subnetIds;
+        } else {
+            // Use auto-created private subnets
+            vpcConfig.subnetIds = [
+                { Ref: 'FriggPrivateSubnet1' },
+                { Ref: 'FriggPrivateSubnet2' }
+            ];
+        }
+
+        // Set VPC config for Lambda functions
+        definition.provider.vpc = vpcConfig;
+
+        // Add VPC-related IAM permissions
+        definition.provider.iamRoleStatements.push({
+            Effect: 'Allow',
+            Action: [
+                'ec2:CreateNetworkInterface',
+                'ec2:DescribeNetworkInterfaces',
+                'ec2:DeleteNetworkInterface',
+                'ec2:AttachNetworkInterface',
+                'ec2:DetachNetworkInterface'
+            ],
+            Resource: '*'
+        });
+
+        // Add VPC infrastructure resources to CloudFormation
+        const vpcResources = createVPCInfrastructure(AppDefinition);
+        Object.assign(definition.resources.Resources, vpcResources);
     }
 
     // Add integration-specific functions and resources
@@ -365,7 +828,7 @@ const composeServerlessDefinition = (AppDefinition) => {
                     http: {
                         path: `/api/${integrationName}-integration/{proxy+}`,
                         method: 'ANY',
-                        cors: true,
+                        cors: corsConfig,
                     },
                 },
             ],
@@ -425,4 +888,4 @@ const composeServerlessDefinition = (AppDefinition) => {
     return definition;
 };
 
-module.exports = { composeServerlessDefinition };
+module.exports = { composeServerlessDefinition };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.397.fe6d7a2.0",
+  "version": "2.0.0--canary.405.45825cd.0",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/test": "2.0.0--canary.397.fe6d7a2.0",
+    "@friggframework/test": "2.0.0--canary.405.45825cd.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -27,8 +27,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.397.fe6d7a2.0",
-    "@friggframework/prettier-config": "2.0.0--canary.397.fe6d7a2.0",
+    "@friggframework/eslint-config": "2.0.0--canary.405.45825cd.0",
+    "@friggframework/prettier-config": "2.0.0--canary.405.45825cd.0",
     "prettier": "^2.7.1",
     "serverless": "3.39.0",
     "serverless-dotenv-plugin": "^6.0.0",
@@ -60,5 +60,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "fe6d7a2d20c22ee67c13948c0af57ed3b72ca481"
+  "gitHead": "45825cde018fed76379aae97a58f03c5695f40c9"
 }

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;