envio 3.3.1 → 3.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.3.1",
+  "version": "3.3.2",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -69,10 +69,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.3.1",
-    "envio-linux-x64-musl": "3.3.1",
-    "envio-linux-arm64": "3.3.1",
-    "envio-darwin-x64": "3.3.1",
-    "envio-darwin-arm64": "3.3.1"
+    "envio-linux-x64": "3.3.2",
+    "envio-linux-x64-musl": "3.3.2",
+    "envio-linux-arm64": "3.3.2",
+    "envio-darwin-x64": "3.3.2",
+    "envio-darwin-arm64": "3.3.2"
   }
 }

package/src/PgStorage.res

@@ -1,5 +1,3 @@
-let getCacheRowCountFnName = "get_cache_row_count"
-
 let makeClient = () => {
   Postgres.makeSql(
     ~config={
@@ -267,18 +265,7 @@ GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
   | None => ()
   }
 
-  [
-    query.contents,
-    `CREATE OR REPLACE FUNCTION ${getCacheRowCountFnName}(table_name text) 
-RETURNS integer AS $$
-DECLARE
-  result integer;
-BEGIN
-  EXECUTE format('SELECT COUNT(*) FROM "${pgSchema}".%I', table_name) INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;`,
-  ]
+  [query.contents]
 }
 
 let makeLoadQuery = (~pgSchema, ~tableName, ~condition) => {
@@ -661,16 +648,19 @@ type schemaCacheTableInfo = {
   count: int,
 }
 
+type cacheRowCount = {
+  @as("count")
+  count: int,
+}
+
 // Matches both the cross-chain (`envio_effect_<name>`) and chain-scoped
 // (`envio_<chainId>_effect_<name>`) cache-table formats. Kept in sync with
 // Internal.EffectCache.
-let makeSchemaCacheTableInfoQuery = (~pgSchema) => {
+let makeEffectCacheTableNamesQuery = (~pgSchema) => {
   // The column guard requires the effect-cache shape (exactly an `id` + `output`
   // pair) so a user entity table that happens to match the name pattern is never
   // mistaken for an effect cache.
-  `SELECT
-    t.table_name,
-    ${getCacheRowCountFnName}(t.table_name) as count
+  `SELECT t.table_name
    FROM information_schema.tables t
    WHERE t.table_schema = '${pgSchema}'
    AND t.table_name ~ '^envio_([0-9]+_)?effect_.+'
@@ -681,6 +671,15 @@ let makeSchemaCacheTableInfoQuery = (~pgSchema) => {
    ) = ARRAY['id', 'output'];`
 }
 
+let makeCacheRowCountQuery = (~pgSchema, ~tableName) => {
+  // The table name comes from information_schema, so anything cache-shaped that
+  // was created out-of-band in the schema reaches here. Splice both identifiers
+  // as quoted identifiers, doubling embedded quotes, so a crafted name can't
+  // break out into raw SQL.
+  let quoteIdent = ident => `"${ident->String.replaceAll("\"", "\"\"")}"`
+  `SELECT COUNT(*)::int AS count FROM ${quoteIdent(pgSchema)}.${quoteIdent(tableName)};`
+}
+
 type psqlExecState =
   Unknown | Pending(promise<result<string, string>>) | Resolved(result<string, string>)
 
@@ -1301,6 +1300,23 @@ let make = (
     result
   }
 
+  // Each indexer counts the effect-cache tables in its own schema. The counts
+  // are computed here per table rather than through a shared SQL helper so
+  // indexers isolated by schema in one database never touch each other's state.
+  let queryCacheTableInfo = async (): array<schemaCacheTableInfo> => {
+    let tableNames: array<schemaTableName> = await sql->Postgres.unsafe(
+      makeEffectCacheTableNamesQuery(~pgSchema),
+    )
+    await tableNames
+    ->Array.map(async ({tableName}) => {
+      let rows: array<cacheRowCount> = await sql->Postgres.unsafe(
+        makeCacheRowCountQuery(~pgSchema, ~tableName),
+      )
+      ({tableName, count: (rows->Array.getUnsafe(0)).count}: schemaCacheTableInfo)
+    })
+    ->Promise.all
+  }
+
   let restoreEffectCache = async (~withUpload) => {
     if withUpload {
       // Try to restore cache tables from the .envio/cache TSV files
@@ -1340,9 +1356,7 @@ let make = (
       }
     }
 
-    let cacheTableInfo: array<schemaCacheTableInfo> = await sql->Postgres.unsafe(
-      makeSchemaCacheTableInfoQuery(~pgSchema),
-    )
+    let cacheTableInfo = await queryCacheTableInfo()
 
     if withUpload && cacheTableInfo->Utils.Array.notEmpty {
       // Integration with other tools like Hasura
@@ -1551,10 +1565,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
 
   let dumpEffectCache = async () => {
     try {
-      let cacheTableInfo: array<schemaCacheTableInfo> =
-        (await sql->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema)))->Array.filter(i =>
-          i.count > 0
-        )
+      let cacheTableInfo = (await queryCacheTableInfo())->Array.filter(i => i.count > 0)
 
       if cacheTableInfo->Utils.Array.notEmpty {
         // Create .envio/cache directory if it doesn't exist

package/src/PgStorage.res.mjs

@@ -27,8 +27,6 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-let getCacheRowCountFnName = "get_cache_row_count";
-
 function makeClient() {
   return Postgres({
     host: Env.Db.host,
@@ -222,18 +220,7 @@ GRANT ALL ON SCHEMA "` + pgSchema + `" TO public;`)
   if (initialChainsValuesQuery !== undefined) {
     query.contents = query.contents + "\n" + initialChainsValuesQuery;
   }
-  return [
-    query.contents,
-    `CREATE OR REPLACE FUNCTION ` + getCacheRowCountFnName + `(table_name text) 
-RETURNS integer AS $$
-DECLARE
-  result integer;
-BEGIN
-  EXECUTE format('SELECT COUNT(*) FROM "` + pgSchema + `".%I', table_name) INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;`
-  ];
+  return [query.contents];
 }
 
 function makeLoadQuery(pgSchema, tableName, condition) {
@@ -492,10 +479,8 @@ function makeSchemaTableNamesQuery(pgSchema) {
   return `SELECT table_name FROM information_schema.tables WHERE table_schema = '` + pgSchema + `';`;
 }
 
-function makeSchemaCacheTableInfoQuery(pgSchema) {
-  return `SELECT
-    t.table_name,
-    ` + getCacheRowCountFnName + `(t.table_name) as count
+function makeEffectCacheTableNamesQuery(pgSchema) {
+  return `SELECT t.table_name
    FROM information_schema.tables t
    WHERE t.table_schema = '` + pgSchema + `'
    AND t.table_name ~ '^envio_([0-9]+_)?effect_.+'
@@ -506,6 +491,11 @@ function makeSchemaCacheTableInfoQuery(pgSchema) {
    ) = ARRAY['id', 'output'];`;
 }
 
+function makeCacheRowCountQuery(pgSchema, tableName) {
+  let quoteIdent = ident => `"` + ident.replaceAll("\"", "\"\"") + `"`;
+  return `SELECT COUNT(*)::int AS count FROM ` + quoteIdent(pgSchema) + `.` + quoteIdent(tableName) + `;`;
+}
+
 let psqlExecState = {
   contents: "Unknown"
 };
@@ -889,6 +879,17 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     }));
     return result;
   };
+  let queryCacheTableInfo = async () => {
+    let tableNames = await sql.unsafe(makeEffectCacheTableNamesQuery(pgSchema));
+    return await Promise.all(tableNames.map(async param => {
+      let tableName = param.table_name;
+      let rows = await sql.unsafe(makeCacheRowCountQuery(pgSchema, tableName));
+      return {
+        table_name: tableName,
+        count: rows[0].count
+      };
+    }));
+  };
   let restoreEffectCache = async withUpload => {
     if (withUpload) {
       let entries = await scanCacheDir();
@@ -920,7 +921,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         Logging.info("No cache found to upload.");
       }
     }
-    let cacheTableInfo = await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema));
+    let cacheTableInfo = await queryCacheTableInfo();
     if (withUpload && Utils.$$Array.notEmpty(cacheTableInfo) && onNewTables !== undefined) {
       await onNewTables(cacheTableInfo.map(info => info.table_name));
     }
@@ -1041,7 +1042,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
   };
   let dumpEffectCache = async () => {
     try {
-      let cacheTableInfo = (await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema))).filter(i => i.count > 0);
+      let cacheTableInfo = (await queryCacheTableInfo()).filter(i => i.count > 0);
       if (!Utils.$$Array.notEmpty(cacheTableInfo)) {
         return;
       }
@@ -1250,7 +1251,6 @@ function makePersistenceFromConfig(config, storageOpt) {
 let maxItemsPerQuery = 500;
 
 export {
-  getCacheRowCountFnName,
   makeClient,
   makeCreateIndexQuery,
   directionToSql,
@@ -1279,7 +1279,8 @@ export {
   setQueryCache,
   setOrThrow,
   makeSchemaTableNamesQuery,
-  makeSchemaCacheTableInfoQuery,
+  makeEffectCacheTableNamesQuery,
+  makeCacheRowCountQuery,
   getConnectedPsqlExec,
   deleteByIdsOrThrow,
   makeInsertDeleteUpdatesQuery,