@friggframework/devtools 2.0.0--canary.405.b81908d.0 → 2.0.0--canary.397.c07f148.0

package/infrastructure/create-frigg-infrastructure.js

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

package/infrastructure/serverless-template.js

@@ -102,309 +102,6 @@ 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: 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) => {
     const definition = {
         frameworkVersion: '>=3.17.0',
@@ -541,25 +238,6 @@ const composeServerlessDefinition = (AppDefinition) => {
                     },
                 ],
             },
-            health: {
-                handler: 'node_modules/@friggframework/core/handlers/routers/health.handler',
-                events: [
-                    {
-                        http: {
-                            path: '/health',
-                            method: 'GET',
-                            cors: true,
-                        },
-                    },
-                    {
-                        http: {
-                            path: '/health/{proxy+}',
-                            method: 'GET',
-                            cors: true,
-                        },
-                    },
-                ],
-            },
         },
         resources: {
             Resources: {
@@ -651,20 +329,6 @@ const composeServerlessDefinition = (AppDefinition) => {
         },
     };
 
-    definition.provider.environment.BASE_URL = {
-        'Fn::Join': [
-            '',
-            [
-                'https://',
-                { Ref: 'ApiGatewayRestApi' },
-                '.execute-api.',
-                { Ref: 'AWS::Region' },
-                '.amazonaws.com/',
-                '${self:provider.stage}',
-            ],
-        ],
-    };
-
     // KMS Configuration based on App Definition
     if (AppDefinition.encryption?.useDefaultKMSForFieldLevelEncryption === true) {
         // Add KMS IAM permissions
@@ -689,51 +353,6 @@ const composeServerlessDefinition = (AppDefinition) => {
         };
     }
 
-    // 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
     for (const integration of AppDefinition.integrations) {
         const integrationName = integration.Definition.name;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.405.b81908d.0",
+  "version": "2.0.0--canary.397.c07f148.0",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/test": "2.0.0--canary.405.b81908d.0",
+    "@friggframework/test": "2.0.0--canary.397.c07f148.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.405.b81908d.0",
-    "@friggframework/prettier-config": "2.0.0--canary.405.b81908d.0",
+    "@friggframework/eslint-config": "2.0.0--canary.397.c07f148.0",
+    "@friggframework/prettier-config": "2.0.0--canary.397.c07f148.0",
     "prettier": "^2.7.1",
     "serverless": "3.39.0",
     "serverless-dotenv-plugin": "^6.0.0",
@@ -60,5 +60,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b81908d5f795baf937e4b382dff63dedd40ddceb"
+  "gitHead": "c07f148505b5831d3f8be581529be9f0e18b5934"
 }

package/test/index.js

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

package/test/mock-integration.js

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

package/test/auther-definition-tester.js

@@ -1,125 +0,0 @@
-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 }
-