envio 3.5.0-alpha.1 → 3.5.0-alpha.3

package/src/db/IndexRegistry.res.mjs

@@ -0,0 +1,195 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+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";
+
+function fromIndexFields(indexFields) {
+  return indexFields.map(param => ({
+    name: param.fieldName,
+    direction: param.direction
+  }));
+}
+
+function makeKey(tableName, columns, method) {
+  return tableName + `|` + method + `|` + columns.map(param => {
+    let name = param.name;
+    if (param.direction === "Asc") {
+      return name;
+    } else {
+      return name + " DESC";
+    }
+  }).join(",");
+}
+
+let catalogRowsSchema = S$RescriptSchema.array(S$RescriptSchema.object(s => ({
+  tableName: s.f("tableName", S$RescriptSchema.string),
+  indexName: s.f("indexName", S$RescriptSchema.string),
+  method: s.f("method", S$RescriptSchema.string),
+  isValid: s.f("isValid", S$RescriptSchema.int),
+  isPlain: s.f("isPlain", S$RescriptSchema.int),
+  columns: s.f("columns", S$RescriptSchema.array(S$RescriptSchema.string)),
+  directions: s.f("directions", S$RescriptSchema.array(S$RescriptSchema.string))
+})));
+
+function makeCatalogQuery(pgSchema) {
+  return `SELECT
+  t.relname AS "tableName",
+  i.relname AS "indexName",
+  am.amname AS "method",
+  CASE WHEN ix.indisvalid AND ix.indisready THEN 1 ELSE 0 END AS "isValid",
+  CASE
+    WHEN ix.indisunique OR ix.indpred IS NOT NULL OR ix.indexprs IS NOT NULL THEN 0
+    ELSE 1
+  END AS "isPlain",
+  array_agg(
+    CASE WHEN k.attnum = 0
+      THEN pg_get_indexdef(ix.indexrelid, k.ord::int, true)
+      ELSE a.attname
+    END ORDER BY k.ord
+  ) AS "columns",
+  array_agg(
+    CASE WHEN (ix.indoption[k.ord - 1] & 1) = 1 THEN 'DESC' ELSE 'ASC' END ORDER BY k.ord
+  ) AS "directions"
+FROM pg_index ix
+JOIN pg_class i ON i.oid = ix.indexrelid
+JOIN pg_class t ON t.oid = ix.indrelid
+JOIN pg_namespace n ON n.oid = t.relnamespace
+JOIN pg_am am ON am.oid = i.relam
+JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON k.ord <= ix.indnkeyatts
+LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+WHERE n.nspname = '` + pgSchema + `'
+GROUP BY t.relname, i.relname, am.amname, ix.indisvalid, ix.indisready,
+         ix.indisunique, ix.indpred, ix.indexprs;`;
+}
+
+function make() {
+  return {
+    keys: new Set(),
+    invalidByName: {},
+    inflight: {},
+    tableQueue: {}
+  };
+}
+
+function has(registry, key) {
+  return registry.keys.has(key);
+}
+
+function add(registry, key) {
+  registry.keys.add(key);
+}
+
+function size(registry) {
+  return registry.keys.size;
+}
+
+function toArray(registry) {
+  return Array.from(registry.keys).toSorted(Primitive_string.compare);
+}
+
+function getInvalid(registry, name) {
+  return registry.invalidByName[name];
+}
+
+function clearInvalidName(registry, name) {
+  Utils.Dict.deleteInPlace(registry.invalidByName, name);
+}
+
+function reload(registry, rows) {
+  registry.keys.clear();
+  Object.keys(registry.invalidByName).forEach(name => Utils.Dict.deleteInPlace(registry.invalidByName, name));
+  let invalidIndexNames = [];
+  rows.forEach(row => {
+    let key = makeKey(row.tableName, row.columns.map((name, idx) => {
+      let match = row.directions[idx];
+      let tmp;
+      tmp = match === "DESC" ? "Desc" : "Asc";
+      return {
+        name: name,
+        direction: tmp
+      };
+    }), row.method);
+    if (row.isValid === 0) {
+      invalidIndexNames.push(row.indexName);
+      registry.invalidByName[row.indexName] = {
+        key: key,
+        isRepairable: row.isPlain === 1
+      };
+      return;
+    } else {
+      return add(registry, key);
+    }
+  });
+  return invalidIndexNames;
+}
+
+function ensure(registry, key, tableName, build) {
+  if (registry.keys.has(key)) {
+    return Promise.resolve();
+  }
+  let promise = registry.inflight[key];
+  if (promise !== undefined) {
+    return promise;
+  }
+  let tail = registry.tableQueue[tableName];
+  let tail$1 = tail !== undefined ? tail : Promise.resolve();
+  let promise$1 = tail$1.then(() => {
+    if (registry.keys.has(key)) {
+      return Promise.resolve();
+    } else {
+      return build();
+    }
+  }).then(() => add(registry, key));
+  registry.inflight[key] = promise$1;
+  registry.tableQueue[tableName] = Utils.$$Promise.silentCatch(promise$1);
+  return promise$1.finally(() => Utils.Dict.deleteInPlace(registry.inflight, key));
+}
+
+function truncateIndexName(description) {
+  if (description.length > 63) {
+    return description.slice(0, 63);
+  } else {
+    return description;
+  }
+}
+
+function validateIndexNamesOrThrow(descriptions) {
+  let byName = {};
+  descriptions.forEach(description => {
+    let name = truncateIndexName(description);
+    let existing = byName[name];
+    if (existing !== undefined && existing !== description) {
+      return Stdlib_JsError.throwWithMessage(`Index names "` + existing + `" and "` + description + `" both truncate to "` + name + `" at PostgreSQL's ` + (63).toString() + `-character identifier limit. Rename a field or an entity so the generated index names stay distinct.`);
+    } else {
+      byName[name] = description;
+      return;
+    }
+  });
+}
+
+let btree = "btree";
+
+let pgMaxIdentifierLength = 63;
+
+export {
+  btree,
+  fromIndexFields,
+  makeKey,
+  catalogRowsSchema,
+  makeCatalogQuery,
+  make,
+  has,
+  add,
+  size,
+  toArray,
+  getInvalid,
+  clearInvalidName,
+  reload,
+  ensure,
+  pgMaxIdentifierLength,
+  truncateIndexName,
+  validateIndexNamesOrThrow,
+}
+/* catalogRowsSchema Not a pure module */

package/src/db/InternalTable.res

@@ -164,6 +164,13 @@ SET ${setClauses->Array.joinUnsafe(",\n    ")}
 WHERE "${(#id: field :> string)}" = $1;`
   }
 
+  // Written in the same transaction as the deferred schema indexes, so a chain
+  // is never reported ready without the indexes the schema promises.
+  let makeSetReadyAtQuery = (~pgSchema) =>
+    `UPDATE "${pgSchema}"."${table.tableName}"
+SET "${(#ready_at: field :> string)}" = $1
+WHERE "${(#id: field :> string)}" = ANY($2::int[]);`
+
   type rawInitialState = {
     id: int,
     startBlock: int,

package/src/db/InternalTable.res.mjs

@@ -101,6 +101,12 @@ SET ` + setClauses.join(",\n    ") + `
 WHERE "` + "id" + `" = $1;`;
 }
 
+function makeSetReadyAtQuery(pgSchema) {
+  return `UPDATE "` + pgSchema + `"."` + table.tableName + `"
+SET "` + "ready_at" + `" = $1
+WHERE "` + "id" + `" = ANY($2::int[]);`;
+}
+
 function makeGetInitialStateQuery(pgSchema) {
   return `SELECT "` + "id" + `" as "id",
 "` + "start_block" + `" as "startBlock",
@@ -213,6 +219,7 @@ let Chains = {
   makeInitialValuesQuery: makeInitialValuesQuery,
   metaFields: metaFields,
   makeMetaFieldsUpdateQuery: makeMetaFieldsUpdateQuery,
+  makeSetReadyAtQuery: makeSetReadyAtQuery,
   makeGetInitialStateQuery: makeGetInitialStateQuery,
   makeGetIndexingAddressesQuery: makeGetIndexingAddressesQuery,
   getInitialState: getInitialState,

package/src/db/Table.res

@@ -31,7 +31,6 @@ type fieldType =
   | Json
   | Date
   | Enum({config: enumConfig<enum>})
-  | Entity({name: string})
 
 type field = {
   fieldName: string,
@@ -168,7 +167,6 @@ let getPgFieldType = (
   | Date =>
     (isNullable ? Postgres.TimestampWithTimezoneNull : Postgres.TimestampWithTimezone :> string)
   | Enum({config}) => `"${pgSchema}".${config.name}`
-  | Entity(_) => (Postgres.Text :> string) // FIXME: Will it work correctly if id is not a text column?
   }
 
   // Workaround for Hasura bug https://github.com/enviodev/hyperindex/issues/788
@@ -192,14 +190,14 @@ type compositeIndexField = {
 type table = {
   tableName: string,
   fields: array<fieldOrDerived>,
-  compositeIndices: array<array<compositeIndexField>>,
+  compositeIndexes: array<array<compositeIndexField>>,
   description: option<string>,
 }
 
-let mkTable = (tableName, ~compositeIndices=[], ~fields, ~description=?) => {
+let mkTable = (tableName, ~compositeIndexes=[], ~fields, ~description=?) => {
   tableName,
   fields,
-  compositeIndices,
+  compositeIndexes,
   description,
 }
 
@@ -248,6 +246,40 @@ let getDerivedFromFields = table =>
 let getFieldByName = (table, fieldName) =>
   table.fields->Array.find(field => field->getUserDefinedFieldName === fieldName)
 
+exception NoIdField(string)
+
+// The `id` primary-key field. Its type drives both the id column and every
+// foreign key that references the entity, so id-typed SQL (delete-by-id,
+// history backfill) reads the column type and value schema from here.
+let getIdFieldOrThrow = (table): field =>
+  switch table->getFieldByName(idFieldName) {
+  | Some(Field(field)) => field
+  | _ => throw(NoIdField(table.tableName))
+  }
+
+let getIdPgFieldType = (table, ~pgSchema) =>
+  getPgFieldType(
+    ~fieldType=(table->getIdFieldOrThrow).fieldType,
+    ~pgSchema,
+    ~isArray=false,
+    ~isNumericArrayAsText=false,
+    ~isNullable=false,
+  )
+
+// Schema for a single id value, typed opaquely so id-generic code can serialize
+// ids regardless of the underlying scalar.
+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
 
 let getFieldByApiName = (table, apiFieldName) =>
@@ -297,13 +329,12 @@ let makeRowsSchema = (table, ~rowFieldName) =>
   S.array(
     S.object(s => {
       let dict = Dict.make()
-      table.fields->Array.forEach(
-        field =>
-          switch field {
-          | Field(field) =>
-            dict->Dict.set(field->getApiFieldName, s.field(field->rowFieldName, field.fieldSchema))
-          | DerivedFrom(_) => ()
-          },
+      table.fields->Array.forEach(field =>
+        switch field {
+        | Field(field) =>
+          dict->Dict.set(field->getApiFieldName, s.field(field->rowFieldName, field.fieldSchema))
+        | DerivedFrom(_) => ()
+        }
       )
       dict
     })->(Utils.magic: S.t<dict<unknown>> => S.t<unknown>),
@@ -324,11 +355,11 @@ let pgRowsSchema: table => S.t<array<unknown>> = Utils.WeakMap.memoize(table =>
 exception NonExistingTableField(string)
 
 /*
-Gets all composite indicies (whether they are single indices or not)
+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 getUnfilteredCompositeIndicesUnsafe = (table): array<array<compositeIndexField>> => {
-  table.compositeIndices->Array.map(compositeIndex =>
+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
@@ -438,10 +469,10 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
 }
 
 /*
-Gets all single indicies
+Gets all single indexes
 And maps the fields defined to their actual db name (some have _id suffix)
 */
-let getSingleIndices = (table): array<string> => {
+let getSingleIndexes = (table): array<string> => {
   let indexFields = table.fields->Array.filterMap(field =>
     switch field {
     | Field(field) if field.isIndex => Some(field->getPgDbFieldName)
@@ -450,8 +481,8 @@ let getSingleIndices = (table): array<string> => {
   )
 
   table
-  ->getUnfilteredCompositeIndicesUnsafe
-  //get all composite indices with only 1 field defined
+  ->getUnfilteredCompositeIndexesUnsafe
+  //get all composite indexes with only 1 field defined
   //this is still a single index
   ->Array.filterMap(cidx =>
     switch cidx {
@@ -467,11 +498,11 @@ let getSingleIndices = (table): array<string> => {
 }
 
 /*
-Gets all composite indicies
+Gets all composite indexes
 And maps the fields defined to their actual db name (some have _id suffix)
 */
-let getCompositeIndices = (table): array<array<compositeIndexField>> => {
+let getCompositeIndexes = (table): array<array<compositeIndexField>> => {
   table
-  ->getUnfilteredCompositeIndicesUnsafe
+  ->getUnfilteredCompositeIndexesUnsafe
   ->Array.filter(ind => ind->Array.length > 1)
 }

package/src/db/Table.res.mjs

@@ -94,6 +94,8 @@ function getPgFieldName(fieldOrDerived) {
   }
 }
 
+let idFieldName = "id";
+
 function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNullable) {
   let columnType;
   if (typeof fieldType !== "object") {
@@ -142,9 +144,6 @@ function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNu
       case "Enum" :
         columnType = `"` + pgSchema + `".` + fieldType.config.name;
         break;
-      case "Entity" :
-        columnType = "TEXT";
-        break;
     }
   }
   let isNumericAsText = isArray && isNumericArrayAsText;
@@ -154,12 +153,12 @@ function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNu
   );
 }
 
-function mkTable(tableName, compositeIndicesOpt, fields, description) {
-  let compositeIndices = compositeIndicesOpt !== undefined ? compositeIndicesOpt : [];
+function mkTable(tableName, compositeIndexesOpt, fields, description) {
+  let compositeIndexes = compositeIndexesOpt !== undefined ? compositeIndexesOpt : [];
   return {
     tableName: tableName,
     fields: fields,
-    compositeIndices: compositeIndices,
+    compositeIndexes: compositeIndexes,
     description: description
   };
 }
@@ -226,6 +225,41 @@ function getFieldByName(table, fieldName) {
   return table.fields.find(field => getUserDefinedFieldName(field) === fieldName);
 }
 
+let NoIdField = /* @__PURE__ */Primitive_exceptions.create("Table.NoIdField");
+
+function getIdFieldOrThrow(table) {
+  let match = getFieldByName(table, idFieldName);
+  if (match !== undefined) {
+    if (match.TAG === "Field") {
+      return match._0;
+    }
+    throw {
+      RE_EXN_ID: NoIdField,
+      _1: table.tableName,
+      Error: new Error()
+    };
+  }
+  throw {
+    RE_EXN_ID: NoIdField,
+    _1: table.tableName,
+    Error: new Error()
+  };
+}
+
+function getIdPgFieldType(table, pgSchema) {
+  return getPgFieldType(getIdFieldOrThrow(table).fieldType, pgSchema, false, false, false);
+}
+
+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));
+}
+
 function getFieldByApiName(table, apiFieldName) {
   return table.fields.find(field => {
     let tmp;
@@ -270,8 +304,8 @@ let pgRowsSchema = Utils.$$WeakMap.memoize(table => makeRowsSchema(table, getPgD
 
 let NonExistingTableField = /* @__PURE__ */Primitive_exceptions.create("Table.NonExistingTableField");
 
-function getUnfilteredCompositeIndicesUnsafe(table) {
-  return table.compositeIndices.map(compositeIndex => compositeIndex.map(indexField => {
+function getUnfilteredCompositeIndexesUnsafe(table) {
+  return table.compositeIndexes.map(compositeIndex => compositeIndex.map(indexField => {
     let field = getFieldByName(table, indexField.fieldName);
     let dbFieldName;
     if (field !== undefined) {
@@ -385,7 +419,7 @@ function toSqlParams(table, schema, pgSchema) {
   };
 }
 
-function getSingleIndices(table) {
+function getSingleIndexes(table) {
   let indexFields = Stdlib_Array.filterMap(table.fields, field => {
     if (field.TAG !== "Field") {
       return;
@@ -395,7 +429,7 @@ function getSingleIndices(table) {
       return getPgDbFieldName(field$1);
     }
   });
-  return Array.from(new Set(Stdlib_Array.filterMap(getUnfilteredCompositeIndicesUnsafe(table), cidx => {
+  return Array.from(new Set(Stdlib_Array.filterMap(getUnfilteredCompositeIndexesUnsafe(table), cidx => {
     if (cidx.length !== 1) {
       return;
     }
@@ -404,12 +438,10 @@ function getSingleIndices(table) {
   }).concat([indexFields]).flat())).toSorted(Primitive_string.compare);
 }
 
-function getCompositeIndices(table) {
-  return getUnfilteredCompositeIndicesUnsafe(table).filter(ind => ind.length > 1);
+function getCompositeIndexes(table) {
+  return getUnfilteredCompositeIndexesUnsafe(table).filter(ind => ind.length > 1);
 }
 
-let idFieldName = "id";
-
 export {
   makeEnumConfig,
   mkField,
@@ -429,15 +461,21 @@ export {
   getLinkedEntityFields,
   getDerivedFromFields,
   getFieldByName,
+  NoIdField,
+  getIdFieldOrThrow,
+  getIdPgFieldType,
+  getIdSchema,
+  idsArraySchema,
+  encodeIdsToJson,
   getFieldByApiName,
   queryFields,
   makeRowsSchema,
   rowsSchema,
   pgRowsSchema,
   NonExistingTableField,
-  getUnfilteredCompositeIndicesUnsafe,
+  getUnfilteredCompositeIndexesUnsafe,
   toSqlParams,
-  getSingleIndices,
-  getCompositeIndices,
+  getSingleIndexes,
+  getCompositeIndexes,
 }
-/* queryFields Not a pure module */
+/* idsArraySchema Not a pure module */

package/src/sources/AddressSet.res

@@ -0,0 +1,48 @@
+// Binding to the Rust `AddressSet` napi class: an immutable, ordered snapshot
+// of some of a chain's indexed addresses, handed to a fetch-state partition
+// instead of a JS address array. Sets are ordered by
+// `(effectiveStartBlock, address)`, so the same addresses always produce the
+// same set however they were registered or restored. Everything a query derives
+// from one (padded topics, the routing owner index, per-contract counts) is
+// built once inside Rust and shared by every query the partition makes.
+type t
+
+type startBlockGroup = {startBlock: int, count: int}
+
+@send external size: t => int = "size"
+
+// Live addresses of one contract, derived once per set inside Rust — so the
+// fetch state can size and split partitions without ever walking the addresses.
+@send external countFor: (t, string) => int = "countFor"
+
+// The chain-wide address gate, reachable through any set of the store. Not set
+// membership: the simulate source has no native query boundary, so it applies
+// the same gate every real source applies while routing.
+@send external has: (t, Address.t, string, int) => bool = "has"
+
+@send external contractNames: t => array<string> = "contractNames"
+
+// Distinct effective start blocks in this set, ascending — how partition
+// creation decides where one partition ends and the next begins.
+@send external startBlockGroups: t => array<startBlockGroup> = "startBlockGroups"
+
+@send external slice: (t, ~offset: int, ~limit: option<int>) => t = "slice"
+
+// Keeps only the named contracts' addresses, in set order.
+@send external filterByContracts: (t, array<string>) => t = "filterByContracts"
+
+// Drops addresses registered after the target block, and any the store has
+// tombstoned since this set was built.
+@send external filterByRegistrationBlock: (t, int) => t = "filterByRegistrationBlock"
+
+// Union with another set of the same store, keeping set order; duplicates
+// collapse.
+@send external merge: (t, t) => t = "merge"
+
+// Canonical address strings in set order. Not on a query path — queries read
+// the set's cached slices inside Rust.
+@send external addresses: t => array<Address.t> = "addresses"
+
+@send external entries: t => array<Internal.indexingContract> = "entries"
+
+let isEmpty = (set: t) => set->size === 0

package/src/sources/AddressSet.res.mjs

@@ -0,0 +1,11 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function isEmpty(set) {
+  return set.size() === 0;
+}
+
+export {
+  isEmpty,
+}
+/* No side effect */