@budibase/backend-core 2.29.27 → 2.29.29

package/dist/index.js

@@ -15440,7 +15440,7 @@ var require_cookie = __commonJS({
       c.value = cookieValue;
       return c;
     }
-    function parse2(str, options2) {
+    function parse(str, options2) {
       if (!options2 || typeof options2 !== "object") {
         options2 = {};
       }
@@ -15622,7 +15622,7 @@ var require_cookie = __commonJS({
       });
     }
     Cookie2.cookiesCreated = 0;
-    Cookie2.parse = parse2;
+    Cookie2.parse = parse;
     Cookie2.fromJSON = fromJSON;
     Cookie2.prototype.key = "";
     Cookie2.prototype.value = "";
@@ -16179,7 +16179,7 @@ var require_cookie = __commonJS({
     exports.MemoryCookieStore = MemoryCookieStore;
     exports.parseDate = parseDate;
     exports.formatDate = formatDate;
-    exports.parse = parse2;
+    exports.parse = parse;
     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 parse2 = require("url").parse;
+    var parse = 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 = parse2(resource, true), path3 = url.pathname, buf = [];
+      var url = parse(resource, true), path3 = url.pathname, buf = [];
       Object.keys(url.query).forEach(function(key) {
         if (!~keys2.indexOf(key))
           return;
@@ -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 parse2 = require_parse();
+    var parse = require_parse();
     var formats2 = require_formats();
     module2.exports = {
       formats: formats2,
-      parse: parse2,
+      parse,
       stringify
     };
   }
@@ -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 parse2(uriString) {
+      function parse(uriString) {
         var options2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
         var components = {};
         var protocol = options2.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
@@ -42041,8 +42041,8 @@ var require_uri_all = __commonJS({
         var skipNormalization = arguments[3];
         var target = {};
         if (!skipNormalization) {
-          base3 = parse2(serialize(base3, options2), options2);
-          relative = parse2(serialize(relative, options2), options2);
+          base3 = parse(serialize(base3, options2), options2);
+          relative = parse(serialize(relative, options2), options2);
         }
         options2 = options2 || {};
         if (!options2.tolerant && relative.scheme) {
@@ -42093,24 +42093,24 @@ var require_uri_all = __commonJS({
       }
       function resolve(baseURI, relativeURI, options2) {
         var schemelessOptions = assign({ scheme: "null" }, options2);
-        return serialize(resolveComponents(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
+        return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
       }
       function normalize(uri, options2) {
         if (typeof uri === "string") {
-          uri = serialize(parse2(uri, options2), options2);
+          uri = serialize(parse(uri, options2), options2);
         } else if (typeOf(uri) === "object") {
-          uri = parse2(serialize(uri, options2), options2);
+          uri = parse(serialize(uri, options2), options2);
         }
         return uri;
       }
       function equal(uriA, uriB, options2) {
         if (typeof uriA === "string") {
-          uriA = serialize(parse2(uriA, options2), options2);
+          uriA = serialize(parse(uriA, options2), options2);
         } else if (typeOf(uriA) === "object") {
           uriA = serialize(uriA, options2);
         }
         if (typeof uriB === "string") {
-          uriB = serialize(parse2(uriB, options2), options2);
+          uriB = serialize(parse(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 parse3(components, options2) {
+        parse: function parse2(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 parse3(components, options2) {
+        parse: function parse2(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 parse3(urnComponents, options2) {
+        parse: function parse2(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 = parse2;
+      exports2.parse = parse;
       exports2.removeDotSegments = removeDotSegments;
       exports2.serialize = serialize;
       exports2.resolveComponents = resolveComponents;
@@ -54462,6 +54462,15 @@ var DatasourceFeature = /* @__PURE__ */ ((DatasourceFeature2) => {
 })(DatasourceFeature || {});
 
 // ../types/src/sdk/search.ts
+var BasicOperator = /* @__PURE__ */ ((BasicOperator2) => {
+  BasicOperator2["EQUAL"] = "equal";
+  BasicOperator2["NOT_EQUAL"] = "notEqual";
+  BasicOperator2["EMPTY"] = "empty";
+  BasicOperator2["NOT_EMPTY"] = "notEmpty";
+  BasicOperator2["FUZZY"] = "fuzzy";
+  BasicOperator2["STRING"] = "string";
+  return BasicOperator2;
+})(BasicOperator || {});
 var ArrayOperator = /* @__PURE__ */ ((ArrayOperator2) => {
   ArrayOperator2["CONTAINS"] = "contains";
   ArrayOperator2["NOT_CONTAINS"] = "notContains";
@@ -54469,6 +54478,10 @@ var ArrayOperator = /* @__PURE__ */ ((ArrayOperator2) => {
   ArrayOperator2["ONE_OF"] = "oneOf";
   return ArrayOperator2;
 })(ArrayOperator || {});
+var RangeOperator = /* @__PURE__ */ ((RangeOperator2) => {
+  RangeOperator2["RANGE"] = "range";
+  return RangeOperator2;
+})(RangeOperator || {});
 
 // ../types/src/sdk/db.ts
 var isDocument = (doc) => {
@@ -54520,7 +54533,7 @@ var PermissionType = /* @__PURE__ */ ((PermissionType2) => {
 var isCloudAccount = (account) => account.hosting === "cloud" /* CLOUD */;
 var isSSOAccount = (account) => account.authType === "sso" /* SSO */;
 
-// ../types/src/documents/app/automation.ts
+// ../types/src/documents/app/automation/automation.ts
 var AutomationIOType = /* @__PURE__ */ ((AutomationIOType2) => {
   AutomationIOType2["OBJECT"] = "object";
   AutomationIOType2["STRING"] = "string";
@@ -54988,6 +55001,8 @@ function validate(cronExpression) {
 // ../shared-core/src/helpers/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
+  decodeNonAscii: () => decodeNonAscii,
+  encodeNonAscii: () => encodeNonAscii,
   isDeprecatedSingleUserColumn: () => isDeprecatedSingleUserColumn,
   isRequired: () => isRequired
 });
@@ -54999,6 +55014,17 @@ function isRequired(constraints) {
   const isRequired2 = !!constraints && (typeof constraints.presence !== "boolean" && constraints.presence?.allowEmpty === false || constraints.presence === true);
   return isRequired2;
 }
+function encodeNonAscii(str) {
+  return str.split("").map((char) => {
+    return char.charCodeAt(0) > 127 ? "\\u" + char.charCodeAt(0).toString(16).padStart(4, "0") : char;
+  }).join("");
+}
+function decodeNonAscii(str) {
+  return str.replace(
+    /\\u([0-9a-fA-F]{4})/g,
+    (match, p1) => String.fromCharCode(parseInt(p1, 16))
+  );
+}
 
 // ../shared-core/src/filters.ts
 var import_lodash = require("lodash");
@@ -55102,7 +55128,7 @@ var getKeyNumbering = (key) => {
   }
 };
 var ColumnSplitter = class {
-  constructor(tables) {
+  constructor(tables, opts) {
     this.tableNames = tables.map((table) => table.name);
     this.tableIds = tables.map((table) => table._id);
     this.relationshipColumnNames = tables.flatMap(
@@ -55111,11 +55137,28 @@ var ColumnSplitter = class {
       )
     );
     this.relationships = this.tableNames.concat(this.tableIds).concat(this.relationshipColumnNames).sort((a, b) => b.length - a.length);
+    if (opts?.aliases) {
+      this.aliases = {};
+      for (const [key, value] of Object.entries(opts.aliases)) {
+        this.aliases[value] = key;
+      }
+    }
+    this.columnPrefix = opts?.columnPrefix;
   }
   run(key) {
     let { prefix, key: splitKey } = getKeyNumbering(key);
+    let tableName = void 0;
+    if (this.aliases) {
+      for (const possibleAlias of Object.keys(this.aliases || {})) {
+        const withDot = `${possibleAlias}.`;
+        if (splitKey.startsWith(withDot)) {
+          tableName = this.aliases[possibleAlias];
+          splitKey = splitKey.slice(withDot.length);
+        }
+      }
+    }
     let relationship;
-    for (let possibleRelationship of this.relationships) {
+    for (const possibleRelationship of this.relationships) {
       const withDot = `${possibleRelationship}.`;
       if (splitKey.startsWith(withDot)) {
         const finalKeyParts = splitKey.split(withDot);
@@ -55125,7 +55168,13 @@ var ColumnSplitter = class {
         break;
       }
     }
+    if (this.columnPrefix) {
+      if (splitKey.startsWith(this.columnPrefix)) {
+        splitKey = decodeNonAscii(splitKey.slice(this.columnPrefix.length));
+      }
+    }
     return {
+      tableName,
       numberPrefix: prefix,
       relationshipPrefix: relationship,
       column: splitKey
@@ -55466,7 +55515,7 @@ var sort = (docs, sort2, sortOrder, sortType = "string" /* STRING */) => {
   if (!sort2 || !sortOrder || !sortType) {
     return docs;
   }
-  const parse2 = (x) => {
+  const parse = (x) => {
     if (x == null) {
       return x;
     }
@@ -55476,8 +55525,8 @@ var sort = (docs, sort2, sortOrder, sortType = "string" /* STRING */) => {
     return parseFloat(x);
   };
   return docs.slice().sort((a, b) => {
-    const colA = parse2(a[sort2]);
-    const colB = parse2(b[sort2]);
+    const colA = parse(a[sort2]);
+    const colB = parse(b[sort2]);
     const result = colB == null || colA > colB ? 1 : -1;
     if (sortOrder.toLowerCase() === "descending") {
       return result * -1;
@@ -55514,6 +55563,7 @@ __export(utils_exports, {
   filterValueToLabel: () => filterValueToLabel,
   hasSchema: () => hasSchema,
   parallelForeach: () => parallelForeach,
+  trimOtherProps: () => trimOtherProps,
   unreachable: () => unreachable
 });
 function unreachable(value, message = `No such case in exhaustive switch: ${value}`) {
@@ -55560,6 +55610,13 @@ function filterValueToLabel() {
 function hasSchema(test) {
   return typeof test === "object" && !Array.isArray(test) && test !== null && !(test instanceof Date) && Object.keys(test).length > 0;
 }
+function trimOtherProps(object, allowedProps) {
+  const result = Object.keys(object).filter((key) => allowedProps.includes(key)).reduce(
+    (acc, key) => ({ ...acc, [key]: object[key] }),
+    {}
+  );
+  return result;
+}
 
 // ../shared-core/src/sdk/index.ts
 var sdk_exports = {};
@@ -67424,62 +67481,6 @@ __export(sql_exports, {
 // src/sql/sql.ts
 var import_knex2 = require("knex");
 
-// src/sql/sqlStatements.ts
-var SqlStatements = class {
-  constructor(client, table, { allOr, columnPrefix } = {}) {
-    this.client = client;
-    this.table = table;
-    this.allOr = allOr;
-    this.columnPrefix = columnPrefix;
-  }
-  getField(key) {
-    const fieldName = key.split(".")[1];
-    let found = this.table.schema[fieldName];
-    if (!found && this.columnPrefix) {
-      const prefixRemovedFieldName = fieldName.replace(this.columnPrefix, "");
-      found = this.table.schema[prefixRemovedFieldName];
-    }
-    return found;
-  }
-  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) {
@@ -67692,110 +67693,9 @@ var SqlTableQueryBuilder = class {
 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;
-function quote(client, str) {
-  switch (client) {
-    case "sqlite3" /* SQL_LITE */:
-    case "oracledb" /* ORACLE */:
-    case "pg" /* POSTGRES */:
-      return `"${str}"`;
-    case "mssql" /* MS_SQL */:
-      return `[${str}]`;
-    case "mysql2" /* MY_SQL */:
-      return `\`${str}\``;
-  }
-}
-function quotedIdentifier(client, key) {
-  return key.split(".").map((part) => quote(client, part)).join(".");
-}
-function parse(input) {
-  if (Array.isArray(input)) {
-    return JSON.stringify(input);
-  }
-  if (input == void 0) {
-    return null;
-  }
-  if (typeof input !== "string") {
-    return input;
-  }
-  if (isInvalidISODateString(input)) {
-    return null;
-  }
-  if (isValidISODateString(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;
-  const client = knex3.client.config.client;
-  if (!resource || !resource.fields || resource.fields.length === 0) {
-    return "*";
-  }
-  const schema = meta.table.schema;
-  return resource.fields.map((field) => {
-    const parts = field.split(/\./g);
-    let table = void 0;
-    let column = void 0;
-    if (parts.length === 1) {
-      column = parts[0];
-    }
-    if (parts.length === 2) {
-      table = parts[0];
-      column = parts[1];
-    }
-    if (parts.length > 2) {
-      table = parts[0];
-      column = parts.slice(1).join(".");
-    }
-    if (!column) {
-      throw new Error(`Invalid field name: ${field}`);
-    }
-    const columnSchema = schema[column];
-    if (client === "pg" /* POSTGRES */ && columnSchema?.externalType?.includes("money")) {
-      return knex3.raw(
-        `${quotedIdentifier(
-          client,
-          [table, column].join(".")
-        )}::money::numeric as ${quote(client, field)}`
-      );
-    }
-    if (client === "mssql" /* MS_SQL */ && columnSchema?.type === "datetime" /* DATETIME */ && columnSchema.timeOnly) {
-      return knex3.raw(`CONVERT(varchar, ${field}, 108) as "${field}"`);
-    }
-    if (table) {
-      return knex3.raw(
-        `${quote(client, table)}.${quote(client, column)} as ${quote(
-          client,
-          field
-        )}`
-      );
-    } else {
-      return knex3.raw(`${quote(client, field)} as ${quote(client, field)}`);
-    }
-  });
+function getBaseLimit() {
+  const envLimit = environment_default.SQL_MAX_ROWS ? parseInt(environment_default.SQL_MAX_ROWS) : null;
+  return envLimit || 5e3;
 }
 function getTableName(table) {
   if (table?.sourceType === "internal" /* INTERNAL */ || table?.sourceId === INTERNAL_TABLE_SOURCE_ID) {
@@ -67820,23 +67720,203 @@ function convertBooleans(query) {
   return query;
 }
 var InternalBuilder = class {
-  constructor(client) {
+  constructor(client, knex3, query) {
     this.client = client;
+    this.query = query;
+    this.knex = knex3;
+    this.splitter = new filters_exports.ColumnSplitter([this.table], {
+      aliases: this.query.tableAliases,
+      columnPrefix: this.query.meta.columnPrefix
+    });
+  }
+  get table() {
+    return this.query.meta.table;
+  }
+  getFieldSchema(key) {
+    const { column } = this.splitter.run(key);
+    return this.table.schema[column];
+  }
+  // Takes a string like foo and returns a quoted string like [foo] for SQL Server
+  // and "foo" for Postgres.
+  quote(str) {
+    switch (this.client) {
+      case "sqlite3" /* SQL_LITE */:
+      case "oracledb" /* ORACLE */:
+      case "pg" /* POSTGRES */:
+        return `"${str}"`;
+      case "mssql" /* MS_SQL */:
+        return `[${str}]`;
+      case "mysql2" /* MY_SQL */:
+        return `\`${str}\``;
+    }
+  }
+  // Takes a string like a.b.c and returns a quoted identifier like [a].[b].[c]
+  // for SQL Server and `a`.`b`.`c` for MySQL.
+  quotedIdentifier(key) {
+    return key.split(".").map((part) => this.quote(part)).join(".");
+  }
+  generateSelectStatement() {
+    const { resource, meta } = this.query;
+    if (!resource || !resource.fields || resource.fields.length === 0) {
+      return "*";
+    }
+    const schema = meta.table.schema;
+    return resource.fields.map((field) => {
+      const parts = field.split(/\./g);
+      let table = void 0;
+      let column = void 0;
+      if (parts.length === 1) {
+        column = parts[0];
+      }
+      if (parts.length === 2) {
+        table = parts[0];
+        column = parts[1];
+      }
+      if (parts.length > 2) {
+        table = parts[0];
+        column = parts.slice(1).join(".");
+      }
+      if (!column) {
+        throw new Error(`Invalid field name: ${field}`);
+      }
+      const columnSchema = schema[column];
+      if (this.client === "pg" /* POSTGRES */ && columnSchema?.externalType?.includes("money")) {
+        return this.knex.raw(
+          `${this.quotedIdentifier(
+            [table, column].join(".")
+          )}::money::numeric as ${this.quote(field)}`
+        );
+      }
+      if (this.client === "mssql" /* MS_SQL */ && columnSchema?.type === "datetime" /* DATETIME */ && columnSchema.timeOnly) {
+        return this.knex.raw(`CONVERT(varchar, ${field}, 108) as "${field}"`);
+      }
+      if (table) {
+        return this.knex.raw(
+          `${this.quote(table)}.${this.quote(column)} as ${this.quote(field)}`
+        );
+      } else {
+        return this.knex.raw(`${this.quote(field)} as ${this.quote(field)}`);
+      }
+    });
+  }
+  // OracleDB can't use character-large-objects (CLOBs) in WHERE clauses,
+  // so when we use them we need to wrap them in to_char(). This function
+  // converts a field name to the appropriate identifier.
+  convertClobs(field) {
+    const parts = field.split(".");
+    const col = parts.pop();
+    const schema = this.table.schema[col];
+    let identifier = this.quotedIdentifier(field);
+    if (schema.type === "string" /* STRING */ || schema.type === "longform" /* LONGFORM */ || schema.type === "bb_reference_single" /* BB_REFERENCE_SINGLE */ || schema.type === "bb_reference" /* BB_REFERENCE */ || schema.type === "options" /* OPTIONS */ || schema.type === "barcodeqr" /* BARCODEQR */) {
+      identifier = `to_char(${identifier})`;
+    }
+    return identifier;
+  }
+  parse(input, schema) {
+    if (Array.isArray(input)) {
+      return JSON.stringify(input);
+    }
+    if (input == void 0) {
+      return null;
+    }
+    if (this.client === "oracledb" /* ORACLE */ && schema.type === "datetime" /* DATETIME */ && schema.timeOnly) {
+      if (input instanceof Date) {
+        const hours = input.getHours().toString().padStart(2, "0");
+        const minutes = input.getMinutes().toString().padStart(2, "0");
+        const seconds = input.getSeconds().toString().padStart(2, "0");
+        return `${hours}:${minutes}:${seconds}`;
+      }
+      if (typeof input === "string") {
+        return /* @__PURE__ */ new Date(`1970-01-01T${input}Z`);
+      }
+    }
+    if (typeof input === "string") {
+      if (isInvalidISODateString(input)) {
+        return null;
+      }
+      if (isValidISODateString(input)) {
+        return new Date(input.trim());
+      }
+    }
+    return input;
+  }
+  parseBody(body2) {
+    for (let [key, value] of Object.entries(body2)) {
+      const { column } = this.splitter.run(key);
+      const schema = this.table.schema[column];
+      if (!schema) {
+        continue;
+      }
+      body2[key] = this.parse(value, schema);
+    }
+    return body2;
+  }
+  parseFilters(filters) {
+    for (const op of Object.values(BasicOperator)) {
+      const filter = filters[op];
+      if (!filter) {
+        continue;
+      }
+      for (const key of Object.keys(filter)) {
+        if (Array.isArray(filter[key])) {
+          filter[key] = JSON.stringify(filter[key]);
+          continue;
+        }
+        const { column } = this.splitter.run(key);
+        const schema = this.table.schema[column];
+        if (!schema) {
+          continue;
+        }
+        filter[key] = this.parse(filter[key], schema);
+      }
+    }
+    for (const op of Object.values(ArrayOperator)) {
+      const filter = filters[op];
+      if (!filter) {
+        continue;
+      }
+      for (const key of Object.keys(filter)) {
+        const { column } = this.splitter.run(key);
+        const schema = this.table.schema[column];
+        if (!schema) {
+          continue;
+        }
+        filter[key] = filter[key].map((v) => this.parse(v, schema));
+      }
+    }
+    for (const op of Object.values(RangeOperator)) {
+      const filter = filters[op];
+      if (!filter) {
+        continue;
+      }
+      for (const key of Object.keys(filter)) {
+        const { column } = this.splitter.run(key);
+        const schema = this.table.schema[column];
+        if (!schema) {
+          continue;
+        }
+        const value = filter[key];
+        if ("low" in value) {
+          value.low = this.parse(value.low, schema);
+        }
+        if ("high" in value) {
+          value.high = this.parse(value.high, schema);
+        }
+      }
+    }
+    return filters;
   }
   // right now we only do filters on the specific table being queried
-  addFilters(query, filters, table, opts) {
+  addFilters(query, filters, opts) {
     if (!filters) {
       return query;
     }
-    filters = parseFilters(filters);
+    filters = this.parseFilters(filters);
+    const aliases = this.query.tableAliases;
     const allOr = filters.allOr;
-    const sqlStatements = new SqlStatements(this.client, table, {
-      allOr,
-      columnPrefix: opts.columnPrefix
-    });
-    const tableName = this.client === "sqlite3" /* SQL_LITE */ ? table._id : table.name;
+    const tableName = this.client === "sqlite3" /* SQL_LITE */ ? this.table._id : this.table.name;
     function getTableAlias(name) {
-      const alias = opts.aliases?.[name];
+      const alias = aliases?.[name];
       return alias || name;
     }
     function iterate(structure, fn, complexKeyFn) {
@@ -67853,10 +67933,10 @@ var InternalBuilder = class {
             ),
             castedTypeValue.values
           );
-        } else if (!opts.relationship && !isRelationshipField) {
+        } else if (!opts?.relationship && !isRelationshipField) {
           const alias = getTableAlias(tableName);
           fn(alias ? `${alias}.${updatedKey}` : updatedKey, value);
-        } else if (opts.relationship && isRelationshipField) {
+        } else if (opts?.relationship && isRelationshipField) {
           const [filterTableName, property] = updatedKey.split(".");
           const alias = getTableAlias(filterTableName);
           fn(alias ? `${alias}.${property}` : property, value);
@@ -67870,10 +67950,9 @@ var InternalBuilder = class {
         query = query[fnc](key, "ilike", `%${value}%`);
       } else {
         const rawFnc = `${fnc}Raw`;
-        query = query[rawFnc](
-          `LOWER(${quotedIdentifier(this.client, key)}) LIKE ?`,
-          [`%${value.toLowerCase()}%`]
-        );
+        query = query[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
+          `%${value.toLowerCase()}%`
+        ]);
       }
     };
     const contains = (mode, any = false) => {
@@ -67892,10 +67971,10 @@ var InternalBuilder = class {
           const wrap = any ? "" : "'";
           const op = any ? "\\?| array" : "@>";
           const fieldNames = key.split(/\./g);
-          const table2 = fieldNames[0];
+          const table = fieldNames[0];
           const col = fieldNames[1];
           query = query[rawFnc](
-            `${not}COALESCE("${table2}"."${col}"::jsonb ${op} ${wrap}${stringifyArray(
+            `${not}COALESCE("${table}"."${col}"::jsonb ${op} ${wrap}${stringifyArray(
               value,
               any ? "'" : '"'
             )}${wrap}, FALSE)`
@@ -67914,21 +67993,26 @@ var InternalBuilder = class {
         const andOr = mode === filters?.containsAny ? " OR " : " AND ";
         iterate(mode, (key, value) => {
           let statement = "";
+          const identifier = this.quotedIdentifier(key);
           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(${quotedIdentifier(
-              this.client,
-              key
-            )}), '') LIKE ?`;
+            statement += `${statement ? andOr : ""}COALESCE(LOWER(${identifier}), '') LIKE ?`;
           }
           if (statement === "") {
             return;
           }
-          query = query[rawFnc](`${not}(${statement})`, value);
+          if (not) {
+            query = query[rawFnc](
+              `(NOT (${statement}) OR ${identifier} IS NULL)`,
+              value
+            );
+          } else {
+            query = query[rawFnc](statement, value);
+          }
         });
       }
     };
@@ -67937,10 +68021,23 @@ var InternalBuilder = class {
       iterate(
         filters.oneOf,
         (key, array) => {
-          query = query[fnc](key, Array.isArray(array) ? array : [array]);
+          if (this.client === "oracledb" /* ORACLE */) {
+            key = this.convertClobs(key);
+            array = Array.isArray(array) ? array : [array];
+            const binding = new Array(array.length).fill("?").join(",");
+            query = query.whereRaw(`${key} IN (${binding})`, array);
+          } else {
+            query = query[fnc](key, Array.isArray(array) ? array : [array]);
+          }
         },
         (key, array) => {
-          query = query[fnc](key, Array.isArray(array) ? array : [array]);
+          if (this.client === "oracledb" /* ORACLE */) {
+            const keyStr = `(${key.map((k) => this.convertClobs(k)).join(",")})`;
+            const binding = `(${array.map((a) => `(${new Array(a.length).fill("?").join(",")})`).join(",")})`;
+            query = query.whereRaw(`${keyStr} IN ${binding}`, array.flat());
+          } else {
+            query = query[fnc](key, Array.isArray(array) ? array : [array]);
+          }
         }
       );
     }
@@ -67951,10 +68048,9 @@ var InternalBuilder = class {
           query = query[fnc](key, "ilike", `${value}%`);
         } else {
           const rawFnc = `${fnc}Raw`;
-          query = query[rawFnc](
-            `LOWER(${quotedIdentifier(this.client, key)}) LIKE ?`,
-            [`${value.toLowerCase()}%`]
-          );
+          query = query[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
+            `${value.toLowerCase()}%`
+          ]);
         }
       });
     }
@@ -67973,12 +68069,40 @@ var InternalBuilder = class {
           value.high = "";
         }
         const lowValid = isValidFilter(value.low), highValid = isValidFilter(value.high);
+        const schema = this.getFieldSchema(key);
+        if (this.client === "oracledb" /* ORACLE */) {
+          key = this.knex.raw(this.convertClobs(key));
+        }
         if (lowValid && highValid) {
-          query = sqlStatements.between(query, key, value.low, value.high);
+          if (schema?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
+            query = query.whereRaw(
+              `CAST(${key} AS INTEGER) BETWEEN CAST(? AS INTEGER) AND CAST(? AS INTEGER)`,
+              [value.low, value.high]
+            );
+          } else {
+            const fnc = allOr ? "orWhereBetween" : "whereBetween";
+            query = query[fnc](key, [value.low, value.high]);
+          }
         } else if (lowValid) {
-          query = sqlStatements.lte(query, key, value.low);
+          if (schema?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
+            query = query.whereRaw(
+              `CAST(${key} AS INTEGER) >= CAST(? AS INTEGER)`,
+              [value.low]
+            );
+          } else {
+            const fnc = allOr ? "orWhere" : "where";
+            query = query[fnc](key, ">=", value.low);
+          }
         } else if (highValid) {
-          query = sqlStatements.gte(query, key, value.high);
+          if (schema?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
+            query = query.whereRaw(
+              `CAST(${key} AS INTEGER) <= CAST(? AS INTEGER)`,
+              [value.high]
+            );
+          } else {
+            const fnc = allOr ? "orWhere" : "where";
+            query = query[fnc](key, "<=", value.high);
+          }
         }
       });
     }
@@ -67987,20 +68111,18 @@ var InternalBuilder = class {
         const fnc = allOr ? "orWhereRaw" : "whereRaw";
         if (this.client === "mssql" /* MS_SQL */) {
           query = query[fnc](
-            `CASE WHEN ${quotedIdentifier(
-              this.client,
-              key
-            )} = ? THEN 1 ELSE 0 END = 1`,
+            `CASE WHEN ${this.quotedIdentifier(key)} = ? THEN 1 ELSE 0 END = 1`,
             [value]
           );
         } else if (this.client === "oracledb" /* ORACLE */) {
+          const identifier = this.convertClobs(key);
           query = query[fnc](
-            `COALESCE(${quotedIdentifier(this.client, key)}, -1) = ?`,
+            `(${identifier} IS NOT NULL AND ${identifier} = ?)`,
             [value]
           );
         } else {
           query = query[fnc](
-            `COALESCE(${quotedIdentifier(this.client, key)} = ?, FALSE)`,
+            `COALESCE(${this.quotedIdentifier(key)} = ?, FALSE)`,
             [value]
           );
         }
@@ -68011,20 +68133,18 @@ var InternalBuilder = class {
         const fnc = allOr ? "orWhereRaw" : "whereRaw";
         if (this.client === "mssql" /* MS_SQL */) {
           query = query[fnc](
-            `CASE WHEN ${quotedIdentifier(
-              this.client,
-              key
-            )} = ? THEN 1 ELSE 0 END = 0`,
+            `CASE WHEN ${this.quotedIdentifier(key)} = ? THEN 1 ELSE 0 END = 0`,
             [value]
           );
         } else if (this.client === "oracledb" /* ORACLE */) {
+          const identifier = this.convertClobs(key);
           query = query[fnc](
-            `COALESCE(${quotedIdentifier(this.client, key)}, -1) != ?`,
+            `(${identifier} IS NOT NULL AND ${identifier} != ?) OR ${identifier} IS NULL`,
             [value]
           );
         } else {
           query = query[fnc](
-            `COALESCE(${quotedIdentifier(this.client, key)} != ?, TRUE)`,
+            `COALESCE(${this.quotedIdentifier(key)} != ?, TRUE)`,
             [value]
           );
         }
@@ -68051,8 +68171,8 @@ var InternalBuilder = class {
     if (filters.containsAny) {
       contains(filters.containsAny, true);
     }
-    const tableRef = opts?.aliases?.[table._id] || table._id;
-    if (filters.documentType && !isExternalTable(table) && tableRef) {
+    const tableRef = aliases?.[this.table._id] || this.table._id;
+    if (filters.documentType && !isExternalTable(this.table) && tableRef) {
       query.andWhereLike(
         `${tableRef}._id`,
         `${prefixed(filters.documentType)}%`
@@ -68060,34 +68180,39 @@ var InternalBuilder = class {
     }
     return query;
   }
-  addDistinctCount(query, json) {
-    const table = json.meta.table;
-    const primary = table.primary;
-    const aliases = json.tableAliases;
-    const aliased = table.name && aliases?.[table.name] ? aliases[table.name] : table.name;
+  addDistinctCount(query) {
+    const primary = this.table.primary;
+    const aliases = this.query.tableAliases;
+    const aliased = this.table.name && aliases?.[this.table.name] ? aliases[this.table.name] : this.table.name;
     if (!primary) {
       throw new Error("SQL counting requires primary key to be supplied");
     }
     return query.countDistinct(`${aliased}.${primary[0]} as total`);
   }
-  addSorting(query, json) {
-    let { sort: sort2 } = json;
-    const table = json.meta.table;
-    const primaryKey = table.primary;
-    const tableName = getTableName(table);
-    const aliases = json.tableAliases;
-    const aliased = tableName && aliases?.[tableName] ? aliases[tableName] : table?.name;
+  addSorting(query) {
+    let { sort: sort2 } = this.query;
+    const primaryKey = this.table.primary;
+    const tableName = getTableName(this.table);
+    const aliases = this.query.tableAliases;
+    const aliased = tableName && aliases?.[tableName] ? aliases[tableName] : this.table?.name;
     if (!Array.isArray(primaryKey)) {
       throw new Error("Sorting requires primary key to be specified for table");
     }
     if (sort2 && Object.keys(sort2 || {}).length > 0) {
       for (let [key, value] of Object.entries(sort2)) {
         const direction = value.direction === "ascending" /* ASCENDING */ ? "asc" : "desc";
-        let nulls;
-        if (this.client === "pg" /* POSTGRES */) {
+        let nulls = void 0;
+        if (this.client === "pg" /* POSTGRES */ || this.client === "oracledb" /* ORACLE */) {
           nulls = value.direction === "ascending" /* ASCENDING */ ? "first" : "last";
         }
-        query = query.orderBy(`${aliased}.${key}`, direction, nulls);
+        let composite = `${aliased}.${key}`;
+        if (this.client === "oracledb" /* ORACLE */) {
+          query = query.orderByRaw(
+            `${this.convertClobs(composite)} ${direction} nulls ${nulls}`
+          );
+        } else {
+          query = query.orderBy(composite, direction, nulls);
+        }
       }
     }
     if (!sort2 || sort2[primaryKey[0]] === void 0) {
@@ -68162,23 +68287,41 @@ var InternalBuilder = class {
     }
     return query;
   }
-  knexWithAlias(knex3, endpoint, aliases) {
-    const tableName = endpoint.entityId;
-    const tableAlias = aliases?.[tableName];
-    return knex3(
-      this.tableNameWithSchema(tableName, {
-        alias: tableAlias,
-        schema: endpoint.schema
+  qualifiedKnex(opts) {
+    let alias = this.query.tableAliases?.[this.query.endpoint.entityId];
+    if (opts?.alias === false) {
+      alias = void 0;
+    } else if (typeof opts?.alias === "string") {
+      alias = opts.alias;
+    }
+    return this.knex(
+      this.tableNameWithSchema(this.query.endpoint.entityId, {
+        alias,
+        schema: this.query.endpoint.schema
       })
     );
   }
-  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];
+  create(opts) {
+    const { body: body2 } = this.query;
+    let query = this.qualifiedKnex({ alias: false });
+    const parsedBody = this.parseBody(body2);
+    if (this.client === "oracledb" /* ORACLE */) {
+      for (const [column, schema] of Object.entries(
+        this.query.meta.table.schema
+      )) {
+        if (schema.constraints?.presence === true || schema.type === "formula" /* FORMULA */ || schema.type === "auto" /* AUTO */ || schema.type === "link" /* LINK */) {
+          continue;
+        }
+        const value = parsedBody[column];
+        if (value == null) {
+          parsedBody[column] = null;
+        }
+      }
+    } else {
+      for (let [key, value] of Object.entries(parsedBody)) {
+        if (value == null) {
+          delete parsedBody[key];
+        }
       }
     }
     if (opts.disableReturning) {
@@ -68187,40 +68330,40 @@ var InternalBuilder = class {
       return query.insert(parsedBody).returning("*");
     }
   }
-  bulkCreate(knex3, json) {
-    const { endpoint, body: body2 } = json;
-    let query = this.knexWithAlias(knex3, endpoint);
+  bulkCreate() {
+    const { body: body2 } = this.query;
+    let query = this.qualifiedKnex({ alias: false });
     if (!Array.isArray(body2)) {
       return query;
     }
-    const parsedBody = body2.map((row) => parseBody(row));
+    const parsedBody = body2.map((row) => this.parseBody(row));
     return query.insert(parsedBody);
   }
-  bulkUpsert(knex3, json) {
-    const { endpoint, body: body2 } = json;
-    let query = this.knexWithAlias(knex3, endpoint);
+  bulkUpsert() {
+    const { body: body2 } = this.query;
+    let query = this.qualifiedKnex({ alias: false });
     if (!Array.isArray(body2)) {
       return query;
     }
-    const parsedBody = body2.map((row) => parseBody(row));
+    const parsedBody = body2.map((row) => this.parseBody(row));
     if (this.client === "pg" /* POSTGRES */ || this.client === "sqlite3" /* SQL_LITE */ || this.client === "mysql2" /* MY_SQL */) {
-      const primary = json.meta.table.primary;
+      const primary = this.table.primary;
       if (!primary) {
         throw new Error("Primary key is required for upsert");
       }
       const ret = query.insert(parsedBody).onConflict(primary).merge();
       return ret;
-    } else if (this.client === "mssql" /* MS_SQL */) {
+    } else if (this.client === "mssql" /* MS_SQL */ || this.client === "oracledb" /* ORACLE */) {
       return query.insert(parsedBody);
     }
     return query.upsert(parsedBody);
   }
-  read(knex3, json, opts = {}) {
-    let { endpoint, filters, paginate, relationships, tableAliases } = json;
+  read(opts = {}) {
+    let { endpoint, filters, paginate, relationships, tableAliases } = this.query;
     const { limits } = opts;
     const counting = endpoint.operation === "COUNT" /* COUNT */;
     const tableName = endpoint.entityId;
-    let query = this.knexWithAlias(knex3, endpoint, tableAliases);
+    let query = this.qualifiedKnex();
     let foundOffset = null;
     let foundLimit = limits?.query || limits?.base;
     if (paginate && paginate.page && paginate.limit) {
@@ -68241,23 +68384,20 @@ var InternalBuilder = class {
       if (foundOffset != null) {
         query = query.offset(foundOffset);
       }
-      query = this.addSorting(query, json);
+      query = this.addSorting(query);
     }
-    query = this.addFilters(query, filters, json.meta.table, {
-      columnPrefix: json.meta.columnPrefix,
-      aliases: tableAliases
-    });
+    query = this.addFilters(query, filters);
     const alias = tableAliases?.[tableName] || tableName;
-    let preQuery = knex3({
+    let preQuery = this.knex({
       // the typescript definition for the knex constructor doesn't support this
       // syntax, but it is the only way to alias a pre-query result as part of
       // a query - there is an alias dictionary type, but it assumes it can only
       // be a table name, not a pre-query
       [alias]: query
     });
-    preQuery = !counting ? preQuery.select(generateSelectStatement(json, knex3)) : this.addDistinctCount(preQuery, json);
+    preQuery = !counting ? preQuery.select(this.generateSelectStatement()) : this.addDistinctCount(preQuery);
     if (this.client !== "mssql" /* MS_SQL */ && !counting) {
-      preQuery = this.addSorting(preQuery, json);
+      preQuery = this.addSorting(preQuery);
     }
     query = this.addRelationships(
       preQuery,
@@ -68269,43 +68409,33 @@ var InternalBuilder = class {
     if (limits?.base) {
       query = query.limit(limits.base);
     }
-    return this.addFilters(query, filters, json.meta.table, {
-      columnPrefix: json.meta.columnPrefix,
-      relationship: true,
-      aliases: tableAliases
-    });
+    return this.addFilters(query, filters, { relationship: true });
   }
-  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, {
-      columnPrefix: json.meta.columnPrefix,
-      aliases: tableAliases
-    });
+  update(opts) {
+    const { body: body2, filters } = this.query;
+    let query = this.qualifiedKnex();
+    const parsedBody = this.parseBody(body2);
+    query = this.addFilters(query, filters);
     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, {
-      columnPrefix: json.meta.columnPrefix,
-      aliases: tableAliases
-    });
+  delete(opts) {
+    const { filters } = this.query;
+    let query = this.qualifiedKnex();
+    query = this.addFilters(query, filters);
     if (opts.disableReturning) {
       return query.delete();
     } else {
-      return query.delete().returning(generateSelectStatement(json, knex3));
+      return query.delete().returning(this.generateSelectStatement());
     }
   }
 };
 var SqlQueryBuilder = class extends sqlTable_default {
   // pass through client to get flavour of SQL
-  constructor(client, limit2 = BASE_LIMIT) {
+  constructor(client, limit2 = getBaseLimit()) {
     super(client);
     this.limit = limit2;
   }
@@ -68332,38 +68462,38 @@ var SqlQueryBuilder = class extends sqlTable_default {
     const config = {
       client: sqlClient
     };
-    if (sqlClient === "sqlite3" /* SQL_LITE */) {
+    if (sqlClient === "sqlite3" /* SQL_LITE */ || sqlClient === "oracledb" /* ORACLE */) {
       config.useNullAsDefault = true;
     }
     const client = (0, import_knex2.knex)(config);
     let query;
-    const builder = new InternalBuilder(sqlClient);
+    const builder = new InternalBuilder(sqlClient, client, json);
     switch (this._operation(json)) {
       case "CREATE" /* CREATE */:
-        query = builder.create(client, json, opts);
+        query = builder.create(opts);
         break;
       case "READ" /* READ */:
-        query = builder.read(client, json, {
+        query = builder.read({
           limits: {
             query: this.limit,
-            base: BASE_LIMIT
+            base: getBaseLimit()
           }
         });
         break;
       case "COUNT" /* COUNT */:
-        query = builder.read(client, json);
+        query = builder.read();
         break;
       case "UPDATE" /* UPDATE */:
-        query = builder.update(client, json, opts);
+        query = builder.update(opts);
         break;
       case "DELETE" /* DELETE */:
-        query = builder.delete(client, json, opts);
+        query = builder.delete(opts);
         break;
       case "BULK_CREATE" /* BULK_CREATE */:
-        query = builder.bulkCreate(client, json);
+        query = builder.bulkCreate();
         break;
       case "BULK_UPSERT" /* BULK_UPSERT */:
-        query = builder.bulkUpsert(client, json);
+        query = builder.bulkUpsert();
         break;
       case "CREATE_TABLE" /* CREATE_TABLE */:
       case "UPDATE_TABLE" /* UPDATE_TABLE */: