envio/src/db/EntityFilter.res.mjs

A latency and sync speed optimized, developer friendly blockchain data indexer.

// Generated by ReScript, PLEASE EDIT WITH CARE

import * as Table from "./Table.res.mjs";
import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.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";
      }
  }
}

function toString$1(value) {
  if (value !== undefined) {
    return toString(value);
  } else {
    return "undefined";
  }
}

function eq(a, b) {
  if (typeof a === "object" && !Array.isArray(a) && typeof b === "object" && !Array.isArray(b)) {
    return a.isEqualTo(b);
  } else {
    return Primitive_object.equal(a, b);
  }
}

function gt(a, b) {
  if (typeof a === "object" && !Array.isArray(a) && typeof b === "object" && !Array.isArray(b)) {
    return a.isGreaterThan(b);
  } else {
    return Primitive_object.greaterthan(a, b);
  }
}

function lt(a, b) {
  if (typeof a === "object" && !Array.isArray(a) && typeof b === "object" && !Array.isArray(b)) {
    return a.isLessThan(b);
  } else {
    return Primitive_object.lessthan(a, b);
  }
}

let FieldValue = {
  toString: toString$1,
  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 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 codegenHelpMessage = `Rerun 'pnpm dev' to update generated code after schema.graphql changes.`;

function getUndefinedOrNullName(value) {
  if (value === undefined) {
    return "undefined";
  } else if (value === null) {
    return "null";
  } else {
    return;
  }
}

function throwUnsupportedGetWhereValue(valueName, entityName, filterDisplay, hintOpt) {
  let hint = hintOpt !== undefined ? hintOpt : "";
  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 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 => {
    let operatorObj = filter[apiFieldName];
    let valueName = getUndefinedOrNullName(operatorObj);
    if (valueName !== undefined) {
      throwUnsupportedGetWhereValue(valueName, entityName, `{ ` + apiFieldName + `: ` + valueName + ` }`, ` Please provide an operator like { _eq: value }.`);
    }
    if (typeof operatorObj !== "object" || Array.isArray(operatorObj)) {
      Stdlib_JsError.throwWithMessage(`Invalid value passed to context.` + entityName + `.getWhere({ ` + apiFieldName + `: ... }). Please provide an operator like { _eq: value }.`);
    }
    let operatorKeys = Object.keys(operatorObj);
    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" :
        case "_gt" :
        case "_gte" :
        case "_in" :
        case "_lt" :
        case "_lte" :
          return;
        default:
          return throwInvalidOperator(operatorKey);
      }
    });
    let match = Table.getFieldByApiName(table, apiFieldName);
    if (match !== undefined) {
      if (match.TAG === "Field") {
        let match$1 = match._0;
        if (match$1.isPrimaryKey || match$1.isIndex || match$1.linkedEntity !== undefined) {
          
        } else {
          Stdlib_JsError.throwWithMessage(`The field "` + apiFieldName + `" on entity "` + entityName + `" does not have an index. To use it in getWhere(), add the @index directive in your schema.graphql:\n\n  ` + apiFieldName + `: ... @index\n\nThen run 'pnpm envio codegen' to regenerate.`);
        }
      } else {
        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 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.`);
          }
          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);
      }
    });
  });
  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];
    }
  });
}

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;
      }
      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 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];
  }
}

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.`);
}

function merge(filters) {
  let len = filters.length;
  if (len === 1) {
    return 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()
        }];
    default:
      return filters;
  }
}

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));
      } else {
        return Stdlib_JsError.throwWithMessage(`The "and" filter must contain at least one nested filter.`);
      }
  }
}

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))
      };
  }
}

export {
  FieldValue,
  toString$2 as toString,
  valuesCount,
  codegenHelpMessage,
  getUndefinedOrNullName,
  throwUnsupportedGetWhereValue,
  parseGetWhereOrThrow,
  printOperationFilter,
  toOperationKey,
  getParams,
  throwUnmergeable,
  merge,
  matches,
  mapValues,
}
/* Table Not a pure module */