envio 2.26.0-alpha.5 → 2.26.0-alpha.7

package/index.d.ts

@@ -35,26 +35,6 @@ type UnknownToOutput<T> = T extends Sury.Schema<unknown>
     >
   : T;
 
-type UnknownToInput<T> = T extends Sury.Schema<unknown>
-  ? Sury.Input<T>
-  : T extends (...args: any[]) => any
-  ? T
-  : T extends unknown[]
-  ? { [K in keyof T]: UnknownToInput<T[K]> }
-  : T extends { [k in keyof T]: unknown }
-  ? Flatten<
-      {
-        [k in keyof T as HasUndefined<UnknownToInput<T[k]>> extends true
-          ? k
-          : never]?: UnknownToInput<T[k]>;
-      } & {
-        [k in keyof T as HasUndefined<UnknownToInput<T[k]>> extends true
-          ? never
-          : k]: UnknownToInput<T[k]>;
-      }
-    >
-  : T;
-
 type HasUndefined<T> = [T] extends [undefined]
   ? true
   : undefined extends T
@@ -92,7 +72,7 @@ type Flatten<T> = T extends object
 export function experimental_createEffect<
   IS,
   OS,
-  I = UnknownToInput<IS>,
+  I = UnknownToOutput<IS>,
   O = UnknownToOutput<OS>,
   // A hack to enforce that the inferred return type
   // matches the output schema type
@@ -130,6 +110,7 @@ export declare namespace S {
   // Don't expose recursive for now, since it's too advanced
   // export const recursive: typeof Sury.recursive;
   export const transform: typeof Sury.transform;
+  export const shape: typeof Sury.shape;
   export const refine: typeof Sury.refine;
   export const schema: typeof Sury.schema;
   export const record: typeof Sury.record;

package/index.js

@@ -22,6 +22,7 @@ exports.S = {
   // Don't expose recursive for now, since it's too advanced
   // recursive: Sury.recursive,
   transform: Sury.transform,
+  shape: Sury.shape,
   refine: Sury.refine,
   schema: Sury.schema,
   record: Sury.record,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.26.0-alpha.5",
+  "version": "v2.26.0-alpha.7",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.26.0-alpha.5",
-    "envio-linux-arm64": "v2.26.0-alpha.5",
-    "envio-darwin-x64": "v2.26.0-alpha.5",
-    "envio-darwin-arm64": "v2.26.0-alpha.5"
+    "envio-linux-x64": "v2.26.0-alpha.7",
+    "envio-linux-arm64": "v2.26.0-alpha.7",
+    "envio-darwin-x64": "v2.26.0-alpha.7",
+    "envio-darwin-arm64": "v2.26.0-alpha.7"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.5",

package/src/Envio.res

@@ -50,7 +50,16 @@ let experimental_createEffect = (
       >
     ),
     callsCount: 0,
-    output: options.output->(Utils.magic: S.t<'output> => S.t<Internal.effectOutput>),
+    // This is the way to make the createEffect API
+    // work without the need for users to call S.schema themselves,
+    // but simply pass the desired object/tuple/etc.
+    // If they pass a schem, it'll also work.
+    input: S.schema(_ => options.input)->(
+      Utils.magic: S.t<S.t<'input>> => S.t<Internal.effectInput>
+    ),
+    output: S.schema(_ => options.output)->(
+      Utils.magic: S.t<S.t<'output>> => S.t<Internal.effectOutput>
+    ),
     cache: options.cache->Belt.Option.getWithDefault(false),
   }->(Utils.magic: Internal.effect => effect<'input, 'output>)
 }

package/src/Envio.res.js

@@ -3,6 +3,7 @@
 
 var Prometheus = require("./Prometheus.res.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 
 function experimental_createEffect(options, handler) {
   Prometheus.EffectCallsCount.set(0, options.name);
@@ -10,7 +11,12 @@ function experimental_createEffect(options, handler) {
           name: options.name,
           handler: handler,
           cache: Belt_Option.getWithDefault(options.cache, false),
-          output: options.output,
+          output: S$RescriptSchema.schema(function (param) {
+                return options.output;
+              }),
+          input: S$RescriptSchema.schema(function (param) {
+                return options.input;
+              }),
           callsCount: 0
         };
 }

package/src/Internal.res

@@ -199,6 +199,7 @@ type effect = {
   handler: effectArgs => promise<effectOutput>,
   cache: bool,
   output: S.t<effectOutput>,
+  input: S.t<effectInput>,
   mutable callsCount: int,
 }
 

package/src/Persistence.res

@@ -139,7 +139,7 @@ let init = {
             ~enums=persistence.allEnums,
           )
 
-          Logging.info(`The indexer storage is ready. Restoring cache...`)
+          Logging.info(`The indexer storage is ready. Uploading cache...`)
           persistence.storageStatus = Ready({
             cleanRun: true,
             cache: await loadInitialCache(persistence, ~withUpload=true),
@@ -152,7 +152,7 @@ let init = {
           | _ => false
           }
         ) {
-          Logging.info(`The indexer storage is initialized. Restoring cache...`)
+          Logging.info(`The indexer storage is ready.`)
           persistence.storageStatus = Ready({
             cleanRun: false,
             cache: await loadInitialCache(persistence, ~withUpload=false),

package/src/Persistence.res.js

@@ -76,7 +76,7 @@ async function init(persistence, resetOpt) {
     if (reset || !await persistence.storage.isInitialized()) {
       Logging.info("Initializing the indexer storage...");
       await persistence.storage.initialize(persistence.allEntities, persistence.staticTables, persistence.allEnums);
-      Logging.info("The indexer storage is ready. Restoring cache...");
+      Logging.info("The indexer storage is ready. Uploading cache...");
       persistence.storageStatus = {
         TAG: "Ready",
         cleanRun: true,
@@ -87,7 +87,7 @@ async function init(persistence, resetOpt) {
       var tmp;
       tmp = typeof match !== "object" || match.TAG !== "Initializing" ? false : true;
       if (tmp) {
-        Logging.info("The indexer storage is initialized. Restoring cache...");
+        Logging.info("The indexer storage is ready.");
         persistence.storageStatus = {
           TAG: "Ready",
           cleanRun: false,

package/src/PgStorage.res

@@ -387,7 +387,7 @@ let setOrThrow = async (sql, ~items, ~table: Table.table, ~itemSchema, ~pgSchema
       raise(
         Persistence.StorageError({
           message: `Failed to insert items into table "${table.tableName}"`,
-          reason: exn,
+          reason: exn->Internal.prettifyExn,
         }),
       )
     }
@@ -455,14 +455,19 @@ let makeSchemaCacheTableInfoQuery = (~pgSchema) => {
 type psqlExecState =
   Unknown | Pending(promise<result<string, string>>) | Resolved(result<string, string>)
 
-let getPsqlExec = {
+let getConnectedPsqlExec = {
+  let pgDockerServiceName = "envio-postgres"
+  // Should use the default port, since we're executing the command
+  // from the postgres container's network.
+  let pgDockerServicePort = 5432
+
   // For development: We run the indexer process locally,
   //   and there might not be psql installed on the user's machine.
   //   So we use docker-compose to run psql existing in the postgres container.
   // For production: We expect indexer to be running in a container,
   //   with psql installed. So we can call it directly.
   let psqlExecState = ref(Unknown)
-  async (~pgUser, ~pgHost) => {
+  async (~pgUser, ~pgHost, ~pgDatabase, ~pgPort) => {
     switch psqlExecState.contents {
     | Unknown => {
         let promise = Promise.make((resolve, _reject) => {
@@ -470,18 +475,31 @@ let getPsqlExec = {
           NodeJs.ChildProcess.exec(`${binary} --version`, (~error, ~stdout as _, ~stderr as _) => {
             switch error {
             | Value(_) => {
-                let binary = `docker-compose exec -T -u ${pgUser} ${pgHost} psql`
+                let binary = `docker-compose exec -T -u ${pgUser} ${pgDockerServiceName} psql`
                 NodeJs.ChildProcess.exec(
                   `${binary} --version`,
                   (~error, ~stdout as _, ~stderr as _) => {
                     switch error {
-                    | Value(_) => resolve(Error("Failed to find psql binary"))
-                    | Null => resolve(Ok(binary))
+                    | Value(_) =>
+                      resolve(
+                        Error(`Please check if "psql" binary is installed or docker-compose is running for the local indexer.`),
+                      )
+                    | Null =>
+                      resolve(
+                        Ok(
+                          `${binary} -h ${pgHost} -p ${pgDockerServicePort->Js.Int.toString} -U ${pgUser} -d ${pgDatabase}`,
+                        ),
+                      )
                     }
                   },
                 )
               }
-            | Null => resolve(Ok(binary))
+            | Null =>
+              resolve(
+                Ok(
+                  `${binary} -h ${pgHost} -p ${pgPort->Js.Int.toString} -U ${pgUser} -d ${pgDatabase}`,
+                ),
+              )
             }
           })
         })
@@ -496,12 +514,12 @@ let getPsqlExec = {
     }
   }
 }
-let psqlExecMissingErrorMessage = `Please check if "psql" binary is installed or docker-compose is running for the local indexer.`
 
 let make = (
   ~sql: Postgres.sql,
   ~pgHost,
   ~pgSchema,
+  ~pgPort,
   ~pgUser,
   ~pgDatabase,
   ~pgPassword,
@@ -509,7 +527,7 @@ let make = (
   ~onNewTables=?,
 ): Persistence.storage => {
   let psqlExecOptions: NodeJs.ChildProcess.execOptions = {
-    env: Js.Dict.fromArray([("PGPASSWORD", pgPassword)]),
+    env: Js.Dict.fromArray([("PGPASSWORD", pgPassword), ("PATH", %raw(`process.env.PATH`))]),
   }
 
   let cacheDirPath = NodeJs.Path.resolve([
@@ -673,7 +691,7 @@ let make = (
       cacheTablePrefix ++ effectName,
       ~fields=[
         Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-        Table.mkField("output", JsonB, ~fieldSchema=outputSchema),
+        Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false)),
       ],
       ~compositeIndices=[],
     )
@@ -709,73 +727,79 @@ let make = (
   }
 
   let dumpEffectCache = async () => {
-    let cacheTableInfo: array<schemaCacheTableInfo> =
-      (await sql
-      ->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema)))
-      ->Js.Array2.filter(i => i.count > 0)
-
-    if cacheTableInfo->Utils.Array.notEmpty {
-      // Create .envio/cache directory if it doesn't exist
-      try {
-        await NodeJs.Fs.Promises.access(cacheDirPath)
-      } catch {
-      | _ =>
-        // Create directory if it doesn't exist
-        await NodeJs.Fs.Promises.mkdir(~path=cacheDirPath, ~options={recursive: true})
-      }
+    try {
+      let cacheTableInfo: array<schemaCacheTableInfo> =
+        (await sql
+        ->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema)))
+        ->Js.Array2.filter(i => i.count > 0)
+
+      if cacheTableInfo->Utils.Array.notEmpty {
+        // Create .envio/cache directory if it doesn't exist
+        try {
+          await NodeJs.Fs.Promises.access(cacheDirPath)
+        } catch {
+        | _ =>
+          // Create directory if it doesn't exist
+          await NodeJs.Fs.Promises.mkdir(~path=cacheDirPath, ~options={recursive: true})
+        }
 
-      // Command for testing. Run from generated
-      // docker-compose exec -T -u postgres envio-postgres psql -d envio-dev -c 'COPY "public"."envio_effect_getTokenMetadata" TO STDOUT (FORMAT text, HEADER);' > ../.envio/cache/getTokenMetadata.tsv
+        // Command for testing. Run from generated
+        // docker-compose exec -T -u postgres envio-postgres psql -d envio-dev -c 'COPY "public"."envio_effect_getTokenMetadata" TO STDOUT (FORMAT text, HEADER);' > ../.envio/cache/getTokenMetadata.tsv
 
-      switch await getPsqlExec(~pgUser, ~pgHost) {
-      | Ok(psqlExec) => {
-          Logging.info(
-            `Dumping cache: ${cacheTableInfo
-              ->Js.Array2.map(({tableName, count}) =>
-                tableName ++ " (" ++ count->Belt.Int.toString ++ " rows)"
-              )
-              ->Js.Array2.joinWith(", ")}`,
-          )
+        switch await getConnectedPsqlExec(~pgUser, ~pgHost, ~pgDatabase, ~pgPort) {
+        | Ok(psqlExec) => {
+            Logging.info(
+              `Dumping cache: ${cacheTableInfo
+                ->Js.Array2.map(({tableName, count}) =>
+                  tableName ++ " (" ++ count->Belt.Int.toString ++ " rows)"
+                )
+                ->Js.Array2.joinWith(", ")}`,
+            )
 
-          let promises = cacheTableInfo->Js.Array2.map(async ({tableName}) => {
-            let cacheName = tableName->Js.String2.sliceToEnd(~from=cacheTablePrefixLength)
-            let outputFile =
-              NodeJs.Path.join(cacheDirPath, cacheName ++ ".tsv")->NodeJs.Path.toString
-
-            let command = `${psqlExec} -h ${pgHost} -U ${pgUser} -d ${pgDatabase} -c 'COPY "${pgSchema}"."${tableName}" TO STDOUT WITH (FORMAT text, HEADER);' > ${outputFile}`
-
-            Promise.make((resolve, reject) => {
-              NodeJs.ChildProcess.execWithOptions(
-                command,
-                psqlExecOptions,
-                (~error, ~stdout, ~stderr as _) => {
-                  switch error {
-                  | Value(error) => reject(error)
-                  | Null => resolve(stdout)
-                  }
-                },
-              )
+            let promises = cacheTableInfo->Js.Array2.map(async ({tableName}) => {
+              let cacheName = tableName->Js.String2.sliceToEnd(~from=cacheTablePrefixLength)
+              let outputFile =
+                NodeJs.Path.join(cacheDirPath, cacheName ++ ".tsv")->NodeJs.Path.toString
+
+              let command = `${psqlExec} -c 'COPY "${pgSchema}"."${tableName}" TO STDOUT WITH (FORMAT text, HEADER);' > ${outputFile}`
+
+              Promise.make((resolve, reject) => {
+                NodeJs.ChildProcess.execWithOptions(
+                  command,
+                  psqlExecOptions,
+                  (~error, ~stdout, ~stderr as _) => {
+                    switch error {
+                    | Value(error) => reject(error)
+                    | Null => resolve(stdout)
+                    }
+                  },
+                )
+              })
             })
-          })
 
-          let _ = await promises->Promise.all
-          Logging.info(`Successfully dumped cache to ${cacheDirPath->NodeJs.Path.toString}`)
+            let _ = await promises->Promise.all
+            Logging.info(`Successfully dumped cache to ${cacheDirPath->NodeJs.Path.toString}`)
+          }
+        | Error(message) => Logging.error(`Failed to dump cache. ${message}`)
         }
-      | Error(_) => Logging.error(`Failed to dump cache. ${psqlExecMissingErrorMessage}`)
       }
+    } catch {
+    | exn => Logging.errorWithExn(exn->Internal.prettifyExn, `Failed to dump cache.`)
     }
   }
 
   let restoreEffectCache = async (~withUpload) => {
     if withUpload {
       // Try to restore cache tables from binary files
-      let (entries, psqlExecResult) = await Promise.all2((
-        NodeJs.Fs.Promises.readdir(cacheDirPath),
-        getPsqlExec(~pgUser, ~pgHost),
-      ))
-
-      switch psqlExecResult {
-      | Ok(psqlExec) => {
+      let nothingToUploadErrorMessage = "Nothing to upload."
+
+      switch await Promise.all2((
+        NodeJs.Fs.Promises.readdir(cacheDirPath)
+        ->Promise.thenResolve(e => Ok(e))
+        ->Promise.catch(_ => Promise.resolve(Error(nothingToUploadErrorMessage))),
+        getConnectedPsqlExec(~pgUser, ~pgHost, ~pgDatabase, ~pgPort),
+      )) {
+      | (Ok(entries), Ok(psqlExec)) => {
           let cacheFiles = entries->Js.Array2.filter(entry => {
             entry->Js.String2.endsWith(".tsv")
           })
@@ -799,7 +823,7 @@ let make = (
               ->Promise.then(() => {
                 let inputFile = NodeJs.Path.join(cacheDirPath, entry)->NodeJs.Path.toString
 
-                let command = `${psqlExec} -h ${pgHost} -U ${pgUser} -d ${pgDatabase} -c 'COPY "${pgSchema}"."${tableName}" FROM STDIN WITH (FORMAT text, HEADER);' < ${inputFile}`
+                let command = `${psqlExec} -c 'COPY "${pgSchema}"."${tableName}" FROM STDIN WITH (FORMAT text, HEADER);' < ${inputFile}`
 
                 Promise.make(
                   (resolve, reject) => {
@@ -818,18 +842,23 @@ let make = (
               })
             })
             ->Promise.all
+
+          Logging.info("Successfully uploaded cache.")
+        }
+      | (Error(message), _)
+      | (_, Error(message)) =>
+        if message === nothingToUploadErrorMessage {
+          Logging.info("No cache found to upload.")
+        } else {
+          Logging.error(`Failed to upload cache, continuing without it. ${message}`)
         }
-      | Error(_) =>
-        Logging.error(
-          `Failed to restore cache, continuing without it. ${psqlExecMissingErrorMessage}`,
-        )
       }
     }
 
     let cacheTableInfo: array<schemaCacheTableInfo> =
       await sql->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema))
 
-    if withUpload {
+    if withUpload && cacheTableInfo->Utils.Array.notEmpty {
       switch onNewTables {
       | Some(onNewTables) =>
         await onNewTables(

package/src/PgStorage.res.js

@@ -10,6 +10,8 @@ var Js_exn = require("rescript/lib/js/js_exn.js");
 var Schema = require("./db/Schema.res.js");
 var Js_dict = require("rescript/lib/js/js_dict.js");
 var Logging = require("./Logging.res.js");
+var $$Promise = require("./bindings/Promise.res.js");
+var Internal = require("./Internal.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Caml_array = require("rescript/lib/js/caml_array.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
@@ -274,7 +276,7 @@ async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
     throw {
           RE_EXN_ID: Persistence.StorageError,
           message: "Failed to insert items into table \"" + table.tableName + "\"",
-          reason: exn,
+          reason: Internal.prettifyExn(exn),
           Error: new Error()
         };
   }
@@ -307,7 +309,7 @@ var psqlExecState = {
   contents: "Unknown"
 };
 
-async function getPsqlExec(pgUser, pgHost) {
+async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort) {
   var promise = psqlExecState.contents;
   if (typeof promise === "object") {
     if (promise.TAG === "Pending") {
@@ -322,20 +324,20 @@ async function getPsqlExec(pgUser, pgHost) {
                   if (error === null) {
                     return resolve({
                                 TAG: "Ok",
-                                _0: binary
+                                _0: binary + " -h " + pgHost + " -p " + pgPort.toString() + " -U " + pgUser + " -d " + pgDatabase
                               });
                   }
-                  var binary$1 = "docker-compose exec -T -u " + pgUser + " " + pgHost + " psql";
+                  var binary$1 = "docker-compose exec -T -u " + pgUser + " envio-postgres psql";
                   Child_process.exec(binary$1 + " --version", (function (error, param, param$1) {
                           if (error === null) {
                             return resolve({
                                         TAG: "Ok",
-                                        _0: binary$1
+                                        _0: binary$1 + " -h " + pgHost + " -p " + (5432).toString() + " -U " + pgUser + " -d " + pgDatabase
                                       });
                           } else {
                             return resolve({
                                         TAG: "Error",
-                                        _0: "Failed to find psql binary"
+                                        _0: "Please check if \"psql\" binary is installed or docker-compose is running for the local indexer."
                                       });
                           }
                         }));
@@ -353,13 +355,17 @@ async function getPsqlExec(pgUser, pgHost) {
   return result;
 }
 
-var psqlExecMissingErrorMessage = "Please check if \"psql\" binary is installed or docker-compose is running for the local indexer.";
-
-function make(sql, pgHost, pgSchema, pgUser, pgDatabase, pgPassword, onInitialize, onNewTables) {
-  var psqlExecOptions_env = Js_dict.fromArray([[
+function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onInitialize, onNewTables) {
+  var psqlExecOptions_env = Js_dict.fromArray([
+        [
           "PGPASSWORD",
           pgPassword
-        ]]);
+        ],
+        [
+          "PATH",
+          process.env.PATH
+        ]
+      ]);
   var psqlExecOptions = {
     env: psqlExecOptions_env
   };
@@ -464,7 +470,7 @@ function make(sql, pgHost, pgSchema, pgUser, pgDatabase, pgPassword, onInitializ
   var setEffectCacheOrThrow = async function (effectName, ids, outputs, outputSchema, initialize) {
     var table = Table.mkTable(cacheTablePrefix + effectName, [], [
           Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-          Table.mkField("output", "JSONB", outputSchema, undefined, undefined, undefined, undefined, undefined, undefined)
+          Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined)
         ]);
     if (initialize) {
       await sql.unsafe(makeCreateTableQuery(table, pgSchema));
@@ -488,85 +494,120 @@ function make(sql, pgHost, pgSchema, pgUser, pgDatabase, pgPassword, onInitializ
                   }));
   };
   var dumpEffectCache = async function () {
-    var cacheTableInfo = (await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema))).filter(function (i) {
-          return i.count > 0;
-        });
-    if (!Utils.$$Array.notEmpty(cacheTableInfo)) {
-      return ;
-    }
     try {
-      await Fs.promises.access(cacheDirPath);
-    }
-    catch (exn){
-      await Fs.promises.mkdir(cacheDirPath, {
-            recursive: true
+      var cacheTableInfo = (await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema))).filter(function (i) {
+            return i.count > 0;
+          });
+      if (!Utils.$$Array.notEmpty(cacheTableInfo)) {
+        return ;
+      }
+      try {
+        await Fs.promises.access(cacheDirPath);
+      }
+      catch (exn){
+        await Fs.promises.mkdir(cacheDirPath, {
+              recursive: true
+            });
+      }
+      var psqlExec = await getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort);
+      if (psqlExec.TAG !== "Ok") {
+        return Logging.error("Failed to dump cache. " + psqlExec._0);
+      }
+      var psqlExec$1 = psqlExec._0;
+      Logging.info("Dumping cache: " + cacheTableInfo.map(function (param) {
+                  return param.table_name + " (" + String(param.count) + " rows)";
+                }).join(", "));
+      var promises = cacheTableInfo.map(async function (param) {
+            var tableName = param.table_name;
+            var cacheName = tableName.slice(cacheTablePrefixLength);
+            var outputFile = Path.join(cacheDirPath, cacheName + ".tsv");
+            var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + tableName + "\" TO STDOUT WITH (FORMAT text, HEADER);' > " + outputFile;
+            return new Promise((function (resolve, reject) {
+                          Child_process.exec(command, psqlExecOptions, (function (error, stdout, param) {
+                                  if (error === null) {
+                                    return resolve(stdout);
+                                  } else {
+                                    return reject(error);
+                                  }
+                                }));
+                        }));
           });
+      await Promise.all(promises);
+      return Logging.info("Successfully dumped cache to " + cacheDirPath);
     }
-    var psqlExec = await getPsqlExec(pgUser, pgHost);
-    if (psqlExec.TAG !== "Ok") {
-      return Logging.error("Failed to dump cache. " + psqlExecMissingErrorMessage);
+    catch (raw_exn){
+      var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      return Logging.errorWithExn(Internal.prettifyExn(exn$1), "Failed to dump cache.");
     }
-    var psqlExec$1 = psqlExec._0;
-    Logging.info("Dumping cache: " + cacheTableInfo.map(function (param) {
-                return param.table_name + " (" + String(param.count) + " rows)";
-              }).join(", "));
-    var promises = cacheTableInfo.map(async function (param) {
-          var tableName = param.table_name;
-          var cacheName = tableName.slice(cacheTablePrefixLength);
-          var outputFile = Path.join(cacheDirPath, cacheName + ".tsv");
-          var command = psqlExec$1 + " -h " + pgHost + " -U " + pgUser + " -d " + pgDatabase + " -c 'COPY \"" + pgSchema + "\".\"" + tableName + "\" TO STDOUT WITH (FORMAT text, HEADER);' > " + outputFile;
-          return new Promise((function (resolve, reject) {
-                        Child_process.exec(command, psqlExecOptions, (function (error, stdout, param) {
-                                if (error === null) {
-                                  return resolve(stdout);
-                                } else {
-                                  return reject(error);
-                                }
-                              }));
-                      }));
-        });
-    await Promise.all(promises);
-    return Logging.info("Successfully dumped cache to " + cacheDirPath);
   };
   var restoreEffectCache = async function (withUpload) {
     if (withUpload) {
+      var nothingToUploadErrorMessage = "Nothing to upload.";
       var match = await Promise.all([
-            Fs.promises.readdir(cacheDirPath),
-            getPsqlExec(pgUser, pgHost)
+            $$Promise.$$catch(Fs.promises.readdir(cacheDirPath).then(function (e) {
+                      return {
+                              TAG: "Ok",
+                              _0: e
+                            };
+                    }), (function (param) {
+                    return Promise.resolve({
+                                TAG: "Error",
+                                _0: nothingToUploadErrorMessage
+                              });
+                  })),
+            getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort)
           ]);
-      var psqlExecResult = match[1];
-      if (psqlExecResult.TAG === "Ok") {
-        var psqlExec = psqlExecResult._0;
-        var cacheFiles = match[0].filter(function (entry) {
-              return entry.endsWith(".tsv");
-            });
-        await Promise.all(cacheFiles.map(function (entry) {
-                  var cacheName = entry.slice(0, -4);
-                  var tableName = cacheTablePrefix + cacheName;
-                  var table = Table.mkTable(tableName, [], [
-                        Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-                        Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined)
-                      ]);
-                  return sql.unsafe(makeCreateTableQuery(table, pgSchema)).then(function () {
-                              var inputFile = Path.join(cacheDirPath, entry);
-                              var command = psqlExec + " -h " + pgHost + " -U " + pgUser + " -d " + pgDatabase + " -c 'COPY \"" + pgSchema + "\".\"" + tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
-                              return new Promise((function (resolve, reject) {
-                                            Child_process.exec(command, psqlExecOptions, (function (error, stdout, param) {
-                                                    if (error === null) {
-                                                      return resolve(stdout);
-                                                    } else {
-                                                      return reject(error);
-                                                    }
-                                                  }));
-                                          }));
-                            });
-                }));
+      var exit = 0;
+      var message;
+      var entries = match[0];
+      if (entries.TAG === "Ok") {
+        var psqlExec = match[1];
+        if (psqlExec.TAG === "Ok") {
+          var psqlExec$1 = psqlExec._0;
+          var cacheFiles = entries._0.filter(function (entry) {
+                return entry.endsWith(".tsv");
+              });
+          await Promise.all(cacheFiles.map(function (entry) {
+                    var cacheName = entry.slice(0, -4);
+                    var tableName = cacheTablePrefix + cacheName;
+                    var table = Table.mkTable(tableName, [], [
+                          Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
+                          Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined)
+                        ]);
+                    return sql.unsafe(makeCreateTableQuery(table, pgSchema)).then(function () {
+                                var inputFile = Path.join(cacheDirPath, entry);
+                                var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
+                                return new Promise((function (resolve, reject) {
+                                              Child_process.exec(command, psqlExecOptions, (function (error, stdout, param) {
+                                                      if (error === null) {
+                                                        return resolve(stdout);
+                                                      } else {
+                                                        return reject(error);
+                                                      }
+                                                    }));
+                                            }));
+                              });
+                  }));
+          Logging.info("Successfully uploaded cache.");
+        } else {
+          message = match[1]._0;
+          exit = 1;
+        }
       } else {
-        Logging.error("Failed to restore cache, continuing without it. " + psqlExecMissingErrorMessage);
+        message = entries._0;
+        exit = 1;
       }
+      if (exit === 1) {
+        if (message === nothingToUploadErrorMessage) {
+          Logging.info("No cache found to upload.");
+        } else {
+          Logging.error("Failed to upload cache, continuing without it. " + message);
+        }
+      }
+      
     }
     var cacheTableInfo = await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema));
-    if (withUpload && onNewTables !== undefined) {
+    if (withUpload && Utils.$$Array.notEmpty(cacheTableInfo) && onNewTables !== undefined) {
       await onNewTables(cacheTableInfo.map(function (info) {
                 return info.table_name;
               }));
@@ -616,7 +657,6 @@ exports.makeSchemaTableNamesQuery = makeSchemaTableNamesQuery;
 exports.cacheTablePrefix = cacheTablePrefix;
 exports.cacheTablePrefixLength = cacheTablePrefixLength;
 exports.makeSchemaCacheTableInfoQuery = makeSchemaCacheTableInfoQuery;
-exports.getPsqlExec = getPsqlExec;
-exports.psqlExecMissingErrorMessage = psqlExecMissingErrorMessage;
+exports.getConnectedPsqlExec = getConnectedPsqlExec;
 exports.make = make;
 /* pgEncodingErrorSchema Not a pure module */