@friggframework/core 2.0.0--canary.454.cbce887.0 → 2.0.0--canary.454.dc05b2f.0

package/associations/association.js

@@ -0,0 +1,78 @@
+const md5 = require("md5");
+const { get } = require('../assertions');
+
+/**
+ * @file This file is meant to be the thing that enforces proper use of
+ * the Association model.
+ * For now, we're going to use the model directly and worry about proper use
+ * 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] === "";
+  }
+
+  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]);
+    }
+
+    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

@@ -0,0 +1,54 @@
+const mongoose = require("mongoose");
+
+const schema = new mongoose.Schema({
+  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: "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,
+    });
+
+    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);
+module.exports = { Association };

package/lambda/TimeoutCatcher.js

@@ -0,0 +1,43 @@
+const isPositive = (n) => Number.isFinite(n) && n > 0;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class TimeoutCatcher {
+  constructor({ work, timeout, cleanUp = () => {}, cleanUpTime = 2_000 }) {
+    this.isFinished = false;
+    this.work = work;
+    this.cleanUp = cleanUp;
+    this.waitTime = timeout - cleanUpTime;
+
+    if (!isPositive(this.waitTime))
+      throw new Error("Wait time was not a positive number of milliseconds");
+  }
+
+  async watch() {
+    try {
+      await Promise.race([this.doWork(), this.exitBeforeTimeout()]);
+      return true;
+    } catch (error) {
+      if (error.isSentinelTimeout) return false;
+      throw error;
+    }
+  }
+
+  async doWork() {
+    await this.work();
+    this.isFinished = true;
+  }
+
+  async exitBeforeTimeout() {
+    await sleep(this.waitTime);
+
+    if (!this.isFinished) {
+      await this.cleanUp();
+
+      const error = new Error("Sentinel Timed Out");
+      error.isSentinelTimeout = true;
+      throw error;
+    }
+  }
+}
+
+module.exports = { TimeoutCatcher };

package/lambda/index.js

@@ -0,0 +1,3 @@
+const { TimeoutCatcher } = require('./TimeoutCatcher');
+
+module.exports = { TimeoutCatcher }

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.454.cbce887.0",
+    "version": "2.0.0--canary.454.dc05b2f.0",
     "files": [
         "*.js",
         "*.d.ts",
         "application/",
         "assertions/",
+        "associations/",
         "core/",
         "credential/",
         "database/",
@@ -14,12 +15,15 @@
         "errors/",
         "handlers/",
         "integrations/",
+        "lambda/",
         "logs/",
         "modules/",
+        "queues/",
         "syncs/",
         "token/",
         "types/",
         "user/",
+        "utils/",
         "websocket/",
         "prisma-mongodb/",
         "prisma-postgresql/",
@@ -49,9 +53,9 @@
         "uuid": "^9.0.1"
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.454.cbce887.0",
-        "@friggframework/prettier-config": "2.0.0--canary.454.cbce887.0",
-        "@friggframework/test": "2.0.0--canary.454.cbce887.0",
+        "@friggframework/eslint-config": "2.0.0--canary.454.dc05b2f.0",
+        "@friggframework/prettier-config": "2.0.0--canary.454.dc05b2f.0",
+        "@friggframework/test": "2.0.0--canary.454.dc05b2f.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
         "chai": "^4.3.6",
@@ -89,5 +93,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "cbce8872aea93a375c1088a0dcb8d05a5d48d8b7"
+    "gitHead": "dc05b2f560edc9f63630fd4e71fe3c57894dff8e"
 }

package/queues/index.js

@@ -0,0 +1,4 @@
+const { QueuerUtil } = require('./queuer-util');
+module.exports = {
+    QueuerUtil,
+};

package/queues/queuer-util.js

@@ -0,0 +1,61 @@
+const { v4: uuid } = require('uuid');
+const AWS = require('aws-sdk');
+const awsConfigOptions = () => {
+    const config = {};
+    if (process.env.IS_OFFLINE) {
+        console.log('Running in offline mode');
+    }
+    if (process.env.AWS_ENDPOINT) {
+        config.endpoint = process.env.AWS_ENDPOINT;
+    }
+    return config;
+};
+AWS.config.update(awsConfigOptions());
+const sqs = new AWS.SQS();
+
+const QueuerUtil = {
+    batchSend: async (entries = [], queueUrl) => {
+        console.log(
+            `Enqueuing ${entries.length} entries on SQS to queue ${queueUrl}`
+        );
+        const buffer = [];
+        const batchSize = 10;
+
+        for (const entry of entries) {
+            buffer.push({
+                Id: uuid(),
+                MessageBody: JSON.stringify(entry),
+            });
+            // Sends 10, then purges the buffer
+            if (buffer.length === batchSize) {
+                console.log('Buffer at 10, sending batch');
+                await sqs
+                    .sendMessageBatch({
+                        Entries: buffer,
+                        QueueUrl: queueUrl,
+                    })
+                    .promise();
+                // Purge the buffer
+                buffer.splice(0, buffer.length);
+            }
+        }
+        console.log('Buffer at end, sending final batch');
+
+        // If any remaining entries under 10 are left in the buffer, send and return
+        if (buffer.length > 0) {
+            console.log(buffer);
+            return sqs
+                .sendMessageBatch({
+                    Entries: buffer,
+                    QueueUrl: queueUrl,
+                })
+                .promise();
+        }
+
+        // If we're exact... just return an empty object for now
+
+        return {};
+    },
+};
+
+module.exports = { QueuerUtil };

package/utils/backend-path.js

@@ -0,0 +1,38 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const PACKAGE_JSON = 'package.json';
+
+function findNearestBackendPackageJson() {
+    let currentDir = process.cwd();
+    
+    // First check if we're in production by looking for package.json in the current directory
+    const rootPackageJson = path.join(currentDir, PACKAGE_JSON);
+    if (fs.existsSync(rootPackageJson)) {
+        // In production environment, check for index.js in the same directory
+        const indexJs = path.join(currentDir, 'index.js');
+        if (fs.existsSync(indexJs)) {
+            return rootPackageJson;
+        }
+    }
+
+    // If not found at root or not in production, look for it in the backend directory
+    while (currentDir !== path.parse(currentDir).root) {
+        const packageJsonPath = path.join(currentDir, 'backend', PACKAGE_JSON);
+        if (fs.existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+
+function validateBackendPath(backendPath) {
+    if (!backendPath) {
+        throw new Error('Could not find a backend package.json file.');
+    }
+}
+
+module.exports = {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+}; 

package/utils/index.js

@@ -0,0 +1,6 @@
+const { findNearestBackendPackageJson, validateBackendPath } = require('./backend-path');
+
+module.exports = {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+};