envio 2.22.0 → 2.22.1

package/src/Hasura.res.js

@@ -0,0 +1,245 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Rest = require("./vendored/Rest.res.js");
+var Table = require("./db/Table.res.js");
+var Utils = require("./Utils.res.js");
+var Schema = require("./db/Schema.res.js");
+var Logging = require("./Logging.res.js");
+var Internal = require("./Internal.res.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Caml_splice_call = require("rescript/lib/js/caml_splice_call.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+function auth(s) {
+  return {
+          role: s.header("X-Hasura-Role", S$RescriptSchema.string),
+          secret: s.header("X-Hasura-Admin-Secret", S$RescriptSchema.string)
+        };
+}
+
+var responses = [
+  (function (s) {
+      s.status(200);
+      s.data(S$RescriptSchema.unknown);
+      return "QuerySucceeded";
+    }),
+  (function (s) {
+      s.field("code", S$RescriptSchema.$$enum([
+                "already-exists",
+                "already-tracked"
+              ]));
+      return "AlreadyDone";
+    })
+];
+
+function clearMetadataRoute() {
+  return {
+          method: "POST",
+          path: "",
+          input: (function (s) {
+              s.field("type", S$RescriptSchema.literal("clear_metadata"));
+              s.field("args", S$RescriptSchema.literal({}));
+              return auth(s);
+            }),
+          responses: responses
+        };
+}
+
+function trackTablesRoute() {
+  return {
+          method: "POST",
+          path: "",
+          input: (function (s) {
+              s.field("type", S$RescriptSchema.literal("pg_track_tables"));
+              return {
+                      args: s.field("args", S$RescriptSchema.json(false)),
+                      auth: auth(s)
+                    };
+            }),
+          responses: responses
+        };
+}
+
+function createSelectPermissionRoute() {
+  return {
+          method: "POST",
+          path: "",
+          input: (function (s) {
+              s.field("type", S$RescriptSchema.literal("pg_create_select_permission"));
+              return {
+                      args: s.field("args", S$RescriptSchema.json(false)),
+                      auth: auth(s)
+                    };
+            }),
+          responses: responses
+        };
+}
+
+function rawBodyRoute() {
+  return {
+          method: "POST",
+          path: "",
+          input: (function (s) {
+              return {
+                      bodyString: s.rawBody(S$RescriptSchema.string),
+                      auth: auth(s)
+                    };
+            }),
+          responses: responses
+        };
+}
+
+async function clearHasuraMetadata(endpoint, auth) {
+  try {
+    var result = await Rest.$$fetch(clearMetadataRoute, auth, Rest.client(endpoint, undefined));
+    var msg;
+    msg = result === "QuerySucceeded" ? "Metadata Cleared" : "Metadata Already Cleared";
+    return Logging.trace(msg);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return Logging.error({
+                msg: "EE806: There was an issue clearing metadata in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                err: Internal.prettifyExn(exn)
+              });
+  }
+}
+
+async function trackTables(endpoint, auth, pgSchema, tableNames) {
+  try {
+    var result = await Rest.$$fetch(trackTablesRoute, {
+          auth: auth,
+          args: {
+            allow_warnings: false,
+            tables: tableNames.map(function (tableName) {
+                  return {
+                          table: {
+                            name: tableName,
+                            schema: pgSchema
+                          },
+                          configuration: {
+                            custom_name: tableName
+                          }
+                        };
+                })
+          }
+        }, Rest.client(endpoint, undefined));
+    var msg;
+    msg = result === "QuerySucceeded" ? "Tables Tracked" : "Table Already Tracked";
+    return Logging.trace({
+                msg: msg,
+                tableNames: tableNames
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return Logging.error({
+                msg: "EE807: There was an issue tracking tables in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                tableNames: tableNames,
+                err: Internal.prettifyExn(exn)
+              });
+  }
+}
+
+async function createSelectPermissions(auth, endpoint, tableName, pgSchema, responseLimit, aggregateEntities) {
+  try {
+    var result = await Rest.$$fetch(createSelectPermissionRoute, {
+          auth: auth,
+          args: {
+            table: {
+              schema: pgSchema,
+              name: tableName
+            },
+            role: "public",
+            source: "default",
+            permission: {
+              columns: "*",
+              filter: {},
+              limit: responseLimit,
+              allow_aggregations: aggregateEntities.includes(tableName)
+            }
+          }
+        }, Rest.client(endpoint, undefined));
+    var msg;
+    msg = result === "QuerySucceeded" ? "Hasura select permissions created" : "Hasura select permissions already created";
+    return Logging.trace({
+                msg: msg,
+                tableName: tableName
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return Logging.error({
+                msg: "EE808: There was an issue setting up view permissions for the " + tableName + " table in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                tableName: tableName,
+                err: Internal.prettifyExn(exn)
+              });
+  }
+}
+
+async function createEntityRelationship(pgSchema, endpoint, auth, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom) {
+  var derivedFromTo = isDerivedFrom ? "\"id\": \"" + relationalKey + "\"" : "\"" + relationalKey + "_id\" : \"id\"";
+  var bodyString = "{\"type\": \"pg_create_" + relationshipType + "_relationship\",\"args\": {\"table\": {\"schema\": \"" + pgSchema + "\", \"name\": \"" + tableName + "\"},\"name\": \"" + objectName + "\",\"source\": \"default\",\"using\": {\"manual_configuration\": {\"remote_table\": {\"schema\": \"" + pgSchema + "\", \"name\": \"" + mappedEntity + "\"},\"column_mapping\": {" + derivedFromTo + "}}}}}";
+  try {
+    var result = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: bodyString
+        }, Rest.client(endpoint, undefined));
+    var msg;
+    msg = result === "QuerySucceeded" ? "Hasura " + relationshipType + " relationship created" : "Hasura " + relationshipType + " relationship already created";
+    return Logging.trace({
+                msg: msg,
+                tableName: tableName
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return Logging.error({
+                msg: "EE808: There was an issue setting up " + relationshipType + " relationship for the " + tableName + " table in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                tableName: tableName,
+                err: Internal.prettifyExn(exn)
+              });
+  }
+}
+
+async function trackDatabase(endpoint, auth, pgSchema, allStaticTables, allEntityTables, aggregateEntities, responseLimit, schema) {
+  Logging.info("Tracking tables in Hasura");
+  await clearHasuraMetadata(endpoint, auth);
+  var tableNames = Belt_Array.concatMany([
+          allStaticTables,
+          allEntityTables
+        ]).map(function (param) {
+        return param.tableName;
+      });
+  await trackTables(endpoint, auth, pgSchema, tableNames);
+  await Promise.all(Caml_splice_call.spliceObjApply(tableNames.map(function (tableName) {
+                return createSelectPermissions(auth, endpoint, tableName, pgSchema, responseLimit, aggregateEntities);
+              }), "concat", [allEntityTables.map(function (table) {
+                  var tableName = table.tableName;
+                  return [
+                            Table.getDerivedFromFields(table).map(function (derivedFromField) {
+                                  var relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
+                                  return createEntityRelationship(pgSchema, endpoint, auth, tableName, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true);
+                                }),
+                            Table.getLinkedEntityFields(table).map(function (param) {
+                                  var field = param[0];
+                                  return createEntityRelationship(pgSchema, endpoint, auth, tableName, "object", field.fieldName, field.fieldName, param[1], false);
+                                })
+                          ].flat(1);
+                })]));
+}
+
+exports.auth = auth;
+exports.responses = responses;
+exports.clearMetadataRoute = clearMetadataRoute;
+exports.trackTablesRoute = trackTablesRoute;
+exports.createSelectPermissionRoute = createSelectPermissionRoute;
+exports.rawBodyRoute = rawBodyRoute;
+exports.clearHasuraMetadata = clearHasuraMetadata;
+exports.trackTables = trackTables;
+exports.createSelectPermissions = createSelectPermissions;
+exports.createEntityRelationship = createEntityRelationship;
+exports.trackDatabase = trackDatabase;
+/* Rest Not a pure module */

package/src/Internal.res.js

@@ -0,0 +1,50 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var $$BigInt = require("./bindings/BigInt.res.js");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Address = require("./Address.res.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var fuelSupplyParamsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              subId: s.m(S$RescriptSchema.string),
+              amount: s.m($$BigInt.schema)
+            };
+    });
+
+var fuelTransferParamsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              to: s.m(Address.schema),
+              assetId: s.m(S$RescriptSchema.string),
+              amount: s.m($$BigInt.schema)
+            };
+    });
+
+function makeEnumConfig(name, variants) {
+  var v = Belt_Array.get(variants, 0);
+  return {
+          name: name,
+          variants: variants,
+          schema: S$RescriptSchema.$$enum(variants),
+          default: v !== undefined ? Caml_option.valFromOption(v) : Js_exn.raiseError("No variants defined for enum " + name)
+        };
+}
+
+function prettifyExn(exn) {
+  var e = Caml_js_exceptions.internalToOCamlException(exn);
+  if (e.RE_EXN_ID === Js_exn.$$Error) {
+    return e._1;
+  } else {
+    return e;
+  }
+}
+
+exports.fuelSupplyParamsSchema = fuelSupplyParamsSchema;
+exports.fuelTransferParamsSchema = fuelTransferParamsSchema;
+exports.makeEnumConfig = makeEnumConfig;
+exports.prettifyExn = prettifyExn;
+/* fuelSupplyParamsSchema Not a pure module */

package/src/LazyLoader.res.js

@@ -0,0 +1,117 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Utils = require("./Utils.res.js");
+var JsSdsl = require("js-sdsl");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var LoaderTimeout = /* @__PURE__ */Caml_exceptions.create("LazyLoader.LoaderTimeout");
+
+function make(loaderFn, onError, cacheSizeOpt, loaderPoolSizeOpt, retryDelayMillisOpt, timeoutMillisOpt) {
+  var cacheSize = cacheSizeOpt !== undefined ? cacheSizeOpt : 10000;
+  var loaderPoolSize = loaderPoolSizeOpt !== undefined ? loaderPoolSizeOpt : 10;
+  var retryDelayMillis = retryDelayMillisOpt !== undefined ? retryDelayMillisOpt : 5000;
+  var timeoutMillis = timeoutMillisOpt !== undefined ? timeoutMillisOpt : 300000;
+  return {
+          _cacheSize: cacheSize,
+          _loaderPoolSize: loaderPoolSize,
+          _retryDelayMillis: retryDelayMillis,
+          _timeoutMillis: timeoutMillis,
+          externalPromises: new Map(),
+          resolvers: new Map(),
+          inProgress: new Set(),
+          loaderQueue: new JsSdsl.Queue(),
+          loadedKeys: new JsSdsl.Queue(),
+          loaderFn: loaderFn,
+          onError: onError
+        };
+}
+
+function deleteKey(_obj, _k) {
+  ((delete _obj[_k]));
+}
+
+function timeoutAfter(timeoutMillis) {
+  return Utils.delay(timeoutMillis).then(function () {
+              return Promise.reject({
+                          RE_EXN_ID: LoaderTimeout,
+                          _1: "Query took longer than " + String(timeoutMillis / 1000 | 0) + " seconds"
+                        });
+            });
+}
+
+async function loadNext(am, k) {
+  am.inProgress.add(k);
+  var awaitTaskPromiseAndLoadNextWithTimeout = async function () {
+    var val = await Promise.race([
+          am.loaderFn(k),
+          timeoutAfter(am._timeoutMillis)
+        ]);
+    Belt_Option.forEach(am.resolvers.get(k), (function (r) {
+            am.resolvers.delete(k);
+            r(val);
+          }));
+    am.inProgress.delete(k);
+    var loadedKeysNumber = am.loadedKeys.push(k);
+    if (loadedKeysNumber > am._cacheSize) {
+      var old = am.loadedKeys.pop();
+      if (old !== undefined) {
+        am.externalPromises.delete(Caml_option.valFromOption(old));
+      }
+      
+    }
+    var next = am.loaderQueue.pop();
+    if (next !== undefined) {
+      return await loadNext(am, Caml_option.valFromOption(next));
+    }
+    
+  };
+  var tmp;
+  var exit = 0;
+  var val;
+  try {
+    val = await awaitTaskPromiseAndLoadNextWithTimeout();
+    exit = 1;
+  }
+  catch (raw_err){
+    var err = Caml_js_exceptions.internalToOCamlException(raw_err);
+    var onError = am.onError;
+    if (onError !== undefined) {
+      onError(am, err);
+    }
+    await Utils.delay(am._retryDelayMillis);
+    tmp = awaitTaskPromiseAndLoadNextWithTimeout();
+  }
+  if (exit === 1) {
+    tmp = Promise.resolve();
+  }
+  return await tmp;
+}
+
+function get(am, k) {
+  var x = am.externalPromises.get(k);
+  if (x !== undefined) {
+    return Caml_option.valFromOption(x);
+  }
+  var promise = new Promise((function (resolve, param) {
+          am.resolvers.set(k, resolve);
+        }));
+  am.externalPromises.set(k, promise);
+  if (am.inProgress.size < am._loaderPoolSize) {
+    loadNext(am, k);
+  } else {
+    am.loaderQueue.push(k);
+  }
+  return promise;
+}
+
+exports.LoaderTimeout = LoaderTimeout;
+exports.make = make;
+exports.deleteKey = deleteKey;
+exports.timeoutAfter = timeoutAfter;
+exports.loadNext = loadNext;
+exports.get = get;
+/* Utils Not a pure module */

package/src/LoadManager.res.js

@@ -0,0 +1,124 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Utils = require("./Utils.res.js");
+var Internal = require("./Internal.res.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var Call = {};
+
+var Group = {};
+
+function make() {
+  return {
+          groups: {},
+          isCollecting: false
+        };
+}
+
+async function schedule(loadManager) {
+  loadManager.isCollecting = true;
+  await Promise.resolve();
+  loadManager.isCollecting = false;
+  var groups = loadManager.groups;
+  Object.keys(groups).forEach(async function (key) {
+        var group = groups[key];
+        var calls = group.calls;
+        var inputsToLoad = [];
+        var currentInputKeys = [];
+        Object.keys(calls).forEach(function (inputKey) {
+              var call = calls[inputKey];
+              if (!call.isLoading) {
+                call.isLoading = true;
+                currentInputKeys.push(inputKey);
+                if (!group.hasInMemory(inputKey)) {
+                  inputsToLoad.push(call.input);
+                  return ;
+                } else {
+                  return ;
+                }
+              }
+              
+            });
+        if (!Utils.$$Array.isEmpty(inputsToLoad)) {
+          try {
+            await group.load(inputsToLoad);
+          }
+          catch (raw_exn){
+            var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+            var exn$1 = Internal.prettifyExn(exn);
+            Belt_Array.forEach(currentInputKeys, (function (inputKey) {
+                    var call = calls[inputKey];
+                    call.reject(exn$1);
+                  }));
+          }
+        }
+        if (Utils.$$Array.isEmpty(currentInputKeys)) {
+          return ;
+        }
+        currentInputKeys.forEach(function (inputKey) {
+              var call = calls[inputKey];
+              Utils.Dict.deleteInPlace(calls, inputKey);
+              call.resolve(group.getUnsafeInMemory(inputKey));
+            });
+        var latestGroup = groups[key];
+        if (Utils.$$Array.isEmpty(Object.keys(latestGroup.calls))) {
+          return Utils.Dict.deleteInPlace(groups, key);
+        }
+        
+      });
+}
+
+function noopHasher(input) {
+  return input;
+}
+
+function call(loadManager, input, key, load, hasher, shouldGroup, hasInMemory, getUnsafeInMemory) {
+  var inputKey = hasher === noopHasher ? input : hasher(input);
+  if (!shouldGroup && hasInMemory(inputKey)) {
+    return Promise.resolve(getUnsafeInMemory(inputKey));
+  }
+  var group = loadManager.groups[key];
+  var group$1;
+  if (group !== undefined) {
+    group$1 = group;
+  } else {
+    var g_calls = {};
+    var g = {
+      calls: g_calls,
+      load: load,
+      getUnsafeInMemory: getUnsafeInMemory,
+      hasInMemory: hasInMemory
+    };
+    loadManager.groups[key] = g;
+    group$1 = g;
+  }
+  var c = group$1.calls[inputKey];
+  if (c !== undefined) {
+    return c.promise;
+  }
+  var promise = new Promise((function (resolve, reject) {
+          var call = {
+            input: input,
+            resolve: resolve,
+            reject: reject,
+            promise: null,
+            isLoading: false
+          };
+          group$1.calls[inputKey] = call;
+        }));
+  group$1.calls[inputKey].promise = promise;
+  if (!loadManager.isCollecting) {
+    schedule(loadManager);
+  }
+  return promise;
+}
+
+exports.Call = Call;
+exports.Group = Group;
+exports.make = make;
+exports.schedule = schedule;
+exports.noopHasher = noopHasher;
+exports.call = call;
+/* Utils Not a pure module */