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

package/associations/association.js

@@ -1,4 +1,4 @@
-const md5 = require('md5');
+const md5 = require("md5");
 const { get } = require('../assertions');
 
 /**
@@ -8,73 +8,71 @@ const { get } = require('../assertions');
  * later...
  */
 class Association {
-    static Config = {
-        name: 'Association',
-
-        reverseModuleMap: {},
-    };
-    constructor(params) {
-        this.data = {};
-
-        let data = get(params, 'data');
-        this.moduleName = get(params, 'moduleName');
-        this.dataIdentifier = get(params, 'dataIdentifier');
-
-        this.dataIdentifierHash = this.constructor.hashJSON(
-            this.dataIdentifier
-        );
-
-        for (let key of this.constructor.Config.keys) {
-            this.data[key] =
-                this.constructor.Config.moduleMap[this.moduleName][key](data);
-        }
-
-        // matchHash is used to find matches between two sync objects
-        let matchHashData = [];
-        for (let key of this.constructor.Config.matchOn) {
-            matchHashData.push(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] === '';
-    }
+  static Config = {
+    name: "Association",
 
-    isModuleInMap(moduleName) {
-        return this.constructor.Config.moduleMap[name];
-    }
+    reverseModuleMap: {},
+  };
+  constructor(params) {
+    this.data = {};
 
-    getName() {
-        return this.name;
-    }
+    let data = get(params, "data");
+    this.moduleName = get(params, "moduleName");
+    this.dataIdentifier = get(params, "dataIdentifier");
 
-    getHashData() {
-        let orderedData = [];
-        for (let key of this.constructor.Config.keys) {
-            orderedData.push(this.data[key]);
-        }
+    this.dataIdentifierHash = this.constructor.hashJSON(this.dataIdentifier);
 
-        return this.constructor.hashJSON(orderedData);
+    for (let key of this.constructor.Config.keys) {
+      this.data[key] =
+        this.constructor.Config.moduleMap[this.moduleName][key](data);
     }
 
-    setSyncId(syncId) {
-        this.syncId = syncId;
+    // matchHash is used to find matches between two sync objects
+    let matchHashData = [];
+    for (let key of this.constructor.Config.matchOn) {
+      matchHashData.push(this.data[key]);
     }
-
-    reverseModuleMap(moduleName) {
-        return this.constructor.Config.reverseModuleMap[moduleName](this.data);
+    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.name;
+  }
+
+  getHashData() {
+    let orderedData = [];
+    for (let key of this.constructor.Config.keys) {
+      orderedData.push(this.data[key]);
     }
 
-    static hashJSON(data) {
-        let dataString = JSON.stringify(data, null, 2);
-        return md5(dataString);
-    }
+    return this.constructor.hashJSON(orderedData);
+  }
+
+  setSyncId(syncId) {
+    this.syncId = syncId;
+  }
+
+  reverseModuleMap(moduleName) {
+    return this.constructor.Config.reverseModuleMap[moduleName](this.data);
+  }
+
+  static hashJSON(data) {
+    let dataString = JSON.stringify(data, null, 2);
+    return md5(dataString);
+  }
 }
 
 module.exports = Association;

package/associations/model.js

@@ -1,54 +1,54 @@
-const mongoose = require('mongoose');
+const mongoose = require("mongoose");
 
 const schema = new mongoose.Schema({
-    integration: {
+  integration: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Integration",
+    required: true,
+  },
+  name: { type: String, required: true },
+  type: {
+    type: String,
+    enum: ["ONE_TO_MANY", "ONE_TO_ONE", "MANY_TO_ONE"],
+    required: true,
+  },
+  primaryObject: { type: String, required: true },
+  objects: [
+    {
+      entity: {
         type: mongoose.Schema.Types.ObjectId,
-        ref: 'Integration',
+        ref: "Entity",
         required: true,
+      },
+      objectType: { type: String, required: true },
+      objId: { type: String, required: true },
+      metadata: { type: Object, required: false },
     },
-    name: { type: String, required: true },
-    type: {
-        type: String,
-        enum: ['ONE_TO_MANY', 'ONE_TO_ONE', 'MANY_TO_ONE'],
-        required: true,
-    },
-    primaryObject: { type: String, required: true },
-    objects: [
-        {
-            entity: {
-                type: mongoose.Schema.Types.ObjectId,
-                ref: 'Entity',
-                required: true,
-            },
-            objectType: { type: String, required: true },
-            objId: { type: String, required: true },
-            metadata: { type: Object, required: false },
-        },
-    ],
+  ],
 });
 
 schema.statics({
-    addAssociation: async function (id, object) {
-        return this.update({ _id: id }, { $push: { objects: object } });
-    },
-    findAssociation: async function (name, dataIdentifierHash) {
-        const syncList = await this.list({
-            name: name,
-            'dataIdentifiers.hash': dataIdentifierHash,
-        });
+  addAssociation: async function (id, object) {
+    return this.update({ _id: id }, { $push: { objects: object } });
+  },
+  findAssociation: async function (name, dataIdentifierHash) {
+    const syncList = await this.list({
+      name: name,
+      "dataIdentifiers.hash": dataIdentifierHash,
+    });
 
-        if (syncList.length === 1) {
-            return syncList[0];
-        } else if (syncList.length === 0) {
-            return null;
-        } else {
-            throw new Error(
-                `there are multiple sync objects with the name ${name}, for entities [${entities}]`
-            );
-        }
-    },
+    if (syncList.length === 1) {
+      return syncList[0];
+    } else if (syncList.length === 0) {
+      return null;
+    } else {
+      throw new Error(
+        `there are multiple sync objects with the name ${name}, for entities [${entities}]`
+      );
+    }
+  },
 });
 
 const Association =
-    mongoose.models.Association || mongoose.model('Association', schema);
+  mongoose.models.Association || mongoose.model("Association", schema);
 module.exports = { Association };