@friggframework/core 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.35ee143.0

package/syncs/sync.js

@@ -1,117 +1,113 @@
-const md5 = require('md5');
-const { debug } = require('packages/logs');
-const { get } = require('packages/assertions');
+const md5 = require("md5");
+const { debug } = require("packages/logs");
+const { get } = require("packages/assertions");
 
 class Sync {
-    static Config = {
-        name: 'Sync',
-
-        // an array of keys we will use to form an object and then hash it. Order matters here
-        // because it will effect how the hash results
-        keys: [],
-
-        // matchOn is an array of keys that make the variable unique when combined together
-        // and is used to sync with the other objects
-        // matchOn keys _have_ to have a value, otherwise the object is not considered a match
-        matchOn: [],
-
-        // a key value mapping of module to then a list of keys that will map to
-        // an a function that takes in the module object and return the value from it
-        //  format as follows:
-        // {
-        //      ModuleName:{
-        //          firstName:(moduleObject)=>{moduleObject['name'][0]},
-        //          lastName:(moduleObject)=>{moduleObject['name'][1]},
-        //      },
-        //      ....
-        // }
-        moduleMap: {},
-        reverseModuleMap: {},
-    };
-    constructor(params) {
-        this.data = {};
-
-        let data = get(params, 'data');
-        this.moduleName = get(params, 'moduleName');
-        this.dataIdentifier = get(params, 'dataIdentifier');
-        this.useMapping = get(params, 'useMapping', true); // Use with caution...
-
-        this.dataIdentifierHash = this.constructor.hashJSON(
-            this.dataIdentifier
-        );
-
-        if (this.useMapping) {
-            for (let key of this.constructor.Config.keys) {
-                this.data[key] =
-                    this.constructor.Config.moduleMap[this.moduleName][key](
-                        data
-                    );
-            }
-        } else {
-            this.data = data;
-        }
-
-        // matchHash is used to find matches between two sync objects
-        // Match data _has_ to have a value
-        const matchHashData = [];
-        this.missingMatchData = false;
-        for (const key of this.constructor.Config.matchOn) {
-            if (!this.data[key]) {
-                this.missingMatchData = true;
-                debug(`Data key of ${key} was missing from MatchOn`);
-            }
-
-            matchHashData.push(this.data[key]);
-        }
-        this.matchHash = this.constructor.hashJSON(matchHashData);
-
-        this.syncId = null;
+  static Config = {
+    name: "Sync",
+
+    // an array of keys we will use to form an object and then hash it. Order matters here
+    // because it will effect how the hash results
+    keys: [],
+
+    // matchOn is an array of keys that make the variable unique when combined together
+    // and is used to sync with the other objects
+    // matchOn keys _have_ to have a value, otherwise the object is not considered a match
+    matchOn: [],
+
+    // a key value mapping of module to then a list of keys that will map to
+    // an a function that takes in the module object and return the value from it
+    //  format as follows:
+    // {
+    //      ModuleName:{
+    //          firstName:(moduleObject)=>{moduleObject['name'][0]},
+    //          lastName:(moduleObject)=>{moduleObject['name'][1]},
+    //      },
+    //      ....
+    // }
+    moduleMap: {},
+    reverseModuleMap: {},
+  };
+  constructor(params) {
+    this.data = {};
+
+    let data = get(params, "data");
+    this.moduleName = get(params, "moduleName");
+    this.dataIdentifier = get(params, "dataIdentifier");
+    this.useMapping = get(params, "useMapping", true); // Use with caution...
+
+    this.dataIdentifierHash = this.constructor.hashJSON(this.dataIdentifier);
+
+    if (this.useMapping) {
+      for (let key of this.constructor.Config.keys) {
+        this.data[key] =
+          this.constructor.Config.moduleMap[this.moduleName][key](data);
+      }
+    } else {
+      this.data = data;
     }
 
-    equals(syncObj) {
-        return this.matchHash === syncObj.matchHash;
+    // matchHash is used to find matches between two sync objects
+    // Match data _has_ to have a value
+    const matchHashData = [];
+    this.missingMatchData = false;
+    for (const key of this.constructor.Config.matchOn) {
+      if (!this.data[key]) {
+        this.missingMatchData = true;
+        debug(`Data key of ${key} was missing from MatchOn`);
+      }
+
+      matchHashData.push(this.data[key]);
     }
-    dataKeyIsReplaceable(key) {
-        return this.data[key] === null || this.data[key] === '';
+    this.matchHash = this.constructor.hashJSON(matchHashData);
+
+    this.syncId = null;
+  }
+
+  equals(syncObj) {
+    return this.matchHash === syncObj.matchHash;
+  }
+  dataKeyIsReplaceable(key) {
+    return this.data[key] === null || this.data[key] === "";
+  }
+
+  isModuleInMap(moduleName) {
+    return this.constructor.Config.moduleMap[name];
+  }
+
+  getName() {
+    return this.constructor.Config.name;
+  }
+
+  getHashData(params) {
+    let omitEmptyStringsFromData = get(
+      params,
+      "omitEmptyStringsFromData",
+      false
+    );
+    let orderedData = [];
+    for (let key of this.constructor.Config.keys) {
+      if (omitEmptyStringsFromData && this.data[key] === "") {
+        this.data[key] = undefined;
+      }
+      orderedData.push(this.data[key]);
     }
 
-    isModuleInMap(moduleName) {
-        return this.constructor.Config.moduleMap[name];
-    }
-
-    getName() {
-        return this.constructor.Config.name;
-    }
-
-    getHashData(params) {
-        let omitEmptyStringsFromData = get(
-            params,
-            'omitEmptyStringsFromData',
-            false
-        );
-        let orderedData = [];
-        for (let key of this.constructor.Config.keys) {
-            if (omitEmptyStringsFromData && this.data[key] === '') {
-                this.data[key] = undefined;
-            }
-            orderedData.push(this.data[key]);
-        }
-
-        return this.constructor.hashJSON(orderedData);
-    }
+    return this.constructor.hashJSON(orderedData);
+  }
 
-    setSyncId(syncId) {
-        this.syncId = syncId;
-    }
+  setSyncId(syncId) {
+    this.syncId = syncId;
+  }
 
-    reverseModuleMap(moduleName) {
-        return this.constructor.Config.reverseModuleMap[moduleName](this.data);
-    }
+  reverseModuleMap(moduleName) {
+    return this.constructor.Config.reverseModuleMap[moduleName](this.data);
+  }
 
-    static hashJSON(data) {
-        let dataString = JSON.stringify(data, null, 2);
-        return md5(dataString);
-    }
+  static hashJSON(data) {
+    let dataString = JSON.stringify(data, null, 2);
+    return md5(dataString);
+  }
 }
 
 module.exports = Sync;

package/token/repositories/token-repository-factory.js

@@ -1,6 +1,8 @@
 const { TokenRepositoryMongo } = require('./token-repository-mongo');
 const { TokenRepositoryPostgres } = require('./token-repository-postgres');
-const { TokenRepositoryDocumentDB } = require('./token-repository-documentdb');
+const {
+    TokenRepositoryDocumentDB,
+} = require('./token-repository-documentdb');
 const config = require('../../database/config');
 
 /**

package/types/assertions/index.d.ts

@@ -1,83 +1,83 @@
-declare module '@friggframework/assertions' {
-    type TypeOfType =
-        | 'undefined'
-        | 'object'
-        | 'boolean'
-        | 'number'
-        | 'string'
-        | 'function'
-        | 'symbol'
-        | 'bigint';
+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 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 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 getAll<TObject extends object, TKey extends keyof TObject>(
+    object: TObject,
+    requiredKeys: TKey[]
+  ): Partial<TObject>;
 
-    export function verifyType(value: unknown, paramType: TypeOfType): void;
+  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 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 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 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 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 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;
+  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

@@ -1,74 +1,74 @@
-declare module '@friggframework/associations/model' {
-    import { Model } from 'mongoose';
+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;
-        }[];
-    }
+  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;
+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: {};
-        };
+    static Config: {
+      name: "Association";
+      reverseModuleMap: {};
+    };
 
-        constructor(params: AssociationConstructor);
+    constructor(params: AssociationConstructor);
 
-        dataKeyIsReplaceable(key: string): boolean;
+    dataKeyIsReplaceable(key: string): boolean;
 
-        equals(syncObj: any): boolean;
+    equals(syncObj: any): boolean;
 
-        getHashData(): string;
+    getHashData(): string;
 
-        getName(): any;
+    getName(): any;
 
-        hashJSON(data: any): string;
+    hashJSON(data: any): string;
 
-        isModuleInMap(moduleName: any): any;
+    isModuleInMap(moduleName: any): any;
 
-        reverseModuleMap(moduleName: any): any;
+    reverseModuleMap(moduleName: any): any;
 
-        setSyncId(syncId: string): any;
-    }
+    setSyncId(syncId: string): any;
+  }
 
-    interface IFriggAssociation {
-        data: any;
-        moduleName: any;
-        dataIdentifier: any;
-        dataIdentifierHash: string;
-        matchHash: string;
-        syncId: 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;
-    }
+    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;
-    };
+  type AssociationConstructor = {
+    data: any;
+    moduleName: any;
+    dataIdentifier: any;
+  };
 }

package/types/core/index.d.ts

@@ -1,60 +1,54 @@
-declare module '@friggframework/core' {
-    import type { SendMessageCommandInput } from '@aws-sdk/client-sqs';
-
-    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 = SendMessageCommandInput;
+declare module "@friggframework/core" {
+  import type { SendMessageCommandInput } from "@aws-sdk/client-sqs";
+
+  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 = SendMessageCommandInput;
 }

package/types/database/index.d.ts

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

package/types/encrypt/index.d.ts

@@ -1,5 +1,5 @@
-declare module '@friggframework/encrypt' {
-    import { Schema } from 'mongoose';
+declare module "@friggframework/encrypt" {
+  import { Schema } from "mongoose";
 
-    export function Encrypt(schema: Schema, options: any): void;
+  export function Encrypt(schema: Schema, options: any): void;
 }