envio 3.12.0 → 3.13.0-alpha.0

package/src/db/EntityFilter.res.mjs

@@ -2,104 +2,48 @@
 
 import * as Table from "./Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 
-function toString(tNonOptional) {
-  if (Array.isArray(tNonOptional)) {
-    return `[` + tNonOptional.map(toString).join(",") + `]`;
-  }
-  switch (typeof tNonOptional) {
-    case "string" :
-      return tNonOptional;
-    case "bigint" :
-    case "number" :
-      return tNonOptional.toString();
-    case "object" :
-      return tNonOptional.toString();
-    case "boolean" :
-      if (tNonOptional) {
-        return "true";
-      } else {
-        return "false";
-      }
-  }
-}
+let nullish = (v => v === undefined || v === null);
 
-function asBytes(value) {
-  return Utils.Bytes.asUint8Array(value);
+function asArray(v) {
+  return v;
 }
 
-function toString$1(value) {
-  let match = Utils.Bytes.asUint8Array(value);
-  if (match !== undefined) {
-    return Utils.Bytes.toHex(match);
-  } else if (value !== undefined) {
-    return toString(value);
-  } else {
-    return "undefined";
+let encodeValueKey = (v => {
+  if (v === null) return "z"
+  switch (typeof v) {
+    case "string": return "s" + v.length + ":" + v
+    case "number": { const s = "" + v; return "n" + s.length + ":" + s }
+    case "bigint": { const s = "" + v; return "g" + s.length + ":" + s }
+    case "boolean": return v ? "t" : "f"
+    case "undefined": return "u"
+    default: { const s = JSON.stringify(v); return "o" + s.length + ":" + s }
   }
-}
+});
 
-function compareWith(a, b, bigDecimal, bytes, fallback) {
-  let match = Utils.Bytes.asUint8Array(a);
-  let match$1 = Utils.Bytes.asUint8Array(b);
-  if (match !== undefined && match$1 !== undefined) {
-    return bytes(Utils.Bytes.compare(match, match$1));
-  }
-  if (typeof a === "object" && !Array.isArray(a) && typeof b === "object" && !Array.isArray(b)) {
-    return bigDecimal(a, b);
-  } else {
-    return fallback(a, b);
-  }
-}
+let isKeyable = (function isKeyable(v) {
+  if (typeof v !== "object" || v === null) return true
+  if (Array.isArray(v)) return v.every(isKeyable)
+  try { JSON.stringify(v); return true } catch { return false }
+});
 
-function eq(a, b) {
-  return compareWith(a, b, (prim0, prim1) => prim0.isEqualTo(prim1), order => order === 0, Primitive_object.equal);
-}
-
-function gt(a, b) {
-  return compareWith(a, b, (prim0, prim1) => prim0.isGreaterThan(prim1), order => order > 0, Primitive_object.greaterthan);
-}
-
-function lt(a, b) {
-  return compareWith(a, b, (prim0, prim1) => prim0.isLessThan(prim1), order => order < 0, Primitive_object.lessthan);
-}
-
-let FieldValue = {
-  asBytes: asBytes,
-  toString: toString$1,
-  compareWith: compareWith,
-  eq: eq,
-  gt: gt,
-  lt: lt
-};
-
-function toString$2(filter) {
-  switch (filter.operator) {
-    case "=" :
-      return filter.fieldName + `:Eq:` + toString$1(filter.fieldValue);
-    case ">" :
-      return filter.fieldName + `:Gt:` + toString$1(filter.fieldValue);
-    case "<" :
-      return filter.fieldName + `:Lt:` + toString$1(filter.fieldValue);
-    case "in" :
-      return filter.fieldName + `:In:[` + filter.fieldValue.map(toString$1).join(",") + `]`;
-    case "and" :
-      return `And(` + filter.filters.map(toString$2).join(",") + `)`;
-  }
+function entries(filter) {
+  return filter;
 }
 
 function valuesCount(filter) {
-  switch (filter.operator) {
-    case "in" :
-      return filter.fieldValue.length;
-    case "and" :
-      return Stdlib_Array.reduce(filter.filters, 0, (acc, filter) => acc + valuesCount(filter) | 0);
-    default:
-      return 1;
-  }
+  let count = {
+    contents: 0
+  };
+  Utils.Dict.forEachWithKey(filter, (operators, param) => Utils.Dict.forEachWithKey(operators, (fieldValue, operator) => {
+    count.contents = count.contents + (
+      operator === "_in" ? fieldValue.length : 1
+    ) | 0;
+  }));
+  return count.contents;
 }
 
 let codegenHelpMessage = `Rerun 'pnpm dev' to update generated code after schema.graphql changes.`;
@@ -119,12 +63,69 @@ function throwUnsupportedGetWhereValue(valueName, entityName, filterDisplay, hin
   return Stdlib_JsError.throwWithMessage(`Invalid ` + valueName + ` value passed to context.` + entityName + `.getWhere(` + filterDisplay + `). Filtering by null or undefined values is not supported in getWhere.` + hint);
 }
 
-function parseGetWhereOrThrow(filter, entityName, table) {
+let isDate = (v => v instanceof Date);
+
+function expectedValueType(field) {
+  let match = field.fieldType;
+  if (typeof match === "object") {
+    return;
+  }
+  switch (match) {
+    case "Bytea" :
+      return field.isArray ? "an array of Uint8Array" : "a Uint8Array";
+    case "Date" :
+      return field.isArray ? "an array of Date" : "a Date";
+    default:
+      return;
+  }
+}
+
+function keyUsesSerializer(field) {
+  let match = field.fieldType;
+  if (typeof match === "object") {
+    return match.type !== "BigDecimal";
+  }
+  switch (match) {
+    case "Bytea" :
+    case "Date" :
+      return false;
+    default:
+      return true;
+  }
+}
+
+function matchesFieldType(value, field) {
+  let matchesScalar = value => {
+    let match = field.fieldType;
+    if (typeof match === "object") {
+      return true;
+    }
+    switch (match) {
+      case "Bytea" :
+        return Stdlib_Option.isSome(Utils.Bytes.asUint8Array(value));
+      case "Date" :
+        return isDate(value);
+      default:
+        return true;
+    }
+  };
+  if (field.isArray) {
+    if (Array.isArray(value)) {
+      return value.every(matchesScalar);
+    } else {
+      return false;
+    }
+  } else {
+    return matchesScalar(value);
+  }
+}
+
+function parseOrThrow(filter, entityName, table) {
   let filterKeys = Object.keys(filter);
   if (filterKeys.length === 0) {
     Stdlib_JsError.throwWithMessage(`Empty filter passed to context.` + entityName + `.getWhere(). Please provide a filter like { fieldName: { _eq: value } }.`);
   }
-  let filterGroups = filterKeys.flatMap(apiFieldName => {
+  filterKeys.forEach(apiFieldName => {
     let operatorObj = filter[apiFieldName];
     let valueName = getUndefinedOrNullName(operatorObj);
     if (valueName !== undefined) {
@@ -137,7 +138,6 @@ function parseGetWhereOrThrow(filter, entityName, table) {
     if (operatorKeys.length === 0) {
       Stdlib_JsError.throwWithMessage(`Empty operator passed to context.` + entityName + `.getWhere({ ` + apiFieldName + `: {} }). Please provide an operator like { _eq: value }, { _gt: value }, { _lt: value }, { _gte: value }, { _lte: value }, or { _in: [values] }.`);
     }
-    let throwInvalidOperator = operatorKey => Stdlib_JsError.throwWithMessage(`Invalid operator "` + operatorKey + `" in context.` + entityName + `.getWhere({ ` + apiFieldName + `: { ` + operatorKey + `: ... } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`);
     operatorKeys.forEach(operatorKey => {
       switch (operatorKey) {
         case "_eq" :
@@ -148,167 +148,108 @@ function parseGetWhereOrThrow(filter, entityName, table) {
         case "_lte" :
           return;
         default:
-          return throwInvalidOperator(operatorKey);
+          return Stdlib_JsError.throwWithMessage(`Invalid operator "` + operatorKey + `" in context.` + entityName + `.getWhere({ ` + apiFieldName + `: { ` + operatorKey + `: ... } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`);
       }
     });
     let match = Table.getFieldByApiName(table, apiFieldName);
-    if (match !== undefined) {
-      if (match.TAG !== "Field") {
-        Stdlib_JsError.throwWithMessage(`The field "` + apiFieldName + `" on entity "` + entityName + `" is a derived field and cannot be used in getWhere(). Use the source entity's indexed field instead.`);
-      }
-    } else {
-      Stdlib_JsError.throwWithMessage(`Invalid field "` + apiFieldName + `" in context.` + entityName + `.getWhere(). The field doesn't exist. ` + codegenHelpMessage);
-    }
-    return operatorKeys.map(operatorKey => {
+    let field = match !== undefined ? (
+        match.TAG === "Field" ? match._0 : Stdlib_JsError.throwWithMessage(`The field "` + apiFieldName + `" on entity "` + entityName + `" is a derived field and cannot be used in getWhere(). Use the source entity's indexed field instead.`)
+      ) : Stdlib_JsError.throwWithMessage(`Invalid field "` + apiFieldName + `" in context.` + entityName + `.getWhere(). The field doesn't exist. ` + codegenHelpMessage);
+    let expectedType = expectedValueType(field);
+    let checkKeyable = keyUsesSerializer(field);
+    operatorKeys.forEach(operatorKey => {
       let fieldValue = operatorObj[operatorKey];
       let valueName = getUndefinedOrNullName(fieldValue);
       if (valueName !== undefined) {
         throwUnsupportedGetWhereValue(valueName, entityName, `{ ` + apiFieldName + `: { ` + operatorKey + `: ` + valueName + ` } }`, undefined);
       }
-      switch (operatorKey) {
-        case "_eq" :
-          return [{
-              operator: "=",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            }];
-        case "_gt" :
-          return [{
-              operator: ">",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            }];
-        case "_gte" :
-          return [
-            {
-              operator: "=",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            },
-            {
-              operator: ">",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            }
-          ];
-        case "_in" :
-          if (!Array.isArray(fieldValue)) {
-            Stdlib_JsError.throwWithMessage(`Invalid value passed to context.` + entityName + `.getWhere({ ` + apiFieldName + `: { _in: ... } }). The _in operator expects an array of values.`);
+      let throwUnexpectedType = (typeName, hint) => Stdlib_JsError.throwWithMessage(`Invalid value passed to context.` + entityName + `.getWhere({ ` + apiFieldName + `: { ` + operatorKey + `: ... } }). The field "` + apiFieldName + `" expects ` + typeName + `.` + hint);
+      let throwUnkeyable = hint => Stdlib_JsError.throwWithMessage(`Invalid value passed to context.` + entityName + `.getWhere({ ` + apiFieldName + `: { ` + operatorKey + `: ... } }). The value can't be serialized, so it can't be used as a filter. An object holding a bigint, or a circular reference, is not supported.` + hint);
+      if (operatorKey === "_in") {
+        if (!Array.isArray(fieldValue)) {
+          Stdlib_JsError.throwWithMessage(`Invalid value passed to context.` + entityName + `.getWhere({ ` + apiFieldName + `: { _in: ... } }). The _in operator expects an array of values.`);
+        }
+        fieldValue.forEach((fieldValue, index) => {
+          let valueName = getUndefinedOrNullName(fieldValue);
+          if (valueName !== undefined) {
+            throwUnsupportedGetWhereValue(valueName, entityName, `{ ` + apiFieldName + `: { _in: [...] } }`, ` The ` + valueName + ` value is at index ` + index.toString() + ` of the _in array.`);
           }
-          return fieldValue.map((fieldValue, index) => {
-            let valueName = getUndefinedOrNullName(fieldValue);
-            if (valueName !== undefined) {
-              throwUnsupportedGetWhereValue(valueName, entityName, `{ ` + apiFieldName + `: { _in: [...] } }`, ` The ` + valueName + ` value is at index ` + index.toString() + ` of the _in array.`);
-            }
-            return {
-              operator: "=",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            };
-          });
-        case "_lt" :
-          return [{
-              operator: "<",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            }];
-        case "_lte" :
-          return [
-            {
-              operator: "=",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            },
-            {
-              operator: "<",
-              fieldName: apiFieldName,
-              fieldValue: fieldValue
-            }
-          ];
-        default:
-          return throwInvalidOperator(operatorKey);
+          if (expectedType !== undefined && !matchesFieldType(fieldValue, field)) {
+            throwUnexpectedType(expectedType, ` The value is at index ` + index.toString() + ` of the _in array.`);
+          }
+          if (checkKeyable && !isKeyable(fieldValue)) {
+            return throwUnkeyable(` The value is at index ` + index.toString() + ` of the _in array.`);
+          }
+        });
+        return;
+      }
+      if (expectedType !== undefined && !matchesFieldType(fieldValue, field)) {
+        throwUnexpectedType(expectedType, "");
+      }
+      if (checkKeyable && !isKeyable(fieldValue)) {
+        return throwUnkeyable("");
       }
     });
   });
-  return Stdlib_Array.reduce(filterGroups, [[]], (combinations, group) => combinations.flatMap(combination => group.map(filter => combination.concat([filter])))).map(filters => {
-    if (filters.length !== 1) {
-      return {
-        operator: "and",
-        filters: filters
-      };
-    } else {
-      return filters[0];
-    }
-  });
+  return filter;
 }
 
-function printOperationFilter(filter, paramsCount) {
-  switch (filter.operator) {
-    case "=" :
-      paramsCount.contents = paramsCount.contents + 1 | 0;
-      return filter.fieldName + `: $` + paramsCount.contents.toString();
-    case ">" :
-      paramsCount.contents = paramsCount.contents + 1 | 0;
-      return filter.fieldName + `: {_gt: $` + paramsCount.contents.toString() + `}`;
-    case "<" :
-      paramsCount.contents = paramsCount.contents + 1 | 0;
-      return filter.fieldName + `: {_lt: $` + paramsCount.contents.toString() + `}`;
-    case "in" :
-      paramsCount.contents = paramsCount.contents + 1 | 0;
-      return filter.fieldName + `: {_in: $` + paramsCount.contents.toString() + `}`;
-    case "and" :
-      let filters = filter.filters;
-      let acc = "";
-      for (let idx = 0, idx_finish = filters.length; idx < idx_finish; ++idx) {
-        let part = printOperationFilter(filters[idx], paramsCount);
-        acc = acc === "" ? part : acc + `, ` + part;
+function byIds(ids) {
+  return Object.fromEntries([[
+      Table.idFieldName,
+      {
+        _in: ids
       }
-      return acc;
-  }
+    ]]);
 }
 
-function toOperationKey(filter, entityName) {
-  switch (filter.operator) {
-    case "=" :
-      return entityName + `.getWhere({` + filter.fieldName + `: $1})`;
-    case ">" :
-      return entityName + `.getWhere({` + filter.fieldName + `: {_gt: $1}})`;
-    case "<" :
-      return entityName + `.getWhere({` + filter.fieldName + `: {_lt: $1}})`;
-    case "in" :
-      return entityName + `.getWhere({` + filter.fieldName + `: {_in: $1}})`;
-    case "and" :
-      return entityName + `.getWhere({` + printOperationFilter(filter, {
-        contents: 0
-      }) + `})`;
+function scoped(filter, table, scope) {
+  let match = Table.getChainIdField(table);
+  if (scope === "crossChain") {
+    return filter;
+  }
+  if (match === undefined) {
+    return filter;
   }
+  let scoped$1 = Utils.Dict.shallowCopy(filter);
+  scoped$1[match.fieldName] = {
+    _eq: scope
+  };
+  return scoped$1;
 }
 
 function getParams(filter) {
-  switch (filter.operator) {
-    case "in" :
-      return filter.fieldValue;
-    case "and" :
-      let acc = [];
-      let collect = filter => {
-        switch (filter.operator) {
-          case "and" :
-            filter.filters.forEach(collect);
-            return;
-          default:
-            acc.push(filter.fieldValue);
-            return;
-        }
-      };
-      collect(filter);
-      return acc;
-    default:
-      return [filter.fieldValue];
+  let params = [];
+  Utils.Dict.forEachWithKey(filter, (operators, param) => Utils.Dict.forEachWithKey(operators, (fieldValue, param) => {
+    params.push(fieldValue);
+  }));
+  return params;
+}
+
+function asSingleOperator(filter) {
+  let match = Object.keys(filter);
+  if (match.length !== 1) {
+    return;
+  }
+  let fieldName = match[0];
+  let operators = filter[fieldName];
+  let match$1 = Object.keys(operators);
+  if (match$1.length !== 1) {
+    return;
   }
+  let operator = match$1[0];
+  return [
+    fieldName,
+    operator,
+    operators[operator]
+  ];
 }
 
 function throwUnmergeable(filter) {
-  return Stdlib_JsError.throwWithMessage(`Unexpected filter ` + toString$2(filter) + ` in a merged batch. Filters batched into a single query must use the same operator and field.`);
+  let match = asSingleOperator(filter);
+  return Stdlib_JsError.throwWithMessage(`Unexpected ` + (
+    match !== undefined ? match[1] : "composite"
+  ) + ` filter in a merged batch. Filters batched into a single query must use the same operator and field.`);
 }
 
 function merge(filters) {
@@ -319,110 +260,417 @@ function merge(filters) {
   if (len === 0) {
     return filters;
   }
-  let match = filters[0];
-  switch (match.operator) {
-    case "=" :
-      return [{
-          operator: "in",
-          fieldName: match.fieldName,
-          fieldValue: filters.map(filter => {
-            if (filter.operator === "=") {
-              return filter.fieldValue;
-            } else {
-              return throwUnmergeable(filter);
-            }
-          })
-        }];
-    case "in" :
-      return [{
-          operator: "in",
-          fieldName: match.fieldName,
-          fieldValue: filters.map(filter => {
-            if (filter.operator === "in") {
-              return filter.fieldValue;
-            } else {
-              return throwUnmergeable(filter);
-            }
-          }).flat()
-        }];
+  let match = asSingleOperator(filters[0]);
+  if (match === undefined) {
+    return filters;
+  }
+  let operator = match[1];
+  let fieldName = match[0];
+  switch (operator) {
+    case "_eq" :
+    case "_in" :
+      break;
     default:
       return filters;
   }
+  let values = [];
+  filters.forEach(filter => {
+    let match = asSingleOperator(filter);
+    if (match === undefined) {
+      return throwUnmergeable(filter);
+    }
+    if (match[0] !== fieldName || match[1] !== operator) {
+      return throwUnmergeable(filter);
+    }
+    let fieldValue = match[2];
+    if (operator === "_in") {
+      fieldValue.forEach(value => {
+        values.push(value);
+      });
+    } else {
+      values.push(fieldValue);
+    }
+  });
+  return [Object.fromEntries([[
+        fieldName,
+        {
+          _in: values
+        }
+      ]])];
+}
+
+function nativeEq(a, b) {
+  return a === b;
+}
+
+let nativeGt = ((a, b) => a != null && a > b);
+
+let nativeLt = ((a, b) => a != null && a < b);
+
+function identityKey(v) {
+  return v;
 }
 
-function matches(filter, entity) {
-  switch (filter.operator) {
-    case "=" :
-      return eq(entity[filter.fieldName], filter.fieldValue);
-    case ">" :
-      return gt(entity[filter.fieldName], filter.fieldValue);
-    case "<" :
-      return lt(entity[filter.fieldName], filter.fieldValue);
-    case "in" :
-      let entityFieldValue = entity[filter.fieldName];
-      return filter.fieldValue.some(fieldValue => eq(entityFieldValue, fieldValue));
-    case "and" :
-      let filters = filter.filters;
-      if (filters.length !== 0) {
-        return filters.every(filter => matches(filter, entity));
+let native = {
+  eq: nativeEq,
+  gt: nativeGt,
+  lt: nativeLt,
+  key: identityKey
+};
+
+function nullSafe(compare) {
+  return {
+    eq: (a, b) => {
+      if (nullish(a)) {
+        return false;
       } else {
-        return Stdlib_JsError.throwWithMessage(`The "and" filter must contain at least one nested filter.`);
+        return compare.eq(a, b);
       }
+    },
+    gt: (a, b) => {
+      if (nullish(a)) {
+        return false;
+      } else {
+        return compare.gt(a, b);
+      }
+    },
+    lt: (a, b) => {
+      if (nullish(a)) {
+        return false;
+      } else {
+        return compare.lt(a, b);
+      }
+    },
+    key: compare.key
+  };
+}
+
+function asBigDecimal(v) {
+  return v;
+}
+
+let bigDecimal = nullSafe({
+  eq: (a, b) => a.isEqualTo(b),
+  gt: (a, b) => a.isGreaterThan(b),
+  lt: (a, b) => a.isLessThan(b),
+  key: v => v.toString()
+});
+
+function getTime(v) {
+  return v.getTime();
+}
+
+let date = nullSafe({
+  eq: (a, b) => a.getTime() === b.getTime(),
+  gt: (a, b) => a.getTime() > b.getTime(),
+  lt: (a, b) => a.getTime() < b.getTime(),
+  key: v => v.getTime()
+});
+
+let json = nullSafe({
+  eq: Primitive_object.equal,
+  gt: Primitive_object.greaterthan,
+  lt: Primitive_object.lessthan,
+  key: v => JSON.stringify(v)
+});
+
+function asBytes(v) {
+  return v;
+}
+
+let bytes = nullSafe({
+  eq: (a, b) => Utils.Bytes.compare(a, b) === 0,
+  gt: (a, b) => Utils.Bytes.compare(a, b) > 0,
+  lt: (a, b) => Utils.Bytes.compare(a, b) < 0,
+  key: v => Utils.Bytes.toHex(v)
+});
+
+function enum_(config) {
+  let ranks = {};
+  config.variants.forEach((variant, rank) => {
+    ranks[variant] = rank;
+  });
+  return {
+    eq: nativeEq,
+    gt: (a, b) => {
+      if (nullish(a)) {
+        return false;
+      } else {
+        return ranks[a] > ranks[b];
+      }
+    },
+    lt: (a, b) => {
+      if (nullish(a)) {
+        return false;
+      } else {
+        return ranks[a] < ranks[b];
+      }
+    },
+    key: identityKey
+  };
+}
+
+function scalarCompare(fieldType) {
+  if (typeof fieldType !== "object") {
+    switch (fieldType) {
+      case "Bytea" :
+        return bytes;
+      case "Json" :
+        return json;
+      case "Date" :
+        return date;
+      default:
+        return native;
+    }
+  } else {
+    switch (fieldType.type) {
+      case "BigDecimal" :
+        return bigDecimal;
+      case "Enum" :
+        return enum_(fieldType.config);
+      default:
+        return native;
+    }
   }
 }
 
-function mapValues(filter, mapValue) {
-  switch (filter.operator) {
-    case "=" :
-      let fieldName = filter.fieldName;
-      return {
-        operator: "=",
-        fieldName: fieldName,
-        fieldValue: mapValue(fieldName, filter.fieldValue, false)
-      };
-    case ">" :
-      let fieldName$1 = filter.fieldName;
-      return {
-        operator: ">",
-        fieldName: fieldName$1,
-        fieldValue: mapValue(fieldName$1, filter.fieldValue, false)
-      };
-    case "<" :
-      let fieldName$2 = filter.fieldName;
-      return {
-        operator: "<",
-        fieldName: fieldName$2,
-        fieldValue: mapValue(fieldName$2, filter.fieldValue, false)
-      };
-    case "in" :
-      let fieldName$3 = filter.fieldName;
-      return {
-        operator: "in",
-        fieldName: fieldName$3,
-        fieldValue: mapValue(fieldName$3, filter.fieldValue, true)
-      };
-    case "and" :
-      return {
-        operator: "and",
-        filters: filter.filters.map(filter => mapValues(filter, mapValue))
+function arrayCompare(element) {
+  let eq = (a, b) => {
+    let len = a.length;
+    if (len !== b.length) {
+      return false;
+    }
+    let _i = 0;
+    while (true) {
+      let i = _i;
+      if (i >= len) {
+        return true;
+      }
+      if (!element.eq(a[i], b[i])) {
+        return false;
+      }
+      _i = i + 1 | 0;
+      continue;
+    };
+  };
+  let order = gt => ((a, b) => {
+    let la = a.length;
+    let lb = b.length;
+    let len = la < lb ? la : lb;
+    let _i = 0;
+    while (true) {
+      let i = _i;
+      if (i >= len) {
+        if (gt) {
+          return la > lb;
+        } else {
+          return la < lb;
+        }
+      }
+      let x = a[i];
+      let y = b[i];
+      if (!element.eq(x, y)) {
+        if (gt) {
+          return element.gt(x, y);
+        } else {
+          return element.lt(x, y);
+        }
+      }
+      _i = i + 1 | 0;
+      continue;
+    };
+  });
+  return nullSafe({
+    eq: eq,
+    gt: order(true),
+    lt: order(false),
+    key: v => {
+      let key = {
+        contents: ""
       };
+      v.forEach(item => {
+        key.contents = key.contents + encodeValueKey(element.key(item));
+      });
+      return key.contents;
+    }
+  });
+}
+
+let comparesByField = Utils.$$WeakMap.memoize(table => {
+  let compares = {};
+  table.fields.forEach(field => {
+    if (field.TAG !== "Field") {
+      return;
+    }
+    let field$1 = field._0;
+    let element = scalarCompare(field$1.fieldType);
+    compares[Table.getApiFieldName(field$1)] = field$1.isArray ? arrayCompare(element) : element;
+  });
+  return compares;
+});
+
+function fieldCompare(table, fieldName) {
+  let compare = comparesByField(table)[fieldName];
+  if (compare !== undefined) {
+    return compare;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Internal error: no comparator for the field "` + fieldName + `" on the table "` + table.tableName + `". A filter is parsed against its table before it reaches the in-memory matcher.`);
+  }
+}
+
+function makeValueKey(table, fieldName) {
+  return fieldCompare(table, fieldName).key;
+}
+
+function toString(filter, table) {
+  let key = {
+    contents: ""
+  };
+  Utils.Dict.forEachWithKey(filter, (operators, fieldName) => {
+    let keyOf = fieldCompare(table, fieldName).key;
+    Utils.Dict.forEachWithKey(operators, (fieldValue, operator) => {
+      key.contents = key.contents + fieldName + operator;
+      if (operator === "_in") {
+        fieldValue.forEach(value => {
+          key.contents = key.contents + encodeValueKey(keyOf(value));
+        });
+      } else {
+        key.contents = key.contents + encodeValueKey(keyOf(fieldValue));
+      }
+      key.contents = key.contents + ";";
+    });
+  });
+  return key.contents;
+}
+
+function toOperationKey(filter, entityName) {
+  let params = {
+    contents: 0
+  };
+  let printed = {
+    contents: ""
+  };
+  Utils.Dict.forEachWithKey(filter, (operators, fieldName) => {
+    let ops = {
+      contents: ""
+    };
+    let loneEq = {
+      contents: false
+    };
+    Utils.Dict.forEachWithKey(operators, (param, operator) => {
+      params.contents = params.contents + 1 | 0;
+      let part = operator + `: $` + params.contents.toString();
+      loneEq.contents = ops.contents === "" && operator === "_eq";
+      ops.contents = ops.contents === "" ? part : ops.contents + ", " + part;
+    });
+    let part = loneEq.contents ? fieldName + `: $` + params.contents.toString() : fieldName + `: {` + ops.contents + `}`;
+    printed.contents = printed.contents === "" ? part : printed.contents + ", " + part;
+  });
+  return entityName + `.getWhere({` + printed.contents + `})`;
+}
+
+function makeMatcher(filter, table) {
+  let checks = [];
+  Utils.Dict.forEachWithKey(filter, (operators, fieldName) => {
+    let compare = fieldCompare(table, fieldName);
+    Utils.Dict.forEachWithKey(operators, (fieldValue, operator) => {
+      let check;
+      switch (operator) {
+        case "_eq" :
+          check = entity => compare.eq(entity[fieldName], fieldValue);
+          break;
+        case "_gt" :
+          check = entity => compare.gt(entity[fieldName], fieldValue);
+          break;
+        case "_gte" :
+          check = entity => {
+            let entityFieldValue = entity[fieldName];
+            if (compare.eq(entityFieldValue, fieldValue)) {
+              return true;
+            } else {
+              return compare.gt(entityFieldValue, fieldValue);
+            }
+          };
+          break;
+        case "_in" :
+          if (compare.eq === nativeEq) {
+            let set = new Set(fieldValue);
+            check = entity => set.has(entity[fieldName]);
+          } else {
+            check = entity => {
+              let entityFieldValue = entity[fieldName];
+              return fieldValue.some(candidate => compare.eq(entityFieldValue, candidate));
+            };
+          }
+          break;
+        case "_lt" :
+          check = entity => compare.lt(entity[fieldName], fieldValue);
+          break;
+        case "_lte" :
+          check = entity => {
+            let entityFieldValue = entity[fieldName];
+            if (compare.eq(entityFieldValue, fieldValue)) {
+              return true;
+            } else {
+              return compare.lt(entityFieldValue, fieldValue);
+            }
+          };
+          break;
+        default:
+          check = Stdlib_JsError.throwWithMessage(`Invalid operator "` + operator + `" in a getWhere filter. Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`);
+      }
+      checks.push(check);
+    });
+  });
+  if (checks.length !== 1) {
+    return entity => checks.every(check => check(entity));
+  } else {
+    return checks[0];
   }
 }
 
 export {
-  FieldValue,
-  toString$2 as toString,
+  nullish,
+  asArray,
+  encodeValueKey,
+  isKeyable,
+  entries,
   valuesCount,
   codegenHelpMessage,
   getUndefinedOrNullName,
   throwUnsupportedGetWhereValue,
-  parseGetWhereOrThrow,
-  printOperationFilter,
-  toOperationKey,
+  isDate,
+  expectedValueType,
+  keyUsesSerializer,
+  matchesFieldType,
+  parseOrThrow,
+  byIds,
+  scoped,
   getParams,
+  asSingleOperator,
   throwUnmergeable,
   merge,
-  matches,
-  mapValues,
+  nativeEq,
+  nativeGt,
+  nativeLt,
+  identityKey,
+  native,
+  nullSafe,
+  asBigDecimal,
+  bigDecimal,
+  getTime,
+  date,
+  json,
+  asBytes,
+  bytes,
+  enum_,
+  scalarCompare,
+  arrayCompare,
+  comparesByField,
+  fieldCompare,
+  makeValueKey,
+  toString,
+  toOperationKey,
+  makeMatcher,
 }
-/* Table Not a pure module */
+/* bigDecimal Not a pure module */