@budibase/backend-core 2.27.4 → 2.27.5

package/dist/index.js

@@ -1045,11 +1045,11 @@ var require_Condition = __commonJS({
           return schema.concat(branch.resolve(options3));
         };
       }
-      resolve(base, options2) {
+      resolve(base2, options2) {
         let values2 = this.refs.map((ref) => ref.getValue(options2 == null ? void 0 : options2.value, options2 == null ? void 0 : options2.parent, options2 == null ? void 0 : options2.context));
-        let schema = this.fn.apply(base, values2.concat(base, options2));
-        if (schema === void 0 || schema === base)
-          return base;
+        let schema = this.fn.apply(base2, values2.concat(base2, options2));
+        if (schema === void 0 || schema === base2)
+          return base2;
         if (!(0, _isSchema.default)(schema))
           throw new TypeError("conditions must return a schema object");
         return schema.resolve(options2);
@@ -1439,7 +1439,7 @@ var require_createValidation = __commonJS({
       return target;
     }
     function createValidation(config) {
-      function validate3(_ref, cb) {
+      function validate4(_ref, cb) {
         let {
           value,
           path: path3 = "",
@@ -1514,8 +1514,8 @@ var require_createValidation = __commonJS({
         else
           cb(null, result);
       }
-      validate3.OPTIONS = config;
-      return validate3;
+      validate4.OPTIONS = config;
+      return validate4;
     }
   }
 });
@@ -1759,17 +1759,17 @@ var require_schema = __commonJS({
           return this;
         if (schema.type !== this.type && this.type !== "mixed")
           throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema.type}`);
-        let base = this;
+        let base2 = this;
         let combined = schema.clone();
-        const mergedSpec = _extends({}, base.spec, combined.spec);
+        const mergedSpec = _extends({}, base2.spec, combined.spec);
         combined.spec = mergedSpec;
-        combined._typeError || (combined._typeError = base._typeError);
-        combined._whitelistError || (combined._whitelistError = base._whitelistError);
-        combined._blacklistError || (combined._blacklistError = base._blacklistError);
-        combined._whitelist = base._whitelist.merge(schema._whitelist, schema._blacklist);
-        combined._blacklist = base._blacklist.merge(schema._blacklist, schema._whitelist);
-        combined.tests = base.tests;
-        combined.exclusiveTests = base.exclusiveTests;
+        combined._typeError || (combined._typeError = base2._typeError);
+        combined._whitelistError || (combined._whitelistError = base2._whitelistError);
+        combined._blacklistError || (combined._blacklistError = base2._blacklistError);
+        combined._whitelist = base2._whitelist.merge(schema._whitelist, schema._blacklist);
+        combined._blacklist = base2._blacklist.merge(schema._blacklist, schema._whitelist);
+        combined.tests = base2.tests;
+        combined.exclusiveTests = base2.exclusiveTests;
         combined.withMutation((next) => {
           schema.tests.forEach((fn) => {
             next.test(fn.OPTIONS);
@@ -2024,7 +2024,7 @@ attempted value: ${formattedValue}
         if (typeof opts.test !== "function")
           throw new TypeError("`test` is a required parameters");
         let next = this.clone();
-        let validate3 = (0, _createValidation.default)(opts);
+        let validate4 = (0, _createValidation.default)(opts);
         let isExclusive = opts.exclusive || opts.name && next.exclusiveTests[opts.name] === true;
         if (opts.exclusive) {
           if (!opts.name)
@@ -2036,12 +2036,12 @@ attempted value: ${formattedValue}
           if (fn.OPTIONS.name === opts.name) {
             if (isExclusive)
               return false;
-            if (fn.OPTIONS.test === validate3.OPTIONS.test)
+            if (fn.OPTIONS.test === validate4.OPTIONS.test)
               return false;
           }
           return true;
         });
-        next.tests.push(validate3);
+        next.tests.push(validate4);
         return next;
       }
       when(keys2, options2) {
@@ -3145,9 +3145,9 @@ var require_object = __commonJS({
         return this.transformKeys((key) => (0, _snakeCase.default)(key).toUpperCase());
       }
       describe() {
-        let base = super.describe();
-        base.fields = (0, _mapValues.default)(this.fields, (value) => value.describe());
-        return base;
+        let base2 = super.describe();
+        base2.fields = (0, _mapValues.default)(this.fields, (value) => value.describe());
+        return base2;
       }
     };
     exports.default = ObjectSchema;
@@ -3354,10 +3354,10 @@ var require_array = __commonJS({
         return this.transform((values2) => values2 != null ? values2.filter(reject) : values2);
       }
       describe() {
-        let base = super.describe();
+        let base2 = super.describe();
         if (this.innerType)
-          base.innerType = this.innerType.describe();
-        return base;
+          base2.innerType = this.innerType.describe();
+        return base2;
       }
       nullable(isNullable = true) {
         return super.nullable(isNullable);
@@ -15440,7 +15440,7 @@ var require_cookie = __commonJS({
       c.value = cookieValue;
       return c;
     }
-    function parse(str, options2) {
+    function parse2(str, options2) {
       if (!options2 || typeof options2 !== "object") {
         options2 = {};
       }
@@ -15622,7 +15622,7 @@ var require_cookie = __commonJS({
       });
     }
     Cookie2.cookiesCreated = 0;
-    Cookie2.parse = parse;
+    Cookie2.parse = parse2;
     Cookie2.fromJSON = fromJSON;
     Cookie2.prototype.key = "";
     Cookie2.prototype.value = "";
@@ -15685,7 +15685,7 @@ var require_cookie = __commonJS({
     Cookie2.prototype.clone = function() {
       return fromJSON(this.toJSON());
     };
-    Cookie2.prototype.validate = function validate3() {
+    Cookie2.prototype.validate = function validate4() {
       if (!COOKIE_OCTETS.test(this.value)) {
         return false;
       }
@@ -16179,7 +16179,7 @@ var require_cookie = __commonJS({
     exports.MemoryCookieStore = MemoryCookieStore;
     exports.parseDate = parseDate;
     exports.formatDate = formatDate;
-    exports.parse = parse;
+    exports.parse = parse2;
     exports.fromJSON = fromJSON;
     exports.domainMatch = domainMatch;
     exports.defaultPath = defaultPath;
@@ -16381,7 +16381,7 @@ var require_aws_sign2 = __commonJS({
   "../../node_modules/aws-sign2/index.js"(exports, module2) {
     "use strict";
     var crypto2 = require("crypto");
-    var parse = require("url").parse;
+    var parse2 = require("url").parse;
     var keys2 = [
       "acl",
       "location",
@@ -16447,7 +16447,7 @@ var require_aws_sign2 = __commonJS({
     }
     module2.exports.canonicalizeHeaders = canonicalizeHeaders;
     function canonicalizeResource(resource) {
-      var url = parse(resource, true), path3 = url.pathname, buf = [];
+      var url = parse2(resource, true), path3 = url.pathname, buf = [];
       Object.keys(url.query).forEach(function(key) {
         if (!~keys2.indexOf(key))
           return;
@@ -29966,7 +29966,7 @@ var require_validate = __commonJS({
         root.jsonSchema = factory();
       }
     })(exports, function() {
-      var exports2 = validate3;
+      var exports2 = validate4;
       exports2.Integer = { type: "integer" };
       var primitiveConstructors = {
         String,
@@ -29976,15 +29976,15 @@ var require_validate = __commonJS({
         Array,
         Date
       };
-      exports2.validate = validate3;
-      function validate3(instance, schema) {
-        return validate3(instance, schema, { changing: false });
+      exports2.validate = validate4;
+      function validate4(instance, schema) {
+        return validate4(instance, schema, { changing: false });
       }
       ;
       exports2.checkPropertyChange = function(value, schema, property) {
-        return validate3(value, schema, { changing: property || "property" });
+        return validate4(value, schema, { changing: property || "property" });
       };
-      var validate3 = exports2._validate = function(instance, schema, options2) {
+      var validate4 = exports2._validate = function(instance, schema, options2) {
         if (!options2)
           options2 = {};
         var _changing = options2.changing;
@@ -30460,7 +30460,7 @@ var require_jsprim = __commonJS({
       }
       var c;
       var pbase = -1;
-      var base = options2.base;
+      var base2 = options2.base;
       var start2;
       var mult = 1;
       var value = 0;
@@ -30482,19 +30482,19 @@ var require_jsprim = __commonJS({
       if (str[idx] === "0") {
         if (options2.allowPrefix) {
           pbase = prefixToBase(str.charCodeAt(idx + 1));
-          if (pbase !== -1 && (!baseOverride || pbase === base)) {
-            base = pbase;
+          if (pbase !== -1 && (!baseOverride || pbase === base2)) {
+            base2 = pbase;
             idx += 2;
           }
         }
         if (pbase === -1 && options2.leadingZeroIsOctal) {
-          base = 8;
+          base2 = 8;
         }
       }
       for (start2 = idx; idx < len; ++idx) {
         c = translateDigit(str.charCodeAt(idx));
-        if (c !== -1 && c < base) {
-          value *= base;
+        if (c !== -1 && c < base2) {
+          value *= base2;
           value += c;
         } else {
           break;
@@ -41274,11 +41274,11 @@ var require_lib7 = __commonJS({
   "../../node_modules/request/node_modules/qs/lib/index.js"(exports, module2) {
     "use strict";
     var stringify = require_stringify2();
-    var parse = require_parse();
+    var parse2 = require_parse();
     var formats2 = require_formats();
     module2.exports = {
       formats: formats2,
-      parse,
+      parse: parse2,
       stringify
     };
   }
@@ -41444,7 +41444,7 @@ var require_uri_all = __commonJS({
         }
       };
       var maxInt = 2147483647;
-      var base = 36;
+      var base2 = 36;
       var tMin = 1;
       var tMax = 26;
       var skew = 38;
@@ -41460,7 +41460,7 @@ var require_uri_all = __commonJS({
         "not-basic": "Illegal input >= 0x80 (not a basic code point)",
         "invalid-input": "Invalid input"
       };
-      var baseMinusTMin = base - tMin;
+      var baseMinusTMin = base2 - tMin;
       var floor = Math.floor;
       var stringFromCharCode = String.fromCharCode;
       function error$1(type) {
@@ -41519,7 +41519,7 @@ var require_uri_all = __commonJS({
         if (codePoint - 97 < 26) {
           return codePoint - 97;
         }
-        return base;
+        return base2;
       };
       var digitToBasic = function digitToBasic2(digit, flag) {
         return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
@@ -41532,7 +41532,7 @@ var require_uri_all = __commonJS({
           ;
           /* no initialization */
           delta > baseMinusTMin * tMax >> 1;
-          k += base
+          k += base2
         ) {
           delta = floor(delta / baseMinusTMin);
         }
@@ -41557,16 +41557,16 @@ var require_uri_all = __commonJS({
         for (var index2 = basic > 0 ? basic + 1 : 0; index2 < inputLength; ) {
           var oldi = i;
           for (
-            var w = 1, k = base;
+            var w = 1, k = base2;
             ;
             /* no condition */
-            k += base
+            k += base2
           ) {
             if (index2 >= inputLength) {
               error$1("invalid-input");
             }
             var digit = basicToDigit(input.charCodeAt(index2++));
-            if (digit >= base || digit > floor((maxInt - i) / w)) {
+            if (digit >= base2 || digit > floor((maxInt - i) / w)) {
               error$1("overflow");
             }
             i += digit * w;
@@ -41574,7 +41574,7 @@ var require_uri_all = __commonJS({
             if (digit < t) {
               break;
             }
-            var baseMinusT = base - t;
+            var baseMinusT = base2 - t;
             if (w > floor(maxInt / baseMinusT)) {
               error$1("overflow");
             }
@@ -41671,17 +41671,17 @@ var require_uri_all = __commonJS({
               if (_currentValue == n) {
                 var q2 = delta;
                 for (
-                  var k = base;
+                  var k = base2;
                   ;
                   /* no condition */
-                  k += base
+                  k += base2
                 ) {
                   var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
                   if (q2 < t) {
                     break;
                   }
                   var qMinusT = q2 - t;
-                  var baseMinusT = base - t;
+                  var baseMinusT = base2 - t;
                   output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
                   q2 = floor(qMinusT / baseMinusT);
                 }
@@ -41870,7 +41870,7 @@ var require_uri_all = __commonJS({
       }
       var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i;
       var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === void 0;
-      function parse(uriString) {
+      function parse2(uriString) {
         var options2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
         var components = {};
         var protocol = options2.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
@@ -42036,13 +42036,13 @@ var require_uri_all = __commonJS({
         }
         return uriTokens.join("");
       }
-      function resolveComponents(base2, relative) {
+      function resolveComponents(base3, relative) {
         var options2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
         var skipNormalization = arguments[3];
         var target = {};
         if (!skipNormalization) {
-          base2 = parse(serialize(base2, options2), options2);
-          relative = parse(serialize(relative, options2), options2);
+          base3 = parse2(serialize(base3, options2), options2);
+          relative = parse2(serialize(relative, options2), options2);
         }
         options2 = options2 || {};
         if (!options2.tolerant && relative.scheme) {
@@ -42061,56 +42061,56 @@ var require_uri_all = __commonJS({
             target.query = relative.query;
           } else {
             if (!relative.path) {
-              target.path = base2.path;
+              target.path = base3.path;
               if (relative.query !== void 0) {
                 target.query = relative.query;
               } else {
-                target.query = base2.query;
+                target.query = base3.query;
               }
             } else {
               if (relative.path.charAt(0) === "/") {
                 target.path = removeDotSegments(relative.path);
               } else {
-                if ((base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0) && !base2.path) {
+                if ((base3.userinfo !== void 0 || base3.host !== void 0 || base3.port !== void 0) && !base3.path) {
                   target.path = "/" + relative.path;
-                } else if (!base2.path) {
+                } else if (!base3.path) {
                   target.path = relative.path;
                 } else {
-                  target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative.path;
+                  target.path = base3.path.slice(0, base3.path.lastIndexOf("/") + 1) + relative.path;
                 }
                 target.path = removeDotSegments(target.path);
               }
               target.query = relative.query;
             }
-            target.userinfo = base2.userinfo;
-            target.host = base2.host;
-            target.port = base2.port;
+            target.userinfo = base3.userinfo;
+            target.host = base3.host;
+            target.port = base3.port;
           }
-          target.scheme = base2.scheme;
+          target.scheme = base3.scheme;
         }
         target.fragment = relative.fragment;
         return target;
       }
       function resolve(baseURI, relativeURI, options2) {
         var schemelessOptions = assign({ scheme: "null" }, options2);
-        return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
+        return serialize(resolveComponents(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
       }
       function normalize(uri, options2) {
         if (typeof uri === "string") {
-          uri = serialize(parse(uri, options2), options2);
+          uri = serialize(parse2(uri, options2), options2);
         } else if (typeOf(uri) === "object") {
-          uri = parse(serialize(uri, options2), options2);
+          uri = parse2(serialize(uri, options2), options2);
         }
         return uri;
       }
       function equal(uriA, uriB, options2) {
         if (typeof uriA === "string") {
-          uriA = serialize(parse(uriA, options2), options2);
+          uriA = serialize(parse2(uriA, options2), options2);
         } else if (typeOf(uriA) === "object") {
           uriA = serialize(uriA, options2);
         }
         if (typeof uriB === "string") {
-          uriB = serialize(parse(uriB, options2), options2);
+          uriB = serialize(parse2(uriB, options2), options2);
         } else if (typeOf(uriB) === "object") {
           uriB = serialize(uriB, options2);
         }
@@ -42125,7 +42125,7 @@ var require_uri_all = __commonJS({
       var handler = {
         scheme: "http",
         domainHost: true,
-        parse: function parse2(components, options2) {
+        parse: function parse3(components, options2) {
           if (!components.host) {
             components.error = components.error || "HTTP URIs must have a host.";
           }
@@ -42154,7 +42154,7 @@ var require_uri_all = __commonJS({
       var handler$2 = {
         scheme: "ws",
         domainHost: true,
-        parse: function parse2(components, options2) {
+        parse: function parse3(components, options2) {
           var wsComponents = components;
           wsComponents.secure = isSecure(wsComponents);
           wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
@@ -42330,7 +42330,7 @@ var require_uri_all = __commonJS({
       var UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/;
       var handler$6 = {
         scheme: "urn:uuid",
-        parse: function parse2(urnComponents, options2) {
+        parse: function parse3(urnComponents, options2) {
           var uuidComponents = urnComponents;
           uuidComponents.uuid = uuidComponents.nss;
           uuidComponents.nss = void 0;
@@ -42355,7 +42355,7 @@ var require_uri_all = __commonJS({
       exports2.SCHEMES = SCHEMES;
       exports2.pctEncChar = pctEncChar;
       exports2.pctDecChars = pctDecChars;
-      exports2.parse = parse;
+      exports2.parse = parse2;
       exports2.removeDotSegments = removeDotSegments;
       exports2.serialize = serialize;
       exports2.resolveComponents = resolveComponents;
@@ -43588,9 +43588,9 @@ var require_compile = __commonJS({
         endCompiling.call(this, schema, root, baseId);
       }
       function callValidate() {
-        var validate3 = compilation.validate;
-        var result = validate3.apply(this, arguments);
-        callValidate.errors = validate3.errors;
+        var validate4 = compilation.validate;
+        var result = validate4.apply(this, arguments);
+        callValidate.errors = validate4.errors;
         return result;
       }
       function localCompile(_schema, _root, localRefs2, baseId2) {
@@ -43624,7 +43624,7 @@ var require_compile = __commonJS({
         sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode) + vars(defaults, defaultCode) + vars(customRules, customRuleCode) + sourceCode;
         if (opts.processCode)
           sourceCode = opts.processCode(sourceCode, _schema);
-        var validate3;
+        var validate4;
         try {
           var makeValidate = new Function(
             "self",
@@ -43639,7 +43639,7 @@ var require_compile = __commonJS({
             "ValidationError",
             sourceCode
           );
-          validate3 = makeValidate(
+          validate4 = makeValidate(
             self2,
             RULES,
             formats2,
@@ -43651,26 +43651,26 @@ var require_compile = __commonJS({
             ucs2length,
             ValidationError
           );
-          refVal[0] = validate3;
+          refVal[0] = validate4;
         } catch (e) {
           self2.logger.error("Error compiling schema, function code:", sourceCode);
           throw e;
         }
-        validate3.schema = _schema;
-        validate3.errors = null;
-        validate3.refs = refs;
-        validate3.refVal = refVal;
-        validate3.root = isRoot ? validate3 : _root;
+        validate4.schema = _schema;
+        validate4.errors = null;
+        validate4.refs = refs;
+        validate4.refVal = refVal;
+        validate4.root = isRoot ? validate4 : _root;
         if ($async)
-          validate3.$async = true;
+          validate4.$async = true;
         if (opts.sourceCode === true) {
-          validate3.source = {
+          validate4.source = {
             code: sourceCode,
             patterns,
             defaults
           };
         }
-        return validate3;
+        return validate4;
       }
       function resolveRef(baseId2, ref, isRoot) {
         ref = resolve.url(baseId2, ref);
@@ -43767,27 +43767,27 @@ var require_compile = __commonJS({
           }
         }
         var compile2 = rule.definition.compile, inline = rule.definition.inline, macro = rule.definition.macro;
-        var validate3;
+        var validate4;
         if (compile2) {
-          validate3 = compile2.call(self2, schema2, parentSchema, it);
+          validate4 = compile2.call(self2, schema2, parentSchema, it);
         } else if (macro) {
-          validate3 = macro.call(self2, schema2, parentSchema, it);
+          validate4 = macro.call(self2, schema2, parentSchema, it);
           if (opts.validateSchema !== false)
-            self2.validateSchema(validate3, true);
+            self2.validateSchema(validate4, true);
         } else if (inline) {
-          validate3 = inline.call(self2, it, rule.keyword, schema2, parentSchema);
+          validate4 = inline.call(self2, it, rule.keyword, schema2, parentSchema);
         } else {
-          validate3 = rule.definition.validate;
-          if (!validate3)
+          validate4 = rule.definition.validate;
+          if (!validate4)
             return;
         }
-        if (validate3 === void 0)
+        if (validate4 === void 0)
           throw new Error('custom keyword "' + rule.keyword + '"failed to compile');
         var index2 = customRules.length;
-        customRules[index2] = validate3;
+        customRules[index2] = validate4;
         return {
           code: "customRule" + index2,
-          validate: validate3
+          validate: validate4
         };
       }
     }
@@ -47338,7 +47338,7 @@ var require_ajv = __commonJS({
     var $dataMetaSchema = require_data();
     var util = require_util2();
     module2.exports = Ajv;
-    Ajv.prototype.validate = validate3;
+    Ajv.prototype.validate = validate4;
     Ajv.prototype.compile = compile;
     Ajv.prototype.addSchema = addSchema;
     Ajv.prototype.addMetaSchema = addMetaSchema;
@@ -47393,7 +47393,7 @@ var require_ajv = __commonJS({
         this.addKeyword("nullable", { metaSchema: { type: "boolean" } });
       addInitialSchemas(this);
     }
-    function validate3(schemaKeyRef, data) {
+    function validate4(schemaKeyRef, data) {
       var v;
       if (typeof schemaKeyRef == "string") {
         v = this.getSchema(schemaKeyRef);
@@ -48611,68 +48611,68 @@ var require_promise = __commonJS({
       ajv2.addSchema(schemas);
       return ajv2;
     }
-    function validate3(name, data) {
+    function validate4(name, data) {
       data = data || {};
       ajv = ajv || createAjvInstance();
-      var validate4 = ajv.getSchema(name + ".json");
+      var validate5 = ajv.getSchema(name + ".json");
       return new Promise(function(resolve, reject) {
-        var valid = validate4(data);
-        !valid ? reject(new HARError(validate4.errors)) : resolve(data);
+        var valid = validate5(data);
+        !valid ? reject(new HARError(validate5.errors)) : resolve(data);
       });
     }
     exports.afterRequest = function(data) {
-      return validate3("afterRequest", data);
+      return validate4("afterRequest", data);
     };
     exports.beforeRequest = function(data) {
-      return validate3("beforeRequest", data);
+      return validate4("beforeRequest", data);
     };
     exports.browser = function(data) {
-      return validate3("browser", data);
+      return validate4("browser", data);
     };
     exports.cache = function(data) {
-      return validate3("cache", data);
+      return validate4("cache", data);
     };
     exports.content = function(data) {
-      return validate3("content", data);
+      return validate4("content", data);
     };
     exports.cookie = function(data) {
-      return validate3("cookie", data);
+      return validate4("cookie", data);
     };
     exports.creator = function(data) {
-      return validate3("creator", data);
+      return validate4("creator", data);
     };
     exports.entry = function(data) {
-      return validate3("entry", data);
+      return validate4("entry", data);
     };
     exports.har = function(data) {
-      return validate3("har", data);
+      return validate4("har", data);
     };
     exports.header = function(data) {
-      return validate3("header", data);
+      return validate4("header", data);
     };
     exports.log = function(data) {
-      return validate3("log", data);
+      return validate4("log", data);
     };
     exports.page = function(data) {
-      return validate3("page", data);
+      return validate4("page", data);
     };
     exports.pageTimings = function(data) {
-      return validate3("pageTimings", data);
+      return validate4("pageTimings", data);
     };
     exports.postData = function(data) {
-      return validate3("postData", data);
+      return validate4("postData", data);
     };
     exports.query = function(data) {
-      return validate3("query", data);
+      return validate4("query", data);
     };
     exports.request = function(data) {
-      return validate3("request", data);
+      return validate4("request", data);
     };
     exports.response = function(data) {
-      return validate3("response", data);
+      return validate4("response", data);
     };
     exports.timings = function(data) {
-      return validate3("timings", data);
+      return validate4("timings", data);
     };
   }
 });
@@ -48683,7 +48683,7 @@ var require_har2 = __commonJS({
     "use strict";
     var fs5 = require("fs");
     var qs2 = require("querystring");
-    var validate3 = require_promise();
+    var validate4 = require_promise();
     var extend = require_extend();
     function Har(request) {
       this.request = request;
@@ -48780,7 +48780,7 @@ var require_har2 = __commonJS({
       har.bodySize = 0;
       har.headersSize = 0;
       har.postData.size = 0;
-      if (!validate3.request(har)) {
+      if (!validate4.request(har)) {
         return options2;
       }
       var req = this.prep(har);
@@ -49012,33 +49012,33 @@ var require_oauth_sign = __commonJS({
       }).map(function(p) {
         return p.join("=");
       }).join("&");
-      var base = [
+      var base2 = [
         rfc3986(httpMethod ? httpMethod.toUpperCase() : "GET"),
         rfc3986(base_uri),
         rfc3986(normalized)
       ].join("&");
-      return base;
+      return base2;
     }
     function hmacsign(httpMethod, base_uri, params2, consumer_secret, token_secret) {
-      var base = generateBase(httpMethod, base_uri, params2);
+      var base2 = generateBase(httpMethod, base_uri, params2);
       var key = [
         consumer_secret || "",
         token_secret || ""
       ].map(rfc3986).join("&");
-      return sha(key, base, "sha1");
+      return sha(key, base2, "sha1");
     }
     function hmacsign256(httpMethod, base_uri, params2, consumer_secret, token_secret) {
-      var base = generateBase(httpMethod, base_uri, params2);
+      var base2 = generateBase(httpMethod, base_uri, params2);
       var key = [
         consumer_secret || "",
         token_secret || ""
       ].map(rfc3986).join("&");
-      return sha(key, base, "sha256");
+      return sha(key, base2, "sha256");
     }
     function rsasign(httpMethod, base_uri, params2, private_key, token_secret) {
-      var base = generateBase(httpMethod, base_uri, params2);
+      var base2 = generateBase(httpMethod, base_uri, params2);
       var key = private_key || "";
-      return rsa(key, base);
+      return rsa(key, base2);
     }
     function plaintext(consumer_secret, token_secret) {
       var key = [
@@ -50836,16 +50836,16 @@ var require_request2 = __commonJS({
     };
     Request.prototype.qs = function(q2, clobber) {
       var self2 = this;
-      var base;
+      var base2;
       if (!clobber && self2.uri.query) {
-        base = self2._qs.parse(self2.uri.query);
+        base2 = self2._qs.parse(self2.uri.query);
       } else {
-        base = {};
+        base2 = {};
       }
       for (var i in q2) {
-        base[i] = q2[i];
+        base2[i] = q2[i];
       }
-      var qs2 = self2._qs.stringify(base);
+      var qs2 = self2._qs.stringify(base2);
       if (qs2 === "") {
         return self2;
       }
@@ -54139,6 +54139,11 @@ __export(src_exports, {
   BudibaseError: () => BudibaseError,
   Config: () => Config,
   Cookie: () => Cookie,
+  DEFAULT_BB_DATASOURCE_ID: () => DEFAULT_BB_DATASOURCE_ID,
+  DEFAULT_EMPLOYEE_TABLE_ID: () => DEFAULT_EMPLOYEE_TABLE_ID,
+  DEFAULT_EXPENSES_TABLE_ID: () => DEFAULT_EXPENSES_TABLE_ID,
+  DEFAULT_INVENTORY_TABLE_ID: () => DEFAULT_INVENTORY_TABLE_ID,
+  DEFAULT_JOBS_TABLE_ID: () => DEFAULT_JOBS_TABLE_ID,
   DEFAULT_TENANT_ID: () => DEFAULT_TENANT_ID,
   DeprecatedViews: () => DeprecatedViews,
   DocumentType: () => DocumentType,
@@ -54158,6 +54163,7 @@ __export(src_exports, {
   RedisClient: () => redis_default,
   SEPARATOR: () => SEPARATOR,
   SQLITE_DESIGN_DOC_ID: () => SQLITE_DESIGN_DOC_ID,
+  SQS_DATASOURCE_INTERNAL: () => SQS_DATASOURCE_INTERNAL,
   StaticDatabases: () => StaticDatabases,
   UNICODE_MAX: () => UNICODE_MAX,
   UsageLimitError: () => UsageLimitError,
@@ -54195,6 +54201,7 @@ __export(src_exports, {
   roles: () => roles_exports,
   security: () => security_exports,
   sessions: () => sessions_exports,
+  sql: () => sql_exports,
   tenancy: () => tenancy,
   timers: () => timers_exports,
   userUtils: () => utils_exports4,
@@ -54563,6 +54570,19 @@ var AutomationStepIdArray = [
   ...Object.values(AutomationTriggerStepId)
 ];
 
+// ../types/src/documents/app/table/table.ts
+var INTERNAL_TABLE_SOURCE_ID = "bb_internal";
+
+// ../types/src/documents/app/row.ts
+var JsonTypes = [
+  "attachment_single" /* ATTACHMENT_SINGLE */,
+  "attachment" /* ATTACHMENTS */,
+  // only BB_REFERENCE is JSON, it's an array, BB_REFERENCE_SINGLE is a string type
+  "bb_reference" /* BB_REFERENCE */,
+  "json" /* JSON */,
+  "array" /* ARRAY */
+];
+
 // ../types/src/documents/document.ts
 var SEPARATOR = "_";
 var UNICODE_MAX = "\uFFF0";
@@ -54645,6 +54665,11 @@ __export(constants_exports2, {
   BUDIBASE_DATASOURCE_TYPE: () => BUDIBASE_DATASOURCE_TYPE,
   Config: () => Config,
   Cookie: () => Cookie,
+  DEFAULT_BB_DATASOURCE_ID: () => DEFAULT_BB_DATASOURCE_ID,
+  DEFAULT_EMPLOYEE_TABLE_ID: () => DEFAULT_EMPLOYEE_TABLE_ID,
+  DEFAULT_EXPENSES_TABLE_ID: () => DEFAULT_EXPENSES_TABLE_ID,
+  DEFAULT_INVENTORY_TABLE_ID: () => DEFAULT_INVENTORY_TABLE_ID,
+  DEFAULT_JOBS_TABLE_ID: () => DEFAULT_JOBS_TABLE_ID,
   DEFAULT_TENANT_ID: () => DEFAULT_TENANT_ID,
   DeprecatedViews: () => DeprecatedViews,
   DocumentType: () => DocumentType,
@@ -54655,6 +54680,7 @@ __export(constants_exports2, {
   MIN_VALID_DATE: () => MIN_VALID_DATE,
   SEPARATOR: () => SEPARATOR,
   SQLITE_DESIGN_DOC_ID: () => SQLITE_DESIGN_DOC_ID,
+  SQS_DATASOURCE_INTERNAL: () => SQS_DATASOURCE_INTERNAL,
   StaticDatabases: () => StaticDatabases,
   UNICODE_MAX: () => UNICODE_MAX,
   UserStatus: () => UserStatus,
@@ -54715,8 +54741,14 @@ var StaticDatabases = {
 var APP_PREFIX = prefixed("app" /* APP */);
 var APP_DEV = prefixed("app_dev" /* APP_DEV */);
 var APP_DEV_PREFIX = APP_DEV;
+var SQS_DATASOURCE_INTERNAL = "internal";
 var BUDIBASE_DATASOURCE_TYPE = "budibase";
 var SQLITE_DESIGN_DOC_ID = "_design/sqlite";
+var DEFAULT_JOBS_TABLE_ID = "ta_bb_jobs";
+var DEFAULT_INVENTORY_TABLE_ID = "ta_bb_inventory";
+var DEFAULT_EXPENSES_TABLE_ID = "ta_bb_expenses";
+var DEFAULT_EMPLOYEE_TABLE_ID = "ta_bb_employee";
+var DEFAULT_BB_DATASOURCE_ID = "datasource_internal_bb_default";
 
 // ../shared-core/src/constants/api.ts
 var Header = /* @__PURE__ */ ((Header2) => {
@@ -54854,6 +54886,19 @@ __export(filters_exports, {
 });
 var import_dayjs = __toESM(require_dayjs_min());
 
+// ../shared-core/src/helpers/index.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  cron: () => cron_exports,
+  deepGet: () => deepGet,
+  getUserColor: () => getUserColor,
+  getUserInitials: () => getUserInitials,
+  getUserLabel: () => getUserLabel,
+  isGoogleSheets: () => isGoogleSheets,
+  isSQL: () => isSQL,
+  schema: () => schema_exports
+});
+
 // ../shared-core/src/helpers/helpers.ts
 var deepGet = (obj, key) => {
   if (!obj || !key) {
@@ -54868,9 +54913,110 @@ var deepGet = (obj, key) => {
   }
   return obj;
 };
+var getUserInitials = (user) => {
+  if (!user) {
+    return "?";
+  }
+  let initials = "";
+  initials += user.firstName ? user.firstName[0] : "";
+  initials += user.lastName ? user.lastName[0] : "";
+  if (initials !== "") {
+    return initials;
+  }
+  return user.email?.[0] || "U";
+};
+var getUserColor = (user) => {
+  let id = user?._id;
+  if (!id) {
+    return "var(--spectrum-global-color-blue-400)";
+  }
+  id = id.replace("ro_ta_users_", "");
+  let hue = 1;
+  for (let i = 0; i < id.length; i++) {
+    hue += id.charCodeAt(i);
+    hue = hue % 36;
+  }
+  return `hsl(${hue * 10}, 50%, 40%)`;
+};
+var getUserLabel = (user) => {
+  if (!user) {
+    return "";
+  }
+  const { firstName, lastName, email } = user;
+  if (firstName && lastName) {
+    return `${firstName} ${lastName}`;
+  } else if (firstName) {
+    return firstName;
+  } else if (lastName) {
+    return lastName;
+  } else {
+    return email;
+  }
+};
+
+// ../shared-core/src/helpers/integrations.ts
+function isGoogleSheets(type) {
+  return type === "GOOGLE_SHEETS" /* GOOGLE_SHEETS */;
+}
+function isSQL(datasource2) {
+  if (!datasource2 || !datasource2.source) {
+    return false;
+  }
+  const SQL = [
+    "POSTGRES" /* POSTGRES */,
+    "SQL_SERVER" /* SQL_SERVER */,
+    "MYSQL" /* MYSQL */,
+    "ORACLE" /* ORACLE */
+  ];
+  return SQL.indexOf(datasource2.source) !== -1 || datasource2.isSQL === true;
+}
 
 // ../shared-core/src/helpers/cron.ts
+var cron_exports = {};
+__export(cron_exports, {
+  validate: () => validate
+});
 var import_cron_validate = __toESM(require_lib2());
+var INPUT_CRON_START = "(Input cron: ";
+var ERROR_SWAPS = {
+  "smaller than lower limit": "less than",
+  "bigger than upper limit": "greater than",
+  daysOfMonth: "'days of the month'",
+  daysOfWeek: "'days of the week'",
+  years: "'years'",
+  months: "'months'",
+  hours: "'hours'",
+  minutes: "'minutes'",
+  seconds: "'seconds'"
+};
+function improveErrors(errors) {
+  const finalErrors = [];
+  for (let error of errors) {
+    if (error.includes(INPUT_CRON_START)) {
+      error = error.split(INPUT_CRON_START)[0].trim();
+    }
+    for (let [oldErr, newErr] of Object.entries(ERROR_SWAPS)) {
+      if (error.includes(oldErr)) {
+        error = error.replace(new RegExp(oldErr, "g"), newErr);
+      }
+    }
+    finalErrors.push(error);
+  }
+  return finalErrors;
+}
+function validate(cronExpression) {
+  const result = (0, import_cron_validate.default)(cronExpression, {
+    preset: "npm-node-cron",
+    override: {
+      useSeconds: false
+    }
+  });
+  if (!result.isValid()) {
+    return { valid: false, err: improveErrors(result.getError()) };
+  } else {
+    return { valid: true };
+  }
+}
 
 // ../shared-core/src/helpers/schema.ts
 var schema_exports = {};
@@ -55191,10 +55337,10 @@ var luceneSort = (docs, sort, sortOrder, sortType = "string" /* STRING */) => {
   if (!sort || !sortOrder || !sortType) {
     return docs;
   }
-  const parse = sortType === "string" ? (x) => `${x}` : (x) => parseFloat(x);
+  const parse2 = sortType === "string" ? (x) => `${x}` : (x) => parseFloat(x);
   return docs.slice().sort((a, b) => {
-    const colA = parse(a[sort]);
-    const colB = parse(b[sort]);
+    const colA = parse2(a[sort]);
+    const colB = parse2(b[sort]);
     if (sortOrder.toLowerCase() === "descending") {
       return colA > colB ? -1 : 1;
     } else {
@@ -55749,6 +55895,9 @@ var environment = {
   DEPLOYMENT_ENVIRONMENT: process.env.DEPLOYMENT_ENVIRONMENT || "docker-compose",
   HTTP_LOGGING: httpLogging(),
   ENABLE_AUDIT_LOG_IP_ADDR: process.env.ENABLE_AUDIT_LOG_IP_ADDR,
+  // Couch/search
+  SQL_LOGGING_ENABLE: process.env.SQL_LOGGING_ENABLE,
+  SQL_MAX_ROWS: process.env.SQL_MAX_ROWS,
   // smtp
   SMTP_FALLBACK_ENABLED: process.env.SMTP_FALLBACK_ENABLED,
   SMTP_USER: process.env.SMTP_USER,
@@ -57089,6 +57238,11 @@ __export(db_exports, {
   BUDIBASE_DATASOURCE_TYPE: () => BUDIBASE_DATASOURCE_TYPE,
   CONSTANT_EXTERNAL_ROW_COLS: () => CONSTANT_EXTERNAL_ROW_COLS,
   CONSTANT_INTERNAL_ROW_COLS: () => CONSTANT_INTERNAL_ROW_COLS,
+  DEFAULT_BB_DATASOURCE_ID: () => DEFAULT_BB_DATASOURCE_ID,
+  DEFAULT_EMPLOYEE_TABLE_ID: () => DEFAULT_EMPLOYEE_TABLE_ID,
+  DEFAULT_EXPENSES_TABLE_ID: () => DEFAULT_EXPENSES_TABLE_ID,
+  DEFAULT_INVENTORY_TABLE_ID: () => DEFAULT_INVENTORY_TABLE_ID,
+  DEFAULT_JOBS_TABLE_ID: () => DEFAULT_JOBS_TABLE_ID,
   DatabaseImpl: () => DatabaseImpl,
   DatabaseWithConnection: () => DatabaseWithConnection,
   DeprecatedViews: () => DeprecatedViews,
@@ -57098,6 +57252,7 @@ __export(db_exports, {
   Replication: () => Replication_default,
   SEPARATOR: () => SEPARATOR,
   SQLITE_DESIGN_DOC_ID: () => SQLITE_DESIGN_DOC_ID,
+  SQS_DATASOURCE_INTERNAL: () => SQS_DATASOURCE_INTERNAL,
   StaticDatabases: () => StaticDatabases,
   UNICODE_MAX: () => UNICODE_MAX,
   ViewName: () => ViewName,
@@ -57798,7 +57953,7 @@ var QueryBuilder = class _QueryBuilder {
   static {
     this.maxLimit = 200;
   }
-  constructor(dbName, index2, base) {
+  constructor(dbName, index2, base2) {
     this.#dbName = dbName;
     this.#index = index2;
     this.#query = {
@@ -57815,7 +57970,7 @@ var QueryBuilder = class _QueryBuilder {
       contains: {},
       notContains: {},
       containsAny: {},
-      ...base
+      ...base2
     };
     this.#limit = 50;
     this.#sortOrder = "ascending";
@@ -64577,14 +64732,14 @@ function removePortalUserPermissions(user) {
   delete user.builder;
   return user;
 }
-function cleanseUserObject(user, base) {
+function cleanseUserObject(user, base2) {
   delete user.admin;
   delete user.builder;
   delete user.roles;
-  if (base) {
-    user.admin = base.admin;
-    user.builder = base.builder;
-    user.roles = base.roles;
+  if (base2) {
+    user.admin = base2.admin;
+    user.builder = base2.builder;
+    user.roles = base2.roles;
   }
   return user;
 }
@@ -65835,9 +65990,9 @@ function encrypt(input, secretOption = "api" /* API */) {
   const salt = import_crypto.default.randomBytes(SALT_LENGTH);
   const stretched = stretchString(getSecret(secretOption), salt);
   const cipher = import_crypto.default.createCipheriv(ALGO, stretched, salt);
-  const base = cipher.update(input);
+  const base2 = cipher.update(input);
   const final = cipher.final();
-  const encrypted = Buffer.concat([base, final]).toString("hex");
+  const encrypted = Buffer.concat([base2, final]).toString("hex");
   return `${salt.toString("hex")}${SEPARATOR3}${encrypted}`;
 }
 function decrypt(input, secretOption = "api" /* API */) {
@@ -65845,9 +66000,9 @@ function decrypt(input, secretOption = "api" /* API */) {
   const saltBuffer = Buffer.from(salt, "hex");
   const stretched = stretchString(getSecret(secretOption), saltBuffer);
   const decipher = import_crypto.default.createDecipheriv(ALGO, stretched, saltBuffer);
-  const base = decipher.update(Buffer.from(encrypted, "hex"));
+  const base2 = decipher.update(Buffer.from(encrypted, "hex"));
   const final = decipher.final();
-  return Buffer.concat([base, final]).toString();
+  return Buffer.concat([base2, final]).toString();
 }
 async function encryptFile({ dir, filename }, secret) {
   const outputFileName = `${filename}.enc`;
@@ -66299,7 +66454,7 @@ __export(joi_validator_exports, {
   params: () => params
 });
 var import_joi = __toESM(require("joi"));
-function validate(schema, property) {
+function validate2(schema, property) {
   return (ctx, next) => {
     if (!schema) {
       return next();
@@ -66325,10 +66480,10 @@ function validate(schema, property) {
   };
 }
 function body(schema) {
-  return validate(schema, "body");
+  return validate2(schema, "body");
 }
 function params(schema) {
-  return validate(schema, "params");
+  return validate2(schema, "params");
 }
 
 // src/middleware/index.ts
@@ -66464,7 +66619,7 @@ async function platformLogout(opts) {
 // src/plugin/index.ts
 var plugin_exports = {};
 __export(plugin_exports, {
-  validate: () => validate2
+  validate: () => validate3
 });
 
 // src/plugin/utils.ts
@@ -66581,7 +66736,7 @@ function validateAutomation(schema) {
   });
   runJoi(validator, schema);
 }
-function validate2(schema) {
+function validate3(schema) {
   switch (schema?.type) {
     case "component" /* COMPONENT */:
       validateComponent(schema);
@@ -66738,6 +66893,1083 @@ function init8(processors2) {
   }
 }
 
+// src/sql/index.ts
+var sql_exports = {};
+__export(sql_exports, {
+  Sql: () => sql_default,
+  SqlTable: () => sqlTable_default,
+  designDoc: () => designDoc_exports,
+  utils: () => utils_exports5
+});
+
+// src/sql/utils.ts
+var utils_exports5 = {};
+__export(utils_exports5, {
+  breakExternalTableId: () => breakExternalTableId,
+  breakRowIdField: () => breakRowIdField,
+  buildExternalTableId: () => buildExternalTableId,
+  convertRowId: () => convertRowId,
+  generateRowIdField: () => generateRowIdField,
+  getNativeSql: () => getNativeSql,
+  isExternalTable: () => isExternalTable,
+  isExternalTableID: () => isExternalTableID,
+  isInternalTableID: () => isInternalTableID,
+  isIsoDateString: () => isIsoDateString,
+  isRowId: () => isRowId,
+  isValidFilter: () => isValidFilter
+});
+var DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
+var ROW_ID_REGEX = /^\[.*]$/g;
+var ENCODED_SPACE = encodeURIComponent(" ");
+function isExternalTableID(tableId) {
+  return tableId.startsWith("datasource" /* DATASOURCE */ + SEPARATOR);
+}
+function isInternalTableID(tableId) {
+  return !isExternalTableID(tableId);
+}
+function getNativeSql(query) {
+  let sql = query.toSQL();
+  if (Array.isArray(sql)) {
+    return sql;
+  }
+  let native;
+  if (sql.toNative) {
+    native = sql.toNative();
+  }
+  return {
+    sql: native?.sql || sql.sql,
+    bindings: native?.bindings || sql.bindings
+  };
+}
+function isExternalTable(table) {
+  if (table?.sourceId && table.sourceId.includes("datasource" /* DATASOURCE */ + SEPARATOR) && table?.sourceId !== DEFAULT_BB_DATASOURCE_ID) {
+    return true;
+  } else if (table?.sourceType === "external" /* EXTERNAL */) {
+    return true;
+  } else if (table?._id && isExternalTableID(table._id)) {
+    return true;
+  }
+  return false;
+}
+function buildExternalTableId(datasourceId, tableName) {
+  if (tableName.includes(" ")) {
+    tableName = encodeURIComponent(tableName);
+  }
+  return `${datasourceId}${DOUBLE_SEPARATOR}${tableName}`;
+}
+function breakExternalTableId(tableId) {
+  if (!tableId) {
+    return {};
+  }
+  const parts = tableId.split(DOUBLE_SEPARATOR);
+  let datasourceId = parts.shift();
+  let tableName = parts.join(DOUBLE_SEPARATOR);
+  if (tableName.includes(ENCODED_SPACE)) {
+    tableName = decodeURIComponent(tableName);
+  }
+  return { datasourceId, tableName };
+}
+function generateRowIdField(keyProps = []) {
+  if (!Array.isArray(keyProps)) {
+    keyProps = [keyProps];
+  }
+  for (let index2 in keyProps) {
+    if (keyProps[index2] instanceof Buffer) {
+      keyProps[index2] = keyProps[index2].toString();
+    }
+  }
+  return encodeURIComponent(JSON.stringify(keyProps).replace(/"/g, "'"));
+}
+function isRowId(field) {
+  return Array.isArray(field) || typeof field === "string" && field.match(ROW_ID_REGEX) != null;
+}
+function convertRowId(field) {
+  if (Array.isArray(field)) {
+    return field[0];
+  }
+  if (typeof field === "string" && field.match(ROW_ID_REGEX) != null) {
+    return field.substring(1, field.length - 1);
+  }
+  return field;
+}
+function breakRowIdField(_id) {
+  if (!_id) {
+    return [];
+  }
+  const id = typeof _id === "string" ? _id : _id._id;
+  const decoded = decodeURIComponent(id).replace(/'/g, '"');
+  try {
+    const parsed = JSON.parse(decoded);
+    return Array.isArray(parsed) ? parsed : [parsed];
+  } catch (err) {
+    return [_id];
+  }
+}
+function isIsoDateString(str) {
+  const trimmedValue = str.trim();
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/.test(trimmedValue)) {
+    return false;
+  }
+  let d = new Date(trimmedValue);
+  return d.toISOString() === trimmedValue;
+}
+function isValidFilter(value) {
+  return value != null && value !== "";
+}
+
+// src/sql/sql.ts
+var import_knex2 = require("knex");
+
+// src/sql/sqlStatements.ts
+var SqlStatements = class {
+  constructor(client, table, { allOr } = {}) {
+    this.client = client;
+    this.table = table;
+    this.allOr = allOr;
+  }
+  getField(key) {
+    const fieldName = key.split(".")[1];
+    return this.table.schema[fieldName];
+  }
+  between(query, key, low, high) {
+    const field = this.getField(key);
+    if (field?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
+      query = query.whereRaw(
+        `CAST(${key} AS INTEGER) BETWEEN CAST(? AS INTEGER) AND CAST(? AS INTEGER)`,
+        [low, high]
+      );
+    } else {
+      const fnc = this.allOr ? "orWhereBetween" : "whereBetween";
+      query = query[fnc](key, [low, high]);
+    }
+    return query;
+  }
+  lte(query, key, low) {
+    const field = this.getField(key);
+    if (field?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
+      query = query.whereRaw(`CAST(${key} AS INTEGER) >= CAST(? AS INTEGER)`, [
+        low
+      ]);
+    } else {
+      const fnc = this.allOr ? "orWhere" : "where";
+      query = query[fnc](key, ">=", low);
+    }
+    return query;
+  }
+  gte(query, key, high) {
+    const field = this.getField(key);
+    if (field?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
+      query = query.whereRaw(`CAST(${key} AS INTEGER) <= CAST(? AS INTEGER)`, [
+        high
+      ]);
+    } else {
+      const fnc = this.allOr ? "orWhere" : "where";
+      query = query[fnc](key, "<=", high);
+    }
+    return query;
+  }
+};
+
+// src/sql/sqlTable.ts
+var import_knex = require("knex");
+function isIgnoredType(type) {
+  const ignored = ["link" /* LINK */, "formula" /* FORMULA */];
+  return ignored.indexOf(type) !== -1;
+}
+function generateSchema(schema, table, tables, oldTable = null, renamed) {
+  let primaryKey = table && table.primary ? table.primary[0] : null;
+  const columns = Object.values(table.schema);
+  let metaCols = columns.filter((col) => col.meta);
+  let isJunction = metaCols.length === columns.length;
+  if (primaryKey && !oldTable && !isJunction) {
+    schema.increments(primaryKey).primary();
+  } else if (!oldTable && isJunction) {
+    schema.primary(metaCols.map((col) => col.name));
+  }
+  const foreignKeys = Object.values(table.schema).map(
+    (col) => col.foreignKey
+  );
+  for (let [key, column] of Object.entries(table.schema)) {
+    const oldColumn = oldTable ? oldTable.schema[key] : null;
+    if (oldColumn && oldColumn.type || primaryKey === key && !isJunction || renamed?.updated === key) {
+      continue;
+    }
+    const columnType = column.type;
+    switch (columnType) {
+      case "string" /* STRING */:
+      case "options" /* OPTIONS */:
+      case "longform" /* LONGFORM */:
+      case "barcodeqr" /* BARCODEQR */:
+      case "bb_reference_single" /* BB_REFERENCE_SINGLE */:
+        schema.text(key);
+        break;
+      case "number" /* NUMBER */:
+        if (column.meta && column.meta.toKey && column.meta.toTable) {
+          const { toKey, toTable } = column.meta;
+          schema.integer(key).unsigned();
+          schema.foreign(key).references(`${toTable}.${toKey}`);
+        } else if (foreignKeys.indexOf(key) === -1) {
+          schema.float(key);
+        }
+        break;
+      case "bigint" /* BIGINT */:
+        schema.bigint(key);
+        break;
+      case "boolean" /* BOOLEAN */:
+        schema.boolean(key);
+        break;
+      case "datetime" /* DATETIME */:
+        if (!column.timeOnly) {
+          schema.datetime(key, {
+            useTz: !column.ignoreTimezones
+          });
+        } else {
+          schema.time(key);
+        }
+        break;
+      case "array" /* ARRAY */:
+      case "bb_reference" /* BB_REFERENCE */:
+        if (helpers_exports.schema.isDeprecatedSingleUserColumn(column)) {
+          schema.text(key);
+        } else {
+          schema.json(key);
+        }
+        break;
+      case "link" /* LINK */:
+        if (column.relationshipType !== "many-to-one" /* MANY_TO_ONE */ && column.relationshipType !== "many-to-many" /* MANY_TO_MANY */) {
+          if (!column.foreignKey || !column.tableId) {
+            throw new Error("Invalid relationship schema");
+          }
+          const { tableName } = breakExternalTableId(column.tableId);
+          const relatedTable = tables[tableName];
+          if (!relatedTable) {
+            throw new Error("Referenced table doesn't exist");
+          }
+          const relatedPrimary = relatedTable.primary[0];
+          const externalType = relatedTable.schema[relatedPrimary].externalType;
+          if (externalType) {
+            schema.specificType(column.foreignKey, externalType);
+          } else {
+            schema.integer(column.foreignKey).unsigned();
+          }
+          schema.foreign(column.foreignKey).references(`${tableName}.${relatedPrimary}`);
+        }
+        break;
+      case "formula" /* FORMULA */:
+        break;
+      case "attachment" /* ATTACHMENTS */:
+      case "attachment_single" /* ATTACHMENT_SINGLE */:
+      case "signature_single" /* SIGNATURE_SINGLE */:
+      case "auto" /* AUTO */:
+      case "json" /* JSON */:
+      case "internal" /* INTERNAL */:
+        throw `${column.type} is not a valid SQL type`;
+      default:
+        utils_exports.unreachable(columnType);
+    }
+  }
+  const oldType = renamed ? oldTable?.schema[renamed.old].type : void 0;
+  if (renamed && oldType && !isIgnoredType(oldType)) {
+    schema.renameColumn(renamed.old, renamed.updated);
+  }
+  if (oldTable) {
+    const deletedColumns = Object.entries(oldTable.schema).filter(
+      ([key, column]) => !isIgnoredType(column.type) && table.schema[key] == null
+    );
+    deletedColumns.forEach(([key, column]) => {
+      if (renamed?.old === key || isIgnoredType(column.type)) {
+        return;
+      }
+      if (oldTable.constrained && oldTable.constrained.indexOf(key) !== -1) {
+        schema.dropForeign(key);
+      }
+      schema.dropColumn(key);
+    });
+  }
+  return schema;
+}
+function buildCreateTable(knex3, table, tables) {
+  return knex3.createTable(table.name, (schema) => {
+    generateSchema(schema, table, tables);
+  });
+}
+function buildUpdateTable(knex3, table, tables, oldTable, renamed) {
+  return knex3.alterTable(table.name, (schema) => {
+    generateSchema(schema, table, tables, oldTable, renamed);
+  });
+}
+function buildDeleteTable(knex3, table) {
+  return knex3.dropTable(table.name);
+}
+var SqlTableQueryBuilder = class {
+  // pass through client to get flavour of SQL
+  constructor(client) {
+    this.sqlClient = client;
+  }
+  getSqlClient() {
+    return this.sqlClient;
+  }
+  /**
+   * @param json the input JSON structure from which an SQL query will be built.
+   * @return the operation that was found in the JSON.
+   */
+  _operation(json) {
+    return json.endpoint.operation;
+  }
+  _tableQuery(json) {
+    let client = (0, import_knex.knex)({ client: this.sqlClient }).schema;
+    let schemaName = json?.endpoint?.schema;
+    if (schemaName) {
+      client = client.withSchema(schemaName);
+    }
+    let query;
+    if (!json.table || !json.meta || !json.meta.tables) {
+      throw new Error("Cannot execute without table being specified");
+    }
+    if (json.table.sourceType === "internal" /* INTERNAL */) {
+      throw new Error("Cannot perform table actions for SQS.");
+    }
+    switch (this._operation(json)) {
+      case "CREATE_TABLE" /* CREATE_TABLE */:
+        query = buildCreateTable(client, json.table, json.meta.tables);
+        break;
+      case "UPDATE_TABLE" /* UPDATE_TABLE */:
+        if (!json.meta || !json.meta.table) {
+          throw new Error("Must specify old table for update");
+        }
+        if (this.sqlClient === "mysql2" /* MY_SQL */ && json.meta.renamed) {
+          const updatedColumn = json.meta.renamed.updated;
+          const tableName = schemaName ? `\`${schemaName}\`.\`${json.table.name}\`` : `\`${json.table.name}\``;
+          return {
+            sql: `alter table ${tableName} rename column \`${json.meta.renamed.old}\` to \`${updatedColumn}\`;`,
+            bindings: []
+          };
+        }
+        query = buildUpdateTable(
+          client,
+          json.table,
+          json.meta.tables,
+          json.meta.table,
+          json.meta.renamed
+        );
+        if (this.sqlClient === "mssql" /* MS_SQL */ && json.meta.renamed) {
+          const oldColumn = json.meta.renamed.old;
+          const updatedColumn = json.meta.renamed.updated;
+          const tableName = schemaName ? `${schemaName}.${json.table.name}` : `${json.table.name}`;
+          const sql = getNativeSql(query);
+          if (Array.isArray(sql)) {
+            for (const query2 of sql) {
+              if (query2.sql.startsWith("exec sp_rename")) {
+                query2.sql = `exec sp_rename '${tableName}.${oldColumn}', '${updatedColumn}', 'COLUMN'`;
+                query2.bindings = [];
+              }
+            }
+          }
+          return sql;
+        }
+        break;
+      case "DELETE_TABLE" /* DELETE_TABLE */:
+        query = buildDeleteTable(client, json.table);
+        break;
+      default:
+        throw new Error("Table operation is of unknown type");
+    }
+    return getNativeSql(query);
+  }
+};
+var sqlTable_default = SqlTableQueryBuilder;
+
+// src/sql/sql.ts
+var envLimit = environment_default.SQL_MAX_ROWS ? parseInt(environment_default.SQL_MAX_ROWS) : null;
+var BASE_LIMIT = envLimit || 5e3;
+var MIN_ISO_DATE = "0000-00-00T00:00:00.000Z";
+var MAX_ISO_DATE = "9999-00-00T00:00:00.000Z";
+function likeKey(client, key) {
+  let start2, end2;
+  switch (client) {
+    case "mysql2" /* MY_SQL */:
+      start2 = end2 = "`";
+      break;
+    case "sqlite3" /* SQL_LITE */:
+    case "oracledb" /* ORACLE */:
+    case "pg" /* POSTGRES */:
+      start2 = end2 = '"';
+      break;
+    case "mssql" /* MS_SQL */:
+      start2 = "[";
+      end2 = "]";
+      break;
+    default:
+      throw new Error("Unknown client generating like key");
+  }
+  const parts = key.split(".");
+  key = parts.map((part) => `${start2}${part}${end2}`).join(".");
+  return key;
+}
+function parse(input) {
+  if (Array.isArray(input)) {
+    return JSON.stringify(input);
+  }
+  if (input == void 0) {
+    return null;
+  }
+  if (typeof input !== "string") {
+    return input;
+  }
+  if (input === MAX_ISO_DATE || input === MIN_ISO_DATE) {
+    return null;
+  }
+  if (isIsoDateString(input)) {
+    return new Date(input.trim());
+  }
+  return input;
+}
+function parseBody(body2) {
+  for (let [key, value] of Object.entries(body2)) {
+    body2[key] = parse(value);
+  }
+  return body2;
+}
+function parseFilters(filters) {
+  if (!filters) {
+    return {};
+  }
+  for (let [key, value] of Object.entries(filters)) {
+    let parsed;
+    if (typeof value === "object") {
+      parsed = parseFilters(value);
+    } else {
+      parsed = parse(value);
+    }
+    filters[key] = parsed;
+  }
+  return filters;
+}
+function generateSelectStatement(json, knex3) {
+  const { resource, meta } = json;
+  if (!resource) {
+    return "*";
+  }
+  const schema = meta?.table?.schema;
+  return resource.fields.map((field) => {
+    const fieldNames = field.split(/\./g);
+    const tableName = fieldNames[0];
+    const columnName = fieldNames[1];
+    const columnSchema = schema?.[columnName];
+    if (columnSchema && knex3.client.config.client === "pg" /* POSTGRES */) {
+      const externalType = schema[columnName].externalType;
+      if (externalType?.includes("money")) {
+        return knex3.raw(
+          `"${tableName}"."${columnName}"::money::numeric as "${field}"`
+        );
+      }
+    }
+    if (knex3.client.config.client === "mssql" /* MS_SQL */ && columnSchema?.type === "datetime" /* DATETIME */ && columnSchema.timeOnly) {
+      return knex3.raw(`CONVERT(varchar, ${field}, 108) as "${field}"`);
+    }
+    return `${field} as ${field}`;
+  });
+}
+function getTableName(table) {
+  if (table?.sourceType === "internal" /* INTERNAL */ || table?.sourceId === INTERNAL_TABLE_SOURCE_ID) {
+    return table?._id;
+  } else {
+    return table?.name;
+  }
+}
+function convertBooleans(query) {
+  if (Array.isArray(query)) {
+    return query.map((q2) => convertBooleans(q2));
+  } else {
+    if (query.bindings) {
+      query.bindings = query.bindings.map((binding) => {
+        if (typeof binding === "boolean") {
+          return binding ? 1 : 0;
+        }
+        return binding;
+      });
+    }
+  }
+  return query;
+}
+var InternalBuilder = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // right now we only do filters on the specific table being queried
+  addFilters(query, filters, table, opts) {
+    if (!filters) {
+      return query;
+    }
+    filters = parseFilters(filters);
+    const allOr = filters.allOr;
+    const sqlStatements = new SqlStatements(this.client, table, { allOr });
+    const tableName = this.client === "sqlite3" /* SQL_LITE */ ? table._id : table.name;
+    function getTableAlias(name) {
+      const alias = opts.aliases?.[name];
+      return alias || name;
+    }
+    function iterate(structure, fn) {
+      for (let [key, value] of Object.entries(structure)) {
+        const updatedKey = removeKeyNumbering2(key);
+        const isRelationshipField = updatedKey.includes(".");
+        if (!opts.relationship && !isRelationshipField) {
+          const alias = getTableAlias(tableName);
+          fn(alias ? `${alias}.${updatedKey}` : updatedKey, value);
+        }
+        if (opts.relationship && isRelationshipField) {
+          const [filterTableName, property] = updatedKey.split(".");
+          const alias = getTableAlias(filterTableName);
+          fn(alias ? `${alias}.${property}` : property, value);
+        }
+      }
+    }
+    const like = (key, value) => {
+      const fuzzyOr = filters?.fuzzyOr;
+      const fnc = fuzzyOr || allOr ? "orWhere" : "where";
+      if (this.client === "pg" /* POSTGRES */) {
+        query = query[fnc](key, "ilike", `%${value}%`);
+      } else {
+        const rawFnc = `${fnc}Raw`;
+        query = query[rawFnc](`LOWER(${likeKey(this.client, key)}) LIKE ?`, [
+          `%${value.toLowerCase()}%`
+        ]);
+      }
+    };
+    const contains = (mode, any = false) => {
+      const rawFnc = allOr ? "orWhereRaw" : "whereRaw";
+      const not = mode === filters?.notContains ? "NOT " : "";
+      function stringifyArray(value, quoteStyle = '"') {
+        for (let i in value) {
+          if (typeof value[i] === "string") {
+            value[i] = `${quoteStyle}${value[i]}${quoteStyle}`;
+          }
+        }
+        return `[${value.join(",")}]`;
+      }
+      if (this.client === "pg" /* POSTGRES */) {
+        iterate(mode, (key, value) => {
+          const wrap = any ? "" : "'";
+          const op = any ? "\\?| array" : "@>";
+          const fieldNames = key.split(/\./g);
+          const table2 = fieldNames[0];
+          const col = fieldNames[1];
+          query = query[rawFnc](
+            `${not}COALESCE("${table2}"."${col}"::jsonb ${op} ${wrap}${stringifyArray(
+              value,
+              any ? "'" : '"'
+            )}${wrap}, FALSE)`
+          );
+        });
+      } else if (this.client === "mysql2" /* MY_SQL */) {
+        const jsonFnc = any ? "JSON_OVERLAPS" : "JSON_CONTAINS";
+        iterate(mode, (key, value) => {
+          query = query[rawFnc](
+            `${not}COALESCE(${jsonFnc}(${key}, '${stringifyArray(
+              value
+            )}'), FALSE)`
+          );
+        });
+      } else {
+        const andOr = mode === filters?.containsAny ? " OR " : " AND ";
+        iterate(mode, (key, value) => {
+          let statement = "";
+          for (let i in value) {
+            if (typeof value[i] === "string") {
+              value[i] = `%"${value[i].toLowerCase()}"%`;
+            } else {
+              value[i] = `%${value[i]}%`;
+            }
+            statement += (statement ? andOr : "") + `COALESCE(LOWER(${likeKey(this.client, key)}), '') LIKE ?`;
+          }
+          if (statement === "") {
+            return;
+          }
+          query = query[rawFnc](`${not}(${statement})`, value);
+        });
+      }
+    };
+    if (filters.oneOf) {
+      iterate(filters.oneOf, (key, array) => {
+        const fnc = allOr ? "orWhereIn" : "whereIn";
+        query = query[fnc](key, Array.isArray(array) ? array : [array]);
+      });
+    }
+    if (filters.string) {
+      iterate(filters.string, (key, value) => {
+        const fnc = allOr ? "orWhere" : "where";
+        if (this.client === "pg" /* POSTGRES */) {
+          query = query[fnc](key, "ilike", `${value}%`);
+        } else {
+          const rawFnc = `${fnc}Raw`;
+          query = query[rawFnc](`LOWER(${likeKey(this.client, key)}) LIKE ?`, [
+            `${value.toLowerCase()}%`
+          ]);
+        }
+      });
+    }
+    if (filters.fuzzy) {
+      iterate(filters.fuzzy, like);
+    }
+    if (filters.range) {
+      iterate(filters.range, (key, value) => {
+        const isEmptyObject = (val) => {
+          return val && Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+        };
+        if (isEmptyObject(value.low)) {
+          value.low = "";
+        }
+        if (isEmptyObject(value.high)) {
+          value.high = "";
+        }
+        const lowValid = isValidFilter(value.low), highValid = isValidFilter(value.high);
+        if (lowValid && highValid) {
+          query = sqlStatements.between(query, key, value.low, value.high);
+        } else if (lowValid) {
+          query = sqlStatements.lte(query, key, value.low);
+        } else if (highValid) {
+          query = sqlStatements.gte(query, key, value.high);
+        }
+      });
+    }
+    if (filters.equal) {
+      iterate(filters.equal, (key, value) => {
+        const fnc = allOr ? "orWhereRaw" : "whereRaw";
+        if (this.client === "mssql" /* MS_SQL */) {
+          query = query[fnc](
+            `CASE WHEN ${likeKey(this.client, key)} = ? THEN 1 ELSE 0 END = 1`,
+            [value]
+          );
+        } else {
+          query = query[fnc](
+            `COALESCE(${likeKey(this.client, key)} = ?, FALSE)`,
+            [value]
+          );
+        }
+      });
+    }
+    if (filters.notEqual) {
+      iterate(filters.notEqual, (key, value) => {
+        const fnc = allOr ? "orWhereRaw" : "whereRaw";
+        if (this.client === "mssql" /* MS_SQL */) {
+          query = query[fnc](
+            `CASE WHEN ${likeKey(this.client, key)} = ? THEN 1 ELSE 0 END = 0`,
+            [value]
+          );
+        } else {
+          query = query[fnc](
+            `COALESCE(${likeKey(this.client, key)} != ?, TRUE)`,
+            [value]
+          );
+        }
+      });
+    }
+    if (filters.empty) {
+      iterate(filters.empty, (key) => {
+        const fnc = allOr ? "orWhereNull" : "whereNull";
+        query = query[fnc](key);
+      });
+    }
+    if (filters.notEmpty) {
+      iterate(filters.notEmpty, (key) => {
+        const fnc = allOr ? "orWhereNotNull" : "whereNotNull";
+        query = query[fnc](key);
+      });
+    }
+    if (filters.contains) {
+      contains(filters.contains);
+    }
+    if (filters.notContains) {
+      contains(filters.notContains);
+    }
+    if (filters.containsAny) {
+      contains(filters.containsAny, true);
+    }
+    if (filters.documentType && !isExternalTable(table)) {
+      const tableRef = opts?.aliases?.[table._id] || table._id;
+      query.andWhereLike(
+        `${tableRef}._id`,
+        `${prefixed(filters.documentType)}%`
+      );
+    }
+    return query;
+  }
+  addSorting(query, json) {
+    let { sort, paginate } = json;
+    const table = json.meta.table;
+    const tableName = getTableName(table);
+    const aliases = json.tableAliases;
+    const aliased = tableName && aliases?.[tableName] ? aliases[tableName] : table?.name;
+    if (sort && Object.keys(sort || {}).length > 0) {
+      for (let [key, value] of Object.entries(sort)) {
+        const direction = value.direction === "ASCENDING" /* ASCENDING */ ? "asc" : "desc";
+        let nulls;
+        if (this.client === "pg" /* POSTGRES */) {
+          nulls = value.direction === "ASCENDING" /* ASCENDING */ ? "first" : "last";
+        }
+        query = query.orderBy(`${aliased}.${key}`, direction, nulls);
+      }
+    } else if (this.client === "mssql" /* MS_SQL */ && paginate?.limit) {
+      query = query.orderBy(`${aliased}.${table?.primary[0]}`);
+    }
+    return query;
+  }
+  tableNameWithSchema(tableName, opts) {
+    let withSchema = opts?.schema ? `${opts.schema}.${tableName}` : tableName;
+    if (opts?.alias) {
+      withSchema += ` as ${opts.alias}`;
+    }
+    return withSchema;
+  }
+  addRelationships(query, fromTable, relationships, schema, aliases) {
+    if (!relationships) {
+      return query;
+    }
+    const tableSets = {};
+    for (let relationship of relationships) {
+      const keyObj = {
+        toTable: relationship.tableName,
+        throughTable: void 0
+      };
+      if (relationship.through) {
+        keyObj.throughTable = relationship.through;
+      }
+      const key = JSON.stringify(keyObj);
+      if (tableSets[key]) {
+        tableSets[key].push(relationship);
+      } else {
+        tableSets[key] = [relationship];
+      }
+    }
+    for (let [key, relationships2] of Object.entries(tableSets)) {
+      const { toTable, throughTable } = JSON.parse(key);
+      const toAlias = aliases?.[toTable] || toTable, throughAlias = aliases?.[throughTable] || throughTable, fromAlias = aliases?.[fromTable] || fromTable;
+      let toTableWithSchema = this.tableNameWithSchema(toTable, {
+        alias: toAlias,
+        schema
+      });
+      let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
+        alias: throughAlias,
+        schema
+      });
+      if (!throughTable) {
+        query = query.leftJoin(toTableWithSchema, function() {
+          for (let relationship of relationships2) {
+            const from = relationship.from, to = relationship.to;
+            this.orOn(`${fromAlias}.${from}`, "=", `${toAlias}.${to}`);
+          }
+        });
+      } else {
+        query = query.leftJoin(throughTableWithSchema, function() {
+          for (let relationship of relationships2) {
+            const fromPrimary = relationship.fromPrimary;
+            const from = relationship.from;
+            this.orOn(
+              `${fromAlias}.${fromPrimary}`,
+              "=",
+              `${throughAlias}.${from}`
+            );
+          }
+        }).leftJoin(toTableWithSchema, function() {
+          for (let relationship of relationships2) {
+            const toPrimary = relationship.toPrimary;
+            const to = relationship.to;
+            this.orOn(`${toAlias}.${toPrimary}`, `${throughAlias}.${to}`);
+          }
+        });
+      }
+    }
+    return query.limit(BASE_LIMIT);
+  }
+  knexWithAlias(knex3, endpoint, aliases) {
+    const tableName = endpoint.entityId;
+    const tableAlias = aliases?.[tableName];
+    const query = knex3(
+      this.tableNameWithSchema(tableName, {
+        alias: tableAlias,
+        schema: endpoint.schema
+      })
+    );
+    return query;
+  }
+  create(knex3, json, opts) {
+    const { endpoint, body: body2 } = json;
+    let query = this.knexWithAlias(knex3, endpoint);
+    const parsedBody = parseBody(body2);
+    for (let [key, value] of Object.entries(parsedBody)) {
+      if (value == null) {
+        delete parsedBody[key];
+      }
+    }
+    if (opts.disableReturning) {
+      return query.insert(parsedBody);
+    } else {
+      return query.insert(parsedBody).returning("*");
+    }
+  }
+  bulkCreate(knex3, json) {
+    const { endpoint, body: body2 } = json;
+    let query = this.knexWithAlias(knex3, endpoint);
+    if (!Array.isArray(body2)) {
+      return query;
+    }
+    const parsedBody = body2.map((row) => parseBody(row));
+    return query.insert(parsedBody);
+  }
+  read(knex3, json, limit) {
+    let { endpoint, resource, filters, paginate, relationships, tableAliases } = json;
+    const tableName = endpoint.entityId;
+    if (!resource) {
+      resource = { fields: [] };
+    }
+    let selectStatement = "*";
+    if (resource.fields && resource.fields.length > 0) {
+      selectStatement = generateSelectStatement(json, knex3);
+    }
+    let foundLimit = limit || BASE_LIMIT;
+    let foundOffset = null;
+    if (paginate && paginate.page && paginate.limit) {
+      const page = paginate.page <= 1 ? 0 : paginate.page - 1;
+      const offset = page * paginate.limit;
+      foundLimit = paginate.limit;
+      foundOffset = offset;
+    } else if (paginate && paginate.limit) {
+      foundLimit = paginate.limit;
+    }
+    let query = this.knexWithAlias(knex3, endpoint, tableAliases);
+    query = query.limit(foundLimit);
+    if (foundOffset) {
+      query = query.offset(foundOffset);
+    }
+    query = this.addFilters(query, filters, json.meta.table, {
+      aliases: tableAliases
+    });
+    query = this.addSorting(query, json);
+    const alias = tableAliases?.[tableName] || tableName;
+    let preQuery = knex3({
+      [alias]: query
+    }).select(selectStatement);
+    if (this.client !== "mssql" /* MS_SQL */) {
+      preQuery = this.addSorting(preQuery, json);
+    }
+    query = this.addRelationships(
+      preQuery,
+      tableName,
+      relationships,
+      endpoint.schema,
+      tableAliases
+    );
+    return this.addFilters(query, filters, json.meta.table, {
+      relationship: true,
+      aliases: tableAliases
+    });
+  }
+  update(knex3, json, opts) {
+    const { endpoint, body: body2, filters, tableAliases } = json;
+    let query = this.knexWithAlias(knex3, endpoint, tableAliases);
+    const parsedBody = parseBody(body2);
+    query = this.addFilters(query, filters, json.meta.table, {
+      aliases: tableAliases
+    });
+    if (opts.disableReturning) {
+      return query.update(parsedBody);
+    } else {
+      return query.update(parsedBody).returning("*");
+    }
+  }
+  delete(knex3, json, opts) {
+    const { endpoint, filters, tableAliases } = json;
+    let query = this.knexWithAlias(knex3, endpoint, tableAliases);
+    query = this.addFilters(query, filters, json.meta.table, {
+      aliases: tableAliases
+    });
+    if (opts.disableReturning) {
+      return query.delete();
+    } else {
+      return query.delete().returning(generateSelectStatement(json, knex3));
+    }
+  }
+};
+var SqlQueryBuilder = class extends sqlTable_default {
+  // pass through client to get flavour of SQL
+  constructor(client, limit = BASE_LIMIT) {
+    super(client);
+    this.limit = limit;
+  }
+  /**
+   * @param json The JSON query DSL which is to be converted to SQL.
+   * @param opts extra options which are to be passed into the query builder, e.g. disableReturning
+   * which for the sake of mySQL stops adding the returning statement to inserts, updates and deletes.
+   * @return the query ready to be passed to the driver.
+   */
+  _query(json, opts = {}) {
+    const sqlClient = this.getSqlClient();
+    const config = {
+      client: sqlClient
+    };
+    if (sqlClient === "sqlite3" /* SQL_LITE */) {
+      config.useNullAsDefault = true;
+    }
+    const client = (0, import_knex2.knex)(config);
+    let query;
+    const builder = new InternalBuilder(sqlClient);
+    switch (this._operation(json)) {
+      case "CREATE" /* CREATE */:
+        query = builder.create(client, json, opts);
+        break;
+      case "READ" /* READ */:
+        query = builder.read(client, json, this.limit);
+        break;
+      case "UPDATE" /* UPDATE */:
+        query = builder.update(client, json, opts);
+        break;
+      case "DELETE" /* DELETE */:
+        query = builder.delete(client, json, opts);
+        break;
+      case "BULK_CREATE" /* BULK_CREATE */:
+        query = builder.bulkCreate(client, json);
+        break;
+      case "CREATE_TABLE" /* CREATE_TABLE */:
+      case "UPDATE_TABLE" /* UPDATE_TABLE */:
+      case "DELETE_TABLE" /* DELETE_TABLE */:
+        return this._tableQuery(json);
+      default:
+        throw `Operation type is not supported by SQL query builder`;
+    }
+    if (opts?.disableBindings) {
+      return { sql: query.toString() };
+    } else {
+      let native = getNativeSql(query);
+      if (sqlClient === "sqlite3" /* SQL_LITE */) {
+        native = convertBooleans(native);
+      }
+      return native;
+    }
+  }
+  async getReturningRow(queryFn, json) {
+    if (!json.extra || !json.extra.idFilter) {
+      return {};
+    }
+    const input = this._query({
+      endpoint: {
+        ...json.endpoint,
+        operation: "READ" /* READ */
+      },
+      resource: {
+        fields: []
+      },
+      filters: json.extra?.idFilter,
+      paginate: {
+        limit: 1
+      },
+      meta: json.meta
+    });
+    return queryFn(input, "READ" /* READ */);
+  }
+  // when creating if an ID has been inserted need to make sure
+  // the id filter is enriched with it before trying to retrieve the row
+  checkLookupKeys(id, json) {
+    if (!id || !json.meta.table || !json.meta.table.primary) {
+      return json;
+    }
+    const primaryKey = json.meta.table.primary?.[0];
+    json.extra = {
+      idFilter: {
+        equal: {
+          [primaryKey]: id
+        }
+      }
+    };
+    return json;
+  }
+  // this function recreates the returning functionality of postgres
+  async queryWithReturning(json, queryFn, processFn = (result) => result) {
+    const sqlClient = this.getSqlClient();
+    const operation = this._operation(json);
+    const input = this._query(json, { disableReturning: true });
+    if (Array.isArray(input)) {
+      const responses = [];
+      for (let query of input) {
+        responses.push(await queryFn(query, operation));
+      }
+      return responses;
+    }
+    let row;
+    if (operation === "DELETE" /* DELETE */) {
+      row = processFn(await this.getReturningRow(queryFn, json));
+    }
+    const response = await queryFn(input, operation);
+    const results = processFn(response);
+    if (operation === "CREATE" /* CREATE */ || operation === "UPDATE" /* UPDATE */) {
+      let id;
+      if (sqlClient === "mssql" /* MS_SQL */) {
+        id = results?.[0].id;
+      } else if (sqlClient === "mysql2" /* MY_SQL */) {
+        id = results?.insertId;
+      }
+      row = processFn(
+        await this.getReturningRow(queryFn, this.checkLookupKeys(id, json))
+      );
+    }
+    if (operation !== "READ" /* READ */) {
+      return row;
+    }
+    return results.length ? results : [{ [operation.toLowerCase()]: true }];
+  }
+  convertJsonStringColumns(table, results, aliases) {
+    const tableName = getTableName(table);
+    for (const [name, field] of Object.entries(table.schema)) {
+      if (!this._isJsonColumn(field)) {
+        continue;
+      }
+      const aliasedTableName = tableName && aliases?.[tableName] || tableName;
+      const fullName = `${aliasedTableName}.${name}`;
+      for (let row of results) {
+        if (typeof row[fullName] === "string") {
+          row[fullName] = JSON.parse(row[fullName]);
+        }
+        if (typeof row[name] === "string") {
+          row[name] = JSON.parse(row[name]);
+        }
+      }
+    }
+    return results;
+  }
+  _isJsonColumn(field) {
+    return JsonTypes.includes(field.type) && !helpers_exports.schema.isDeprecatedSingleUserColumn(field);
+  }
+  log(query, values2) {
+    if (!environment_default.SQL_LOGGING_ENABLE) {
+      return;
+    }
+    const sqlClient = this.getSqlClient();
+    let string = `[SQL] [${sqlClient.toUpperCase()}] query="${query}"`;
+    if (values2) {
+      string += ` values="${values2.join(", ")}"`;
+    }
+    console.log(string);
+  }
+};
+var sql_default = SqlQueryBuilder;
+
+// src/sql/designDoc.ts
+var designDoc_exports = {};
+__export(designDoc_exports, {
+  base: () => base
+});
+function base(tableIdProp) {
+  return {
+    _id: SQLITE_DESIGN_DOC_ID,
+    language: "sqlite",
+    sql: {
+      tables: {},
+      options: {
+        table_name: tableIdProp
+      }
+    }
+  };
+}
+
 // src/index.ts
 var tenancy = {
   ...tenancy_exports,
@@ -66757,6 +67989,11 @@ var init9 = (opts = {}) => {
   BudibaseError,
   Config,
   Cookie,
+  DEFAULT_BB_DATASOURCE_ID,
+  DEFAULT_EMPLOYEE_TABLE_ID,
+  DEFAULT_EXPENSES_TABLE_ID,
+  DEFAULT_INVENTORY_TABLE_ID,
+  DEFAULT_JOBS_TABLE_ID,
   DEFAULT_TENANT_ID,
   DeprecatedViews,
   DocumentType,
@@ -66776,6 +68013,7 @@ var init9 = (opts = {}) => {
   RedisClient,
   SEPARATOR,
   SQLITE_DESIGN_DOC_ID,
+  SQS_DATASOURCE_INTERNAL,
   StaticDatabases,
   UNICODE_MAX,
   UsageLimitError,
@@ -66813,6 +68051,7 @@ var init9 = (opts = {}) => {
   roles,
   security,
   sessions,
+  sql,
   tenancy,
   timers,
   userUtils,