envio 3.12.0 → 3.12.1

package/src/PgStorage.res.mjs

@@ -19,6 +19,7 @@ import * as ChainState from "./ChainState.res.mjs";
 import * as AddressRows from "./AddressRows.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
+import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as IndexCatalog from "./db/IndexCatalog.res.mjs";
 import * as IndexManager from "./db/IndexManager.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -301,7 +302,7 @@ function makeLoadQuery(pgSchema, tableName, condition) {
   return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE ` + condition + `;`;
 }
 
-function makeFilterCondition(filter, table, params) {
+function makeFilterCondition(filter, table, pgSchema, params) {
   let getQueryFieldOrThrow = fieldName => {
     let queryField = Table.queryFields(table)[fieldName];
     if (queryField !== undefined) {
@@ -333,39 +334,76 @@ function makeFilterCondition(filter, table, params) {
     params.push(param);
     return `$` + params.length.toString();
   };
-  let scalarCondition = (fieldName, fieldValue, op) => {
-    let queryField = getQueryFieldOrThrow(fieldName);
-    return `"` + queryField.pgDbFieldName + `" ` + op + ` ` + serializeParamOrThrow(queryField, fieldName, fieldValue, false);
+  let condition = {
+    contents: ""
   };
-  switch (filter.operator) {
-    case "=" :
-      let fieldValue = filter.fieldValue;
-      let fieldName = filter.fieldName;
-      if (getQueryFieldOrThrow(fieldName).isChainId) {
-        return `"` + getQueryFieldOrThrow(fieldName).pgDbFieldName + `" = ` + ChainId.toString(ChainId.normalizeOrThrow(fieldValue));
-      } else {
-        return scalarCondition(fieldName, fieldValue, "=");
+  Utils.Dict.forEachWithKey(EntityFilter.entries(filter), (operators, fieldName) => {
+    let queryField = getQueryFieldOrThrow(fieldName);
+    Utils.Dict.forEachWithKey(operators, (fieldValue, operator) => {
+      let column = `"` + queryField.pgDbFieldName + `"`;
+      let part;
+      let exit = 0;
+      switch (operator) {
+        case "_eq" :
+          if (queryField.isChainId) {
+            part = column + ` = ` + ChainId.toString(ChainId.normalizeOrThrow(fieldValue));
+          } else {
+            exit = 1;
+          }
+          break;
+        case "_in" :
+          if (queryField.isArray || queryField.fieldType === "Boolean") {
+            let candidates = EntityFilter.asArray(fieldValue);
+            part = candidates.length !== 0 ? `(` + candidates.map(candidate => column + ` = ` + serializeParamOrThrow(queryField, fieldName, candidate, false)).join(" OR ") + `)` : "FALSE";
+          } else {
+            let param = serializeParamOrThrow(queryField, fieldName, fieldValue, true);
+            let match = queryField.fieldType;
+            let exit$1 = 0;
+            if (typeof match !== "object" || match.type !== "Enum") {
+              exit$1 = 2;
+            } else {
+              part = column + ` = ANY(` + param + `::TEXT[]::"` + pgSchema + `".` + match.config.name + `[])`;
+            }
+            if (exit$1 === 2) {
+              part = column + ` = ANY(` + param + `)`;
+            }
+          }
+          break;
+        default:
+          exit = 1;
       }
-    case ">" :
-      return scalarCondition(filter.fieldName, filter.fieldValue, ">");
-    case "<" :
-      return scalarCondition(filter.fieldName, filter.fieldValue, "<");
-    case "in" :
-      let fieldName$1 = filter.fieldName;
-      let queryField = getQueryFieldOrThrow(fieldName$1);
-      return `"` + queryField.pgDbFieldName + `" = ANY(` + serializeParamOrThrow(queryField, fieldName$1, filter.fieldValue, true) + `)`;
-    case "and" :
-      let filters = filter.filters;
-      if (filters.length !== 0) {
-        return `(` + filters.map(filter => makeFilterCondition(filter, table, params)).join(" AND ") + `)`;
+      if (exit === 1) {
+        let sqlOperator;
+        switch (operator) {
+          case "_eq" :
+            sqlOperator = "=";
+            break;
+          case "_gt" :
+            sqlOperator = ">";
+            break;
+          case "_gte" :
+            sqlOperator = ">=";
+            break;
+          case "_lt" :
+            sqlOperator = "<";
+            break;
+          case "_lte" :
+            sqlOperator = "<=";
+            break;
+          default:
+            throw {
+              RE_EXN_ID: Persistence.StorageError,
+              message: `Failed loading "` + table.tableName + `" from storage. Unknown filter operator "` + operator + `".`,
+              reason: new Error(`Unknown filter operator "` + operator + `"`),
+              Error: new Error()
+            };
+        }
+        part = column + ` ` + sqlOperator + ` ` + serializeParamOrThrow(queryField, fieldName, fieldValue, false);
       }
-      throw {
-        RE_EXN_ID: Persistence.StorageError,
-        message: `Failed loading "` + table.tableName + `" from storage. The "and" filter must contain at least one nested filter.`,
-        reason: new Error(`Empty "and" filter`),
-        Error: new Error()
-      };
-  }
+      condition.contents = condition.contents === "" ? part : condition.contents + " AND " + part;
+    });
+  });
+  return condition.contents;
 }
 
 function makeChainIdCondition(table, chainId) {
@@ -1032,16 +1070,10 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let isolated = isolatedOpt !== undefined ? isolatedOpt : false;
   let containerName = "envio-postgres";
-  let psqlExecOptions_env = Object.fromEntries([
-    [
-      "PGPASSWORD",
-      pgPassword
-    ],
-    [
-      "PATH",
-      process.env.PATH
-    ]
-  ]);
+  let psqlExecOptions_env = {
+    PGPASSWORD: pgPassword,
+    PATH: process.env.PATH
+  };
   let psqlExecOptions = {
     env: psqlExecOptions_env
   };
@@ -1222,7 +1254,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   };
   let loadOrThrow = async (filter, table) => {
     let params = [];
-    let condition = makeFilterCondition(filter, table, params);
+    let condition = makeFilterCondition(filter, table, pgSchema, params);
     let rows;
     try {
       rows = await sql.unsafe(makeLoadQuery(pgSchema, table.tableName, condition), params, {prepare: true});
@@ -1251,12 +1283,8 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     let queryFields = Table.queryFields(table);
     let columns = [];
     let seen = new Set();
-    let collect = filter => {
-      if (filter.operator === "and") {
-        filter.filters.forEach(collect);
-        return;
-      }
-      let match = queryFields[filter.fieldName];
+    filters.forEach(filter => Utils.Dict.forEachWithKey(EntityFilter.entries(filter), (param, fieldName) => {
+      let match = queryFields[fieldName];
       if (match === undefined) {
         return;
       }
@@ -1266,8 +1294,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         columns.push(pgDbFieldName);
         return;
       }
-    };
-    filters.forEach(collect);
+    }));
     return columns;
   };
   let runAndVerify = async (sql, prepared) => {

package/src/TestIndexer.res

@@ -75,15 +75,10 @@ let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFi
   | None => []
   | Some(entityConfig) =>
     let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
-    let matched =
-      entityDict
-      ->Dict.valuesToArray
-      ->Array.filter(entity => {
-        // The store holds decoded entities and the filter carries decoded values,
-        // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
-        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-        filter->EntityFilter.matches(~entity=entityAsDict)
-      })
+    // The store holds decoded entities and the filter carries decoded values,
+    // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
+    let matcher = filter->EntityFilter.makeMatcher(~table=entityConfig.table)
+    let matched = entityDict->Dict.valuesToArray->Array.filter(matcher)
     // The chain is already fixed by the scope the load ran for, so the loaded
     // entity is handed back in the shape the handlers see.
     switch entityConfig.table->Table.getChainIdField {
@@ -544,23 +539,12 @@ let makeEntityGetWhere = (~state: testIndexerState, ~entityConfig: Internal.enti
         `Cannot call ${entityConfig.name}.getWhere() while indexer.process() is running. ` ++ "Wait for process() to complete before accessing entities directly.",
       )
     }
-    let filters =
-      filter->EntityFilter.parseGetWhereOrThrow(
-        ~entityName=entityConfig.name,
-        ~table=entityConfig.table,
-      )
+    let matcher =
+      filter
+      ->EntityFilter.parseOrThrow(~entityName=entityConfig.name, ~table=entityConfig.table)
+      ->EntityFilter.makeMatcher(~table=entityConfig.table)
     let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
-    // parseGetWhereOrThrow expands an operator group into alternatives whose
-    // matches are disjoint, so the union needs no dedup.
-    Promise.resolve(
-      entityDict
-      ->Dict.valuesToArray
-      ->Array.filter(entity => {
-        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-        filters->Array.some(filter => filter->EntityFilter.matches(~entity=entityAsDict))
-      })
-      ->Array.map(copyEntity),
-    )
+    Promise.resolve(entityDict->Dict.valuesToArray->Array.filter(matcher)->Array.map(copyEntity))
   }
 }
 

package/src/TestIndexer.res.mjs

@@ -56,7 +56,8 @@ function handleLoad(state, tableName, filter) {
     return [];
   }
   let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
-  let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
+  let matcher = EntityFilter.makeMatcher(filter, entityConfig.table);
+  let matched = Object.values(entityDict).filter(matcher);
   let field = Table.getChainIdField(entityConfig.table);
   if (field !== undefined) {
     return matched.map(entity => {
@@ -376,9 +377,9 @@ function makeEntityGetWhere(state, entityConfig) {
     if (state.processInProgress) {
       Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.getWhere() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
     }
-    let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
+    let matcher = EntityFilter.makeMatcher(EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table), entityConfig.table);
     let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-    return Promise.resolve(Object.values(entityDict).filter(entity => filters.some(filter => EntityFilter.matches(filter, entity))).map(copyEntity));
+    return Promise.resolve(Object.values(entityDict).filter(matcher).map(copyEntity));
   };
 }
 

package/src/UserContext.res

@@ -122,39 +122,20 @@ type entityContextParams = {
 // The handler context is always chain-scoped, so a per-chain entity resolves to
 // the chain the handler runs on and a cross-chain one to the shared partition.
 let entityScope = (params: entityContextParams) =>
-  params.entityConfig->InMemoryStore.entityScope(
-    ~chainId=params.item->Internal.getItemChainId,
-  )
-
-let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>) => {
-  let entityConfig = params.entityConfig
-
-  @inline
-  let loadWithFilter = filter =>
-    LoadLayer.loadByFilter(
-      ~loadManager=params.loadManager,
-      ~persistence=params.persistence,
-      ~entityConfig,
-      ~scope=params->entityScope,
-      ~indexerState=params.indexerState,
-      ~shouldGroup=params.isPreload,
-      ~item=params.item,
-      ~ecosystem=params.config.ecosystem,
-      ~filter,
-    )
+  params.entityConfig->InMemoryStore.entityScope(~chainId=params.item->Internal.getItemChainId)
 
-  switch filter->EntityFilter.parseGetWhereOrThrow(
-    ~entityName=entityConfig.name,
-    ~table=entityConfig.table,
-  ) {
-  | [single] => loadWithFilter(single)
-  | filters =>
-    filters
-    ->Array.map(filter => loadWithFilter(filter))
-    ->Promise.all
-    ->Promise.thenResolve(results => results->Array.flat)
-  }
-}
+let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>) =>
+  LoadLayer.loadByFilter(
+    ~loadManager=params.loadManager,
+    ~persistence=params.persistence,
+    ~entityConfig=params.entityConfig,
+    ~scope=params->entityScope,
+    ~indexerState=params.indexerState,
+    ~shouldGroup=params.isPreload,
+    ~item=params.item,
+    ~ecosystem=params.config.ecosystem,
+    ~filter,
+  )
 
 let noopSet = (_entity: Internal.entity) => ()
 let noopDeleteUnsafe = (_entityId: EntityId.t) => ()

package/src/UserContext.res.mjs

@@ -77,13 +77,7 @@ function entityScope(params) {
 }
 
 function getWhereHandler(params, filter) {
-  let entityConfig = params.entityConfig;
-  let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
-  if (filters.length !== 1) {
-    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
-  } else {
-    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
-  }
+  return LoadLayer.loadByFilter(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter);
 }
 
 function noopSet(_entity) {

package/src/Utils.res

@@ -273,7 +273,7 @@ module Dict = {
 }
 
 module Math = {
-  let minOptInt = (a, b) =>
+  let minOptInt = (a: option<int>, b: option<int>) =>
     switch (a, b) {
     | (Some(a), Some(b)) => Some(a < b ? a : b)
     | (Some(a), None) => Some(a)
@@ -374,9 +374,6 @@ module Array = {
   /**
 Helper to check if a value exists in an array
 */
-  let includes = (arr: array<'a>, val: 'a) =>
-    arr->Array.find(item => item == val)->Stdlib.Option.isSome
-
   let isEmpty = (arr: array<_>) =>
     switch arr {
     | [] => true

package/src/Utils.res.mjs

@@ -6,11 +6,9 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -221,19 +219,17 @@ let Dict = {
 };
 
 function minOptInt(a, b) {
-  if (a === undefined) {
+  if (a !== undefined) {
     if (b !== undefined) {
-      return Primitive_option.some(Primitive_option.valFromOption(b));
+      return a < b ? a : b;
     } else {
-      return;
+      return a;
     }
+  } else if (b !== undefined) {
+    return b;
+  } else {
+    return;
   }
-  let a$1 = Primitive_option.valFromOption(a);
-  if (b === undefined) {
-    return Primitive_option.some(a$1);
-  }
-  let b$1 = Primitive_option.valFromOption(b);
-  return Primitive_option.some(Primitive_object.lessthan(a$1, b$1) ? a$1 : b$1);
 }
 
 let $$Math = {
@@ -324,10 +320,6 @@ function transposeResults(results) {
   };
 }
 
-function includes(arr, val) {
-  return Stdlib_Option.isSome(arr.find(item => Primitive_object.equal(item, val)));
-}
-
 function isEmpty$1(arr) {
   return arr.length === 0;
 }
@@ -435,7 +427,6 @@ let $$Array$1 = {
   clearInPlace: clearInPlace$1,
   setIndexImmutable: setIndexImmutable,
   transposeResults: transposeResults,
-  includes: includes,
   isEmpty: isEmpty$1,
   notEmpty: notEmpty,
   awaitEach: awaitEach,