@friggframework/core 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

package/syncs/sync.js

@@ -1,113 +1,117 @@
-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;
+    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;
     }
 
-    // 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]);
+    equals(syncObj) {
+        return this.matchHash === syncObj.matchHash;
     }
-    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]);
+    dataKeyIsReplaceable(key) {
+        return this.data[key] === null || this.data[key] === '';
     }
 
-    return this.constructor.hashJSON(orderedData);
-  }
+    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);
+    }
 
-  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,8 +1,4 @@
-const { TokenRepositoryMongo } = require('./token-repository-mongo');
 const { TokenRepositoryPostgres } = require('./token-repository-postgres');
-const {
-    TokenRepositoryDocumentDB,
-} = require('./token-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -16,12 +12,14 @@ function createTokenRepository() {
 
     switch (dbType) {
         case 'mongodb':
+            const { TokenRepositoryMongo } = require('./token-repository-mongo');
             return new TokenRepositoryMongo();
 
         case 'postgresql':
             return new TokenRepositoryPostgres();
 
         case 'documentdb':
+            const { TokenRepositoryDocumentDB } = require('./token-repository-documentdb');
             return new TokenRepositoryDocumentDB();
 
         default:
@@ -34,7 +32,7 @@ function createTokenRepository() {
 module.exports = {
     createTokenRepository,
     // Export adapters for direct testing
-    TokenRepositoryMongo,
+    get TokenRepositoryMongo() { return require('./token-repository-mongo').TokenRepositoryMongo; },
     TokenRepositoryPostgres,
-    TokenRepositoryDocumentDB,
+    get TokenRepositoryDocumentDB() { return require('./token-repository-documentdb').TokenRepositoryDocumentDB; },
 };

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/core/index.d.ts

@@ -1,54 +1,99 @@
-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' {
+    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>;
+    }
+
+    /** Interface for queue message operations (port in hexagonal architecture) */
+    export interface QueueClientInterface {
+        sendMessage(params: SendMessageParams): Promise<{ MessageId: string }>;
+        sendMessageBatch(params: SendMessageBatchParams): Promise<any>;
+        getQueueUrl(params: GetQueueURLParams): Promise<string>;
+    }
+
+    export class Worker implements IWorker {
+        constructor(options?: { queueClient?: QueueClientInterface });
+
+        getQueueURL(params: GetQueueURLParams): Promise<string | undefined>;
+
+        run(params: { Records: any }): Promise<void>;
+
+        send(
+            params: object & { QueueUrl: any },
+            delay?: number
+        ): Promise<string>;
+
+        sendAsyncSQSMessage(params: SendMessageParams): 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: SendMessageParams): Promise<string>;
+    }
+
+    export function loadInstalledModules(): any[];
+
+    type GetQueueURLParams = {
+        QueueName: string;
+        QueueOwnerAWSAccountId?: string;
+    };
+
+    type SendMessageParams = {
+        QueueUrl: string;
+        MessageBody: string;
+        DelaySeconds?: number;
+    };
+
+    type SendMessageBatchParams = {
+        QueueUrl: string;
+        Entries: Array<{ Id: string; MessageBody: string }>;
+    };
+
+    /** Interface for envelope encryption key operations */
+    export class EncryptionKeyProviderInterface {
+        generateDataKey(): Promise<{
+            keyId: string;
+            encryptedKey: string;
+            plaintext: string | Buffer;
+        }>;
+        decryptDataKey(
+            keyId: string,
+            encryptedKey: string | Buffer
+        ): Promise<string | Buffer>;
+    }
+
+    /** Interface for WebSocket message sending */
+    export class WebSocketMessageSenderInterface {
+        send(connectionId: string, data: any, endpoint: string): Promise<void>;
+    }
+
+    export class StaleConnectionError extends Error {
+        connectionId: string;
+        constructor(connectionId: string);
+    }
 }