@friggframework/devtools 1.2.0-canary.293.5731c31.0 → 1.2.1

package/frigg-cli/installCommand.js

@@ -0,0 +1,57 @@
+const { installPackage } = require('./installPackage');
+const { createIntegrationFile } = require('./integrationFile');
+const { resolve } = require('node:path');
+const { updateBackendJsFile } = require('./backendJs');
+const { logInfo, logError } = require('./logger');
+const { commitChanges } = require('./commitChanges');
+const {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+} = require('./backendPath');
+const { handleEnvVariables } = require('./environmentVariables');
+const {
+    validatePackageExists,
+    searchAndSelectPackage,
+} = require('./validatePackage');
+
+const installCommand = async (apiModuleName) => {
+    try {
+        const packageNames = await searchAndSelectPackage(apiModuleName);
+        if (!packageNames || packageNames.length === 0) return;
+
+        const backendPath = findNearestBackendPackageJson();
+        validateBackendPath(backendPath);
+
+        for (const packageName of packageNames) {
+            await validatePackageExists(packageName);
+            installPackage(backendPath, packageName);
+
+            const modulePath = resolve(
+                backendPath,
+                `../../node_modules/${packageName}`
+            );
+            const {
+                Config: { label },
+                Api: ApiClass,
+            } = require(modulePath);
+
+            const sanitizedLabel = label.replace(
+                /[<>:"/\\|?*\x00-\x1F\s]/g,
+                ''
+            ); // Remove invalid characters and spaces            console.log('Installing integration for:', sanitizedLabel);
+            createIntegrationFile(backendPath, sanitizedLabel, ApiClass);
+            updateBackendJsFile(backendPath, sanitizedLabel);
+            commitChanges(backendPath, sanitizedLabel);
+            logInfo(
+                `Successfully installed ${packageName} and updated the project.`
+            );
+
+            await handleEnvVariables(backendPath, modulePath);
+        }
+    } catch (error) {
+        logError('An error occurred:', error);
+        process.exit(1);
+    }
+};
+
+module.exports = { installCommand };

package/frigg-cli/installPackage.js

@@ -0,0 +1,13 @@
+const { execSync } = require('child_process');
+const path = require('path');
+
+function installPackage(backendPath, packageName) {
+    execSync(`npm install ${packageName}`, {
+        cwd: path.dirname(backendPath),
+        stdio: 'inherit',
+    });
+}
+
+module.exports = {
+    installPackage,
+};

package/frigg-cli/integrationFile.js

@@ -0,0 +1,30 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { logInfo } = require('./logger');
+const { getIntegrationTemplate } = require('./template');
+const INTEGRATIONS_DIR = 'src/integrations';
+
+function createIntegrationFile(backendPath, apiModuleName, ApiClass) {
+    const integrationDir = path.join(
+        path.dirname(backendPath),
+        INTEGRATIONS_DIR
+    );
+    logInfo(`Ensuring directory exists: ${integrationDir}`);
+    fs.ensureDirSync(integrationDir);
+
+    const integrationFilePath = path.join(
+        integrationDir,
+        `${apiModuleName}Integration.js`
+    );
+    logInfo(`Writing integration file: ${integrationFilePath}`);
+    const integrationTemplate = getIntegrationTemplate(
+        apiModuleName,
+        backendPath,
+        ApiClass
+    );
+    fs.writeFileSync(integrationFilePath, integrationTemplate);
+}
+
+module.exports = {
+    createIntegrationFile,
+};

package/frigg-cli/logger.js

@@ -0,0 +1,12 @@
+function logInfo(message) {
+    console.log(message);
+}
+
+function logError(message, error) {
+    console.error(message, error);
+}
+
+module.exports = {
+    logInfo,
+    logError,
+};

package/frigg-cli/template.js

@@ -0,0 +1,90 @@
+const path = require('path');
+
+function getIntegrationTemplate(apiModuleName, backendPath, ApiClass) {
+    // Find the sample data method
+    const apiMethods = Object.getOwnPropertyNames(ApiClass.prototype);
+    const sampleDataMethod =
+        apiMethods.find(
+            (method) =>
+                method.toLowerCase().includes('search') ||
+                method.toLowerCase().includes('list') ||
+                method.toLowerCase().includes('get')
+        ) || 'searchDeals';
+
+    return `const { get, IntegrationBase, Options } = require('@friggframework/core');
+const { Definition: ${apiModuleName}Module, Config: defaultConfig } = require('@friggframework/api-module-${apiModuleName.toLowerCase()}');
+
+class ${apiModuleName}Integration extends IntegrationBase {
+    static Config = {
+        name: defaultConfig.name || '${apiModuleName.toLowerCase()}',
+        version: '1.0.0',
+        supportedVersions: ['1.0.0'],
+        events: ['SEARCH_DEALS'],
+    };
+
+    static Options =
+        new Options({
+            module: ${apiModuleName}Module,
+            integrations: [${apiModuleName}Module],
+            display: {
+                name: defaultConfig.displayName || '${apiModuleName}',
+                description: defaultConfig.description || 'Sales & CRM, Marketing',
+                category: defaultConfig.category || 'Sales & CRM, Marketing',
+                detailsUrl: defaultConfig.detailsUrl || 'https://www.${apiModuleName.toLowerCase()}.com',
+                icon: defaultConfig.icon || 'https://friggframework.org/assets/img/${apiModuleName.toLowerCase()}.jpeg',
+            },
+            hasUserConfig: true,
+        });
+
+    static modules = {
+        ${apiModuleName.toLowerCase()}: ${apiModuleName}Module,
+    }
+
+    /**
+     * HANDLE EVENTS
+     */
+    async receiveNotification(notifier, event, object = null) {
+        if (event === 'SEARCH_DEALS') {
+            return this.target.api.searchDeals(object);
+        }
+    }
+
+    /**
+     * ALL CUSTOM/OPTIONAL METHODS FOR AN INTEGRATION MANAGER
+     */
+    async getSampleData() {
+        const res = await this.target.api.${sampleDataMethod}();
+        return { data: res };
+    }
+
+    /**
+     * ALL REQUIRED METHODS FOR AN INTEGRATION MANAGER
+     */
+    async onCreate(params) {
+        // Validate that we have all of the data we need
+        // Set integration status as makes sense. Default ENABLED
+        // TODO turn this into a validateConfig method/function
+        this.record.status = 'ENABLED';
+        await this.record.save();
+        return this.record;
+    }
+
+    async onUpdate(params) {
+        const newConfig = get(params, 'config');
+        const oldConfig = this.record.config;
+        // Just save whatever
+        this.record.markModified('config');
+        await this.record.save();
+        return this.validateConfig();
+    }
+
+    async getConfigOptions() {
+        const options = {}
+        return options;
+    }
+}
+
+module.exports = ${apiModuleName}Integration;`;
+}
+
+module.exports = { getIntegrationTemplate };

package/frigg-cli/validatePackage.js

@@ -0,0 +1,79 @@
+const { execSync } = require('child_process');
+const axios = require('axios');
+const { logError } = require('./logger');
+const inquirer = require('inquirer');
+
+async function searchPackages(apiModuleName) {
+    const searchCommand = `npm search @friggframework/api-module-${apiModuleName} --json`;
+    const result = execSync(searchCommand, { encoding: 'utf8' });
+    return JSON.parse(result);
+}
+
+async function checkPackageExists(packageName) {
+    try {
+        const response = await axios.get(
+            `https://registry.npmjs.org/${packageName}`
+        );
+        return response.status === 200;
+    } catch (error) {
+        return false;
+    }
+}
+
+async function validatePackageExists(packageName) {
+    const packageExists = await checkPackageExists(packageName);
+    if (!packageExists) {
+        throw new Error(`Package ${packageName} does not exist on npm.`);
+    }
+}
+
+const searchAndSelectPackage = async (apiModuleName) => {
+    const searchResults = await searchPackages(apiModuleName || '');
+
+    if (searchResults.length === 0) {
+        logError(`No packages found matching ${apiModuleName}`);
+        process.exit(1);
+    }
+
+    const filteredResults = searchResults.filter((pkg) => {
+        const version = pkg.version
+            ? pkg.version.split('.').map(Number)
+            : [];
+        return version[0] >= 1;
+    });
+
+    if (filteredResults.length === 0) {
+        const earlierVersions = searchResults
+            .map((pkg) => `${pkg.name} (${pkg.version})`)
+            .join(', ');
+        logError(
+            `No packages found with version 1.0.0 or above for ${apiModuleName}. Found earlier versions: ${earlierVersions}`
+        );
+        process.exit(1);
+    }
+
+    const choices = filteredResults.map((pkg) => {
+        return {
+            name: `${pkg.name} (${pkg.version})`,
+            checked: filteredResults.length === 1, // Automatically select if only one result
+        };
+    });
+
+    const { selectedPackages } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedPackages',
+            message: 'Select the packages to install:',
+            choices,
+        },
+    ]);
+
+    return selectedPackages.map(choice => choice.split(' ')[0]);
+};
+
+module.exports = {
+    validatePackageExists,
+    checkPackageExists,
+    searchPackages,
+    searchAndSelectPackage,
+};

package/index.js

@@ -1,9 +1,5 @@
-const eslintConfig = require('./eslint-config')
-const prettierConfig = require('./prettier-config')
-const testEnvironment = require('./test-environment/index');
+const test = require('./test');
 
 module.exports = {
-    eslintConfig,
-    prettierConfig,
-    ...testEnvironment
+    ...test
 }

package/package.json

@@ -1,26 +1,36 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "1.2.0-canary.293.5731c31.0",
+  "version": "1.2.1",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
+    "@babel/parser": "^7.25.3",
+    "@babel/traverse": "^7.25.3",
+    "@friggframework/core": "^1.2.1",
+    "@friggframework/test": "^1.2.1",
+    "axios": "^1.7.2",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
     "eslint": "^8.22.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-json": "^3.1.0",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-no-only-tests": "^3.0.0",
     "eslint-plugin-yaml": "^0.5.0",
-    "jest-runner-groups": "^2.2.0",
-    "mongodb-memory-server": "^8.9.0"
+    "fs-extra": "^11.2.0",
+    "inquirer": "^10.1.6"
   },
   "devDependencies": {
-    "jest": "^28.1.3",
-    "prettier": "^2.7.1"
+    "@friggframework/eslint-config": "^1.2.1",
+    "@friggframework/prettier-config": "^1.2.1"
   },
   "scripts": {
     "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
     "test": "jest --passWithNoTests # TODO"
   },
+  "bin": {
+    "frigg": "./frigg-cli/index.js"
+  },
   "author": "",
   "license": "MIT",
   "main": "index.js",
@@ -36,5 +46,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5731c31f2ef22a9b47b43a626cd8ff0e849bd561"
+  "gitHead": "3c2bb949c71be314cf44e326e618b3e16b787e8c"
 }

package/test/auther-definition-method-tester.js

@@ -0,0 +1,45 @@
+const {flushDebugLog} = require('@friggframework/core');
+
+async function testDefinitionRequiredAuthMethods(api, definition, authCallbackParams, tokenResponse, userId) {
+
+    // const response = await definition.getToken(api, authCallbackParams);
+    // expect(api.setTokens).toHaveBeenCalled();
+    // if (tokenResponse) {
+    //     expect(response).toMatchObject(tokenResponse);
+    // }
+
+    const entityDetails = await definition.requiredAuthMethods.getEntityDetails(api, authCallbackParams, tokenResponse, userId);
+    expect(entityDetails).toHaveProperty('identifiers');
+    expect(Object.values(entityDetails.identifiers).length).toBeGreaterThan(0);
+    for (const key of Object.keys(entityDetails.identifiers)){
+        expect(key).toBeDefined();
+        expect(entityDetails.identifiers[key]).toBeDefined();
+    }
+
+
+    const credentialDetails = await definition.requiredAuthMethods.getCredentialDetails(api);
+    expect(credentialDetails).toHaveProperty('identifiers');
+    expect(Object.values(entityDetails.identifiers).length).toBeGreaterThan(0);
+    for (const key of Object.keys(entityDetails.identifiers)){
+        expect(key).toBeDefined();
+        expect(entityDetails.identifiers[key]).toBeDefined();
+    }
+
+    const successResponse = await definition.requiredAuthMethods.testAuthRequest(api);
+    expect(successResponse).toBeTruthy();
+    const savedKeys = {};
+    for (const key of definition.requiredAuthMethods.apiPropertiesToPersist.credential){
+        savedKeys[key] = api[key];
+        delete api[key];
+    }
+    let validAuth = false;
+    try {
+        if (await definition.requiredAuthMethods.testAuthRequest(api)) validAuth = true;
+    } catch (e) {
+        flushDebugLog(e);
+    }
+    expect(validAuth).not.toBeTruthy();
+    Object.assign(api, savedKeys);
+}
+
+module.exports = { testDefinitionRequiredAuthMethods }

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

@@ -0,0 +1,11 @@
+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-environment → test}/mock-api.js

@@ -1,5 +1,5 @@
 const nock = require('nock');
-const Authenticator = require('./Authenticator');
+const { Authenticator } = require('@friggframework/test');
 const { join: joinPath } = require('path');
 const { parse: parseUrl } = require('url');
 const { mkdir, readFile, rename, rm, writeFile } = require('fs/promises');

package/test/mock-integration.js

@@ -0,0 +1,83 @@
+const { Auther, Credential, Entity, IntegrationFactory, createObjectId } = require('@friggframework/core');
+
+
+async function createMockIntegration(IntegrationClassDef, userId = null, config = {},) {
+    const integrationFactory = new IntegrationFactory([IntegrationClassDef]);
+    userId = userId || createObjectId();
+
+    const insertOptions = {
+        new: true,
+        upsert: true,
+        setDefaultsOnInsert: true,
+    }
+    const user = {user: userId}
+
+    const credential = await Credential.findOneAndUpdate(
+        user,
+        { $set: user },
+        insertOptions
+    );
+    const entity1 = await Entity.findOneAndUpdate(
+        user,
+        {
+            $set: {
+                credential: credential.id,
+                user: userId,
+                name: 'Test user',
+                externalId: '1234567890123456',
+            },
+        },
+        insertOptions
+    );
+    const entity2 = await Entity.findOneAndUpdate(
+        user,
+        {
+            $set: {
+                credential: credential.id,
+                user: userId,
+            },
+        },
+        insertOptions
+    );
+
+    const entities = [entity1, entity2]
+
+    const integration =
+        await integrationFactory.createIntegration(
+            entities,
+            userId,
+            config,
+        );
+
+    integration.id = integration.record._id
+
+    for (const i in entities){
+        if (Object.entries(IntegrationClassDef.modules).length <= i) break
+        const [moduleName, ModuleDef] = Object.entries(IntegrationClassDef.modules)[i];
+        const module = await Auther.getInstance({definition: ModuleDef, userId: userId})
+        module.entity = entities[i];
+        integration[moduleName] = module;
+    }
+
+    return integration
+}
+
+function createMockApiObject(jest, api = {}, mockMethodMap) {
+    // take in an api class and object with keys that are method names
+    // and values which are the mock response (or implementation)
+    const clone = (data) => JSON.parse(JSON.stringify(data));
+
+    for (const [methodName, mockDataOrImplementation] of Object.entries(mockMethodMap)) {
+        if (mockDataOrImplementation instanceof Function) {
+            api[methodName] = jest.fn(mockDataOrImplementation);
+        }
+        else if (api[methodName]?.constructor?.name === "AsyncFunction") {
+            api[methodName] = jest.fn().mockResolvedValue(clone(mockDataOrImplementation));
+        } else {
+            api[methodName] = jest.fn().mockReturnValue(clone(mockDataOrImplementation));
+        }
+    }
+    return api;
+}
+
+module.exports = {createMockIntegration, createMockApiObject};

package/eslint-config/CHANGELOG.md

@@ -1,17 +0,0 @@
-# v1.0.8 (Mon Jan 09 2023)
-
-#### 🐛 Bug Fix
-
-- Merge remote-tracking branch 'origin/main' into gitbook-updates [#48](https://github.com/friggframework/frigg/pull/48) ([@seanspeaks](https://github.com/seanspeaks))
-- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
-- Merge remote-tracking branch 'origin/main' into simplify-mongoose-models ([@seanspeaks](https://github.com/seanspeaks))
-- Add READMEs for all packages and api-modules [#20](https://github.com/friggframework/frigg/pull/20) ([@seanspeaks](https://github.com/seanspeaks))
-- Add READMEs for all packages and api-modules ([@seanspeaks](https://github.com/seanspeaks))
-
-#### ⚠️ Pushed to `main`
-
-- Refactored for more conventional naming (at least for packages) ([@seanspeaks](https://github.com/seanspeaks))
-
-#### Authors: 1
-
-- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))

package/eslint-config/LICENSE.md

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Left Hook Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/eslint-config/README.md

@@ -1,3 +0,0 @@
-# eslint-config
-
-This package exports the default `eslint-config` settings used in [Frigg](https://friggframework.org). You can find its documentation [on Frigg's website](https://docs.friggframework.org/packages/eslint-config).