envio 3.15.0 → 3.16.0-subgraph

package/src/db/Table.res

@@ -160,34 +160,6 @@ let fitPgTableName = (fullName, ~uniqueSuffix) =>
     fullName
   }
 
-// The variant's name and whichever of precision, scale and enum name it
-// carries. They travel to the addon separately because napi has no tagged
-// union of its own.
-let pgFieldTypeParts = (fieldType: fieldType) =>
-  switch fieldType {
-  | String => ("String", None, None, None)
-  | Boolean => ("Boolean", None, None, None)
-  | Uint32 => ("Uint32", None, None, None)
-  | UInt52 => ("UInt52", None, None, None)
-  | SmallInt => ("SmallInt", None, None, None)
-  | Bytea => ("Bytea", None, None, None)
-  | UInt64 => ("UInt64", None, None, None)
-  | Int32 => ("Int32", None, None, None)
-  | ChainId => ("ChainId", None, None, None)
-  | Number => ("Number", None, None, None)
-  | BigInt({?precision}) => ("BigInt", precision, None, None)
-  | BigDecimal({?config}) =>
-    switch config {
-    | Some((precision, scale)) => ("BigDecimal", Some(precision), Some(scale), None)
-    | None => ("BigDecimal", None, None, None)
-    }
-  | Serial => ("Serial", None, None, None)
-  | BigSerial => ("BigSerial", None, None, None)
-  | Json => ("Json", None, None, None)
-  | Date => ("Date", None, None, None)
-  | Enum({config}) => ("Enum", None, None, Some(config.name))
-  }
-
 type indexFieldDirection = Asc | Desc
 
 type compositeIndexField = {
@@ -200,13 +172,37 @@ type table = {
   fields: array<fieldOrDerived>,
   compositeIndexes: array<array<compositeIndexField>>,
   description: option<string>,
+  // The string an id keys a dict or Set by, picked from the id column's type
+  // so a string id, the common case, is its own key.
+  entityIdToKey: EntityId.t => string,
 }
 
+let stringEntityIdToKey = (Utils.magic: EntityId.t => string)
+// Always a string, never the raw number: a Set tells 7 from "7".
+let numericEntityIdToKey = (String.make: EntityId.t => string)
+// Hex rather than `String`, which decodes a Buffer as UTF-8 and so collides
+// distinct byte sequences.
+let bytesEntityIdToKey =
+  Utils.Bytes.toHex->(Utils.magic: (Uint8Array.t => string) => EntityId.t => string)
+
+let entityIdToKeyFor = (fields: array<fieldOrDerived>) =>
+  switch fields->Array.findMap(field =>
+    switch field {
+    | Field({fieldName, fieldType}) if fieldName === idFieldName => Some(fieldType)
+    | _ => None
+    }
+  ) {
+  | Some(Bytea) => bytesEntityIdToKey
+  | Some(String) | None => stringEntityIdToKey
+  | Some(_) => numericEntityIdToKey
+  }
+
 let mkTable = (tableName, ~compositeIndexes=[], ~fields, ~description=?) => {
   tableName,
   fields,
   compositeIndexes,
   description,
+  entityIdToKey: entityIdToKeyFor(fields),
 }
 
 let getFields = table =>
@@ -275,15 +271,6 @@ let getIdFieldOrThrow = (table): field =>
 let getIdSchema = (table): S.t<EntityId.t> =>
   (table->getIdFieldOrThrow).fieldSchema->(Utils.magic: S.t<unknown> => S.t<EntityId.t>)
 
-// Serializes an array of ids to the JSON form the SQL layer binds. The array
-// schema is memoized per table so its serializer compiles once, not on every
-// (high-frequency) delete/history write.
-let idsArraySchema: table => S.t<array<EntityId.t>> = Utils.WeakMap.memoize(table =>
-  S.array(table->getIdSchema)
-)
-let encodeIdsToJson = (table, ids: array<EntityId.t>): JSON.t =>
-  ids->S.reverseConvertToJsonOrThrow(table->idsArraySchema)
-
 // TODO: Test whether it should be passed via args and match the column type
 
 // Resolved once per table, because a getWhere looks up every field it filters
@@ -368,116 +355,3 @@ let pgEntityRowsSchema: table => S.t<array<unknown>> = Utils.WeakMap.memoize(tab
 )
 
 exception NonExistingTableField(string)
-
-/*
-Gets all composite indexes (whether they are single indexes or not)
-And maps the fields defined to their actual db name (some have _id suffix)
-*/
-let getUnfilteredCompositeIndexesUnsafe = (table): array<array<compositeIndexField>> => {
-  table.compositeIndexes->Array.map(compositeIndex =>
-    compositeIndex->Array.map(indexField => {
-      let dbFieldName = switch table->getFieldByName(indexField.fieldName) {
-      | Some(field) => field->getPgFieldName
-      | None => throw(NonExistingTableField(indexField.fieldName)) //Unexpected should be validated in schema parser
-      }
-      {fieldName: dbFieldName, direction: indexField.direction}
-    })
-  )
-}
-
-// The table's fields in the order the schema names them, which is the order an
-// insert names its columns and binds its values.
-//
-// A `@derivedFrom` field is not one of them: it is resolved from the other side
-// of the relationship rather than stored, so no row schema carries one and
-// there is no column for it to be.
-let schemaOrderedFields = (table: table, ~schema): array<field> =>
-  switch schema->S.classify {
-  | Object({items}) =>
-    items->Array.map(({location}) =>
-      switch table->getFieldByApiName(location) {
-      | Some(Field(field)) => field
-      | Some(DerivedFrom(_)) | None => throw(NonExistingTableField(location))
-      }
-    )
-  | _ =>
-    JsError.throwWithMessage(
-      `Failed reading the columns of "${table.tableName}". Expected an object schema for a table.`,
-    )
-  }
-
-let toDbSchema = (table: table, ~schema): S.t<'entity> => {
-  let dbSchema: S.t<dict<unknown>> = S.schema(s =>
-    switch schema->S.classify {
-    | Object({items}) =>
-      let dict = Dict.make()
-      items->Array.forEach(({location, schema}) => {
-        let rec coerceSchema = schema =>
-          switch schema->S.classify {
-          | BigInt => Utils.BigInt.schema->S.toUnknown
-          | Option(child)
-          | Null(child) =>
-            Utils.Schema.nullTolerant(child->coerceSchema)->S.toUnknown
-          | Array(child) => S.array(child->coerceSchema)->S.toUnknown
-          | Bool =>
-            // Booleans travel as 1/0; the insert casts them back.
-            S.union([
-              S.literal(1)->S.shape(_ => true),
-              S.literal(0)->S.shape(_ => false),
-            ])->S.toUnknown
-          | _ => schema
-          }
-
-        if table->getFieldByApiName(location)->Option.isNone {
-          throw(NonExistingTableField(location))
-        }
-
-        dict->Dict.set(location, s.matches(schema->coerceSchema))
-      })
-      dict
-    | _ =>
-      JsError.throwWithMessage("Failed creating db schema. Expected an object schema for table")
-    }
-  )
-
-  dbSchema->(Utils.magic: S.t<dict<unknown>> => S.t<'entity>)
-}
-
-/*
-Gets all single indexes
-And maps the fields defined to their actual db name (some have _id suffix)
-*/
-let getSingleIndexes = (table): array<string> => {
-  let indexFields = table.fields->Array.filterMap(field =>
-    switch field {
-    | Field(field) if field.isIndex => Some(field->getPgDbFieldName)
-    | _ => None
-    }
-  )
-
-  table
-  ->getUnfilteredCompositeIndexesUnsafe
-  //get all composite indexes with only 1 field defined
-  //this is still a single index
-  ->Array.filterMap(cidx =>
-    switch cidx {
-    | [{fieldName}] => Some([fieldName])
-    | _ => None
-    }
-  )
-  ->Array.concat([indexFields])
-  ->Array.flat
-  ->Set.fromArray
-  ->Set.toArray
-  ->Array.toSorted(String.compare)
-}
-
-/*
-Gets all composite indexes
-And maps the fields defined to their actual db name (some have _id suffix)
-*/
-let getCompositeIndexes = (table): array<array<compositeIndexField>> => {
-  table
-  ->getUnfilteredCompositeIndexesUnsafe
-  ->Array.filter(ind => ind->Array.length > 1)
-}

package/src/db/Table.res.mjs

@@ -3,8 +3,6 @@
 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_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -106,142 +104,39 @@ function fitPgTableName(fullName, uniqueSuffix) {
   }
 }
 
-function pgFieldTypeParts(fieldType) {
-  if (typeof fieldType !== "object") {
-    switch (fieldType) {
-      case "String" :
-        return [
-          "String",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Boolean" :
-        return [
-          "Boolean",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Uint32" :
-        return [
-          "Uint32",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "UInt52" :
-        return [
-          "UInt52",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "SmallInt" :
-        return [
-          "SmallInt",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Bytea" :
-        return [
-          "Bytea",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "UInt64" :
-        return [
-          "UInt64",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Int32" :
-        return [
-          "Int32",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "ChainId" :
-        return [
-          "ChainId",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Number" :
-        return [
-          "Number",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Serial" :
-        return [
-          "Serial",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "BigSerial" :
-        return [
-          "BigSerial",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Json" :
-        return [
-          "Json",
-          undefined,
-          undefined,
-          undefined
-        ];
-      case "Date" :
-        return [
-          "Date",
-          undefined,
-          undefined,
-          undefined
-        ];
+function stringEntityIdToKey(prim) {
+  return prim;
+}
+
+function numericEntityIdToKey(prim) {
+  return String(prim);
+}
+
+let bytesEntityIdToKey = Utils.Bytes.toHex;
+
+function entityIdToKeyFor(fields) {
+  let match = Stdlib_Array.findMap(fields, field => {
+    if (field.TAG !== "Field") {
+      return;
     }
-  } else {
-    switch (fieldType.type) {
-      case "BigInt" :
-        return [
-          "BigInt",
-          fieldType.precision,
-          undefined,
-          undefined
-        ];
-      case "BigDecimal" :
-        let config = fieldType.config;
-        if (config !== undefined) {
-          return [
-            "BigDecimal",
-            config[0],
-            config[1],
-            undefined
-          ];
-        } else {
-          return [
-            "BigDecimal",
-            undefined,
-            undefined,
-            undefined
-          ];
-        }
-      case "Enum" :
-        return [
-          "Enum",
-          undefined,
-          undefined,
-          fieldType.config.name
-        ];
+    let match = field._0;
+    if (match.fieldName === idFieldName) {
+      return match.fieldType;
     }
+  });
+  if (match === undefined) {
+    return stringEntityIdToKey;
+  }
+  if (typeof match === "object") {
+    return numericEntityIdToKey;
+  }
+  switch (match) {
+    case "String" :
+      return stringEntityIdToKey;
+    case "Bytea" :
+      return bytesEntityIdToKey;
+    default:
+      return numericEntityIdToKey;
   }
 }
 
@@ -251,7 +146,8 @@ function mkTable(tableName, compositeIndexesOpt, fields, description) {
     tableName: tableName,
     fields: fields,
     compositeIndexes: compositeIndexes,
-    description: description
+    description: description,
+    entityIdToKey: entityIdToKeyFor(fields)
   };
 }
 
@@ -346,12 +242,6 @@ function getIdSchema(table) {
   return getIdFieldOrThrow(table).fieldSchema;
 }
 
-let idsArraySchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.array(getIdFieldOrThrow(table).fieldSchema));
-
-function encodeIdsToJson(table, ids) {
-  return S$RescriptSchema.reverseConvertToJsonOrThrow(ids, idsArraySchema(table));
-}
-
 let fieldsByApiName = Utils.$$WeakMap.memoize(table => {
   let byApiName = {};
   table.fields.forEach(field => {
@@ -408,126 +298,6 @@ let pgEntityRowsSchema = Utils.$$WeakMap.memoize(table => makeRowsSchema(table,
 
 let NonExistingTableField = /* @__PURE__ */Primitive_exceptions.create("Table.NonExistingTableField");
 
-function getUnfilteredCompositeIndexesUnsafe(table) {
-  return table.compositeIndexes.map(compositeIndex => compositeIndex.map(indexField => {
-    let field = getFieldByName(table, indexField.fieldName);
-    let dbFieldName;
-    if (field !== undefined) {
-      dbFieldName = getPgFieldName(field);
-    } else {
-      throw {
-        RE_EXN_ID: NonExistingTableField,
-        _1: indexField.fieldName,
-        Error: new Error()
-      };
-    }
-    return {
-      fieldName: dbFieldName,
-      direction: indexField.direction
-    };
-  }));
-}
-
-function schemaOrderedFields(table, schema) {
-  let match = schema.t;
-  if (typeof match === "object" && match.TAG === "object") {
-    return match.items.map(param => {
-      let location = param.location;
-      let match = fieldsByApiName(table)[location];
-      if (match !== undefined) {
-        if (match.TAG === "Field") {
-          return match._0;
-        }
-        throw {
-          RE_EXN_ID: NonExistingTableField,
-          _1: location,
-          Error: new Error()
-        };
-      }
-      throw {
-        RE_EXN_ID: NonExistingTableField,
-        _1: location,
-        Error: new Error()
-      };
-    });
-  }
-  return Stdlib_JsError.throwWithMessage(`Failed reading the columns of "` + table.tableName + `". Expected an object schema for a table.`);
-}
-
-function toDbSchema(table, schema) {
-  return S$RescriptSchema.schema(s => {
-    let match = schema.t;
-    if (typeof match !== "object") {
-      return Stdlib_JsError.throwWithMessage("Failed creating db schema. Expected an object schema for table");
-    }
-    if (match.TAG !== "object") {
-      return Stdlib_JsError.throwWithMessage("Failed creating db schema. Expected an object schema for table");
-    }
-    let dict = {};
-    match.items.forEach(param => {
-      let location = param.location;
-      let coerceSchema = schema => {
-        let child = schema.t;
-        if (typeof child !== "object") {
-          switch (child) {
-            case "bigint" :
-              return Utils.$$BigInt.schema;
-            case "boolean" :
-              return S$RescriptSchema.union([
-                S$RescriptSchema.shape(S$RescriptSchema.literal(1), param => true),
-                S$RescriptSchema.shape(S$RescriptSchema.literal(0), param => false)
-              ]);
-            default:
-              return schema;
-          }
-        } else {
-          switch (child.TAG) {
-            case "option" :
-            case "null" :
-              return Utils.Schema.nullTolerant(coerceSchema(child._0));
-            case "array" :
-              return S$RescriptSchema.array(coerceSchema(child._0));
-            default:
-              return schema;
-          }
-        }
-      };
-      if (Stdlib_Option.isNone(fieldsByApiName(table)[location])) {
-        throw {
-          RE_EXN_ID: NonExistingTableField,
-          _1: location,
-          Error: new Error()
-        };
-      }
-      dict[location] = s.m(coerceSchema(param.schema));
-    });
-    return dict;
-  });
-}
-
-function getSingleIndexes(table) {
-  let indexFields = Stdlib_Array.filterMap(table.fields, field => {
-    if (field.TAG !== "Field") {
-      return;
-    }
-    let field$1 = field._0;
-    if (field$1.isIndex) {
-      return getPgDbFieldName(field$1);
-    }
-  });
-  return Array.from(new Set(Stdlib_Array.filterMap(getUnfilteredCompositeIndexesUnsafe(table), cidx => {
-    if (cidx.length !== 1) {
-      return;
-    }
-    let match = cidx[0];
-    return [match.fieldName];
-  }).concat([indexFields]).flat())).toSorted(Primitive_string.compare);
-}
-
-function getCompositeIndexes(table) {
-  return getUnfilteredCompositeIndexesUnsafe(table).filter(ind => ind.length > 1);
-}
-
 let maxPgTableNameLength = 63;
 
 export {
@@ -543,7 +313,10 @@ export {
   idFieldName,
   maxPgTableNameLength,
   fitPgTableName,
-  pgFieldTypeParts,
+  stringEntityIdToKey,
+  numericEntityIdToKey,
+  bytesEntityIdToKey,
+  entityIdToKeyFor,
   mkTable,
   getFields,
   getNonDefaultFields,
@@ -555,8 +328,6 @@ export {
   NoIdField,
   getIdFieldOrThrow,
   getIdSchema,
-  idsArraySchema,
-  encodeIdsToJson,
   fieldsByApiName,
   getFieldByApiName,
   queryFields,
@@ -564,10 +335,5 @@ export {
   pgRowsSchema,
   pgEntityRowsSchema,
   NonExistingTableField,
-  getUnfilteredCompositeIndexesUnsafe,
-  schemaOrderedFields,
-  toDbSchema,
-  getSingleIndexes,
-  getCompositeIndexes,
 }
-/* idsArraySchema Not a pure module */
+/* fieldsByApiName Not a pure module */

package/src/sources/AddressSet.res

@@ -10,6 +10,8 @@ type startBlockGroup = {startBlock: int, count: int}
 
 @send external contractNames: t => array<string> = "contractNames"
 
+@send external addressesOf: (t, string) => array<Address.t> = "addressesOf"
+
 @send external startBlockGroups: t => array<startBlockGroup> = "startBlockGroups"
 
 @send external slice: (t, ~offset: int, ~limit: option<int>) => t = "slice"

package/src/sources/AddressStore.res

@@ -7,6 +7,9 @@ type registration = {
   contractName: string,
   // -1 for a config address.
   registrationBlock: int,
+  // Subgraph mode: the round (see `Internal.getItemCreationRound`) the
+  // registering handler ran in, plus one. Not part of the addon's registration.
+  creationRound?: int,
 }
 
 type verdict =