@mastra/core 0.1.0 → 0.1.2

package/dist/core.esm.js

@@ -0,0 +1,4947 @@
+import { PrismaClient, PropertyType, Prisma } from '@prisma-app/client';
+export { PropertyType } from '@prisma-app/client';
+import { UTCDate } from '@date-fns/utc';
+import * as dateFns from 'date-fns';
+import { startOfDay, endOfDay } from 'date-fns';
+import { PrismaClientKnownRequestError, PrismaClientValidationError } from '@prisma/client/runtime/library';
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+import { headers } from 'next/headers';
+import qs from 'qs';
+import { serve } from 'inngest/next';
+import path from 'path';
+import * as fs from 'fs';
+import first from 'lodash-es/first';
+import last from 'lodash-es/last';
+import { Inngest } from 'inngest';
+import { OAuth2Client } from '@badgateway/oauth2-client';
+import _, { isEmpty, omit, omitBy } from 'lodash-es';
+
+var WorkflowStatusEnum = {
+  DRAFT: 'DRAFT',
+  UNPUBLISHED: 'UNPUBLISHED',
+  PUBLISHED: 'PUBLISHED'
+};
+var RunStatus = {
+  PENDING: 'PENDING',
+  RUNNING: 'RUNNING',
+  COMPLETED: 'COMPLETED',
+  FAILED: 'FAILED'
+};
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: !0
+      } : {
+        done: !1,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.includes(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+          } else {
+            if (!u) throw Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? new Map() : void 0;
+  return _wrapNativeSuper = function (t) {
+    if (null === t || !_isNativeFunction(t)) return t;
+    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t)) return r.get(t);
+      r.set(t, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _setPrototypeOf(Wrapper, t);
+  }, _wrapNativeSuper(t);
+}
+
+var IntegrationError = /*#__PURE__*/function (_Error) {
+  function IntegrationError(message) {
+    var _this;
+    _this = _Error.call(this, message) || this;
+    _this.name = _this.constructor.name;
+    return _this;
+  }
+  _inheritsLoose(IntegrationError, _Error);
+  return IntegrationError;
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+var globalForPrisma = globalThis;
+var logLevels = ['error', 'warn', 'info'];
+if (process.env.SHOW_SQL_QUERY === 'true') {
+  logLevels.push('query');
+}
+var prisma = function prisma(url) {
+  var prismaInstance;
+  if (globalForPrisma.standardPrisma) {
+    console.log('Reusing Global Prisma Client...');
+    prismaInstance = globalForPrisma.standardPrisma;
+  } else {
+    prismaInstance = new PrismaClient({
+      datasourceUrl: url,
+      log: logLevels
+    });
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    globalForPrisma.standardPrisma = prismaInstance;
+  }
+  return prismaInstance;
+};
+
+var PropertyService = /*#__PURE__*/function () {
+  function PropertyService(_ref) {
+    var db = _ref.db;
+    this.db = void 0;
+    this.db = db;
+  }
+  var _proto = PropertyService.prototype;
+  _proto.getPropertiesByEntityType = /*#__PURE__*/function () {
+    var _getPropertiesByEntityType = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
+      var entityType;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            entityType = _ref2.entityType;
+            return _context.abrupt("return", this.db.property.findMany({
+              where: {
+                entity: {
+                  type: entityType
+                }
+              }
+            }));
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function getPropertiesByEntityType(_x) {
+      return _getPropertiesByEntityType.apply(this, arguments);
+    }
+    return getPropertiesByEntityType;
+  }();
+  return PropertyService;
+}();
+
+var FilterOperators;
+(function (FilterOperators) {
+  FilterOperators["IS"] = "is";
+  FilterOperators["EQUAL"] = "eq";
+  FilterOperators["NOT_EQUAL"] = "not_eq";
+  FilterOperators["CONTAINS"] = "contains";
+  FilterOperators["IN"] = "in";
+  FilterOperators["NOT_IN"] = "not_in";
+  FilterOperators["GREATER_THAN"] = "gt";
+  FilterOperators["LESS_THAN"] = "lt";
+  FilterOperators["NOT_CONTAINS"] = "not_contains";
+  FilterOperators["GREATER_THAN_OR_EQUAL"] = "gte";
+  FilterOperators["LESS_THAN_OR_EQUAL"] = "lte";
+  FilterOperators["OP"] = "op";
+  FilterOperators["SET"] = "set";
+  FilterOperators["NOT_SET"] = "not_set";
+})(FilterOperators || (FilterOperators = {}));
+
+var _FieldTypePrimitiveMa, _FilterOperatorToSQL;
+var fieldsWithCommaSeparatedValues = ['SINGLE_SELECT', 'MULTI_SELECT', 'USER', 'COMPANY', 'CONTACT'];
+var FieldTypePrimitiveMap = (_FieldTypePrimitiveMa = {}, _FieldTypePrimitiveMa[PropertyType.BADGE_LIST] = 'string', _FieldTypePrimitiveMa[PropertyType.CHECKBOX] = 'boolean', _FieldTypePrimitiveMa[PropertyType.BOOLEAN] = 'boolean', _FieldTypePrimitiveMa[PropertyType.NUMBER] = 'number', _FieldTypePrimitiveMa[PropertyType.FLOAT] = 'number', _FieldTypePrimitiveMa[PropertyType.JSON_ARRAY] = 'string', _FieldTypePrimitiveMa[PropertyType.JSON_OBJECT] = 'string', _FieldTypePrimitiveMa[PropertyType.CURRENCY] = 'number', _FieldTypePrimitiveMa[PropertyType.DATE] = 'date', _FieldTypePrimitiveMa[PropertyType.LONG_TEXT] = 'string', _FieldTypePrimitiveMa[PropertyType.MULTI_SELECT] = 'string', _FieldTypePrimitiveMa[PropertyType.PHONE] = 'string', _FieldTypePrimitiveMa[PropertyType.SINGLE_LINE_TEXT] = 'string', _FieldTypePrimitiveMa[PropertyType.SINGLE_SELECT] = 'string', _FieldTypePrimitiveMa[PropertyType.URL] = 'string', _FieldTypePrimitiveMa[PropertyType.USER] = 'string', _FieldTypePrimitiveMa[PropertyType.CONTACT] = 'string', _FieldTypePrimitiveMa[PropertyType.COMPANY] = 'string', _FieldTypePrimitiveMa[PropertyType.COMPOSITE] = 'string', _FieldTypePrimitiveMa[PropertyType.PERSON] = 'string', _FieldTypePrimitiveMa[PropertyType.ENRICHMENT] = 'string', _FieldTypePrimitiveMa);
+var SORT_MODE_TO_ABBR = {
+  ascending: 'asc',
+  descending: 'desc'
+};
+var FilterOperatorToSQL = (_FilterOperatorToSQL = {}, _FilterOperatorToSQL[FilterOperators.IS] = '=', _FilterOperatorToSQL[FilterOperators.EQUAL] = '=', _FilterOperatorToSQL[FilterOperators.NOT_EQUAL] = '!=', _FilterOperatorToSQL[FilterOperators.CONTAINS] = '~*', _FilterOperatorToSQL[FilterOperators.IN] = 'IN', _FilterOperatorToSQL[FilterOperators.NOT_IN] = 'NOT IN', _FilterOperatorToSQL[FilterOperators.GREATER_THAN] = '>', _FilterOperatorToSQL[FilterOperators.LESS_THAN] = '<', _FilterOperatorToSQL[FilterOperators.NOT_CONTAINS] = '!~*', _FilterOperatorToSQL[FilterOperators.GREATER_THAN_OR_EQUAL] = '>=', _FilterOperatorToSQL[FilterOperators.LESS_THAN_OR_EQUAL] = '<=', _FilterOperatorToSQL[FilterOperators.OP] = 'AND', _FilterOperatorToSQL[FilterOperators.SET] = 'IS NOT NULL', _FilterOperatorToSQL[FilterOperators.NOT_SET] = 'IS NULL', _FilterOperatorToSQL);
+
+/**
+ * Split a string on commas and strip quotes from each part
+ * @param str input string
+ * @returns array of strings
+ */
+var splitAndStripQuotes = function splitAndStripQuotes(str) {
+  // Raw regex pattern for splitting on non-quoted commas
+  var pattern = /,\s*(?=(?:[^"]*"[^"]*")*[^"]*$)/;
+  // Split the string
+  var parts = str.split(pattern);
+  // Strip quotes from each part
+  var cleanedParts = parts.map(function (part) {
+    return part.trim().replace(/^"|"$/g, '');
+  });
+  return cleanedParts;
+};
+var transformFilterValueArray = function transformFilterValueArray(value) {
+  if (typeof value === 'string') return value.split(',');
+  return value;
+};
+var transformFilterValueBoolean = function transformFilterValueBoolean(value) {
+  if (typeof value === 'string') return value === 'true';
+  return value;
+};
+/**
+ * This returns the SQL field for a JSON field with appropriate casting.
+ * @param column - JSON field to cast.
+ * @param type - Type of the JSON field.
+ */
+var getJSONField = function getJSONField(column, type) {
+  var primitiveType = FieldTypePrimitiveMap[type];
+  switch (primitiveType) {
+    case 'number':
+      {
+        // cast to number if field is numeric
+        return "(" + column + ")::bigint";
+      }
+    case 'boolean':
+      {
+        // cast to boolean if field is boolean
+        return "(" + column + ")::boolean";
+      }
+    case 'date':
+      {
+        return "(" + column + ")::timestamp";
+      }
+  }
+  return "(" + column + ")::text";
+};
+/**
+ * @description
+ * Builds a query string from filter and sort query strings
+ * @param filterQueryString Filter query string
+ * @param sortQueryString Sort query string
+ * @returns
+ */
+function buildQueryString(_ref) {
+  var filterQueryString = _ref.filterQueryString,
+    sortQueryString = _ref.sortQueryString;
+  if (!filterQueryString && !sortQueryString) return '';
+  if (!filterQueryString) return "" + sortQueryString;
+  if (!sortQueryString) return "" + filterQueryString;
+  return filterQueryString + "&" + sortQueryString;
+}
+
+/**
+ * Get the SQL filter clause for the given filters.
+ * @param filters - Filters to apply.
+ * @param fields - Optional. JSON fields with associated types to apply filters on.
+ * @param parentTableRef - Parent table reference to apply filters on.
+ */
+var getFilterClauseSQL = function getFilterClauseSQL(_ref) {
+  var filters = _ref.filters,
+    fields = _ref.fields,
+    parentTableRef = _ref.parentTableRef;
+  if (!parentTableRef || !Object.keys(filters).length) return '';
+  var getValue = function getValue(value, primitiveType, isMultiple) {
+    if (isMultiple) {
+      var multipleValues = splitAndStripQuotes(value);
+      return "(" + multipleValues.map(function (v) {
+        return primitiveType === 'number' ? Number(v) + "::bigint" : "'" + v + "'";
+      }).join(',') + ")";
+    }
+    switch (primitiveType) {
+      case 'number':
+        {
+          // cast to number if field is numeric
+          return Number(value) + "::bigint";
+        }
+      case 'boolean':
+        {
+          // cast to boolean if field is boolean
+          return value + "::boolean";
+        }
+      case 'string':
+        {
+          return "'" + value + "'";
+        }
+      case 'date':
+        {
+          return "'" + value + "'::timestamp";
+        }
+      default:
+        {
+          return value;
+        }
+    }
+  };
+  var getFilterClause = function getFilterClause(table, field, filter) {
+    var _fields$find;
+    var fieldType = (fields == null || (_fields$find = fields.find(function (f) {
+      return field.startsWith(f.name);
+    })) == null ? void 0 : _fields$find.type) || PropertyType.SINGLE_LINE_TEXT;
+    var column = "\"mastra\".\"" + table + "\".\"" + field + "\"";
+    var operators = Object.keys(filter);
+    var logicOperator = filter.op || 'or';
+    var isJSONField = field.includes('.');
+    // JSON fields contains a parent field and a child field. e.g. data.amount
+    if (isJSONField) {
+      var _fields$find2;
+      var _field$split = field.split('.'),
+        parentField = _field$split[0],
+        childField = _field$split[1];
+      fieldType = (fields == null || (_fields$find2 = fields.find(function (f) {
+        return f.name === childField;
+      })) == null ? void 0 : _fields$find2.type) || PropertyType.SINGLE_LINE_TEXT;
+      var JSONField = "\"mastra\".\"" + table + "\".\"" + parentField + "\"->>'" + childField + "'";
+      column = getJSONField(JSONField, fieldType);
+    }
+    var primitiveType = FieldTypePrimitiveMap[fieldType || PropertyType.SINGLE_LINE_TEXT];
+    var clauses = operators.filter(function (op) {
+      return op !== FilterOperators.OP;
+    }).map(function (op) {
+      var isContains = op === FilterOperators.CONTAINS || op === FilterOperators.NOT_CONTAINS;
+      var isSetOperator = op === FilterOperators.SET || op === FilterOperators.NOT_SET;
+      var isINOperator = op === FilterOperators.IN || op === FilterOperators.NOT_IN;
+      var operatorSQL = FilterOperatorToSQL[op];
+      var inputValues = Array.isArray(filter[op]) ? filter[op] : [filter[op]];
+      var queryValues = isContains ?
+      // if operator is 'contains', we use POSIX regex to match any the values
+      ["'.*" + inputValues.join('.*|.*') + ".*'"] // e.g. ['foo', 'bar'] => /.*foo.*|.*bar.*/
+      :
+      // limitation of this is that we can't have `AND` clauses for the `contains` operator
+      // else, we use the value as is
+      // N/B: in and not_in operators are handled differently as they're not transformed to arrays
+      inputValues.map(function (v) {
+        return getValue(v, primitiveType, isINOperator && v.includes(','));
+      });
+      if (primitiveType === "date" && !isSetOperator) {
+        var hasTimezone = filter[op].toLowerCase().includes('z');
+        var inputVal = new UTCDate(hasTimezone ? filter[op] : filter[op] + "Z");
+        var startDayVal = getValue(startOfDay(inputVal).toISOString(), primitiveType, false);
+        var endDayVal = getValue(endOfDay(inputVal).toISOString(), primitiveType, false);
+        if (op === "eq") {
+          return "((" + column + " >= " + startDayVal + ") AND (" + column + " <= " + endDayVal + "))";
+        } else if (op === "lt") {
+          return "(" + column + " " + operatorSQL + " " + startDayVal + ")";
+        } else if (op === "gt") {
+          return "(" + column + " " + operatorSQL + " " + endDayVal + ")";
+        } else if (op === "lte") {
+          return "(" + column + " " + operatorSQL + " " + endDayVal + ")";
+        } else if (op === "gte") {
+          return "(" + column + " " + operatorSQL + " " + startDayVal + ")";
+        } else if (op === "not_eq") {
+          return "((" + column + " < " + startDayVal + ") OR (" + column + " > " + endDayVal + "))";
+        }
+      }
+      return "(" + queryValues.map(function (value) {
+        return isSetOperator ? "(" + column + " " + operatorSQL + ")" : "(" + column + " " + operatorSQL + " " + value + ")";
+      }).join(" " + logicOperator.toUpperCase() + " ") + ")";
+    });
+    var filterClause = "(" + clauses.join(" " + logicOperator.toUpperCase() + " ") + ")";
+    return filterClause;
+  };
+  var combinedFields = Object.keys(filters).filter(function (field) {
+    return field.includes(',');
+  });
+  var normalFields = Object.keys(filters).filter(function (field) {
+    return !field.includes(',');
+  });
+  var filterClauseMap = normalFields.reduce(function (acc, field) {
+    var _extends2;
+    return _extends({}, acc, (_extends2 = {}, _extends2[field] = getFilterClause(parentTableRef, field, filters[field]), _extends2));
+  }, {});
+  var combinedFilterClauses = combinedFields.map(function (field) {
+    var fields = field.split(',');
+    var logicGroupOperator = filters[field].op || 'and';
+    var clauses = fields.map(function (f) {
+      return filterClauseMap[f];
+    });
+    return "(" + clauses.join(" " + logicGroupOperator.toUpperCase() + " ") + ")";
+  });
+  var normalFilterClauses = Object.entries(filterClauseMap).map(function (_ref2) {
+    var field = _ref2[0],
+      clause = _ref2[1];
+    return combinedFields.some(function (f) {
+      return f.includes(field);
+    }) ? [] : clause;
+  }).flat();
+  return "(" + [].concat(combinedFilterClauses, normalFilterClauses).join(' AND ') + ")";
+};
+
+/**
+ * Get the SQL sort clause for the given sort fields.
+ * A sort clause is an array of strings where each string is a field to sort by.
+ * e.g. ["field1 ASC", "field2 DESC"] will sort by field1 in ascending order and field2 in descending order.
+ */
+var getSortClauseSQL = function getSortClauseSQL(_ref) {
+  var sort = _ref.sort,
+    parentTableRef = _ref.parentTableRef,
+    fields = _ref.fields;
+  if (!parentTableRef) return [];
+  return sort
+  // filter out invalid sort fields
+  .filter(function (sortField) {
+    return sortField.startsWith('asc(') || sortField.startsWith('desc(');
+  }).map(function (sortField) {
+    var _sortField$slice$spli = sortField.slice(0, sortField.length - 1).split('('),
+      order = _sortField$slice$spli[0],
+      field = _sortField$slice$spli[1];
+    var isJSONField = typeof field.split('.')[1] !== 'undefined';
+    if (isJSONField) {
+      var _fields$find;
+      var _field$split = field.split('.'),
+        parentField = _field$split[0],
+        childField = _field$split[1];
+      var fieldType = (fields == null || (_fields$find = fields.find(function (f) {
+        return f.name === childField;
+      })) == null ? void 0 : _fields$find.type) || PropertyType.SINGLE_LINE_TEXT;
+      var JSONField = "\"mastra\".\"" + parentTableRef + "\".\"" + parentField + "\"->>'" + childField + "'";
+      var column = getJSONField(JSONField, fieldType);
+      return column + " " + order.toUpperCase();
+    }
+    return "\"mastra\".\"" + parentTableRef + "\".\"" + field + "\" " + order.toUpperCase();
+  });
+};
+
+var RecordService = /*#__PURE__*/function () {
+  function RecordService(_ref) {
+    var db = _ref.db;
+    this.db = void 0;
+    this.propertyService = void 0;
+    this.db = db;
+    this.propertyService = new PropertyService({
+      db: db
+    });
+  }
+  var _proto = RecordService.prototype;
+  _proto.buildRecordQuerySql = function buildRecordQuerySql(_ref2) {
+    var whereClause = _ref2.whereClause,
+      filterClause = _ref2.filterClause,
+      sortClauses = _ref2.sortClauses,
+      entityType = _ref2.entityType;
+    return "\n      SELECT\n    \"mastra\".\"records\".*,\n    row_to_json(\"mastra\".\"entity\".*) AS \"entity\"\n    FROM \"mastra\".\"records\"\n    LEFT JOIN \"mastra\".\"entity\" ON \"mastra\".\"entity\".\"id\" = \"mastra\".\"records\".\"entityId\"\n    " + whereClause + "\n    " + (entityType ? "AND \"mastra\".\"entity\".\"type\" = '" + entityType + "'" : '') + "\n    AND \"records\".\"deletedAt\" IS NULL\n    " + (filterClause ? "AND " + filterClause : '') + "\n    ORDER BY " + (sortClauses.length > 0 ? sortClauses.join(', ') : '') + "\n    ";
+  };
+  _proto.getFilteredRecords = /*#__PURE__*/function () {
+    var _getFilteredRecords = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref3) {
+      var entityType, k_id, filters, sort, properties, dateFields, fullProperties, filterClause, sortClauses, sqlStatement, records;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            entityType = _ref3.entityType, k_id = _ref3.k_id, filters = _ref3.filters, sort = _ref3.sort;
+            _context.next = 3;
+            return this.propertyService.getPropertiesByEntityType({
+              entityType: entityType
+            });
+          case 3:
+            properties = _context.sent;
+            dateFields = [{
+              name: "createdAt",
+              type: "DATE"
+            }, {
+              name: "updatedAt",
+              type: "DATE"
+            }];
+            fullProperties = [].concat(properties, dateFields);
+            filterClause = '', sortClauses = ["\"mastra\".\"records\".\"createdAt\" DESC"];
+            if (filters) {
+              filterClause = getFilterClauseSQL({
+                filters: filters,
+                fields: fullProperties,
+                parentTableRef: 'records'
+              });
+            }
+            if (sort) {
+              sortClauses = getSortClauseSQL({
+                sort: sort,
+                fields: fullProperties,
+                parentTableRef: 'records'
+              });
+            }
+            sqlStatement = this.buildRecordQuerySql({
+              whereClause: "WHERE \"mastra\".\"entity\".\"k_id\" = '" + k_id + "'",
+              filterClause: filterClause,
+              sortClauses: sortClauses,
+              entityType: entityType
+            });
+            _context.prev = 10;
+            _context.next = 13;
+            return this.db.$queryRawUnsafe(sqlStatement);
+          case 13:
+            records = _context.sent;
+            return _context.abrupt("return", records);
+          case 17:
+            _context.prev = 17;
+            _context.t0 = _context["catch"](10);
+            if (!(_context.t0 instanceof PrismaClientValidationError)) {
+              _context.next = 21;
+              break;
+            }
+            return _context.abrupt("return", []);
+          case 21:
+            if (!(_context.t0 instanceof PrismaClientKnownRequestError)) {
+              _context.next = 24;
+              break;
+            }
+            if (!(_context.t0.code === 'P2010' && _context.t0.meta && _context.t0.meta.code === '42703')) {
+              _context.next = 24;
+              break;
+            }
+            return _context.abrupt("return", []);
+          case 24:
+            throw _context.t0;
+          case 25:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this, [[10, 17]]);
+    }));
+    function getFilteredRecords(_x) {
+      return _getFilteredRecords.apply(this, arguments);
+    }
+    return getFilteredRecords;
+  }();
+  return RecordService;
+}();
+
+var _excluded$4 = ["k_id"];
+var DataLayer = /*#__PURE__*/function () {
+  function DataLayer(_ref) {
+    var url = _ref.url;
+    this.db = void 0;
+    this.recordService = void 0;
+    this.db = prisma(url);
+    this.recordService = new RecordService({
+      db: this.db
+    });
+  }
+  var _proto = DataLayer.prototype;
+  _proto.createConnection = /*#__PURE__*/function () {
+    var _createConnection = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
+      var connection, credential;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            connection = _ref2.connection, credential = _ref2.credential;
+            return _context.abrupt("return", this.db.connection.upsert({
+              where: {
+                connectionId_name: {
+                  connectionId: connection.connectionId,
+                  name: connection.name
+                }
+              },
+              create: _extends({}, connection, {
+                credential: {
+                  create: credential
+                }
+              }),
+              update: _extends({}, connection, {
+                credential: {
+                  update: credential
+                }
+              }),
+              include: {
+                credential: true
+              }
+            }));
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function createConnection(_x) {
+      return _createConnection.apply(this, arguments);
+    }
+    return createConnection;
+  }();
+  _proto.deleteConnection = /*#__PURE__*/function () {
+    var _deleteConnection = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref3) {
+      var connectionId;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            connectionId = _ref3.connectionId;
+            return _context2.abrupt("return", this.db.connection["delete"]({
+              where: {
+                id: connectionId
+              }
+            }));
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function deleteConnection(_x2) {
+      return _deleteConnection.apply(this, arguments);
+    }
+    return deleteConnection;
+  }();
+  _proto.getConnection = /*#__PURE__*/function () {
+    var _getConnection = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref4) {
+      var connectionId, name;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            connectionId = _ref4.connectionId, name = _ref4.name;
+            return _context3.abrupt("return", this.db.connection.findUnique({
+              where: {
+                connectionId_name: {
+                  connectionId: connectionId,
+                  name: name
+                }
+              }
+            }));
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function getConnection(_x3) {
+      return _getConnection.apply(this, arguments);
+    }
+    return getConnection;
+  }();
+  _proto.getConnectionsByIntegrationName = /*#__PURE__*/function () {
+    var _getConnectionsByIntegrationName = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref5) {
+      var name;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            name = _ref5.name;
+            return _context4.abrupt("return", this.db.connection.findMany({
+              where: {
+                name: name
+              },
+              orderBy: {
+                createdAt: 'desc'
+              }
+            }));
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function getConnectionsByIntegrationName(_x4) {
+      return _getConnectionsByIntegrationName.apply(this, arguments);
+    }
+    return getConnectionsByIntegrationName;
+  }();
+  _proto.getAllConnections = /*#__PURE__*/function () {
+    var _getAllConnections = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            return _context5.abrupt("return", this.db.connection.findMany({
+              select: {
+                name: true,
+                connectionId: true
+              }
+            }));
+          case 1:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this);
+    }));
+    function getAllConnections() {
+      return _getAllConnections.apply(this, arguments);
+    }
+    return getAllConnections;
+  }();
+  _proto.getConnectionById = /*#__PURE__*/function () {
+    var _getConnectionById = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(_ref6) {
+      var k_id;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            k_id = _ref6.k_id;
+            return _context6.abrupt("return", this.db.connection.findUnique({
+              where: {
+                id: k_id
+              }
+            }));
+          case 2:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this);
+    }));
+    function getConnectionById(_x5) {
+      return _getConnectionById.apply(this, arguments);
+    }
+    return getConnectionById;
+  }();
+  _proto.getCredentialsByConnection = /*#__PURE__*/function () {
+    var _getCredentialsByConnection = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(k_id) {
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return this.db.credential.findUniqueOrThrow({
+              where: {
+                k_id: k_id
+              },
+              include: {
+                connection: true
+              }
+            });
+          case 2:
+            return _context7.abrupt("return", _context7.sent);
+          case 3:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7, this);
+    }));
+    function getCredentialsByConnection(_x6) {
+      return _getCredentialsByConnection.apply(this, arguments);
+    }
+    return getCredentialsByConnection;
+  }();
+  _proto.updateConnectionCredential = /*#__PURE__*/function () {
+    var _updateConnectionCredential = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(_ref7) {
+      var k_id, token;
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            k_id = _ref7.k_id, token = _ref7.token;
+            return _context8.abrupt("return", this.db.credential.update({
+              where: {
+                k_id: k_id
+              },
+              data: {
+                value: token
+              }
+            }));
+          case 2:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8, this);
+    }));
+    function updateConnectionCredential(_x7) {
+      return _updateConnectionCredential.apply(this, arguments);
+    }
+    return updateConnectionCredential;
+  }();
+  _proto.createEntity = /*#__PURE__*/function () {
+    var _createEntity = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9(_ref8) {
+      var connectionId, type, k_id;
+      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            connectionId = _ref8.connectionId, type = _ref8.type, k_id = _ref8.k_id;
+            return _context9.abrupt("return", this.db.entity.create({
+              data: {
+                k_id: k_id,
+                type: type,
+                createdBy: connectionId
+              }
+            }));
+          case 2:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9, this);
+    }));
+    function createEntity(_x8) {
+      return _createEntity.apply(this, arguments);
+    }
+    return createEntity;
+  }();
+  _proto.getEntityById = /*#__PURE__*/function () {
+    var _getEntityById = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee10(entityId) {
+      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            _context10.next = 2;
+            return this.db.entity.findUniqueOrThrow({
+              where: {
+                id: entityId
+              }
+            });
+          case 2:
+            return _context10.abrupt("return", _context10.sent);
+          case 3:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10, this);
+    }));
+    function getEntityById(_x9) {
+      return _getEntityById.apply(this, arguments);
+    }
+    return getEntityById;
+  }();
+  _proto.addPropertiesToEntity = /*#__PURE__*/function () {
+    var _addPropertiesToEntity = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee11(_ref9) {
+      var entityId, properties;
+      return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            entityId = _ref9.entityId, properties = _ref9.properties;
+            return _context11.abrupt("return", this.db.entity.update({
+              where: {
+                id: entityId
+              },
+              data: {
+                properties: {
+                  create: properties
+                }
+              }
+            }));
+          case 2:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11, this);
+    }));
+    function addPropertiesToEntity(_x10) {
+      return _addPropertiesToEntity.apply(this, arguments);
+    }
+    return addPropertiesToEntity;
+  }();
+  _proto.getEntityRecordsByConnectionAndType = /*#__PURE__*/function () {
+    var _getEntityRecordsByConnectionAndType = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee12(_ref10) {
+      var k_id, type;
+      return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            k_id = _ref10.k_id, type = _ref10.type;
+            _context12.next = 3;
+            return this.db.entity.findUnique({
+              where: {
+                k_id_type: {
+                  k_id: k_id,
+                  type: type
+                }
+              },
+              include: {
+                properties: true,
+                records: true
+              }
+            });
+          case 3:
+            return _context12.abrupt("return", _context12.sent);
+          case 4:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12, this);
+    }));
+    function getEntityRecordsByConnectionAndType(_x11) {
+      return _getEntityRecordsByConnectionAndType.apply(this, arguments);
+    }
+    return getEntityRecordsByConnectionAndType;
+  }();
+  _proto.getEntityByConnectionAndType = /*#__PURE__*/function () {
+    var _getEntityByConnectionAndType = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee13(_ref11) {
+      var k_id, type;
+      return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            k_id = _ref11.k_id, type = _ref11.type;
+            _context13.next = 3;
+            return this.db.entity.findUnique({
+              where: {
+                k_id_type: {
+                  k_id: k_id,
+                  type: type
+                }
+              }
+            });
+          case 3:
+            return _context13.abrupt("return", _context13.sent);
+          case 4:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13, this);
+    }));
+    function getEntityByConnectionAndType(_x12) {
+      return _getEntityByConnectionAndType.apply(this, arguments);
+    }
+    return getEntityByConnectionAndType;
+  }();
+  _proto.updateEntityLastSyncId = /*#__PURE__*/function () {
+    var _updateEntityLastSyncId = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee14(_ref12) {
+      var entityId, syncId;
+      return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            entityId = _ref12.entityId, syncId = _ref12.syncId;
+            return _context14.abrupt("return", this.db.entity.update({
+              where: {
+                id: entityId
+              },
+              data: {
+                lastSyncId: syncId
+              }
+            }));
+          case 2:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14, this);
+    }));
+    function updateEntityLastSyncId(_x13) {
+      return _updateEntityLastSyncId.apply(this, arguments);
+    }
+    return updateEntityLastSyncId;
+  }();
+  _proto.deleteEntityById = /*#__PURE__*/function () {
+    var _deleteEntityById = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee15(entityId) {
+      return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
+          case 0:
+            return _context15.abrupt("return", this.db.entity["delete"]({
+              where: {
+                id: entityId
+              }
+            }));
+          case 1:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15, this);
+    }));
+    function deleteEntityById(_x14) {
+      return _deleteEntityById.apply(this, arguments);
+    }
+    return deleteEntityById;
+  }()
+  /**
+   * Creates new records for a entity, or updates existing record 'data' if it already exists
+   * @param entityId
+   * @param records
+   */
+  ;
+  _proto.mergeExternalRecordsForEntity =
+  /*#__PURE__*/
+  function () {
+    var _mergeExternalRecordsForEntity = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee16(_ref13) {
+      var entityId, records, uniqueRecordsMap, _iterator, _step, record, uniqueRecords, externalIds, existingRecords, toCreate, toUpdate, createPromise, updatePromise;
+      return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
+          case 0:
+            entityId = _ref13.entityId, records = _ref13.records;
+            if (records != null && records.length) {
+              _context16.next = 3;
+              break;
+            }
+            return _context16.abrupt("return");
+          case 3:
+            uniqueRecordsMap = new Map();
+            for (_iterator = _createForOfIteratorHelperLoose(records); !(_step = _iterator()).done;) {
+              record = _step.value;
+              if (record.externalId && !uniqueRecordsMap.has(record.externalId)) {
+                uniqueRecordsMap.set(record.externalId, record);
+              }
+            }
+            uniqueRecords = Array.from(uniqueRecordsMap.values());
+            externalIds = uniqueRecords.map(function (record) {
+              return record.externalId;
+            });
+            _context16.next = 9;
+            return this.db.record.findMany({
+              select: {
+                id: true,
+                externalId: true,
+                data: true
+              },
+              where: {
+                entityId: entityId,
+                externalId: {
+                  "in": externalIds
+                }
+              }
+            });
+          case 9:
+            existingRecords = _context16.sent;
+            toCreate = [];
+            toUpdate = [];
+            uniqueRecords.forEach(function (record) {
+              var existing = existingRecords.find(function (existingRecord) {
+                return existingRecord.externalId === record.externalId;
+              });
+              if (existing) {
+                toUpdate.push(_extends({}, record, {
+                  data: _extends({}, existing.data, record.data)
+                }));
+              } else {
+                toCreate.push(_extends({}, record, {
+                  entityId: entityId
+                }));
+              }
+            });
+            createPromise = toCreate.length ? this.db.record.createMany({
+              data: toCreate.map(function (record) {
+                return _extends({}, record, {
+                  data: record.data
+                });
+              })
+            }) : undefined;
+            updatePromise = toUpdate.length ? this.db.$executeRaw(Prisma.raw("\n          WITH updated_records (\"externalId\", \"data\") AS (\n            VALUES\n            " + toUpdate.map(function (_ref14) {
+              var externalId = _ref14.externalId,
+                data = _ref14.data;
+              return "('" + externalId + "', '" + JSON.stringify(data).replace(/'/g, "''") + "'::jsonb)";
+            }).join(',') + "\n          )\n          UPDATE records\n          SET \"data\" = updated_records.\"data\"\n          FROM updated_records\n          WHERE records.\"externalId\" = updated_records.\"externalId\";\n        ")) : undefined;
+            return _context16.abrupt("return", Promise.all([createPromise, updatePromise]));
+          case 16:
+          case "end":
+            return _context16.stop();
+        }
+      }, _callee16, this);
+    }));
+    function mergeExternalRecordsForEntity(_x15) {
+      return _mergeExternalRecordsForEntity.apply(this, arguments);
+    }
+    return mergeExternalRecordsForEntity;
+  }();
+  _proto.updateConnectionCredentials = /*#__PURE__*/function () {
+    var _updateConnectionCredentials = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee17(_ref15) {
+      var k_id, update;
+      return _regeneratorRuntime().wrap(function _callee17$(_context17) {
+        while (1) switch (_context17.prev = _context17.next) {
+          case 0:
+            k_id = _ref15.k_id, update = /*#__PURE__*/_objectWithoutPropertiesLoose(_ref15, _excluded$4);
+            return _context17.abrupt("return", this.db.credential.update({
+              where: {
+                k_id: k_id
+              },
+              data: update
+            }));
+          case 2:
+          case "end":
+            return _context17.stop();
+        }
+      }, _callee17, this);
+    }));
+    function updateConnectionCredentials(_x16) {
+      return _updateConnectionCredentials.apply(this, arguments);
+    }
+    return updateConnectionCredentials;
+  }();
+  _proto.getRecords = /*#__PURE__*/function () {
+    var _getRecords = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee18(_ref16) {
+      var entityType, k_id, filters, sort, recordData;
+      return _regeneratorRuntime().wrap(function _callee18$(_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
+          case 0:
+            entityType = _ref16.entityType, k_id = _ref16.k_id, filters = _ref16.filters, sort = _ref16.sort;
+            recordData = this.recordService.getFilteredRecords({
+              entityType: entityType,
+              k_id: k_id,
+              filters: filters,
+              sort: sort
+            });
+            return _context18.abrupt("return", recordData);
+          case 3:
+          case "end":
+            return _context18.stop();
+        }
+      }, _callee18, this);
+    }));
+    function getRecords(_x17) {
+      return _getRecords.apply(this, arguments);
+    }
+    return getRecords;
+  }();
+  _proto.getRecordByPropertyNameAndValues = /*#__PURE__*/function () {
+    var _getRecordByPropertyNameAndValues = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee19(_ref17) {
+      var propertyName, propertValues, type, connectionId, OR;
+      return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+        while (1) switch (_context19.prev = _context19.next) {
+          case 0:
+            propertyName = _ref17.propertyName, propertValues = _ref17.propertValues, type = _ref17.type, connectionId = _ref17.connectionId;
+            OR = propertValues.map(function (value) {
+              return {
+                data: {
+                  path: [propertyName],
+                  equals: value
+                }
+              };
+            });
+            return _context19.abrupt("return", this.db.record.findMany({
+              where: {
+                entity: {
+                  connection: {
+                    connectionId: connectionId
+                  },
+                  type: type
+                },
+                OR: OR
+              }
+            }));
+          case 3:
+          case "end":
+            return _context19.stop();
+        }
+      }, _callee19, this);
+    }));
+    function getRecordByPropertyNameAndValues(_x18) {
+      return _getRecordByPropertyNameAndValues.apply(this, arguments);
+    }
+    return getRecordByPropertyNameAndValues;
+  }();
+  _proto.getRecordByPropertyNameAndValue = /*#__PURE__*/function () {
+    var _getRecordByPropertyNameAndValue = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee20(_ref18) {
+      var propertyName, propertyValue, type, connectionId;
+      return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+        while (1) switch (_context20.prev = _context20.next) {
+          case 0:
+            propertyName = _ref18.propertyName, propertyValue = _ref18.propertyValue, type = _ref18.type, connectionId = _ref18.connectionId;
+            return _context20.abrupt("return", this.db.record.findFirst({
+              where: {
+                entity: {
+                  connection: {
+                    connectionId: connectionId
+                  },
+                  type: type
+                },
+                data: {
+                  path: [propertyName],
+                  equals: propertyValue
+                }
+              }
+            }));
+          case 2:
+          case "end":
+            return _context20.stop();
+        }
+      }, _callee20, this);
+    }));
+    function getRecordByPropertyNameAndValue(_x19) {
+      return _getRecordByPropertyNameAndValue.apply(this, arguments);
+    }
+    return getRecordByPropertyNameAndValue;
+  }();
+  _proto.getRecordsByPropertyName = /*#__PURE__*/function () {
+    var _getRecordsByPropertyName = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee21(_ref19) {
+      var propertyName, connectionId;
+      return _regeneratorRuntime().wrap(function _callee21$(_context21) {
+        while (1) switch (_context21.prev = _context21.next) {
+          case 0:
+            propertyName = _ref19.propertyName, connectionId = _ref19.connectionId;
+            return _context21.abrupt("return", this.db.record.findMany({
+              where: {
+                entity: {
+                  connection: {
+                    connectionId: connectionId
+                  }
+                },
+                data: {
+                  path: [propertyName],
+                  not: Prisma.JsonNull
+                }
+              }
+            }));
+          case 2:
+          case "end":
+            return _context21.stop();
+        }
+      }, _callee21, this);
+    }));
+    function getRecordsByPropertyName(_x20) {
+      return _getRecordsByPropertyName.apply(this, arguments);
+    }
+    return getRecordsByPropertyName;
+  }();
+  _proto.setConnectionError = /*#__PURE__*/function () {
+    var _setConnectionError = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee22(_ref20) {
+      var k_id, error;
+      return _regeneratorRuntime().wrap(function _callee22$(_context22) {
+        while (1) switch (_context22.prev = _context22.next) {
+          case 0:
+            k_id = _ref20.k_id, error = _ref20.error;
+            _context22.next = 3;
+            return this.db.connection.update({
+              where: {
+                id: k_id
+              },
+              data: {
+                issues: [error]
+              }
+            });
+          case 3:
+            return _context22.abrupt("return", _context22.sent);
+          case 4:
+          case "end":
+            return _context22.stop();
+        }
+      }, _callee22, this);
+    }));
+    function setConnectionError(_x21) {
+      return _setConnectionError.apply(this, arguments);
+    }
+    return setConnectionError;
+  }();
+  _proto.setConnectionSubscriptionId = /*#__PURE__*/function () {
+    var _setConnectionSubscriptionId = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee23(_ref21) {
+      var k_id, subscriptionId;
+      return _regeneratorRuntime().wrap(function _callee23$(_context23) {
+        while (1) switch (_context23.prev = _context23.next) {
+          case 0:
+            k_id = _ref21.k_id, subscriptionId = _ref21.subscriptionId;
+            _context23.next = 3;
+            return this.db.connection.update({
+              where: {
+                id: k_id
+              },
+              data: {
+                subscriptionId: subscriptionId
+              }
+            });
+          case 3:
+            return _context23.abrupt("return", _context23.sent);
+          case 4:
+          case "end":
+            return _context23.stop();
+        }
+      }, _callee23, this);
+    }));
+    function setConnectionSubscriptionId(_x22) {
+      return _setConnectionSubscriptionId.apply(this, arguments);
+    }
+    return setConnectionSubscriptionId;
+  }();
+  _proto.syncData = /*#__PURE__*/function () {
+    var _syncData = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee24(_ref22) {
+      var _existingEntity2;
+      var connectionId, name, data, type, properties, lastSyncId, dataInt, existingEntity, _existingEntity, _existingEntity3;
+      return _regeneratorRuntime().wrap(function _callee24$(_context24) {
+        while (1) switch (_context24.prev = _context24.next) {
+          case 0:
+            connectionId = _ref22.connectionId, name = _ref22.name, data = _ref22.data, type = _ref22.type, properties = _ref22.properties, lastSyncId = _ref22.lastSyncId;
+            _context24.next = 3;
+            return this.getConnection({
+              connectionId: connectionId,
+              name: name
+            });
+          case 3:
+            dataInt = _context24.sent;
+            _context24.next = 6;
+            return this.getEntityByConnectionAndType({
+              k_id: dataInt == null ? void 0 : dataInt.id,
+              type: type
+            });
+          case 6:
+            existingEntity = _context24.sent;
+            if (existingEntity) {
+              _context24.next = 13;
+              break;
+            }
+            _context24.next = 10;
+            return this.createEntity({
+              k_id: dataInt == null ? void 0 : dataInt.id,
+              type: type,
+              connectionId: connectionId
+            });
+          case 10:
+            existingEntity = _context24.sent;
+            _context24.next = 13;
+            return this.addPropertiesToEntity({
+              entityId: (_existingEntity = existingEntity) == null ? void 0 : _existingEntity.id,
+              properties: properties
+            });
+          case 13:
+            _context24.next = 15;
+            return this.mergeExternalRecordsForEntity({
+              entityId: (_existingEntity2 = existingEntity) == null ? void 0 : _existingEntity2.id,
+              records: data
+            });
+          case 15:
+            if (!lastSyncId) {
+              _context24.next = 18;
+              break;
+            }
+            _context24.next = 18;
+            return this.updateEntityLastSyncId({
+              entityId: (_existingEntity3 = existingEntity) == null ? void 0 : _existingEntity3.id,
+              syncId: lastSyncId
+            });
+          case 18:
+          case "end":
+            return _context24.stop();
+        }
+      }, _callee24, this);
+    }));
+    function syncData(_x23) {
+      return _syncData.apply(this, arguments);
+    }
+    return syncData;
+  }();
+  _proto.getConnectionsBySubscriptionId = /*#__PURE__*/function () {
+    var _getConnectionsBySubscriptionId = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee25(_ref23) {
+      var subscriptionId;
+      return _regeneratorRuntime().wrap(function _callee25$(_context25) {
+        while (1) switch (_context25.prev = _context25.next) {
+          case 0:
+            subscriptionId = _ref23.subscriptionId;
+            _context25.next = 3;
+            return this.db.connection.findMany({
+              where: {
+                subscriptionId: subscriptionId
+              }
+            });
+          case 3:
+            return _context25.abrupt("return", _context25.sent);
+          case 4:
+          case "end":
+            return _context25.stop();
+        }
+      }, _callee25, this);
+    }));
+    function getConnectionsBySubscriptionId(_x24) {
+      return _getConnectionsBySubscriptionId.apply(this, arguments);
+    }
+    return getConnectionsBySubscriptionId;
+  }();
+  return DataLayer;
+}();
+
+var connectParams = /*#__PURE__*/z.object({
+  name: /*#__PURE__*/z.string(),
+  connectionId: /*#__PURE__*/z.string(),
+  clientRedirectPath: /*#__PURE__*/z.string().optional()["default"]('/')
+});
+var oauthState = /*#__PURE__*/connectParams.extend({
+  previewRedirect: /*#__PURE__*/z.string().optional()
+});
+var callbackParams = /*#__PURE__*/z.object({
+  state: /*#__PURE__*/z.preprocess(function (s) {
+    return JSON.parse(Buffer.from(s, 'base64').toString());
+  }, oauthState),
+  error: /*#__PURE__*/z.string().optional()
+});
+var webhookQueryParams = /*#__PURE__*/z.object({
+  event: /*#__PURE__*/z.string(),
+  name: /*#__PURE__*/z.string()
+});
+var apiKeyConnectionOptions = /*#__PURE__*/z.object({
+  apiKey: /*#__PURE__*/z.string()
+});
+
+var parseQueryParams = function parseQueryParams(req, schema) {
+  var search = req.nextUrl.search.slice(1);
+  var queryParams = qs.parse(search);
+  var _schema$safeParse = schema.safeParse(queryParams),
+    data = _schema$safeParse.data,
+    success = _schema$safeParse.success,
+    error = _schema$safeParse.error;
+  return {
+    success: success,
+    data: data,
+    error: error
+  };
+};
+var nextHeaders = headers;
+
+var makeConnect = function makeConnect(framework) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(req) {
+      var _parseQueryParams, success, error, _parseQueryParams$dat, name, connectionId, clientRedirectPath, _int, authenticator, redirectUri;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _parseQueryParams = parseQueryParams(req, connectParams), success = _parseQueryParams.success, error = _parseQueryParams.error, _parseQueryParams$dat = _parseQueryParams.data, name = _parseQueryParams$dat.name, connectionId = _parseQueryParams$dat.connectionId, clientRedirectPath = _parseQueryParams$dat.clientRedirectPath;
+            if (success) {
+              _context.next = 3;
+              break;
+            }
+            return _context.abrupt("return", NextResponse.json({
+              error: error,
+              status: 400
+            }));
+          case 3:
+            _int = framework.getIntegration(name);
+            authenticator = _int.getAuthenticator();
+            _context.next = 7;
+            return authenticator.getRedirectUri({
+              connectionId: connectionId,
+              clientRedirectPath: clientRedirectPath
+            });
+          case 7:
+            redirectUri = _context.sent;
+            return _context.abrupt("return", NextResponse.redirect(redirectUri));
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+
+var makeCallback = function makeCallback(framework) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(req) {
+      var _parseQueryParams, data, error, _data$state, name, clientRedirectPath, callbackError, _int, redirectUri;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _parseQueryParams = parseQueryParams(req, callbackParams), data = _parseQueryParams.data, error = _parseQueryParams.error;
+            _data$state = data.state, name = _data$state.name, clientRedirectPath = _data$state.clientRedirectPath, callbackError = data.error;
+            if (!(error || callbackError)) {
+              _context.next = 4;
+              break;
+            }
+            return _context.abrupt("return", NextResponse.json({
+              error: error,
+              status: 400
+            }));
+          case 4:
+            _int = framework.getIntegration(name);
+            if (_int) {
+              _context.next = 7;
+              break;
+            }
+            return _context.abrupt("return", NextResponse.json({
+              error: "Callback state cannot locate integration: \"" + name + "\"",
+              status: 400
+            }));
+          case 7:
+            _context.next = 9;
+            return _int.getAuthenticator().processCallback(req.url);
+          case 9:
+            redirectUri = new URL(clientRedirectPath || '', req.nextUrl.protocol + '//' + req.nextUrl.host);
+            return _context.abrupt("return", NextResponse.redirect(redirectUri));
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+
+var APP_ID = 'mastra';
+var client = /*#__PURE__*/new Inngest({
+  id: APP_ID
+});
+
+function readBlueprint(_x) {
+  return _readBlueprint.apply(this, arguments);
+}
+function _readBlueprint() {
+  _readBlueprint = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(filePath) {
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          return _context4.abrupt("return", new Promise(function (resolve, reject) {
+            fs.readFile(filePath, 'utf8', function (err, data) {
+              if (err) reject(err);else {
+                var jsonData = JSON.parse(data);
+                var blueprintFile = last(filePath == null ? void 0 : filePath.split('/'));
+                var blueprintId = first(blueprintFile == null ? void 0 : blueprintFile.split('.json'));
+                resolve(_extends({}, jsonData, {
+                  id: blueprintId
+                }));
+              }
+            });
+          }));
+        case 1:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _readBlueprint.apply(this, arguments);
+}
+function getBlueprints(_x2) {
+  return _getBlueprints.apply(this, arguments);
+}
+function _getBlueprints() {
+  _getBlueprints = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(_ref) {
+    var directoryPath;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          directoryPath = _ref.directoryPath;
+          return _context6.abrupt("return", new Promise(function (resolve, reject) {
+            fs.readdir(directoryPath, /*#__PURE__*/function () {
+              var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(err, files) {
+                var jsonFiles, result, _iterator, _step, file, filePath, jsonData, blueprintFile, blueprintId;
+                return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+                  while (1) switch (_context5.prev = _context5.next) {
+                    case 0:
+                      if (!err) {
+                        _context5.next = 4;
+                        break;
+                      }
+                      reject(err);
+                      _context5.next = 17;
+                      break;
+                    case 4:
+                      jsonFiles = files.filter(function (file) {
+                        return file.endsWith('.json');
+                      });
+                      result = [];
+                      _iterator = _createForOfIteratorHelperLoose(jsonFiles);
+                    case 7:
+                      if ((_step = _iterator()).done) {
+                        _context5.next = 16;
+                        break;
+                      }
+                      file = _step.value;
+                      filePath = path.join(directoryPath, file);
+                      _context5.next = 12;
+                      return readBlueprint(filePath);
+                    case 12:
+                      jsonData = _context5.sent;
+                      if (jsonData.title) {
+                        blueprintFile = last(filePath == null ? void 0 : filePath.split('/'));
+                        blueprintId = first(blueprintFile == null ? void 0 : blueprintFile.split('.json'));
+                        result.push(_extends({}, jsonData, {
+                          id: blueprintId
+                        }));
+                      }
+                    case 14:
+                      _context5.next = 7;
+                      break;
+                    case 16:
+                      resolve(result);
+                    case 17:
+                    case "end":
+                      return _context5.stop();
+                  }
+                }, _callee5);
+              }));
+              return function (_x4, _x5) {
+                return _ref7.apply(this, arguments);
+              };
+            }());
+          }));
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return _getBlueprints.apply(this, arguments);
+}
+var createWorkflowHandler = function createWorkflowHandler(_ref2) {
+  var blueprintDirPath = _ref2.blueprintDirPath,
+    runBlueprint = _ref2.runBlueprint;
+  return client.createFunction({
+    id: 'workflow-executor',
+    retries: 0
+  }, {
+    event: 'workflow/run-automations'
+  }, /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref3) {
+      var event, step, _event$data, trigger, payload, connectionId, getBlueprintsDirPath, blueprints, triggeredAndPublishedBlueprints, runs;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            event = _ref3.event, step = _ref3.step;
+            _context3.prev = 1;
+            _event$data = event.data, trigger = _event$data.trigger, payload = _event$data.payload;
+            connectionId = event.user.connectionId;
+            getBlueprintsDirPath = /*#__PURE__*/function () {
+              var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+                var ARK_APP_DIR;
+                return _regeneratorRuntime().wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      ARK_APP_DIR = process.env.ARK_APP_DIR || process.cwd();
+                      return _context.abrupt("return", path.join(ARK_APP_DIR, blueprintDirPath || '/blueprints'));
+                    case 2:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              }));
+              return function getBlueprintsDirPath() {
+                return _ref5.apply(this, arguments);
+              };
+            }();
+            _context3.next = 7;
+            return getBlueprintsDirPath().then(function (dir) {
+              return getBlueprints({
+                directoryPath: dir
+              });
+            });
+          case 7:
+            blueprints = _context3.sent;
+            triggeredAndPublishedBlueprints = blueprints.filter(function (blueprint) {
+              var _blueprint$trigger;
+              return ((_blueprint$trigger = blueprint.trigger) == null ? void 0 : _blueprint$trigger.type) === trigger && blueprint.status === WorkflowStatusEnum.PUBLISHED;
+            });
+            runs = triggeredAndPublishedBlueprints.map(function (blueprint) {
+              return step.run("run-blueprint: " + blueprint.id, /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+                return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                  while (1) switch (_context2.prev = _context2.next) {
+                    case 0:
+                      return _context2.abrupt("return", runBlueprint({
+                        blueprint: blueprint,
+                        dataCtx: payload,
+                        ctx: {
+                          connectionId: connectionId
+                        }
+                      }));
+                    case 1:
+                    case "end":
+                      return _context2.stop();
+                  }
+                }, _callee2);
+              })));
+            });
+            _context3.next = 12;
+            return Promise.all(runs);
+          case 12:
+            return _context3.abrupt("return", {
+              event: event,
+              body: "sync completed"
+            });
+          case 15:
+            _context3.prev = 15;
+            _context3.t0 = _context3["catch"](1);
+            return _context3.abrupt("return", {
+              event: event,
+              body: "error occurred while running sync: " + _context3.t0
+            });
+          case 18:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[1, 15]]);
+    }));
+    return function (_x3) {
+      return _ref4.apply(this, arguments);
+    };
+  }());
+};
+
+var makeInngest = function makeInngest(framework) {
+  var _framework$config$wor;
+  // TODO: hook into framework to add framework functions to the inngest client
+  var eventHandlers = framework.getGlobalEventHandlers();
+  var globalEventHandlers = eventHandlers.map(function (eh) {
+    return client.createFunction({
+      id: eh.id
+    }, {
+      event: eh.event
+    }, eh.executor);
+  });
+  var systemWorkflowHandler = createWorkflowHandler({
+    blueprintDirPath: (_framework$config$wor = framework.config.workflows) == null ? void 0 : _framework$config$wor.blueprintDirPath,
+    runBlueprint: framework.runBlueprint
+  });
+  var handler = serve({
+    client: client,
+    functions: [].concat(globalEventHandlers, [systemWorkflowHandler])
+  });
+  // @ts-ignore
+  return function (req) {
+    return handler(req);
+  };
+};
+
+var makeWebhook = function makeWebhook(framework) {
+  return function (req) {
+    var params = parseQueryParams(req, webhookQueryParams);
+    var data = params.data,
+      error = params.error;
+    if (error) {
+      return NextResponse.json({
+        error: error,
+        status: 400
+      });
+    }
+    var decodedEvent = decodeURI(data == null ? void 0 : data.event);
+    console.log("webhook event: " + decodedEvent + " from " + (data == null ? void 0 : data.name));
+    var body = req.body;
+    var integration = framework.getIntegration(data == null ? void 0 : data.name);
+    var dataLayer = integration == null ? void 0 : integration.dataLayer;
+    var connectionsBySubscriptionId = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(subscriptionId) {
+        var subscriptions;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return dataLayer == null ? void 0 : dataLayer.getConnectionsBySubscriptionId({
+                subscriptionId: subscriptionId
+              });
+            case 2:
+              subscriptions = _context.sent;
+              return _context.abrupt("return", subscriptions != null ? subscriptions : []);
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function connectionsBySubscriptionId(_x) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+    void (integration == null ? void 0 : integration.processWebhookRequest({
+      reqBody: body,
+      event: decodedEvent,
+      connectionsBySubscriptionId: connectionsBySubscriptionId
+    }));
+    return NextResponse.json({
+      message: 'acknowledged'
+    });
+  };
+};
+
+var registerRoutes = function registerRoutes(_ref) {
+  var framework = _ref.framework;
+  var registry = {
+    connect: makeConnect(framework),
+    'connect/callback': makeCallback(framework),
+    inngest: makeInngest(framework),
+    webhook: makeWebhook(framework)
+  };
+  return function (req, _ref2) {
+    var _Object$keys$at;
+    var params = _ref2.params;
+    var pathKey = (_Object$keys$at = Object.keys(params).at(0)) != null ? _Object$keys$at : 'routes';
+    var route = params[pathKey].length ? params[pathKey].join('/') : '';
+    if (route in registry) {
+      return registry[route](req);
+    }
+    return NextResponse.json({
+      status: 404
+    });
+  };
+};
+
+var IntegrationErrors;
+(function (IntegrationErrors) {
+  IntegrationErrors["BROKEN_CONNECTION"] = "BROKEN_CONNECTION";
+  IntegrationErrors["MISSING_SCOPES"] = "MISSING_SCOPES";
+})(IntegrationErrors || (IntegrationErrors = {}));
+var IntegrationCredentialType;
+(function (IntegrationCredentialType) {
+  IntegrationCredentialType["OAUTH"] = "OAUTH";
+  IntegrationCredentialType["API_KEY"] = "API_KEY";
+})(IntegrationCredentialType || (IntegrationCredentialType = {}));
+var IntegrationFieldTypeEnum = {
+  SINGLE_LINE_TEXT: 'SINGLE_LINE_TEXT',
+  LONG_TEXT: 'LONG_TEXT',
+  RICH_TEXT: 'RICH_TEXT',
+  SINGLE_SELECT: 'SINGLE_SELECT',
+  MULTI_SELECT: 'MULTI_SELECT',
+  CREATABLE_SELECT: 'CREATABLE_SELECT',
+  CHECKBOX: 'CHECKBOX',
+  DATE: 'DATE',
+  USER: 'USER',
+  BADGE_LIST: 'BADGE_LIST',
+  CURRENCY: 'CURRENCY',
+  URL: 'URL',
+  PHONE: 'PHONE',
+  CONTACT: 'CONTACT',
+  COMPANY: 'COMPANY',
+  COMPOSITE: 'COMPOSITE',
+  PERSON: 'PERSON',
+  ENRICHMENT: 'ENRICHMENT'
+};
+
+var filterQuerySchema = /*#__PURE__*/z.object({
+  is: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  eq: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  not_eq: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  contains: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  not_contains: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  gt: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  gte: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  lt: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  lte: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  "in": /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  not_in: /*#__PURE__*/z.array(z.string()).or(z.string()).optional(),
+  op: /*#__PURE__*/z["enum"](['or', 'and']).optional()["default"]('or'),
+  set: /*#__PURE__*/z.string().optional().transform(transformFilterValueBoolean),
+  not_set: /*#__PURE__*/z.string().optional().transform(transformFilterValueBoolean)
+});
+var sortQuerySchema = /*#__PURE__*/z.string().transform(transformFilterValueArray);
+
+/**
+ * Checks if object is empty
+ * @param objectName
+ * @returns boolean
+ */
+var isObjectEmpty = function isObjectEmpty(objectName) {
+  return objectName && Object.keys(objectName).length === 0 && objectName.constructor === Object;
+};
+/**
+ * Get a value from an object by a given path. This function emulates the behavior of lodash's _.get method.
+ *
+ * @param {Record<string, any>} object - The object from which to get the value.
+ * @param {string | string[]} path - The path to the value in the object. This can be a string (e.g., 'a.b.c') or an array of keys (e.g., ['a', 'b', 'c']).
+ * @returns {unknown} The value at the given path in the object, or undefined if the path does not exist.
+ */
+var getPath = function getPath(object, path) {
+  if (typeof path === 'string') {
+    path = path.split('.');
+  }
+  return path.reduce(function (obj, key) {
+    return obj && obj[key] !== undefined ? obj[key] : undefined;
+  }, object);
+};
+function recordHasData(record) {
+  return Object.keys(record).length > 0;
+}
+function isLiteralObject(a) {
+  return !!a && a.constructor === Object;
+}
+var constructObjFromStringPath = function constructObjFromStringPath(path, value) {
+  var _newObject;
+  //key, split the key with ., and then for each item, we update object data.pipeline
+  // {data: {pipeline: 'kbdkjd'}}
+  var pathArr = path.split('.');
+  var newObject = (_newObject = {}, _newObject[pathArr[pathArr.length - 1]] = value, _newObject);
+  var index = pathArr.length - 2;
+  while (index >= 0) {
+    var _newObject2;
+    newObject = (_newObject2 = {}, _newObject2[pathArr[index]] = newObject, _newObject2);
+    index = index - 1;
+  }
+  return newObject;
+};
+/**
+ * Flatten a nested object, flatten from flat package works - https://www.npmjs.com/package/flat
+ * but this allows you to define where you want it to stop by passing the keys that'll exist in the object you want it to stop at
+ *
+ * @param {Record<string, any>} object - The object to flatten.
+ * @param {string[]} endKeys - The keys you want each value (which will be an object in this case) in the flattened object to possible have (e.g., ['a', 'b', 'c']).
+ * @param {boolean} flattenArrayValue - This flag indicates that any array value should be flattened to object too.
+ * @returns {Record<string, any>} Your flattened object
+ */
+var flattenObject = function flattenObject(object, endKeys, flattenArrayValue) {
+  if (endKeys === void 0) {
+    endKeys = [];
+  }
+  var newObj = {};
+  function recurseDip(obj, path) {
+    var _loop = function _loop() {
+      var _Object$entries$_i = _Object$entries[_i],
+        key = _Object$entries$_i[0],
+        value = _Object$entries$_i[1];
+      var newPath = [].concat(path, [key]);
+      if (value && value.constructor === Object) {
+        var _endKeys;
+        var hasOnlyEndKeys = (_endKeys = endKeys) != null && _endKeys.length ? endKeys.every(function (v) {
+          return Object.keys(value).includes(v);
+        }) : false;
+        if (hasOnlyEndKeys) {
+          var _extends2;
+          newObj = _extends({}, newObj, (_extends2 = {}, _extends2[newPath.join('.')] = value, _extends2));
+        } else {
+          recurseDip(value, newPath);
+        }
+      } else if (flattenArrayValue && Array.isArray(value)) {
+        var contructValue = value.reduce(function (a, b) {
+          var _extends3;
+          return _extends({}, a, (_extends3 = {}, _extends3[value.indexOf(b)] = b, _extends3));
+        }, {});
+        recurseDip(contructValue, newPath);
+      } else {
+        var _extends4;
+        newObj = _extends({}, newObj, (_extends4 = {}, _extends4[newPath.join('.')] = value, _extends4));
+      }
+    };
+    for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
+      _loop();
+    }
+  }
+  recurseDip(object, []);
+  return newObj;
+};
+/**
+ * Merges two objects, ensuring that only defined properties from the second object
+ * override those in the first object.
+ *
+ * @template T - The type of the base object.
+ * @template U - The type of the overrides object.
+ * @param {T} base - The base object whose properties will be overridden.
+ * @param {U} overrides - The object containing properties to override in the base object.
+ *                        Only properties that are defined (not `undefined`) will override.
+ * @returns {T & U} - A new object that combines properties from both `base` and `overrides`.
+ *                    Properties in `base` will be overridden by defined properties in `overrides`.
+ *
+ * @example
+ * const worksheetData = { a: 1, b: 2, c: 3 };
+ * const payload = { b: undefined, c: 4 };
+ * const extendedData = mergeWithDefinedOnly(worksheetData, payload);
+ * // extendedData = { a: 1, b: 2, c: 4 }
+ */
+function mergeWithDefinedOnly(base, overrides) {
+  var result = _extends({}, base);
+  for (var key in overrides) {
+    if (overrides[key] !== undefined) {
+      result[key] = overrides[key];
+    }
+  }
+  return result;
+}
+
+var _excluded$3 = ["client"],
+  _excluded2$1 = ["name", "logoUrl"];
+/**
+ * @params T - The type of the client that the integration provides
+ */
+var Integration = /*#__PURE__*/function () {
+  function Integration(config) {
+    var _this = this;
+    this.name = void 0;
+    this.logoUrl = void 0;
+    this.categories = [];
+    this.description = '';
+    this.dataLayer = void 0;
+    this.config = {};
+    this.availableScopes = void 0;
+    this.events = {};
+    this.apis = {};
+    this.entityTypes = {};
+    this.corePresets = {
+      redirectURI: ''
+    };
+    this._convertApiClientToSystemApis = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var _this$getBaseClient, client, clientMethods, clientSchema, clientComments, apis;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _this$getBaseClient = _this.getBaseClient(), client = _this$getBaseClient.client, clientMethods = _objectWithoutPropertiesLoose(_this$getBaseClient, _excluded$3);
+            clientSchema = _this.getClientZodSchema();
+            clientComments = _this.getCommentsForClientApis();
+            apis = Object.entries(clientMethods).reduce(function (acc, _ref2) {
+              var key = _ref2[0],
+                value = _ref2[1];
+              if (typeof value === 'function') {
+                var _clientComments$key, _client$key, _extends2;
+                var camelCasedKey = key.replace(/_([a-z])/g, function (match, letter) {
+                  return letter.toUpperCase();
+                });
+                var sentenceCasedKey = camelCasedKey.replace(/([A-Z])/g, ' $1');
+                var schemaKey = camelCasedKey + "DataSchema";
+                var schema = clientSchema[schemaKey];
+                var comment = (_clientComments$key = clientComments[key]) == null ? void 0 : _clientComments$key.comment;
+                var doc = (_client$key = client[key]) == null ? void 0 : _client$key.doc;
+                var fallbackComment = "Execute " + sentenceCasedKey;
+                var api = {
+                  integrationName: _this.name,
+                  type: key,
+                  icon: {
+                    alt: _this.name,
+                    icon: _this.logoUrl
+                  },
+                  label: sentenceCasedKey,
+                  schema: !schema ? z.object({}) : schema,
+                  executor: function () {
+                    var _executor = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref3) {
+                      var data, connectionId, client, value;
+                      return _regeneratorRuntime().wrap(function _callee$(_context) {
+                        while (1) switch (_context.prev = _context.next) {
+                          case 0:
+                            data = _ref3.data, connectionId = _ref3.ctx.connectionId;
+                            _context.next = 3;
+                            return _this.getApiClient({
+                              connectionId: connectionId
+                            });
+                          case 3:
+                            client = _context.sent;
+                            value = client[key];
+                            return _context.abrupt("return", value(_extends({}, data)));
+                          case 6:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }, _callee);
+                    }));
+                    function executor(_x) {
+                      return _executor.apply(this, arguments);
+                    }
+                    return executor;
+                  }(),
+                  description: comment || fallbackComment,
+                  documentation: doc || fallbackComment
+                };
+                return _extends({}, acc, (_extends2 = {}, _extends2[key] = api, _extends2));
+              } else {
+                return acc;
+              }
+            }, {});
+            _this.apis = apis;
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    this.makeClient = /*#__PURE__*/function () {
+      var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(params) {
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              throw new IntegrationError('Client not implemented');
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      return function (_x2) {
+        return _ref4.apply(this, arguments);
+      };
+    }();
+    this.getEventHandlers = function (_ref5) {
+      var makeWebhookUrl = _ref5.makeWebhookUrl;
+      return Object.keys(_this.events).map(function (eventKey) {
+        var _this$events$eventKey;
+        var eventHandler = (_this$events$eventKey = _this.events[eventKey]) == null ? void 0 : _this$events$eventKey.handler;
+        if (!eventHandler) return null;
+        return eventHandler({
+          integrationInstance: _this,
+          eventKey: eventKey,
+          makeWebhookUrl: makeWebhookUrl
+        });
+      }).filter(Boolean);
+    };
+    if (!(config != null && config.name)) {
+      throw new IntegrationError('Integration name must be defined');
+    }
+    if (!(config != null && config.logoUrl)) {
+      throw new IntegrationError('Integration logoUrl must be defined');
+    }
+    var name = config.name,
+      logoUrl = config.logoUrl,
+      others = _objectWithoutPropertiesLoose(config, _excluded2$1);
+    this.name = name;
+    this.logoUrl = logoUrl;
+    this.config = others;
+  }
+  var _proto = Integration.prototype;
+  _proto.getConfig = function getConfig() {
+    return this.config;
+  };
+  _proto.getClientZodSchema = function getClientZodSchema() {
+    return {};
+  };
+  _proto.getCommentsForClientApis = function getCommentsForClientApis() {
+    return {};
+  };
+  _proto.getBaseClient = function getBaseClient() {
+    return {};
+  };
+  _proto.getApiClient = /*#__PURE__*/function () {
+    var _getApiClient = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(params) {
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            throw new IntegrationError('API not implemented');
+          case 1:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }));
+    function getApiClient(_x3) {
+      return _getApiClient.apply(this, arguments);
+    }
+    return getApiClient;
+  }();
+  _proto.getApi = /*#__PURE__*/function () {
+    var _getApi = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_ref6) {
+      var connectionId;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            connectionId = _ref6.connectionId;
+            _context5.next = 3;
+            return this.getApiClient({
+              connectionId: connectionId
+            });
+          case 3:
+            _context5.t0 = _context5.sent;
+            return _context5.abrupt("return", {
+              client: _context5.t0
+            });
+          case 5:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this);
+    }));
+    function getApi(_x4) {
+      return _getApi.apply(this, arguments);
+    }
+    return getApi;
+  }();
+  _proto.getAuthenticator = function getAuthenticator() {
+    throw new IntegrationError('Authenticator not implemented');
+  };
+  _proto.attachDataLayer = function attachDataLayer(_ref7) {
+    var dataLayer = _ref7.dataLayer;
+    this.dataLayer = dataLayer;
+  };
+  _proto.registerApis = function registerApis() {
+    return {};
+  };
+  _proto.getApis = function getApis() {
+    return this.apis;
+  };
+  _proto.registerEvents = function registerEvents() {
+    return {};
+  };
+  _proto.getEvents = function getEvents() {
+    return this.events;
+  };
+  _proto.query = /*#__PURE__*/function () {
+    var _query = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(props) {
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            return _context6.abrupt("return", []);
+          case 1:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }));
+    function query(_x5) {
+      return _query.apply(this, arguments);
+    }
+    return query;
+  }();
+  _proto.getEvent = function getEvent(name) {
+    var event = this.events[name];
+    if (!event) {
+      throw new Error("No event exists for this name: " + name);
+    }
+    return event;
+  };
+  _proto.processWebhookRequest = /*#__PURE__*/function () {
+    var _processWebhookRequest = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(params) {
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            throw new Error('Not implemented');
+          case 1:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    }));
+    function processWebhookRequest(_x6) {
+      return _processWebhookRequest.apply(this, arguments);
+    }
+    return processWebhookRequest;
+  }();
+  _proto.triggerEvent = /*#__PURE__*/function () {
+    var _triggerEvent = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(_ref8) {
+      var key, data, user, event;
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            key = _ref8.key, data = _ref8.data, user = _ref8.user;
+            _context8.next = 3;
+            return client.send({
+              name: key,
+              data: data,
+              user: user
+            });
+          case 3:
+            event = _context8.sent;
+            return _context8.abrupt("return", event);
+          case 5:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    }));
+    function triggerEvent(_x7) {
+      return _triggerEvent.apply(this, arguments);
+    }
+    return triggerEvent;
+  }();
+  _proto.test = /*#__PURE__*/function () {
+    var _test = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9(_ref9) {
+      var _this$dataLayer;
+      var connectionId, connection, _this$config$scopes, authenticator, bearer, desiredScopes, _bearer$scope, actualScopes, isMissingScopes;
+      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            connectionId = _ref9.connectionId;
+            _context9.next = 3;
+            return (_this$dataLayer = this.dataLayer) == null ? void 0 : _this$dataLayer.getConnection({
+              connectionId: connectionId,
+              name: this.name
+            });
+          case 3:
+            connection = _context9.sent;
+            _context9.prev = 4;
+            authenticator = this.getAuthenticator();
+            _context9.next = 8;
+            return authenticator.getAuthToken({
+              k_id: connection == null ? void 0 : connection.id
+            });
+          case 8:
+            bearer = _context9.sent;
+            desiredScopes = (_this$config$scopes = this == null ? void 0 : this.config.scopes) != null ? _this$config$scopes : [];
+            if (!desiredScopes.length) {
+              _context9.next = 15;
+              break;
+            }
+            actualScopes = (_bearer$scope = bearer.scope) != null ? _bearer$scope : [];
+            isMissingScopes = !desiredScopes.every(function (desired) {
+              return actualScopes.includes(desired);
+            });
+            if (!isMissingScopes) {
+              _context9.next = 15;
+              break;
+            }
+            return _context9.abrupt("return", IntegrationErrors.MISSING_SCOPES);
+          case 15:
+            _context9.next = 20;
+            break;
+          case 17:
+            _context9.prev = 17;
+            _context9.t0 = _context9["catch"](4);
+            return _context9.abrupt("return", IntegrationErrors.BROKEN_CONNECTION);
+          case 20:
+            return _context9.abrupt("return", null);
+          case 21:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9, this, [[4, 17]]);
+    }));
+    function test(_x8) {
+      return _test.apply(this, arguments);
+    }
+    return test;
+  }();
+  _proto.onConnectionCreated = /*#__PURE__*/function () {
+    var _onConnectionCreated = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee10(_ref10) {
+      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+          case 1:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    }));
+    function onConnectionCreated(_x9) {
+      return _onConnectionCreated.apply(this, arguments);
+    }
+    return onConnectionCreated;
+  }();
+  _proto.onDisconnect = /*#__PURE__*/function () {
+    var _onDisconnect = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee11(_ref11) {
+      return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+          case 1:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    }));
+    function onDisconnect(_x10) {
+      return _onDisconnect.apply(this, arguments);
+    }
+    return onDisconnect;
+  }();
+  return Integration;
+}();
+
+var _excluded$2 = ["accessToken", "expiresAt", "refreshToken"];
+var IntegrationAuth = /*#__PURE__*/function () {
+  function IntegrationAuth(_ref) {
+    var config = _ref.config,
+      dataAccess = _ref.dataAccess,
+      onConnectionCreated = _ref.onConnectionCreated;
+    this.config = void 0;
+    this.client = void 0;
+    this.dataAccess = void 0;
+    this.onConnectionCreated = void 0;
+    this.config = config;
+    this.onConnectionCreated = onConnectionCreated;
+    this.dataAccess = dataAccess;
+  }
+  var _proto = IntegrationAuth.prototype;
+  _proto.getClient = function getClient() {
+    if (this.config.AUTH_TYPE === IntegrationCredentialType.API_KEY) {
+      throw new Error('Integrations using API Key authentication do not support OAuth2Client');
+    }
+    var _this$config = this.config,
+      SERVER = _this$config.SERVER,
+      CLIENT_ID = _this$config.CLIENT_ID,
+      CLIENT_SECRET = _this$config.CLIENT_SECRET,
+      DISCOVERY_ENDPOINT = _this$config.DISCOVERY_ENDPOINT,
+      AUTHORIZATION_ENDPOINT = _this$config.AUTHORIZATION_ENDPOINT,
+      REVOCATION_ENDPOINT = _this$config.REVOCATION_ENDPOINT,
+      TOKEN_ENDPOINT = _this$config.TOKEN_ENDPOINT,
+      AUTHENTICATION_METHOD = _this$config.AUTHENTICATION_METHOD;
+    if (!this.client) {
+      try {
+        this.client = new OAuth2Client({
+          server: SERVER,
+          clientId: CLIENT_ID,
+          clientSecret: CLIENT_SECRET,
+          discoveryEndpoint: DISCOVERY_ENDPOINT,
+          authorizationEndpoint: AUTHORIZATION_ENDPOINT,
+          tokenEndpoint: TOKEN_ENDPOINT,
+          revocationEndpoint: REVOCATION_ENDPOINT,
+          authenticationMethod: AUTHENTICATION_METHOD
+        });
+        return this.client;
+      } catch (error) {
+        console.log('Error creating OAuth2Client', error);
+        throw error;
+      }
+    }
+    return this.client;
+  };
+  _proto.getScopes = function getScopes() {
+    if (this.config.AUTH_TYPE === IntegrationCredentialType.API_KEY) {
+      return [];
+    }
+    return this.config.SCOPES;
+  };
+  _proto.getRedirectUri = /*#__PURE__*/function () {
+    var _getRedirectUri = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(state) {
+      var _this$config$EXTRA_AU;
+      var client, redirectUri, scopes, name;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!(this.config.AUTH_TYPE === IntegrationCredentialType.API_KEY)) {
+              _context.next = 2;
+              break;
+            }
+            throw new Error('Integrations using API Key authentication do not use redirect URIs');
+          case 2:
+            client = this.getClient();
+            redirectUri = this.config.REDIRECT_URI;
+            scopes = this.config.SCOPES;
+            name = this.config.INTEGRATION_NAME;
+            _context.next = 8;
+            return client.authorizationCode.getAuthorizeUri({
+              redirectUri: redirectUri,
+              scope: scopes,
+              state: Buffer.from(JSON.stringify(_extends({
+                name: name
+              }, state))).toString('base64'),
+              extraParams: (_this$config$EXTRA_AU = this.config.EXTRA_AUTH_PARAMS) != null ? _this$config$EXTRA_AU : {}
+            });
+          case 8:
+            return _context.abrupt("return", _context.sent);
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function getRedirectUri(_x) {
+      return _getRedirectUri.apply(this, arguments);
+    }
+    return getRedirectUri;
+  }();
+  _proto.getTokenFromCodeRedirect = /*#__PURE__*/function () {
+    var _getTokenFromCodeRedirect = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(url) {
+      var client, _this$config$EXTRA_AU2, res;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(this.config.AUTH_TYPE === IntegrationCredentialType.API_KEY)) {
+              _context2.next = 2;
+              break;
+            }
+            throw new Error('Integrations using API Key authentication do not use authorization codes');
+          case 2:
+            client = this.getClient();
+            _context2.prev = 3;
+            _context2.next = 6;
+            return client.authorizationCode.getTokenFromCodeRedirect(url, {
+              redirectUri: this.config.REDIRECT_URI,
+              codeVerifier: (_this$config$EXTRA_AU2 = this.config.EXTRA_AUTH_PARAMS) == null ? void 0 : _this$config$EXTRA_AU2.code_challenge
+            });
+          case 6:
+            res = _context2.sent;
+            return _context2.abrupt("return", res);
+          case 10:
+            _context2.prev = 10;
+            _context2.t0 = _context2["catch"](3);
+            throw new Error(_context2.t0 == null ? void 0 : _context2.t0.message);
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this, [[3, 10]]);
+    }));
+    function getTokenFromCodeRedirect(_x2) {
+      return _getTokenFromCodeRedirect.apply(this, arguments);
+    }
+    return getTokenFromCodeRedirect;
+  }();
+  _proto.getStateFromRedirect = /*#__PURE__*/function () {
+    var _getStateFromRedirect = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(url) {
+      var state;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            state = new URL(url).searchParams.get('state');
+            if (state) {
+              _context3.next = 3;
+              break;
+            }
+            throw new Error('No state found in redirect');
+          case 3:
+            return _context3.abrupt("return", oauthState.parse(JSON.parse(Buffer.from(state, 'base64').toString())));
+          case 4:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    function getStateFromRedirect(_x3) {
+      return _getStateFromRedirect.apply(this, arguments);
+    }
+    return getStateFromRedirect;
+  }();
+  _proto.processCallback = /*#__PURE__*/function () {
+    var _processCallback = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(url) {
+      var tokenFromRedirect, state, connection, token;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return this.getTokenFromCodeRedirect(url);
+          case 2:
+            tokenFromRedirect = _context4.sent;
+            _context4.next = 5;
+            return this.getStateFromRedirect(url);
+          case 5:
+            state = _context4.sent;
+            _context4.next = 8;
+            return this.dataAccess.createConnection({
+              connection: {
+                connectionId: state.connectionId,
+                name: this.config.INTEGRATION_NAME
+              },
+              credential: {
+                type: this.config.AUTH_TYPE,
+                value: tokenFromRedirect,
+                scope: this.getScopes()
+              }
+            });
+          case 8:
+            connection = _context4.sent;
+            _context4.next = 11;
+            return this.getAuthToken({
+              k_id: connection.id
+            });
+          case 11:
+            token = _context4.sent;
+            if (!this.onConnectionCreated) {
+              _context4.next = 15;
+              break;
+            }
+            _context4.next = 15;
+            return Promise.resolve(this.onConnectionCreated(connection, token));
+          case 15:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function processCallback(_x4) {
+      return _processCallback.apply(this, arguments);
+    }
+    return processCallback;
+  }();
+  _proto.getAuthToken = /*#__PURE__*/function () {
+    var _getAuthToken = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_ref2) {
+      var k_id, credential, token, accessToken, expiresAt, rest, minTokenLifetime, now, refreshedToken;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            k_id = _ref2.k_id;
+            _context5.next = 3;
+            return this.dataAccess.getCredentialsByConnection(k_id);
+          case 3:
+            credential = _context5.sent;
+            if (!(credential.type === IntegrationCredentialType.API_KEY)) {
+              _context5.next = 6;
+              break;
+            }
+            return _context5.abrupt("return", credential.value);
+          case 6:
+            token = credential.value;
+            accessToken = token.accessToken, expiresAt = token.expiresAt, rest = _objectWithoutPropertiesLoose(token, _excluded$2);
+            minTokenLifetime = 60 * 5 * 1000; // 5 minutes
+            now = Date.now(); // If the token has no expiration date, it can be assumed it never expires
+            if (expiresAt) {
+              _context5.next = 12;
+              break;
+            }
+            return _context5.abrupt("return", _extends({
+              accessToken: accessToken,
+              expiresAt: expiresAt
+            }, rest));
+          case 12:
+            if (!(expiresAt - now > minTokenLifetime)) {
+              _context5.next = 14;
+              break;
+            }
+            return _context5.abrupt("return", _extends({
+              accessToken: accessToken,
+              expiresAt: expiresAt
+            }, rest));
+          case 14:
+            _context5.next = 16;
+            return this._refreshAuth({
+              token: token,
+              k_id: k_id
+            });
+          case 16:
+            refreshedToken = _context5.sent;
+            return _context5.abrupt("return", _extends({
+              accessToken: refreshedToken.accessToken,
+              expiresAt: refreshedToken.expiresAt
+            }, rest));
+          case 18:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this);
+    }));
+    function getAuthToken(_x5) {
+      return _getAuthToken.apply(this, arguments);
+    }
+    return getAuthToken;
+  }();
+  _proto._refreshAuth = /*#__PURE__*/function () {
+    var _refreshAuth2 = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(_ref3) {
+      var token, k_id, oauthClient, newToken, existingRefreshToken, accessToken, expiresAt;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            token = _ref3.token, k_id = _ref3.k_id;
+            oauthClient = this.getClient();
+            _context6.next = 4;
+            return oauthClient.refreshToken(token);
+          case 4:
+            newToken = _context6.sent;
+            existingRefreshToken = token.refreshToken;
+            accessToken = newToken.accessToken, expiresAt = newToken.expiresAt;
+            _context6.next = 9;
+            return this.dataAccess.updateConnectionCredential({
+              k_id: k_id,
+              token: {
+                accessToken: accessToken,
+                refreshToken: existingRefreshToken,
+                expiresAt: expiresAt
+              }
+            });
+          case 9:
+            return _context6.abrupt("return", newToken);
+          case 10:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this);
+    }));
+    function _refreshAuth(_x6) {
+      return _refreshAuth2.apply(this, arguments);
+    }
+    return _refreshAuth;
+  }();
+  _proto.revokeAuth = /*#__PURE__*/function () {
+    var _revokeAuth = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(_ref4) {
+      var k_id, oauthClient, credential, token;
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            k_id = _ref4.k_id;
+            oauthClient = this.getClient();
+            _context7.next = 4;
+            return this.dataAccess.getCredentialsByConnection(k_id);
+          case 4:
+            credential = _context7.sent;
+            token = credential.value;
+            _context7.next = 8;
+            return oauthClient.getEndpoint('revocationEndpoint');
+          case 8:
+            if (!_context7.sent) {
+              _context7.next = 17;
+              break;
+            }
+            _context7.prev = 9;
+            _context7.next = 12;
+            return oauthClient.revoke(token, 'refresh_token');
+          case 12:
+            _context7.next = 17;
+            break;
+          case 14:
+            _context7.prev = 14;
+            _context7.t0 = _context7["catch"](9);
+            console.log('Error revoking token', _context7.t0);
+          case 17:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7, this, [[9, 14]]);
+    }));
+    function revokeAuth(_x7) {
+      return _revokeAuth.apply(this, arguments);
+    }
+    return revokeAuth;
+  }();
+  return IntegrationAuth;
+}();
+
+/**
+ * Extract schema options for the provided schema - Builds a map of fieldname to field options
+ * @param schema - schema
+ * @param dataCtx - data context - this is an object of options for each field that isn't enum (meaning string fields) but should have options
+ * @returns schema options
+ * */
+function extractSchemaOptions(_ref) {
+  var schema = _ref.schema,
+    dataCtx = _ref.dataCtx;
+  return Object.entries(schema.shape).reduce(function (acc, _ref2) {
+    var field = _ref2[0],
+      schema = _ref2[1];
+    setFieldOptions({
+      schema: schema,
+      acc: acc,
+      field: field,
+      dataCtxList: dataCtx == null ? void 0 : dataCtx[field]
+    });
+    return acc;
+  }, {});
+}
+/**
+ * Set field options for the schema - Recursively populate the accumulator with field options for the provided field
+ * if the schema is an enum or an array of enums, or an array of strings and has dataCtxList
+ * @param schema - schema
+ * @param acc - accumulator
+ * @param field - field
+ * @param dataCtxList - data context list - custom options for the field
+ * @returns void
+ * */
+function setFieldOptions(_ref3) {
+  var schema = _ref3.schema,
+    acc = _ref3.acc,
+    field = _ref3.field,
+    dataCtxList = _ref3.dataCtxList;
+  if (schema instanceof z.ZodEnum) {
+    acc[field] = {
+      options: schema.options.map(function (value) {
+        return {
+          value: value,
+          label: _.capitalize(value)
+        };
+      })
+    };
+  } else if (schema instanceof z.ZodArray) {
+    if (schema.element instanceof z.ZodEnum) {
+      acc[field] = {
+        options: schema.element.options.map(function (value) {
+          return {
+            value: value,
+            label: _.capitalize(value)
+          };
+        })
+      };
+    } else if (schema.element instanceof z.ZodString && dataCtxList) {
+      acc[field] = dataCtxList || {
+        options: undefined
+      };
+    }
+  } else if (schema instanceof z.ZodString && dataCtxList) {
+    acc[field] = dataCtxList || {
+      options: undefined
+    };
+  } else if (schema instanceof z.ZodOptional) {
+    setFieldOptions({
+      schema: schema._def.innerType,
+      dataCtxList: dataCtxList,
+      field: field,
+      acc: acc
+    });
+  } else {
+    acc[field] = {
+      options: undefined
+    };
+  }
+}
+
+function zodToPropertType(zodType) {
+  if (zodType instanceof z.ZodString) {
+    return PropertyType.SINGLE_LINE_TEXT;
+  }
+  if (zodType instanceof z.ZodBoolean) {
+    return PropertyType.BOOLEAN;
+  }
+  if (zodType instanceof z.ZodRecord) {
+    return PropertyType.JSON_OBJECT;
+  }
+  if (zodType instanceof z.ZodNumber) {
+    return PropertyType.NUMBER;
+  }
+  if (zodType instanceof z.ZodArray) {
+    return PropertyType.JSON_ARRAY;
+  }
+  if (zodType instanceof z.ZodOptional) {
+    return zodToPropertType(zodType._def.innerType);
+  }
+  if (zodType instanceof z.ZodNullable) {
+    return zodToPropertType(zodType._def.innerType);
+  }
+  if (zodType instanceof z.ZodLiteral) {
+    return PropertyType.SINGLE_LINE_TEXT;
+  }
+  if (zodType instanceof z.ZodObject) {
+    return PropertyType.JSON_OBJECT;
+  }
+  // TODO UNIONS
+  return undefined;
+}
+function getResponseDataKey(_ref) {
+  var responseSchema = _ref.responseSchema,
+    listDataKey = _ref.listDataKey;
+  var fields = [];
+  var obj = responseSchema;
+  if (obj && obj instanceof z.ZodArray) {
+    obj = obj._def.type;
+  }
+  if (obj && obj instanceof z.ZodLazy) {
+    obj = responseSchema._def.getter();
+    if (obj instanceof z.ZodLazy) {
+      obj = obj._def.getter();
+    }
+  }
+  if (obj instanceof z.ZodObject) {
+    var shape = obj._def.shape();
+    var keys = Object.keys(shape);
+    var listData = keys.find(function (k) {
+      return k === listDataKey;
+    });
+    if (listData) {
+      var def = shape[listData];
+      if (def instanceof z.ZodArray) {
+        var innerDef = def._def.type;
+        if (innerDef && innerDef instanceof z.ZodLazy) {
+          var _obj = innerDef._def.getter();
+          if (_obj instanceof z.ZodObject) {
+            var _shape = _obj._def.shape();
+            Object.entries(_shape).forEach(function (_ref2) {
+              var k = _ref2[0],
+                v = _ref2[1];
+              var type = zodToPropertType(v);
+              if (type) {
+                fields.push({
+                  name: k,
+                  type: type,
+                  displayName: k,
+                  visible: true,
+                  order: 1,
+                  modifiable: false
+                });
+              }
+            });
+          }
+        }
+      }
+    } else {
+      Object.entries(shape).forEach(function (_ref3) {
+        var k = _ref3[0],
+          v = _ref3[1];
+        var type = zodToPropertType(v);
+        if (type) {
+          fields.push({
+            name: k,
+            type: type,
+            displayName: k,
+            visible: true,
+            order: 1,
+            modifiable: false
+          });
+        }
+      });
+    }
+  }
+  return fields;
+}
+function allowedKey(key) {
+  if (key.startsWith('get')) {
+    return true;
+  }
+  if (/List/.test(key)) {
+    return true;
+  }
+  if (/Get/.test(key)) {
+    return true;
+  }
+  return false;
+}
+function transformKey(input) {
+  // Use a regular expression to match 'get', followed by any characters and then the first uppercase letter
+  return input.replace(/^(get|Get)([A-Z][a-z]*)/, function (_, __, firstPart) {
+    // Convert the first meaningful part to lowercase
+    return firstPart.toLowerCase();
+  }).replace(/^([a-z]+)([A-Z].*)?$/, function (_, firstPart) {
+    // Return the first part in lowercase
+    return firstPart.toLowerCase();
+  }).replace(/^([a-z]+)([A-Z].*)?$/, function (_, firstPart) {
+    // Return the first part in lowercase
+    return firstPart.toLowerCase();
+  });
+}
+function extractPlural(input) {
+  // Use a regular expression to match the pattern
+  var regex = /^get([A-Z][a-z]*(?:[A-Z][a-z]*)*)(?:([A-Z][a-z]+))?$/;
+  var match = input.match(regex);
+  // If there's a match, return the plural part (first capturing group)
+  if (match) {
+    var returnS = match[1].toLowerCase(); // Convert to lowercase to match your output requirements
+    if (!returnS.endsWith('s')) {
+      return returnS + 's';
+    }
+    return returnS;
+  }
+  // Return null if the input does not match the pattern
+  return '';
+}
+function removeDuplicateWord(input) {
+  // Use a regular expression to match duplicated words
+  var regex = /^(.*?)(\1)$/;
+  var match = input.match(regex);
+  // If there's a match, return the first part (original word)
+  if (match) {
+    return match[1];
+  }
+  // Return the original string if no duplicates are found
+  return input;
+}
+function getEntityKey(key) {
+  if (key.startsWith('list')) {
+    return key.replace('list', '').toLowerCase();
+  }
+  if (key.startsWith('get')) {
+    var pluralS = extractPlural(key);
+    if (!pluralS) {
+      return key.replace('get', '').toLowerCase();
+    }
+    return removeDuplicateWord(pluralS.toLowerCase());
+  }
+  return transformKey(key);
+}
+function generateSyncs(_ref4) {
+  var client = _ref4.client,
+    schema = _ref4.schema,
+    name = _ref4.name,
+    idKey = _ref4.idKey,
+    listDataKey = _ref4.listDataKey;
+  var events = {};
+  Object.keys(client).filter(function (k) {
+    return k !== 'client';
+  }).forEach(function (key) {
+    if (allowedKey(key)) {
+      var _schema$schemaKey, _schema$responseSchem;
+      var apiKey = key;
+      var entityKey = getEntityKey(key);
+      var schemaKey = key + "DataSchema";
+      var responseSchemaKey = key + "ResponseSchema";
+      var inputSchema = (_schema$schemaKey = schema == null ? void 0 : schema[schemaKey]) != null ? _schema$schemaKey : z.object({});
+      var responseSchema = (_schema$responseSchem = schema == null ? void 0 : schema[responseSchemaKey]) != null ? _schema$responseSchem : z.object({});
+      var properties = getResponseDataKey({
+        listDataKey: listDataKey,
+        responseSchema: responseSchema
+      });
+      var handler = function handler(_ref5) {
+        var eventKey = _ref5.eventKey,
+          _ref5$integrationInst = _ref5.integrationInstance,
+          name = _ref5$integrationInst.name,
+          getApiClient = _ref5$integrationInst.getApiClient,
+          dataLayer = _ref5$integrationInst.dataLayer;
+        return {
+          id: name + "-sync-" + entityKey,
+          event: eventKey,
+          executor: function () {
+            var _executor = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref6) {
+              var event, connectionId, options, api, result, resultData, records;
+              return _regeneratorRuntime().wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    event = _ref6.event;
+                    connectionId = event.user.connectionId;
+                    options = {};
+                    if (inputSchema && inputSchema instanceof z.ZodObject) {
+                      Object.keys(inputSchema._def.shape()).forEach(function (k) {
+                        var _event$data;
+                        options[k] = event == null || (_event$data = event.data) == null ? void 0 : _event$data[k];
+                      });
+                    }
+                    _context.next = 6;
+                    return getApiClient({
+                      connectionId: connectionId
+                    });
+                  case 6:
+                    api = _context.sent;
+                    _context.next = 9;
+                    return api[apiKey](options);
+                  case 9:
+                    result = _context.sent;
+                    // First see if we are getting the list data
+                    resultData = (result == null ? void 0 : result[listDataKey]) || [result];
+                    records = resultData == null ? void 0 : resultData.map(function (d) {
+                      return {
+                        externalId: d[idKey],
+                        data: d,
+                        entityType: entityKey.toUpperCase()
+                      };
+                    });
+                    _context.next = 14;
+                    return dataLayer == null ? void 0 : dataLayer.syncData({
+                      name: name,
+                      connectionId: connectionId,
+                      data: records,
+                      properties: properties,
+                      type: entityKey.toUpperCase(),
+                      lastSyncId: event == null ? void 0 : event.id
+                    });
+                  case 14:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            }));
+            function executor(_x) {
+              return _executor.apply(this, arguments);
+            }
+            return executor;
+          }()
+        };
+      };
+      events[name + "." + entityKey + "/sync"] = {
+        schema: inputSchema,
+        handler: handler
+      };
+    }
+  });
+  return events;
+}
+
+var FilterOpToValueMapEnum = {
+  EQUAL: 'EQUAL',
+  NOT_EQUAL: 'NOT_EQUAL',
+  CONTAINS: 'CONTAINS',
+  IS: 'IS',
+  IS_NOT: 'IS_NOT',
+  NOT_CONTAINS: 'NOT_CONTAINS',
+  IS_ANY_OF: 'IS_ANY_OF',
+  GREATER_THAN: 'GREATER_THAN',
+  LESS_THAN: 'LESS_THAN',
+  DOES_NOT_CONTAIN: 'DOES_NOT_CONTAIN',
+  GREATER_THAN_OR_EQUAL: 'GREATER_THAN_OR_EQUAL',
+  LESS_THAN_OR_EQUAL: 'LESS_THAN_OR_EQUAL',
+  SET: 'SET',
+  NOT_SET: 'NOT_SET'
+};
+
+var _excluded$1 = ["trigger", "actions"],
+  _excluded2 = ["subActions"],
+  _excluded3 = ["subActions"];
+var getOutputSchemaServer = /*#__PURE__*/function () {
+  var _ref4 = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref3) {
+    var _outputSchema$_def, _outputSchema$_def2, _outputSchema$_def3;
+    var ctx, block, payload, blockType, body, outputSchema, schema, blockSchemaTypeName, discriminatedUnionSchemaOptions, discriminatedUnionSchemaDiscriminator, discriminatorValue, discriminatedUnionSchema, resolvedSchema;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          ctx = _ref3.ctx, block = _ref3.block, payload = _ref3.payload, blockType = _ref3.blockType;
+          body = blockType === 'trigger' ? payload == null ? void 0 : payload.value : payload;
+          if (!(typeof (block == null ? void 0 : block.schema) === 'function')) {
+            _context.next = 8;
+            break;
+          }
+          _context.next = 5;
+          return block == null ? void 0 : block.schema({
+            ctx: ctx
+          });
+        case 5:
+          _context.t0 = _context.sent;
+          _context.next = 9;
+          break;
+        case 8:
+          _context.t0 = block == null ? void 0 : block.schema;
+        case 9:
+          outputSchema = _context.t0;
+          if (!(typeof (block == null ? void 0 : block.schema) === 'function')) {
+            _context.next = 16;
+            break;
+          }
+          _context.next = 13;
+          return block == null ? void 0 : block.schema({
+            ctx: ctx
+          });
+        case 13:
+          _context.t1 = _context.sent;
+          _context.next = 17;
+          break;
+        case 16:
+          _context.t1 = block == null ? void 0 : block.schema;
+        case 17:
+          schema = _context.t1;
+          blockSchemaTypeName = outputSchema == null || (_outputSchema$_def = outputSchema._def) == null ? void 0 : _outputSchema$_def.typeName;
+          discriminatedUnionSchemaOptions = outputSchema == null || (_outputSchema$_def2 = outputSchema._def) == null ? void 0 : _outputSchema$_def2.options;
+          discriminatedUnionSchemaDiscriminator = outputSchema == null || (_outputSchema$_def3 = outputSchema._def) == null ? void 0 : _outputSchema$_def3.discriminator;
+          discriminatorValue = discriminatedUnionSchemaDiscriminator ? body == null ? void 0 : body[discriminatedUnionSchemaDiscriminator] : undefined;
+          discriminatedUnionSchema = discriminatedUnionSchemaOptions == null ? void 0 : discriminatedUnionSchemaOptions.find(function (option) {
+            var _option$shape2;
+            return (option == null || (_option$shape2 = option.shape) == null || (_option$shape2 = _option$shape2[discriminatedUnionSchemaDiscriminator]) == null || (_option$shape2 = _option$shape2._def) == null ? void 0 : _option$shape2.value) === discriminatorValue;
+          });
+          resolvedSchema = blockSchemaTypeName === 'ZodDiscriminatedUnion' ? discriminatedUnionSchema : outputSchema || schema;
+          return _context.abrupt("return", resolvedSchema);
+        case 25:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getOutputSchemaServer(_x) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var getSchemaServer = /*#__PURE__*/function () {
+  var _ref6 = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref5) {
+    var _outputSchema$_def4, _outputSchema$_def5, _outputSchema$_def6;
+    var ctx, block, payload, blockType, body, outputSchema, schema, blockSchemaTypeName, discriminatedUnionSchemaOptions, discriminatedUnionSchemaDiscriminator, discriminatorValue, discriminatedUnionSchema, resolvedSchema;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          ctx = _ref5.ctx, block = _ref5.block, payload = _ref5.payload, blockType = _ref5.blockType;
+          body = blockType === 'trigger' ? payload == null ? void 0 : payload.value : payload;
+          if (!(typeof block.schema === 'function')) {
+            _context2.next = 8;
+            break;
+          }
+          _context2.next = 5;
+          return block.schema({
+            ctx: ctx
+          });
+        case 5:
+          _context2.t0 = _context2.sent;
+          _context2.next = 9;
+          break;
+        case 8:
+          _context2.t0 = block.schema;
+        case 9:
+          outputSchema = _context2.t0;
+          if (!(typeof block.schema === 'function')) {
+            _context2.next = 16;
+            break;
+          }
+          _context2.next = 13;
+          return block.schema({
+            ctx: ctx
+          });
+        case 13:
+          _context2.t1 = _context2.sent;
+          _context2.next = 17;
+          break;
+        case 16:
+          _context2.t1 = block.schema;
+        case 17:
+          schema = _context2.t1;
+          blockSchemaTypeName = outputSchema == null || (_outputSchema$_def4 = outputSchema._def) == null ? void 0 : _outputSchema$_def4.typeName;
+          discriminatedUnionSchemaOptions = outputSchema == null || (_outputSchema$_def5 = outputSchema._def) == null ? void 0 : _outputSchema$_def5.options;
+          discriminatedUnionSchemaDiscriminator = outputSchema == null || (_outputSchema$_def6 = outputSchema._def) == null ? void 0 : _outputSchema$_def6.discriminator;
+          discriminatorValue = discriminatedUnionSchemaDiscriminator ? body == null ? void 0 : body[discriminatedUnionSchemaDiscriminator] : undefined;
+          discriminatedUnionSchema = discriminatedUnionSchemaOptions == null ? void 0 : discriminatedUnionSchemaOptions.find(function (option) {
+            var _option$shape3;
+            return (option == null || (_option$shape3 = option.shape) == null || (_option$shape3 = _option$shape3[discriminatedUnionSchemaDiscriminator]) == null || (_option$shape3 = _option$shape3._def) == null ? void 0 : _option$shape3.value) === discriminatorValue;
+          });
+          resolvedSchema = blockSchemaTypeName === 'ZodDiscriminatedUnion' ? discriminatedUnionSchema : schema || outputSchema;
+          return _context2.abrupt("return", resolvedSchema);
+        case 25:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function getSchemaServer(_x2) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+var filterChecks = {
+  stringCheck: function stringCheck(_ref8) {
+    var filterField = _ref8.filterField,
+      operator = _ref8.operator,
+      comparator = _ref8.comparator;
+    if (!filterField) return false;
+    if (typeof filterField !== 'string') return false;
+    switch (operator) {
+      case FilterOpToValueMapEnum.EQUAL:
+        return filterField.trim().toLowerCase() === comparator.trim().toLowerCase();
+      case FilterOpToValueMapEnum.NOT_EQUAL:
+        return filterField.trim().toLowerCase() !== comparator.trim().toLowerCase();
+      case FilterOpToValueMapEnum.CONTAINS:
+        return filterField.trim().toLowerCase().includes(comparator.trim().toLowerCase());
+      case FilterOpToValueMapEnum.DOES_NOT_CONTAIN:
+        return !filterField.trim().toLowerCase().includes(comparator.trim());
+      case FilterOpToValueMapEnum.SET:
+        return !!filterField;
+      case FilterOpToValueMapEnum.NOT_SET:
+        return !filterField;
+      default:
+        return false;
+    }
+  },
+  numberCheck: function numberCheck(_ref9) {
+    var filterField = _ref9.filterField,
+      operator = _ref9.operator,
+      comparator = _ref9.comparator;
+    if (!filterField) return false;
+    if (typeof filterField !== 'number') return false;
+    switch (operator) {
+      case 'EQUAL':
+        return filterField === comparator;
+      case 'NOT_EQUAL':
+        return filterField !== comparator;
+      case 'GREATER_THAN':
+        return filterField > comparator;
+      case 'LESS_THAN':
+        return filterField < comparator;
+      case 'GREATER_THAN_OR_EQUAL':
+        return filterField >= comparator;
+      case 'LESS_THAN_OR_EQUAL':
+        return filterField <= comparator;
+      default:
+        return false;
+    }
+  },
+  dateCheck: function dateCheck(_ref10) {
+    var filterField = _ref10.filterField,
+      operator = _ref10.operator,
+      comparator = _ref10.comparator;
+    if (!filterField) return false;
+    var datesAreEqual = dateFns.isEqual(filterField, new Date(comparator).toDateString());
+    var dateIsAfter = dateFns.isAfter(filterField, new Date(comparator).toDateString());
+    var dateIsBefore = dateFns.isBefore(filterField, new Date(comparator).toDateString());
+    switch (operator) {
+      case 'EQUAL':
+        return datesAreEqual;
+      case 'NOT_EQUAL':
+        return !datesAreEqual;
+      case 'GREATER_THAN':
+        return dateIsAfter;
+      case 'LESS_THAN':
+        return dateIsBefore;
+      default:
+        return false;
+    }
+  },
+  booleanCheck: function booleanCheck(_ref11) {
+    var filterField = _ref11.filterField,
+      operator = _ref11.operator,
+      comparator = _ref11.comparator;
+    switch (operator) {
+      case 'IS':
+        return filterField === Boolean(comparator);
+      case 'IS_NOT':
+        return filterField !== Boolean(comparator);
+      default:
+        return false;
+    }
+  }
+};
+var constructWorkflowContextBluePrint = function constructWorkflowContextBluePrint(blueprint) {
+  var _workflowContextActio;
+  var trigger = blueprint.trigger,
+    actions = blueprint.actions,
+    blueprintInfo = _objectWithoutPropertiesLoose(blueprint, _excluded$1);
+  var rootAction = actions[0];
+  if (!rootAction) return {
+    trigger: trigger,
+    blueprintInfo: blueprintInfo,
+    actions: {}
+  };
+  var subActions = rootAction.subActions,
+    rest = _objectWithoutPropertiesLoose(rootAction, _excluded2);
+  var workflowContextActions = (_workflowContextActio = {}, _workflowContextActio[rootAction.id] = rest, _workflowContextActio);
+  function recurse(_ref12) {
+    var action = _ref12.action,
+      parentActionId = _ref12.parentActionId;
+    var subActions = action.subActions;
+      _objectWithoutPropertiesLoose(action, _excluded3);
+    action.parentActionId = parentActionId;
+    workflowContextActions[action.id] = action;
+    if (subActions != null && subActions.length) {
+      subActions.forEach(function (sub) {
+        recurse({
+          action: sub,
+          parentActionId: action.id
+        });
+      });
+    }
+  }
+  subActions.forEach(function (action) {
+    recurse({
+      action: action,
+      parentActionId: rootAction.id
+    });
+  });
+  return {
+    trigger: trigger,
+    blueprintInfo: blueprintInfo,
+    actions: workflowContextActions
+  };
+};
+
+var _excluded = ["mastraConnectionId"];
+function evaluateCondition(_ref) {
+  var _c$and, _c$or;
+  var c = _ref.c,
+    dataCtx = _ref.dataCtx,
+    schema = _ref.schema,
+    triggerId = _ref.triggerId;
+  var andBranchResult = true;
+  var baseResult = true;
+  var orBranchResult = true;
+  if (c != null && c.field) {
+    var targetSchema = resolveSchemaPath({
+      currentPath: '',
+      schema: schema,
+      targetPath: c.field,
+      finalMap: {}
+    });
+    baseResult = resolveCondition({
+      c: omit(c, 'and', 'or'),
+      dataCtx: dataCtx,
+      schema: targetSchema,
+      triggerId: c.blockId || triggerId
+    }) === true;
+  }
+  if ((_c$and = c.and) != null && _c$and.length) {
+    andBranchResult = c.and.map(function (andCond) {
+      if (andCond.field) {
+        var _targetSchema = resolveSchemaPath({
+          currentPath: '',
+          schema: schema,
+          targetPath: andCond.field,
+          finalMap: {}
+        });
+        return resolveCondition({
+          c: andCond,
+          dataCtx: dataCtx,
+          schema: _targetSchema,
+          triggerId: andCond.blockId || triggerId
+        });
+      }
+    }).every(Boolean);
+  }
+  if ((_c$or = c.or) != null && _c$or.length) {
+    orBranchResult = c.or.map(function (orCond) {
+      if (orCond.field) {
+        var _targetSchema2 = resolveSchemaPath({
+          currentPath: '',
+          schema: schema,
+          targetPath: orCond.field,
+          finalMap: {}
+        });
+        return resolveCondition({
+          c: orCond,
+          dataCtx: dataCtx,
+          schema: _targetSchema2,
+          triggerId: orCond.blockId || triggerId
+        });
+      }
+    }).some(Boolean);
+  }
+  return baseResult && andBranchResult && orBranchResult;
+}
+function resolveSchemaPath(_ref2) {
+  var currentPath = _ref2.currentPath,
+    schema = _ref2.schema,
+    targetPath = _ref2.targetPath,
+    finalMap = _ref2.finalMap;
+  finalMap[currentPath] = schema;
+  // bail out if the target path is found
+  if (finalMap[targetPath]) {
+    return finalMap[targetPath];
+  }
+  for (var _i = 0, _Object$entries = Object.entries(schema.shape); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _Object$entries[_i],
+      field = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (value instanceof z.ZodObject) {
+      var nestedPathToSchemaMap = resolveSchemaPath({
+        currentPath: currentPath ? currentPath.concat('.', field) : field,
+        schema: value,
+        targetPath: targetPath,
+        finalMap: finalMap
+      });
+      if (nestedPathToSchemaMap) {
+        // bail out if the target path is found
+        return nestedPathToSchemaMap;
+      }
+    } else {
+      finalMap[currentPath ? currentPath.concat('.', field) : field] = value;
+      // bail out if the target path is found
+      if (finalMap[targetPath]) {
+        return finalMap[targetPath];
+      }
+    }
+  }
+  return finalMap[targetPath];
+}
+function replacePayloadVariables(_ref3) {
+  var value = _ref3.value,
+    stringContainingVariables = _ref3.stringContainingVariables,
+    variable = _ref3.variable;
+  return Array.isArray(stringContainingVariables) ? stringContainingVariables.map(function (v) {
+    return v.replace("{{" + variable + "}}", value);
+  }) : stringContainingVariables.replace("{{" + variable + "}}", value);
+}
+function resolveCondition(_ref4) {
+  var c = _ref4.c,
+    dataCtx = _ref4.dataCtx,
+    schema = _ref4.schema,
+    triggerId = _ref4.triggerId;
+  var relevantBlock = dataCtx[(c == null ? void 0 : c.blockId) || triggerId || ''];
+  if (c.isDefault) {
+    return true;
+  }
+  if (!relevantBlock) {
+    // treat as invalid filter, and move onto other filters
+    // we return `true` so that it doesn't invalidate other filters in the same group
+    return true;
+  }
+  var blockValue = resolvePath({
+    path: c.field || '',
+    replacementDataPayload: relevantBlock
+  });
+  var operator = c.operator;
+  if (schema instanceof z.ZodString) {
+    return filterChecks.stringCheck({
+      filterField: blockValue,
+      operator: operator,
+      comparator: c.value
+    });
+  } else if (schema instanceof z.ZodNumber) {
+    return filterChecks.numberCheck({
+      filterField: blockValue,
+      operator: operator,
+      comparator: c.value
+    });
+  } else if (schema instanceof z.ZodBoolean) {
+    return filterChecks.booleanCheck({
+      filterField: blockValue,
+      operator: operator,
+      comparator: c.value
+    });
+  } else if (schema instanceof z.ZodDate) {
+    return filterChecks.dateCheck({
+      filterField: blockValue,
+      operator: operator,
+      comparator: c.value
+    });
+  } else if (schema instanceof z.ZodOptional) {
+    var optionalSchema = schema._def.innerType;
+    return resolveCondition({
+      c: c,
+      dataCtx: dataCtx,
+      schema: optionalSchema,
+      triggerId: triggerId
+    });
+  }
+}
+function resolvePath(_ref5) {
+  var path = _ref5.path,
+    replacementDataPayload = _ref5.replacementDataPayload;
+  var pathParts = path.split('.');
+  var resolvedValue = replacementDataPayload;
+  for (var _iterator = _createForOfIteratorHelperLoose(pathParts), _step; !(_step = _iterator()).done;) {
+    var part = _step.value;
+    resolvedValue = resolvedValue[part];
+  }
+  return resolvedValue;
+}
+function resolvePayload(_ref6) {
+  var payload = _ref6.payload,
+    dataContext = _ref6.dataContext,
+    variables = _ref6.variables,
+    parentKey = _ref6.parentKey;
+  var resolvedPayload = Object.assign({}, payload);
+  for (var _i2 = 0, _Object$entries2 = Object.entries(resolvedPayload); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = _Object$entries2[_i2],
+      key = _Object$entries2$_i[0],
+      value = _Object$entries2$_i[1];
+    if (typeof value === 'object' && !Array.isArray(value)) {
+      resolvedPayload[key] = resolvePayload({
+        payload: value,
+        dataContext: dataContext,
+        variables: variables,
+        parentKey: key
+      });
+    }
+    if (!variables) continue;
+    var currentKey = parentKey ? parentKey + "." + key : key;
+    var variableMap = variables[currentKey];
+    // variableMap = { [variable]: { refBlockId, path }, [variable]: {refBlockId, path} }
+    if (!variableMap) {
+      continue;
+    }
+    var tempValue = value;
+    for (var _i3 = 0, _Object$entries3 = Object.entries(variableMap); _i3 < _Object$entries3.length; _i3++) {
+      var _Object$entries3$_i = _Object$entries3[_i3],
+        variable = _Object$entries3$_i[0],
+        _Object$entries3$_i$ = _Object$entries3$_i[1],
+        refBlockId = _Object$entries3$_i$.refBlockId,
+        path = _Object$entries3$_i$.path;
+      var replacementDataPayload = dataContext[refBlockId]; // get the payload returned by the relevant previous action
+      if (!replacementDataPayload) {
+        // if the reference block to get data from does not exist, skip
+        continue;
+      }
+      // get the value from the replacement data payload at the path specified in the variable map
+      var replacementValue = resolvePath({
+        path: path,
+        replacementDataPayload: replacementDataPayload
+      });
+      tempValue = replacePayloadVariables({
+        value: replacementValue,
+        stringContainingVariables: tempValue,
+        variable: variable
+      });
+    }
+    resolvedPayload[key] = tempValue;
+  }
+  return resolvedPayload;
+}
+function runActionsRecursively(_x) {
+  return _runActionsRecursively.apply(this, arguments);
+}
+function _runActionsRecursively() {
+  _runActionsRecursively = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref7) {
+    var blueprintActions, frameworkApis, frameworkEvents, dataContext, blueprintId, runId, ctx, blueprintActionKVMap, _loop, _ret, _iterator2, _step2;
+    return _regeneratorRuntime().wrap(function _callee$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          blueprintActions = _ref7.blueprintActions, frameworkApis = _ref7.frameworkApis, frameworkEvents = _ref7.frameworkEvents, dataContext = _ref7.dataContext, blueprintId = _ref7.blueprintId, runId = _ref7.runId, ctx = _ref7.ctx, blueprintActionKVMap = _ref7.blueprintActionKVMap;
+          _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+            var _action$subActions;
+            var action, concreteAction, hasValidBranch, _loop2, _ret2, _iterator3, _step3, defaultCondition, defaultAction, actionExecutor, _ref9, mastraConnectionId, actionPayload, resolvedPayload, resolvedSchema, data, executorResult, _ctx, subActions;
+            return _regeneratorRuntime().wrap(function _loop$(_context2) {
+              while (1) switch (_context2.prev = _context2.next) {
+                case 0:
+                  action = _step2.value;
+                  concreteAction = frameworkApis[action.type];
+                  console.log('==========', "Running action " + action.type, {
+                    dataContext: JSON.stringify(dataContext, null, 2)
+                  }, '=======');
+                  // check action conditions
+                  if (!(action.type === 'CONDITIONS')) {
+                    _context2.next = 32;
+                    break;
+                  }
+                  if (action.condition) {
+                    _context2.next = 6;
+                    break;
+                  }
+                  return _context2.abrupt("return", 0);
+                case 6:
+                  hasValidBranch = false;
+                  _loop2 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop2() {
+                    var cond, refBlock, currentConcreteBlock, isAction, actionToRun, resolvedSchema, shouldRunAction, executorResult;
+                    return _regeneratorRuntime().wrap(function _loop2$(_context) {
+                      while (1) switch (_context.prev = _context.next) {
+                        case 0:
+                          cond = _step3.value;
+                          if (!cond.isDefault) {
+                            _context.next = 3;
+                            break;
+                          }
+                          return _context.abrupt("return", 0);
+                        case 3:
+                          console.log('==========', "Found action condition", '=======');
+                          refBlock = blueprintActionKVMap.actions[cond.blockId || ''] || blueprintActionKVMap.trigger;
+                          currentConcreteBlock = frameworkApis[(refBlock == null ? void 0 : refBlock.type) || ''] || frameworkEvents[(refBlock == null ? void 0 : refBlock.type) || ''];
+                          isAction = !!frameworkApis[(refBlock == null ? void 0 : refBlock.type) || ''];
+                          if (currentConcreteBlock) {
+                            _context.next = 9;
+                            break;
+                          }
+                          return _context.abrupt("return", 0);
+                        case 9:
+                          actionToRun = action.subActions.find(function (a) {
+                            return a.id === cond.actionId;
+                          });
+                          if (actionToRun) {
+                            _context.next = 12;
+                            break;
+                          }
+                          return _context.abrupt("return", 0);
+                        case 12:
+                          _context.next = 14;
+                          return getOutputSchemaServer({
+                            block: currentConcreteBlock,
+                            payload: (refBlock == null ? void 0 : refBlock.payload) || {},
+                            blockType: isAction ? 'action' : 'trigger',
+                            ctx: ctx
+                          });
+                        case 14:
+                          resolvedSchema = _context.sent;
+                          shouldRunAction = evaluateCondition({
+                            c: cond,
+                            dataCtx: dataContext,
+                            schema: resolvedSchema
+                          });
+                          console.log('==========', {
+                            shouldRunAction: shouldRunAction
+                          }, '=======');
+                          if (shouldRunAction) {
+                            _context.next = 19;
+                            break;
+                          }
+                          return _context.abrupt("return", 0);
+                        case 19:
+                          hasValidBranch = true;
+                          _context.next = 22;
+                          return runActionsRecursively({
+                            blueprintActions: [actionToRun],
+                            frameworkApis: frameworkApis,
+                            frameworkEvents: frameworkEvents,
+                            dataContext: dataContext,
+                            blueprintId: blueprintId,
+                            runId: runId,
+                            ctx: ctx,
+                            blueprintActionKVMap: blueprintActionKVMap
+                          });
+                        case 22:
+                          executorResult = _context.sent;
+                          if (executorResult) {
+                            _context.next = 25;
+                            break;
+                          }
+                          return _context.abrupt("return", {
+                            v: {
+                              v: false
+                            }
+                          });
+                        case 25:
+                        case "end":
+                          return _context.stop();
+                      }
+                    }, _loop2);
+                  });
+                  _iterator3 = _createForOfIteratorHelperLoose(action.condition);
+                case 9:
+                  if ((_step3 = _iterator3()).done) {
+                    _context2.next = 18;
+                    break;
+                  }
+                  return _context2.delegateYield(_loop2(), "t0", 11);
+                case 11:
+                  _ret2 = _context2.t0;
+                  if (!(_ret2 === 0)) {
+                    _context2.next = 14;
+                    break;
+                  }
+                  return _context2.abrupt("continue", 16);
+                case 14:
+                  if (!_ret2) {
+                    _context2.next = 16;
+                    break;
+                  }
+                  return _context2.abrupt("return", _ret2.v);
+                case 16:
+                  _context2.next = 9;
+                  break;
+                case 18:
+                  if (hasValidBranch) {
+                    _context2.next = 32;
+                    break;
+                  }
+                  console.log('======== No valid branch found for action ============');
+                  // run default branch if available
+                  defaultCondition = action.condition.find(function (c) {
+                    return c.isDefault;
+                  });
+                  defaultAction = action.subActions.find(function (a) {
+                    return a.id === (defaultCondition == null ? void 0 : defaultCondition.actionId);
+                  });
+                  if (!defaultAction) {
+                    _context2.next = 30;
+                    break;
+                  }
+                  console.log('========= running default action =============');
+                  _context2.next = 26;
+                  return runActionsRecursively({
+                    blueprintActions: [defaultAction],
+                    dataContext: dataContext,
+                    frameworkApis: frameworkApis,
+                    frameworkEvents: frameworkEvents,
+                    runId: runId,
+                    ctx: ctx,
+                    blueprintId: blueprintId,
+                    blueprintActionKVMap: blueprintActionKVMap
+                  });
+                case 26:
+                  _context2.t1 = _context2.sent;
+                  return _context2.abrupt("return", {
+                    v: _context2.t1
+                  });
+                case 30:
+                  console.log('========= No default branch found =============');
+                  return _context2.abrupt("return", {
+                    v: false
+                  });
+                case 32:
+                  actionExecutor = concreteAction == null ? void 0 : concreteAction.executor;
+                  if (actionExecutor) {
+                    _context2.next = 36;
+                    break;
+                  }
+                  console.log("No executor found for " + action.type);
+                  return _context2.abrupt("return", 0);
+                case 36:
+                  _ref9 = action.payload || {}, mastraConnectionId = _ref9.mastraConnectionId, actionPayload = _objectWithoutPropertiesLoose(_ref9, _excluded);
+                  resolvedPayload = resolvePayload({
+                    payload: actionPayload,
+                    dataContext: dataContext,
+                    variables: action.variables
+                  });
+                  console.log('====Resolved payload====', {
+                    resolvedPayload: resolvedPayload
+                  });
+                  _context2.next = 41;
+                  return getSchemaServer({
+                    block: concreteAction,
+                    payload: resolvedPayload,
+                    blockType: 'action',
+                    ctx: ctx
+                  });
+                case 41:
+                  resolvedSchema = _context2.sent;
+                  data = resolvedSchema.parse(resolvedPayload);
+                  console.log('====Parsed data====', {
+                    data: data
+                  });
+                  executorResult = {};
+                  _ctx = mastraConnectionId ? {
+                    connectionId: mastraConnectionId
+                  } : ctx;
+                  _context2.prev = 46;
+                  _context2.next = 49;
+                  return actionExecutor({
+                    data: data,
+                    ctx: _ctx
+                  });
+                case 49:
+                  executorResult = _context2.sent;
+                  console.log('executed successfully');
+                  _context2.next = 57;
+                  break;
+                case 53:
+                  _context2.prev = 53;
+                  _context2.t2 = _context2["catch"](46);
+                  console.log('===Error executing action===', {
+                    e: _context2.t2
+                  });
+                  // TODO: Update workflows runs for failed actions
+                  return _context2.abrupt("return", {
+                    v: false
+                  });
+                case 57:
+                  dataContext[action.id] = executorResult;
+                  if (!(action.type === "CONDITIONS" || (_action$subActions = action.subActions) != null && _action$subActions.length)) {
+                    _context2.next = 65;
+                    break;
+                  }
+                  subActions = action.subActions;
+                  if (!(subActions != null && subActions.length)) {
+                    _context2.next = 65;
+                    break;
+                  }
+                  _context2.next = 63;
+                  return runActionsRecursively({
+                    blueprintActions: subActions,
+                    frameworkApis: frameworkApis,
+                    frameworkEvents: frameworkEvents,
+                    dataContext: dataContext,
+                    runId: runId,
+                    ctx: ctx,
+                    blueprintId: blueprintId,
+                    blueprintActionKVMap: blueprintActionKVMap
+                  });
+                case 63:
+                  _context2.t3 = _context2.sent;
+                  return _context2.abrupt("return", {
+                    v: _context2.t3
+                  });
+                case 65:
+                case "end":
+                  return _context2.stop();
+              }
+            }, _loop, null, [[46, 53]]);
+          });
+          _iterator2 = _createForOfIteratorHelperLoose(blueprintActions);
+        case 3:
+          if ((_step2 = _iterator2()).done) {
+            _context3.next = 12;
+            break;
+          }
+          return _context3.delegateYield(_loop(), "t0", 5);
+        case 5:
+          _ret = _context3.t0;
+          if (!(_ret === 0)) {
+            _context3.next = 8;
+            break;
+          }
+          return _context3.abrupt("continue", 10);
+        case 8:
+          if (!_ret) {
+            _context3.next = 10;
+            break;
+          }
+          return _context3.abrupt("return", _ret.v);
+        case 10:
+          _context3.next = 3;
+          break;
+        case 12:
+          return _context3.abrupt("return", true);
+        case 13:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee);
+  }));
+  return _runActionsRecursively.apply(this, arguments);
+}
+function blueprintRunner(_x2) {
+  return _blueprintRunner.apply(this, arguments);
+}
+function _blueprintRunner() {
+  _blueprintRunner = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref8) {
+    var _fullCtx, _blueprint$trigger;
+    var ctx, dataCtx, blueprint, frameworkEvents, frameworkApis, fullCtx, triggerCondition, concreteTrigger, resolvedSchema, shouldRunWorkflow, blueprintActionKVMap, ranSuccessfully;
+    return _regeneratorRuntime().wrap(function _callee2$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          ctx = _ref8.ctx, dataCtx = _ref8.dataCtx, blueprint = _ref8.blueprint, frameworkEvents = _ref8.frameworkEvents, frameworkApis = _ref8.frameworkApis;
+          console.log("Running blueprint " + blueprint.id);
+          fullCtx = (_fullCtx = {}, _fullCtx[blueprint.trigger.id] = dataCtx, _fullCtx);
+          triggerCondition = blueprint.trigger.condition;
+          concreteTrigger = frameworkEvents[blueprint.trigger.type || ''];
+          _context4.next = 8;
+          return getOutputSchemaServer({
+            block: concreteTrigger,
+            payload: ((_blueprint$trigger = blueprint.trigger) == null ? void 0 : _blueprint$trigger.payload) || {},
+            blockType: 'trigger',
+            ctx: ctx
+          });
+        case 8:
+          resolvedSchema = _context4.sent;
+          if (isEmpty(triggerCondition)) {
+            _context4.next = 16;
+            break;
+          }
+          console.log("Found trigger condition", {
+            triggerCondition: triggerCondition
+          });
+          shouldRunWorkflow = evaluateCondition({
+            c: triggerCondition,
+            dataCtx: fullCtx,
+            triggerId: blueprint.trigger.id,
+            schema: resolvedSchema
+          });
+          console.log("Should run workflow", {
+            shouldRunWorkflow: shouldRunWorkflow
+          });
+          if (shouldRunWorkflow) {
+            _context4.next = 16;
+            break;
+          }
+          return _context4.abrupt("return");
+        case 16:
+          blueprintActionKVMap = constructWorkflowContextBluePrint(blueprint);
+          _context4.next = 20;
+          return runActionsRecursively({
+            blueprintActions: blueprint.actions,
+            frameworkApis: frameworkApis,
+            ctx: ctx,
+            frameworkEvents: frameworkEvents,
+            dataContext: fullCtx,
+            blueprintActionKVMap: blueprintActionKVMap,
+            blueprintId: blueprint.id,
+            runId: ''
+          });
+        case 20:
+          ranSuccessfully = _context4.sent;
+          try {
+            if (ranSuccessfully) {
+              // await automationRunService.updateAutomationRun({
+              //   runId: blueprintRun?.id || '',
+              //   blueprintId: blueprint.id,
+              //   completedAt: new Date(),
+              //   status: AutomationRunStatus.COMPLETED,
+              // });
+            }
+          } catch (e) {}
+        case 22:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee2);
+  }));
+  return _blueprintRunner.apply(this, arguments);
+}
+
+var Framework = /*#__PURE__*/function () {
+  function Framework(_ref) {
+    var _this = this;
+    var dataLayer = _ref.dataLayer,
+      config = _ref.config;
+    //global events grouped by Integration
+    this.globalEvents = new Map();
+    // global event handlers
+    this.globalEventHandlers = [];
+    // global apis grouped by Integration
+    this.globalApis = new Map();
+    this.integrations = new Map();
+    this.dataLayer = void 0;
+    this.config = void 0;
+    this.runBlueprint = /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
+        var _this$availableIntegr;
+        var blueprint, _ref2$dataCtx, dataCtx, ctx, systemApis, systemEvents, availableIntegrations, availableIntegrationApis, availableIntegrationEvents, frameworkApis, frameworkEvents;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              blueprint = _ref2.blueprint, _ref2$dataCtx = _ref2.dataCtx, dataCtx = _ref2$dataCtx === void 0 ? {} : _ref2$dataCtx, ctx = _ref2.ctx;
+              systemApis = _this.getSystemApis();
+              systemEvents = _this.getSystemEvents();
+              availableIntegrations = (_this$availableIntegr = _this.availableIntegrations()) == null ? void 0 : _this$availableIntegr.map(function (_ref4) {
+                var integration = _ref4.integration;
+                return integration;
+              });
+              availableIntegrationApis = availableIntegrations.reduce(function (acc, _ref5) {
+                var name = _ref5.name;
+                var apis = _this.getApisByIntegration(name);
+                return _extends({}, acc, apis);
+              }, {});
+              availableIntegrationEvents = availableIntegrations.reduce(function (acc, _ref6) {
+                var name = _ref6.name;
+                var events = _this.getEventsByIntegration(name);
+                return _extends({}, acc, events);
+              }, {});
+              frameworkApis = _extends({}, systemApis, availableIntegrationApis);
+              frameworkEvents = _extends({}, systemEvents, availableIntegrationEvents);
+              _context.next = 10;
+              return blueprintRunner({
+                dataCtx: dataCtx,
+                blueprint: blueprint,
+                frameworkApis: frameworkApis,
+                frameworkEvents: frameworkEvents,
+                ctx: ctx
+              });
+            case 10:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x) {
+        return _ref3.apply(this, arguments);
+      };
+    }();
+    this.dataLayer = dataLayer;
+    this.config = config;
+  }
+  Framework.init = function init(config) {
+    var _config$workflows$sys;
+    if (!config.db.uri) {
+      throw new Error('No database config/provider found');
+    }
+    var dataLayer = new DataLayer({
+      url: config.db.uri,
+      provider: config.db.provider
+    });
+    var framework = new Framework({
+      config: config,
+      dataLayer: dataLayer
+    });
+    // Register integrations
+    config.integrations.forEach(function (integration) {
+      framework.__registerIntgeration(integration);
+    });
+    // Register System apis
+    framework.__registerApis({
+      apis: (_config$workflows$sys = config.workflows.systemApis) == null ? void 0 : _config$workflows$sys.map(function (api) {
+        return _extends({}, api, {
+          integrationName: config.name
+        });
+      })
+    });
+    // Register System events
+    framework.__registerEvents({
+      events: config.workflows.systemEvents
+    });
+    return framework;
+  };
+  var _proto = Framework.prototype;
+  _proto.connectedIntegrations = /*#__PURE__*/function () {
+    var _connectedIntegrations = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref7) {
+      var _this2 = this;
+      var context, ints, connectionChecks;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            context = _ref7.context;
+            ints = this.availableIntegrations();
+            _context3.next = 4;
+            return Promise.all(ints.map(/*#__PURE__*/function () {
+              var _ref9 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref8) {
+                var integration, connection;
+                return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                  while (1) switch (_context2.prev = _context2.next) {
+                    case 0:
+                      integration = _ref8.integration;
+                      _context2.next = 3;
+                      return _this2.dataLayer.getConnection({
+                        connectionId: context.connectionId,
+                        name: integration.name
+                      });
+                    case 3:
+                      connection = _context2.sent;
+                      return _context2.abrupt("return", {
+                        integration: integration,
+                        connected: !!connection
+                      });
+                    case 5:
+                    case "end":
+                      return _context2.stop();
+                  }
+                }, _callee2);
+              }));
+              return function (_x3) {
+                return _ref9.apply(this, arguments);
+              };
+            }()));
+          case 4:
+            connectionChecks = _context3.sent;
+            return _context3.abrupt("return", connectionChecks.filter(function (_ref10) {
+              var connected = _ref10.connected;
+              return connected;
+            }).map(function (_ref11) {
+              var integration = _ref11.integration;
+              return integration;
+            }));
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function connectedIntegrations(_x2) {
+      return _connectedIntegrations.apply(this, arguments);
+    }
+    return connectedIntegrations;
+  }();
+  _proto.__registerIntgeration = function __registerIntgeration(definition) {
+    var _this$globalEventHand;
+    var name = definition.name;
+    definition.attachDataLayer({
+      dataLayer: this.dataLayer
+    });
+    var router = this.createRouter();
+    definition.corePresets = {
+      redirectURI: router.makeRedirectURI()
+    };
+    this.integrations.set(name, definition);
+    definition.registerEvents();
+    this.__registerEvents({
+      events: definition.getEvents(),
+      integrationName: name
+    });
+    definition.registerApis();
+    definition._convertApiClientToSystemApis();
+    this.__registerApis({
+      apis: Object.values(definition.getApis()),
+      integrationName: name
+    });
+    (_this$globalEventHand = this.globalEventHandlers).push.apply(_this$globalEventHand, definition.getEventHandlers({
+      makeWebhookUrl: router.makeWebhookUrl
+    }));
+  };
+  _proto.__registerEvents = function __registerEvents(_ref12) {
+    var events = _ref12.events,
+      _ref12$integrationNam = _ref12.integrationName,
+      integrationName = _ref12$integrationNam === void 0 ? this.config.name : _ref12$integrationNam;
+    var integrationEvents = this.globalEvents.get(integrationName) || {};
+    this.globalEvents.set(integrationName, _extends({}, integrationEvents, events));
+  };
+  _proto.__registerApis = function __registerApis(_ref13) {
+    var apis = _ref13.apis,
+      _ref13$integrationNam = _ref13.integrationName,
+      integrationName = _ref13$integrationNam === void 0 ? this.config.name : _ref13$integrationNam;
+    var integrationApis = this.globalApis.get(integrationName) || {};
+    this.globalApis.set(integrationName, _extends({}, integrationApis, apis.reduce(function (acc, api) {
+      var _extends2;
+      return _extends({}, acc, (_extends2 = {}, _extends2[api.type] = api, _extends2));
+    }, {})));
+  };
+  _proto.availableIntegrations = function availableIntegrations() {
+    return Array.from(this.integrations.entries()).map(function (_ref14) {
+      var name = _ref14[0],
+        integration = _ref14[1];
+      return {
+        name: name,
+        integration: integration
+      };
+    });
+  };
+  _proto.getIntegration = function getIntegration(name) {
+    return this.integrations.get(name);
+  };
+  _proto.getGlobalEvents = function getGlobalEvents() {
+    return this.globalEvents;
+  };
+  _proto.getSystemEvents = function getSystemEvents() {
+    var events = this.globalEvents.get(this.config.name);
+    return events || {};
+  };
+  _proto.getEventsByIntegration = function getEventsByIntegration(name) {
+    return this.globalEvents.get(name);
+  };
+  _proto.getGlobalEventHandlers = function getGlobalEventHandlers() {
+    return this.globalEventHandlers;
+  };
+  _proto.getApis = function getApis() {
+    return this.globalApis;
+  };
+  _proto.getSystemApis = function getSystemApis() {
+    return this.globalApis.get(this.config.name);
+  };
+  _proto.getApisByIntegration = function getApisByIntegration(name, includeHidden) {
+    var integrationApis = this.globalApis.get(name);
+    if (includeHidden) {
+      return integrationApis;
+    }
+    return omitBy(integrationApis, function (value) {
+      return value.isHidden;
+    });
+  };
+  _proto.authenticatableIntegrations = function authenticatableIntegrations() {
+    return this.availableIntegrations().filter(function (_ref15) {
+      var integration = _ref15.integration;
+      try {
+        integration.getAuthenticator();
+        return true;
+      } catch (e) {
+        return false;
+      }
+    });
+  };
+  _proto.authenticator = function authenticator(name) {
+    var _int = this.getIntegration(name);
+    if (!_int) {
+      throw new Error("No integration exists for " + name);
+    }
+    return _int.getAuthenticator();
+  };
+  _proto.connectIntegrationByCredential = /*#__PURE__*/function () {
+    var _connectIntegrationByCredential = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref16) {
+      var name, connectionId, credential, authenticator, integration;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            name = _ref16.name, connectionId = _ref16.connectionId, credential = _ref16.credential;
+            authenticator = this.authenticator(name);
+            if (authenticator) {
+              _context4.next = 4;
+              break;
+            }
+            throw new Error("Authenticator for " + name + " not found");
+          case 4:
+            _context4.next = 6;
+            return authenticator.dataAccess.createConnection({
+              connection: {
+                name: name,
+                connectionId: connectionId
+              },
+              credential: credential
+            });
+          case 6:
+            integration = _context4.sent;
+            if (!authenticator.onConnectionCreated) {
+              _context4.next = 10;
+              break;
+            }
+            _context4.next = 10;
+            return authenticator.onConnectionCreated(integration, credential);
+          case 10:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function connectIntegrationByCredential(_x4) {
+      return _connectIntegrationByCredential.apply(this, arguments);
+    }
+    return connectIntegrationByCredential;
+  }();
+  _proto.disconnectIntegration = /*#__PURE__*/function () {
+    var _disconnectIntegration = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_ref17) {
+      var _yield$this$dataLayer;
+      var name, connectionId, integration, k_id, authenticator;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            name = _ref17.name, connectionId = _ref17.connectionId;
+            integration = this.getIntegration(name);
+            _context5.next = 4;
+            return this.dataLayer.getConnection({
+              name: name,
+              connectionId: connectionId
+            });
+          case 4:
+            _context5.t0 = _yield$this$dataLayer = _context5.sent;
+            if (!(_context5.t0 == null)) {
+              _context5.next = 9;
+              break;
+            }
+            _context5.t1 = void 0;
+            _context5.next = 10;
+            break;
+          case 9:
+            _context5.t1 = _yield$this$dataLayer.id;
+          case 10:
+            k_id = _context5.t1;
+            if (k_id) {
+              _context5.next = 13;
+              break;
+            }
+            throw new Error("No connection found for " + name);
+          case 13:
+            if (!(integration != null && integration.dataLayer)) {
+              _context5.next = 16;
+              break;
+            }
+            _context5.next = 16;
+            return integration.onDisconnect({
+              connectionId: connectionId
+            });
+          case 16:
+            if (!((integration == null ? void 0 : integration.config.authType) === IntegrationCredentialType.OAUTH)) {
+              _context5.next = 20;
+              break;
+            }
+            authenticator = this.authenticator(name);
+            _context5.next = 20;
+            return authenticator.revokeAuth({
+              k_id: k_id
+            });
+          case 20:
+            _context5.next = 22;
+            return this.dataLayer.deleteConnection({
+              connectionId: connectionId
+            });
+          case 22:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this);
+    }));
+    function disconnectIntegration(_x5) {
+      return _disconnectIntegration.apply(this, arguments);
+    }
+    return disconnectIntegration;
+  }();
+  _proto.callApi = /*#__PURE__*/function () {
+    var _callApi = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(_ref18) {
+      var _int2$getApis;
+      var _ref18$integrationNam, integrationName, api, payload, _this$globalApis$get, _apiExecutor, _int2, apiExecutor;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            _ref18$integrationNam = _ref18.integrationName, integrationName = _ref18$integrationNam === void 0 ? this.config.name : _ref18$integrationNam, api = _ref18.api, payload = _ref18.payload;
+            if (!(integrationName === this.config.name)) {
+              _context6.next = 6;
+              break;
+            }
+            _apiExecutor = (_this$globalApis$get = this.globalApis.get(this.config.name)) == null ? void 0 : _this$globalApis$get[api];
+            if (_apiExecutor) {
+              _context6.next = 5;
+              break;
+            }
+            throw new Error("No global api exists for " + api);
+          case 5:
+            return _context6.abrupt("return", _apiExecutor.executor(payload));
+          case 6:
+            _int2 = this.getIntegration(integrationName);
+            if (_int2) {
+              _context6.next = 9;
+              break;
+            }
+            throw new Error("No Integration exists for " + integrationName);
+          case 9:
+            apiExecutor = (_int2$getApis = _int2.getApis()) == null ? void 0 : _int2$getApis[api];
+            if (apiExecutor) {
+              _context6.next = 12;
+              break;
+            }
+            throw new Error("No api exists for " + api + " in " + integrationName);
+          case 12:
+            return _context6.abrupt("return", apiExecutor.executor(payload));
+          case 13:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this);
+    }));
+    function callApi(_x6) {
+      return _callApi.apply(this, arguments);
+    }
+    return callApi;
+  }();
+  _proto.subscribeEvent = /*#__PURE__*/function () {
+    var _subscribeEvent = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(_ref19) {
+      var _process$env$INNGEST_;
+      var id, _ref19$interval, interval, _ref19$timeout, timeout, inngestApiUrl, inngestApiToken, startTime, _poll;
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            id = _ref19.id, _ref19$interval = _ref19.interval, interval = _ref19$interval === void 0 ? 5000 : _ref19$interval, _ref19$timeout = _ref19.timeout, timeout = _ref19$timeout === void 0 ? 60000 : _ref19$timeout;
+            inngestApiUrl = process.env.INNGEST_URL;
+            inngestApiToken = (_process$env$INNGEST_ = process.env.INNGEST_SIGNING_KEY) != null ? _process$env$INNGEST_ : '123';
+            startTime = Date.now();
+            _poll = /*#__PURE__*/function () {
+              var _ref20 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+                var response, _yield$response$json, data, error, lastRun, elapsedTime;
+                return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+                  while (1) switch (_context7.prev = _context7.next) {
+                    case 0:
+                      _context7.prev = 0;
+                      _context7.next = 3;
+                      return fetch(inngestApiUrl + "/v1/events/" + id + "/runs", {
+                        method: 'GET',
+                        headers: {
+                          Accept: 'application/json',
+                          Authorization: "Bearer " + inngestApiToken
+                        }
+                      });
+                    case 3:
+                      response = _context7.sent;
+                      if (!response.ok) {
+                        _context7.next = 16;
+                        break;
+                      }
+                      _context7.next = 7;
+                      return response.json();
+                    case 7:
+                      _yield$response$json = _context7.sent;
+                      data = _yield$response$json.data;
+                      error = _yield$response$json.error;
+                      if (!error) {
+                        _context7.next = 12;
+                        break;
+                      }
+                      return _context7.abrupt("return", null);
+                    case 12:
+                      lastRun = data == null ? void 0 : data[0];
+                      if (lastRun) {
+                        _context7.next = 15;
+                        break;
+                      }
+                      return _context7.abrupt("return", null);
+                    case 15:
+                      return _context7.abrupt("return", {
+                        status: lastRun.status,
+                        startedAt: lastRun.run_started_at,
+                        endedAt: lastRun.ended_at
+                      });
+                    case 16:
+                      _context7.next = 21;
+                      break;
+                    case 18:
+                      _context7.prev = 18;
+                      _context7.t0 = _context7["catch"](0);
+                      console.error("Request failed: " + _context7.t0);
+                    case 21:
+                      // Check if timeout has been reached
+                      elapsedTime = Date.now() - startTime;
+                      if (!(elapsedTime >= timeout)) {
+                        _context7.next = 25;
+                        break;
+                      }
+                      console.log('Polling timeout reached.');
+                      return _context7.abrupt("return", null);
+                    case 25:
+                      _context7.next = 27;
+                      return new Promise(function (resolve) {
+                        return setTimeout(resolve, interval);
+                      });
+                    case 27:
+                      return _context7.abrupt("return", _poll());
+                    case 28:
+                    case "end":
+                      return _context7.stop();
+                  }
+                }, _callee7, null, [[0, 18]]);
+              }));
+              return function poll() {
+                return _ref20.apply(this, arguments);
+              };
+            }();
+            return _context8.abrupt("return", _poll());
+          case 6:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    }));
+    function subscribeEvent(_x7) {
+      return _subscribeEvent.apply(this, arguments);
+    }
+    return subscribeEvent;
+  }();
+  _proto.triggerEvent = /*#__PURE__*/function () {
+    var _triggerEvent = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee11(_ref21) {
+      var _this3 = this;
+      var key, data, user, _ref21$integrationNam, integrationName, returnObj, integrationEvents, integrationEvent, event, workflowEvent;
+      return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            key = _ref21.key, data = _ref21.data, user = _ref21.user, _ref21$integrationNam = _ref21.integrationName, integrationName = _ref21$integrationNam === void 0 ? this.config.name : _ref21$integrationNam;
+            _context11.prev = 1;
+            returnObj = {
+              event: {}
+            };
+            integrationEvents = this.globalEvents.get(integrationName);
+            if (integrationEvents) {
+              _context11.next = 6;
+              break;
+            }
+            throw new Error("No events exists for " + integrationName);
+          case 6:
+            integrationEvent = integrationEvents[key];
+            if (integrationEvent) {
+              _context11.next = 9;
+              break;
+            }
+            throw new Error("No event exists for " + key + " in " + integrationName);
+          case 9:
+            _context11.next = 11;
+            return client.send({
+              name: key,
+              data: data,
+              user: user
+            });
+          case 11:
+            event = _context11.sent;
+            returnObj['event'] = _extends({}, event, {
+              subscribe: function () {
+                var _subscribe = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9(_temp) {
+                  var _event$ids;
+                  var _ref22, interval, timeout;
+                  return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+                    while (1) switch (_context9.prev = _context9.next) {
+                      case 0:
+                        _ref22 = _temp === void 0 ? {} : _temp, interval = _ref22.interval, timeout = _ref22.timeout;
+                        return _context9.abrupt("return", _this3.subscribeEvent({
+                          id: (_event$ids = event.ids) == null ? void 0 : _event$ids[0],
+                          interval: interval,
+                          timeout: timeout
+                        }));
+                      case 2:
+                      case "end":
+                        return _context9.stop();
+                    }
+                  }, _callee9);
+                }));
+                function subscribe(_x9) {
+                  return _subscribe.apply(this, arguments);
+                }
+                return subscribe;
+              }()
+            });
+            _context11.next = 15;
+            return client.send({
+              name: 'workflow/run-automations',
+              data: {
+                trigger: key,
+                payload: data
+              },
+              user: user
+            });
+          case 15:
+            workflowEvent = _context11.sent;
+            returnObj['workflowEvent'] = _extends({}, workflowEvent, {
+              subscribe: function () {
+                var _subscribe2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee10(_temp2) {
+                  var _workflowEvent$ids;
+                  var _ref23, interval, timeout;
+                  return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+                    while (1) switch (_context10.prev = _context10.next) {
+                      case 0:
+                        _ref23 = _temp2 === void 0 ? {} : _temp2, interval = _ref23.interval, timeout = _ref23.timeout;
+                        return _context10.abrupt("return", _this3.subscribeEvent({
+                          id: (_workflowEvent$ids = workflowEvent.ids) == null ? void 0 : _workflowEvent$ids[0],
+                          interval: interval,
+                          timeout: timeout
+                        }));
+                      case 2:
+                      case "end":
+                        return _context10.stop();
+                    }
+                  }, _callee10);
+                }));
+                function subscribe(_x10) {
+                  return _subscribe2.apply(this, arguments);
+                }
+                return subscribe;
+              }()
+            });
+            return _context11.abrupt("return", returnObj);
+          case 20:
+            _context11.prev = 20;
+            _context11.t0 = _context11["catch"](1);
+            throw new Error("Error triggering event: " + _context11.t0);
+          case 23:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11, this, [[1, 20]]);
+    }));
+    function triggerEvent(_x8) {
+      return _triggerEvent.apply(this, arguments);
+    }
+    return triggerEvent;
+  }() //TODO: Rename to triggerWorkflowEvent maybe ?
+  ;
+  _proto.triggerSystemEvent =
+  /*#__PURE__*/
+  function () {
+    var _triggerSystemEvent = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee12(_ref24) {
+      var key, data, user, event, systemEvent;
+      return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            key = _ref24.key, data = _ref24.data, user = _ref24.user;
+            _context12.next = 3;
+            return client.send({
+              name: key,
+              data: data,
+              user: user
+            });
+          case 3:
+            event = _context12.sent;
+            systemEvent = this.getSystemEvents()[key];
+            if (!systemEvent) {
+              _context12.next = 8;
+              break;
+            }
+            _context12.next = 8;
+            return client.send({
+              name: 'workflow/run-automations',
+              data: {
+                trigger: key,
+                payload: data
+              },
+              user: user
+            });
+          case 8:
+            return _context12.abrupt("return", event);
+          case 9:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12, this);
+    }));
+    function triggerSystemEvent(_x11) {
+      return _triggerSystemEvent.apply(this, arguments);
+    }
+    return triggerSystemEvent;
+  }();
+  _proto.createRouter = function createRouter() {
+    var self = this;
+    var makeWebhookUrl = function makeWebhookUrl(_ref25) {
+      var _self$config;
+      var event = _ref25.event,
+        name = _ref25.name;
+      return encodeURI("" + (self == null || (_self$config = self.config) == null ? void 0 : _self$config.systemHostURL) + self.routes.webhook + "?name=" + name + "&event=" + event);
+    };
+    var makeRedirectURI = function makeRedirectURI() {
+      return new URL(self.routes.callback, self.config.systemHostURL).toString();
+    };
+    var makeConnectURI = function makeConnectURI(props) {
+      var params = new URLSearchParams(props);
+      return new URL(self.routes.connect + "?" + params.toString(), self.config.systemHostURL).toString();
+    };
+    var registerRoutes = function registerRoutes() {
+      var _registry;
+      var registry = (_registry = {}, _registry[self.routes.connect] = makeConnect(self), _registry[self.routes.callback] = makeCallback(self), _registry[self.routes.inngest] = makeInngest(self), _registry[self.routes.webhook] = makeWebhook(self), _registry);
+      return function (req) {
+        var route = req.nextUrl.pathname;
+        if (req.nextUrl.pathname in registry) {
+          return registry[route](req);
+        }
+        return NextResponse.json(null, {
+          status: 404
+        });
+      };
+    };
+    return {
+      makeWebhookUrl: makeWebhookUrl,
+      makeRedirectURI: makeRedirectURI,
+      makeConnectURI: makeConnectURI,
+      registerRoutes: registerRoutes
+    };
+  };
+  return _createClass(Framework, [{
+    key: "routes",
+    get: function get() {
+      var _this4 = this;
+      var registry = {
+        connect: '/connect',
+        callback: '/connect/callback',
+        inngest: '/inngest',
+        webhook: '/webhook'
+      };
+      return Object.entries(registry).reduce(function (acc, _ref26) {
+        var _extends3;
+        var key = _ref26[0],
+          value = _ref26[1];
+        return _extends({}, acc, (_extends3 = {}, _extends3[key] = "" + _this4.config.routeRegistrationPath + value, _extends3));
+      }, {});
+    }
+  }]);
+}();
+
+export { DataLayer, FieldTypePrimitiveMap, FilterOperatorToSQL, FilterOperators, Framework, Integration, IntegrationAuth, IntegrationCredentialType, IntegrationError, IntegrationErrors, IntegrationFieldTypeEnum, RunStatus, SORT_MODE_TO_ABBR, WorkflowStatusEnum, allowedKey, apiKeyConnectionOptions, buildQueryString, callbackParams, connectParams, constructObjFromStringPath, extractSchemaOptions, fieldsWithCommaSeparatedValues, filterQuerySchema, flattenObject, generateSyncs, getEntityKey, getJSONField, getPath, getResponseDataKey, isLiteralObject, isObjectEmpty, mergeWithDefinedOnly, nextHeaders, oauthState, parseQueryParams, recordHasData, registerRoutes, sortQuerySchema, splitAndStripQuotes, transformFilterValueArray, transformFilterValueBoolean, webhookQueryParams };
+//# sourceMappingURL=core.esm.js.map