@friggframework/core 0.2.31-v1-alpha.6 → 1.0.1-v1-alpha-package-update.0

package/test-environment/mock-api.js

@@ -0,0 +1,284 @@
+const nock = require('nock');
+const Authenticator = require('./Authenticator');
+const { join: joinPath } = require('path');
+const { parse: parseUrl } = require('url');
+const { mkdir, readFile, rename, rm, writeFile } = require('fs/promises');
+
+// TODO store in DB?
+const tokenDirectory = joinPath(process.cwd(), 'test', '.token-cache');
+const fixtureDirectory = joinPath(process.cwd(), 'test', 'recorded-requests');
+nock.back.fixtures = fixtureDirectory;
+
+// Try to rename but fail silently if the file does not exist.
+const tryRename = async (a, b) => {
+    try {
+        await rename(a, b);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+};
+const getJestGlobalState = () => {
+    const globalSymbols = Object.getOwnPropertySymbols(global);
+    let jestState;
+    globalSymbols.forEach((sym) => {
+        if (sym.toString() === 'Symbol(JEST_STATE_SYMBOL)') {
+            jestState = global[sym];
+        }
+    });
+
+    return jestState;
+};
+
+const checkForOnlies = () => {
+    let didFindOnly = false;
+    const findOnly = (child) => {
+        if (child.mode === 'only') {
+            didFindOnly = true;
+        }
+        if (child.children) {
+            child.children.forEach((nestedChild) => {
+                findOnly(nestedChild);
+            });
+        }
+    };
+    const jestState = getJestGlobalState();
+    const rootDescribe = jestState.rootDescribeBlock;
+
+    for (const child of rootDescribe.children) {
+        findOnly(child);
+    }
+
+    return didFindOnly;
+};
+
+const mockApi = (Api, classOptionByName = {}) => {
+    const {
+        authenticationMode,
+        displayName = Api.name,
+        filteringScope,
+    } = classOptionByName;
+    // The tag is the lower case display name, with any trailing 'Api' in the string removed.
+    const tag = displayName.replace(/Api$/i, '').toLowerCase();
+    const tokenFile = `${displayName}.json`;
+    const tokenFileFullPath = joinPath(tokenDirectory, tokenFile);
+
+    return class MockedApi extends Api {
+        static name = `Mocked${displayName}`;
+        static tokenResponse = null;
+        static excludedRecordingPaths = [];
+        static #context = {};
+
+        static async initialize() {
+            this.#context = {};
+
+            const didFindOnlies = checkForOnlies();
+
+            if (didFindOnlies) {
+                throw new Error(
+                    'Cancelled recording API mocks because some tests were marked `.only`.  Please remove any `.only`s from any `describe` blocks deeper than the root level, and all `it` blocks.'
+                );
+            }
+
+            this.#context.originalNockMode = nock.back.currentMode;
+
+            const { npm_config_record_apis: apisToRecordText = '' } =
+                process.env;
+            const apisToRecord = apisToRecordText
+                .split(',')
+                .map((name) => name.trim().toLowerCase());
+
+            if (apisToRecord.includes(tag)) {
+                this.#context.nockMode = 'update';
+            } else {
+                this.#context.nockMode = 'lockdown';
+            }
+
+            nock.back.setMode(this.#context.nockMode);
+
+            const fixtureFile = `${displayName}.json`;
+
+            if (this.#context.nockMode === 'update') {
+                const fixtureFileFullPath = joinPath(
+                    fixtureDirectory,
+                    fixtureFile
+                );
+                const fixtureFileBackupFullPath = joinPath(
+                    fixtureDirectory,
+                    `.${displayName}.json.backup`
+                );
+
+                await tryRename(fixtureFileFullPath, fixtureFileBackupFullPath);
+
+                this.#context.restoreFixture = async () =>
+                    await tryRename(
+                        fixtureFileBackupFullPath,
+                        fixtureFileFullPath
+                    );
+                this.#context.deleteFixtureBackup = async () =>
+                    await rm(fixtureFileBackupFullPath, { force: true });
+            }
+
+            const nockBack = await nock.back(fixtureFile, {
+                before: (scope) => {
+                    if (filteringScope) {
+                        scope.options.filteringScope = filteringScope;
+                    }
+                },
+                // Filter out token URLs
+                afterRecord: (recordings) =>
+                    recordings.filter(
+                        ({ path }) =>
+                            !this.excludedRecordingPaths.includes(path)
+                    ),
+                recorder: {
+                    output_objects: true,
+                    enable_reqheaders_recording: false,
+                },
+            });
+
+            this.#context.assertAllRequests = () =>
+                nockBack.context.assertScopesFinished();
+            this.#context.done = () => nockBack.nockDone();
+        }
+
+        static async clean() {
+            const {
+                assertAllRequests,
+                done,
+                nockMode,
+                originalNockMode,
+                restoreFixture,
+                deleteFixtureBackup,
+            } = this.#context;
+
+            const { didAllTestsPass } = global.mockApiResults;
+
+            if (done) {
+                done();
+            }
+            if (originalNockMode) {
+                nock.back.setMode(originalNockMode);
+            }
+            if (assertAllRequests && nockMode !== 'update') {
+                assertAllRequests();
+            }
+
+            nock.cleanAll();
+            nock.restore();
+
+            if (nockMode === 'update') {
+                if (!didAllTestsPass) {
+                    try {
+                        await restoreFixture();
+                    } finally {
+                        throw new Error(
+                            'Cancelled recording API mocks because some tests failed.  Please fix the failing tests and try to record again.'
+                        );
+                    }
+                } else {
+                    await deleteFixtureBackup();
+                }
+            }
+        }
+
+        static async saveCachedTokenResponse() {
+            if (!this.tokenResponse) {
+                return;
+            }
+
+            await mkdir(tokenDirectory, { recursive: true });
+            await writeFile(
+                tokenFileFullPath,
+                JSON.stringify(this.tokenResponse)
+            );
+        }
+
+        static async loadCachedTokenResponse() {
+            try {
+                const tokenResponseText = await readFile(tokenFileFullPath);
+                this.tokenResponse = JSON.parse(tokenResponseText);
+            } catch (error) {
+                if (error.code === 'ENOENT') {
+                    this.tokenResponse = null;
+                    return;
+                }
+                throw error;
+            }
+        }
+
+        static async mock(...constructorParameters) {
+            const api = new this(...constructorParameters);
+
+            if (nock.back.currentMode !== 'lockdown') {
+                await this.loadCachedTokenResponse();
+            }
+
+            // TODO read authentication mode from module package
+            if (authenticationMode === 'client_credentials') {
+                // TODO make generic (tied to crossbeam api)
+                api.grantType = 'client_credentials';
+                api.refreshAccessToken = api.getTokenFromClientCredentials;
+
+                if (process.env.CROSSBEAM_API_BASE_URL)
+                    api.baseUrl = process.env.CROSSBEAM_API_BASE_URL;
+                if (process.env.CROSSBEAM_API_AUTH_URL)
+                    api.tokenUri = `${process.env.CROSSBEAM_API_AUTH_URL}/oauth/token`;
+                if (process.env.CROSSBEAM_API_AUDIENCE)
+                    api.audience = process.env.CROSSBEAM_API_AUDIENCE;
+
+                api.client_secret = process.env.CROSSBEAM_TEST_CLIENT_SECRET;
+                api.client_id = process.env.CROSSBEAM_TEST_CLIENT_ID;
+                api.refreshAccessToken = api.getTokenFromClientCredentials;
+
+                this.tokenResponse = await api.getTokenFromClientCredentials();
+            } else if (authenticationMode === 'puppet') {
+                throw new Error('Not yet implemented');
+            } else if (authenticationMode === 'browser') {
+                if (nock.back.currentMode !== 'lockdown') {
+                    const { path: tokenPath } = parseUrl(api.tokenUri);
+                    this.excludedRecordingPaths.push(tokenPath);
+
+                    if (this.tokenResponse) {
+                        await api.setTokens(this.tokenResponse);
+
+                        try {
+                            await api.testAuth();
+                        } catch {
+                            this.tokenResponse = null;
+                            nock.cleanAll();
+                            await rm(tokenFileFullPath, {
+                                force: true,
+                            });
+                        }
+                    }
+
+                    if (!this.tokenResponse) {
+                        const url = api.authorizationUri;
+                        const { data } = await Authenticator.oauth2(url);
+                        const { code } = data;
+                        this.tokenResponse = await api.getTokenFromCode(code);
+                        await api.setTokens(this.tokenResponse);
+                        nock.cleanAll();
+                    }
+                }
+            } else if (authenticationMode === 'manual') {
+                // NOOP.  This space intentionally left blank.  No action should be performed in this mode, and the developer writing the test will handle authentication externally to this module.
+            } else {
+                throw new Error(
+                    'Unrecognized authentication mode for mocked API.'
+                );
+            }
+
+            if (nock.back.currentMode !== 'lockdown') {
+                await this.saveCachedTokenResponse();
+            }
+
+            return api;
+        }
+    };
+};
+
+module.exports = { mockApi };

package/test-environment/mock-integration.js

@@ -0,0 +1,82 @@
+const { Auther, Credential, Entity } = require('../module-plugin');
+const { IntegrationModel } = require('../integrations');
+const { mongoose } = require('../database/mongoose');
+
+async function createMockIntegration(IntegrationClassDef, userId = null, config = {},) {
+    const integration = new IntegrationClassDef();
+    userId = userId || new mongoose.Types.ObjectId();
+    integration.delegateTypes.push(...IntegrationClassDef.Config.events)
+
+    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]
+    integration.record = await IntegrationModel.create({
+        entities,
+        user: userId,
+        config: {type: IntegrationClassDef.Config.name, ...config}
+    })
+
+    integration.id = integration.record._id
+
+    for (const i in entities){
+        const [moduleName, ModuleDef] = Object.entries(IntegrationClassDef.modules)[i];
+        const module = 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/test-environment/mongodb.js

@@ -0,0 +1,22 @@
+const { MongoMemoryServer } = require('mongodb-memory-server');
+
+class TestMongo {
+    #mongoServer;
+
+    // Start the in-memory mongo instance and set env variable for the app to use in its connection.
+    async start() {
+        this.#mongoServer = await MongoMemoryServer.create();
+        process.env.MONGO_URI = this.#mongoServer.getUri();
+        console.log('Started in memory mongo server', process.env.MONGO_URI);
+    }
+
+    async stop() {
+        await this.#mongoServer.stop();
+        process.env.MONGO_URI = undefined;
+        this.#mongoServer = undefined;
+    }
+}
+
+module.exports = {
+    TestMongo,
+};

package/test-environment/override-environment.js

@@ -0,0 +1,11 @@
+const originalEnv = process.env;
+
+function overrideEnvironment(overrideByKey) {
+    process.env = { ...process.env, ...overrideByKey };
+}
+
+function restoreEnvironment() {
+    process.env = originalEnv;
+}
+
+module.exports = { overrideEnvironment, restoreEnvironment };

package/types/CHANGELOG.md

@@ -0,0 +1,49 @@
+# v0.2.0 (Wed Sep 06 2023)
+
+#### 🐛 Bug Fix
+
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v0.1.2 (Thu Aug 03 2023)
+
+#### 🐛 Bug Fix
+
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v0.1.1 (Wed Jul 05 2023)
+
+:tada: This release contains work from new contributors! :tada:
+
+Thanks for all your work!
+
+:heart: Leonardo Ferreira ([@leofmds](https://github.com/leofmds))
+
+:heart: Roberto Oliveros ([@roboli](https://github.com/roboli))
+
+:heart: Charaf ([@Fibii](https://github.com/Fibii))
+
+#### 🐛 Bug Fix
+
+- Add publicshConfig: public and changed license to MIT in types package [#195](https://github.com/friggframework/frigg/pull/195) ([@leofmds](https://github.com/leofmds))
+- Add publicshConfig: public and changed license to MIT in types package ([@leofmds](https://github.com/leofmds))
+- Feature/lef 270 list organizations sites [#192](https://github.com/friggframework/frigg/pull/192) ([@roboli](https://github.com/roboli))
+- add types [#165](https://github.com/friggframework/frigg/pull/165) ([@Fibii](https://github.com/Fibii))
+- add types ([@Fibii](https://github.com/Fibii))
+
+#### Authors: 3
+
+- Charaf ([@Fibii](https://github.com/Fibii))
+- Leonardo Ferreira ([@leofmds](https://github.com/leofmds))
+- Roberto Oliveros ([@roboli](https://github.com/roboli))

package/types/README.md

@@ -0,0 +1,24 @@
+# types
+
+This package exports the `types` used in [Frigg](https://friggframework.org) packages.
+
+
+### Get Started
+Install the package with `npm` or `yarn`:
+
+```bash
+npm install @friggframework/types
+```
+or
+```bash
+yarn add @friggframework/types
+```
+
+Make sure to reference the types in your `tsconfig.json`
+
+```json
+"typeRoots": [
+    "./node_modules/@types",
+    "./node_modules/@friggframework/types"
+]
+```

package/types/assertions/index.d.ts

@@ -0,0 +1,83 @@
+declare module "@friggframework/assertions" {
+  type TypeOfType =
+    | "undefined"
+    | "object"
+    | "boolean"
+    | "number"
+    | "string"
+    | "function"
+    | "symbol"
+    | "bigint";
+
+  export function get<TObject extends object, TKey extends string, TDefault>(
+    object: TObject,
+    key: TKey | undefined,
+    defaultValue: Exclude<TDefault, undefined>
+  ): TKey extends keyof TObject ? TObject[TKey] : TDefault;
+
+  export function get<TObject extends object, TKey extends keyof TObject>(
+    object: TObject,
+    key: TKey
+  ): TObject[TKey];
+
+  export function getAll<TObject extends object, TKey extends keyof TObject>(
+    object: TObject,
+    requiredKeys: TKey[]
+  ): Partial<TObject>;
+
+  export function verifyType(value: unknown, paramType: TypeOfType): void;
+
+  export function getParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends string,
+    TKeyType extends TypeOfType,
+    TDefault
+  >(
+    params: TObject,
+    key: TKey,
+    type: TKeyType,
+    defaultValue: TDefault
+  ): TDefault;
+
+  export function getParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends keyof TObject,
+    TKeyType extends TypeOfType
+  >(params: TObject, key: TKey, type: TKeyType): TObject[TKey];
+
+  export function getArrayParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends string,
+    TKeyType extends TypeOfType,
+    TDefault
+  >(
+    params: TObject,
+    key: TKey,
+    type: TKeyType,
+    defaultValue: TDefault
+  ): TDefault;
+
+  export function getArrayParamAndVerifyParamType<
+    TObject extends object,
+    TKey extends keyof TObject,
+    TKeyType extends TypeOfType
+  >(params: TObject, key: TKey, type: TKeyType): TObject[TKey];
+
+  export function getAndVerifyType<
+    TObject extends object,
+    TKey extends keyof TObject,
+    TClassType extends unknown
+  >(object: TObject, key: TKey, classType: TClassType): TObject[TKey];
+
+  export function getAndVerifyType<
+    TObject extends object,
+    TKey extends string,
+    TClassType extends unknown,
+    TDefault
+  >(
+    object: TObject,
+    key: TKey,
+    classType: TClassType,
+    defaultValue: TDefault
+  ): TKey extends keyof TObject ? TObject[TKey] : TDefault;
+}

package/types/associations/index.d.ts

@@ -0,0 +1,74 @@
+declare module "@friggframework/associations/model" {
+  import { Model } from "mongoose";
+
+  export class Association extends Model {
+    integrationId: string;
+    name: string;
+    type: string;
+    primaryObject: string;
+    objects: {
+      entityId: string;
+      objectType: string;
+      objId: string;
+      metadata?: object;
+    }[];
+  }
+}
+
+declare module "@friggframework/associations/association" {
+  export default class Association implements IFriggAssociation {
+    data: any;
+    dataIdentifier: any;
+    dataIdentifierHash: string;
+    matchHash: string;
+    moduleName: any;
+    syncId: any;
+
+    static Config: {
+      name: "Association";
+      reverseModuleMap: {};
+    };
+
+    constructor(params: AssociationConstructor);
+
+    dataKeyIsReplaceable(key: string): boolean;
+
+    equals(syncObj: any): boolean;
+
+    getHashData(): string;
+
+    getName(): any;
+
+    hashJSON(data: any): string;
+
+    isModuleInMap(moduleName: any): any;
+
+    reverseModuleMap(moduleName: any): any;
+
+    setSyncId(syncId: string): any;
+  }
+
+  interface IFriggAssociation {
+    data: any;
+    moduleName: any;
+    dataIdentifier: any;
+    dataIdentifierHash: string;
+    matchHash: string;
+    syncId: any;
+
+    equals(syncObj: any): boolean;
+    dataKeyIsReplaceable(key: string): boolean;
+    isModuleInMap(moduleName: any): any;
+    getName(): any;
+    getHashData(): string;
+    setSyncId(syncId: string): any;
+    reverseModuleMap(moduleName: any): any;
+    hashJSON(data: any): string;
+  }
+
+  type AssociationConstructor = {
+    data: any;
+    moduleName: any;
+    dataIdentifier: any;
+  };
+}

package/types/core/index.d.ts

@@ -0,0 +1,54 @@
+declare module "@friggframework/core" {
+  import { SQS } from "aws-sdk";
+
+  export class Delegate implements IFriggDelegate {
+    delegate: any;
+    delegateTypes: any[];
+
+    constructor(params: Record<string, unknown> & { delegate?: unknown });
+    notify(delegateString: string, object?: any): Promise<any>;
+    receiveNotification(
+      notifier: any,
+      delegateString: string,
+      object?: any
+    ): Promise<any>;
+  }
+
+  interface IFriggDelegate {
+    delegate: any;
+    delegateTypes: any[];
+
+    notify(delegateString: string, object?: any): Promise<any>;
+    receiveNotification(
+      notifier: any,
+      delegateString: string,
+      object?: any
+    ): Promise<any>;
+  }
+
+  export class Worker implements IWorker {
+    getQueueURL(params: GetQueueURLParams): Promise<string | undefined>;
+
+    run(params: { Records: any }): Promise<void>;
+
+    send(params: object & { QueueUrl: any }, delay?: number): Promise<string>;
+
+    sendAsyncSQSMessage(params: SendSQSMessageParams): Promise<string>;
+  }
+
+  interface IWorker {
+    getQueueURL(params: GetQueueURLParams): Promise<string | undefined>;
+    run(params: { Records: any }): Promise<void>;
+    send(params: object & { QueueUrl: any }, delay?: number): Promise<string>;
+    sendAsyncSQSMessage(params: SendSQSMessageParams): Promise<string>;
+  }
+
+  export function loadInstalledModules(): any[];
+
+  type GetQueueURLParams = {
+    QueueName: string;
+    QueueOwnerAWSAccountId?: string;
+  };
+
+  type SendSQSMessageParams = SQS.SendMessageRequest;
+}

package/types/database/index.d.ts

@@ -0,0 +1,3 @@
+declare module "@friggframework/database/mongo" {
+  export function connectToDatabase(): Promise<void>;
+}