envio 2.21.5 → 2.22.1

package/src/Hasura.res

@@ -0,0 +1,297 @@
+type auth = {
+  role: string,
+  secret: string,
+}
+
+type validHasuraResponse = QuerySucceeded | AlreadyDone
+
+let auth = (s: Rest.s) => {
+  role: s.header("X-Hasura-Role", S.string),
+  secret: s.header("X-Hasura-Admin-Secret", S.string),
+}
+
+let responses = [
+  (s: Rest.Response.s) => {
+    s.status(200)
+    let _ = s.data(S.unknown)
+    QuerySucceeded
+  },
+  s => {
+    let _ = s.field("code", S.enum(["already-exists", "already-tracked"]))
+    AlreadyDone
+  },
+]
+
+let clearMetadataRoute = Rest.route(() => {
+  method: Post,
+  path: "",
+  input: s => {
+    let _ = s.field("type", S.literal("clear_metadata"))
+    let _ = s.field("args", S.literal(Js.Obj.empty()))
+    s->auth
+  },
+  responses,
+})
+
+let trackTablesRoute = Rest.route(() => {
+  method: Post,
+  path: "",
+  input: s => {
+    let _ = s.field("type", S.literal("pg_track_tables"))
+    {
+      "args": s.field("args", S.json(~validate=false)),
+      "auth": s->auth,
+    }
+  },
+  responses,
+})
+
+let createSelectPermissionRoute = Rest.route(() => {
+  method: Post,
+  path: "",
+  input: s => {
+    let _ = s.field("type", S.literal("pg_create_select_permission"))
+    {
+      "args": s.field("args", S.json(~validate=false)),
+      "auth": s->auth,
+    }
+  },
+  responses,
+})
+
+let rawBodyRoute = Rest.route(() => {
+  method: Post,
+  path: "",
+  input: s => {
+    {
+      "bodyString": s.rawBody(S.string),
+      "auth": s->auth,
+    }
+  },
+  responses,
+})
+
+let clearHasuraMetadata = async (~endpoint, ~auth) => {
+  try {
+    let result = await clearMetadataRoute->Rest.fetch(auth, ~client=Rest.client(endpoint))
+    let msg = switch result {
+    | QuerySucceeded => "Metadata Cleared"
+    | AlreadyDone => "Metadata Already Cleared"
+    }
+    Logging.trace(msg)
+  } catch {
+  | exn =>
+    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": exn->Internal.prettifyExn,
+    })
+  }
+}
+
+let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableNames: array<string>) => {
+  try {
+    let result = await trackTablesRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "args": {
+          // If set to false, any warnings will cause the API call to fail and no new tables to be tracked. Otherwise tables that fail to track will be raised as warnings. (default: true)
+          "allow_warnings": false,
+          "tables": tableNames->Js.Array2.map(tableName =>
+            {
+              "table": {
+                "name": tableName,
+                "schema": pgSchema,
+              },
+              "configuration": {
+                // Otherwise the entity in gql will be prefixed with the schema name (when it's not public)
+                "custom_name": tableName,
+              },
+            }
+          ),
+        }->(Utils.magic: 'a => Js.Json.t),
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => "Tables Tracked"
+    | AlreadyDone => "Table Already Tracked"
+    }
+    Logging.trace({
+      "msg": msg,
+      "tableNames": tableNames,
+    })
+  } catch {
+  | exn =>
+    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": exn->Internal.prettifyExn,
+    })
+  }
+}
+
+let createSelectPermissions = async (
+  ~auth,
+  ~endpoint,
+  ~tableName: string,
+  ~pgSchema,
+  ~responseLimit,
+  ~aggregateEntities,
+) => {
+  try {
+    let result = await createSelectPermissionRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "args": {
+          "table": {
+            "schema": pgSchema,
+            "name": tableName,
+          },
+          "role": "public",
+          "source": "default",
+          "permission": {
+            "columns": "*",
+            "filter": Js.Obj.empty(),
+            "limit": responseLimit,
+            "allow_aggregations": aggregateEntities->Js.Array2.includes(tableName),
+          },
+        }->(Utils.magic: 'a => Js.Json.t),
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => "Hasura select permissions created"
+    | AlreadyDone => "Hasura select permissions already created"
+    }
+    Logging.trace({
+      "msg": msg,
+      "tableName": tableName,
+    })
+  } catch {
+  | exn =>
+    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": exn->Internal.prettifyExn,
+    })
+  }
+}
+
+let createEntityRelationship = async (
+  ~pgSchema,
+  ~endpoint,
+  ~auth,
+  ~tableName: string,
+  ~relationshipType: string,
+  ~relationalKey: string,
+  ~objectName: string,
+  ~mappedEntity: string,
+  ~isDerivedFrom: bool,
+) => {
+  let derivedFromTo = isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}_id" : "id"`
+
+  let 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 {
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": bodyString,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura ${relationshipType} relationship created`
+    | AlreadyDone => `Hasura ${relationshipType} relationship already created`
+    }
+    Logging.trace({
+      "msg": msg,
+      "tableName": tableName,
+    })
+  } catch {
+  | exn =>
+    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": exn->Internal.prettifyExn,
+    })
+  }
+}
+
+let trackDatabase = async (
+  ~endpoint,
+  ~auth,
+  ~pgSchema,
+  ~allStaticTables,
+  ~allEntityTables,
+  ~aggregateEntities,
+  ~responseLimit,
+  ~schema,
+) => {
+  Logging.info("Tracking tables in Hasura")
+
+  let _ = await clearHasuraMetadata(~endpoint, ~auth)
+  let tableNames =
+    [allStaticTables, allEntityTables]
+    ->Belt.Array.concatMany
+    ->Js.Array2.map(({tableName}: Table.table) => tableName)
+
+  await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
+
+  let _ =
+    await tableNames
+    ->Js.Array2.map(tableName =>
+      createSelectPermissions(
+        ~endpoint,
+        ~auth,
+        ~tableName,
+        ~pgSchema,
+        ~responseLimit,
+        ~aggregateEntities,
+      )
+    )
+    ->Js.Array2.concatMany(
+      allEntityTables->Js.Array2.map(table => {
+        let {tableName} = table
+        [
+          //Set array relationships
+          table
+          ->Table.getDerivedFromFields
+          ->Js.Array2.map(derivedFromField => {
+            //determines the actual name of the underlying relational field (if it's an entity mapping then suffixes _id for eg.)
+            let relationalFieldName =
+              schema->Schema.getDerivedFromFieldName(derivedFromField)->Utils.unwrapResultExn
+
+            createEntityRelationship(
+              ~endpoint,
+              ~auth,
+              ~pgSchema,
+              ~tableName,
+              ~relationshipType="array",
+              ~isDerivedFrom=true,
+              ~objectName=derivedFromField.fieldName,
+              ~relationalKey=relationalFieldName,
+              ~mappedEntity=derivedFromField.derivedFromEntity,
+            )
+          }),
+          //Set object relationships
+          table
+          ->Table.getLinkedEntityFields
+          ->Js.Array2.map(((field, linkedEntityName)) => {
+            createEntityRelationship(
+              ~endpoint,
+              ~auth,
+              ~pgSchema,
+              ~tableName,
+              ~relationshipType="object",
+              ~isDerivedFrom=false,
+              ~objectName=field.fieldName,
+              ~relationalKey=field.fieldName,
+              ~mappedEntity=linkedEntityName,
+            )
+          }),
+        ]->Utils.Array.flatten
+      }),
+    )
+    ->Promise.all
+}

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

@@ -160,6 +160,31 @@ let fuelTransferParamsSchema = S.schema(s => {
 })
 
 type entity = private {id: string}
+type entityConfig = {
+  name: string,
+  schema: S.t<entity>,
+  rowsSchema: S.t<array<entity>>,
+  table: Table.table,
+  entityHistory: EntityHistory.t<entity>,
+}
+type enum
+type enumConfig<'enum> = {
+  name: string,
+  variants: array<'enum>,
+  schema: S.t<'enum>,
+  default: 'enum,
+}
+external fromGenericEnumConfig: enumConfig<'enum> => enumConfig<enum> = "%identity"
+
+let makeEnumConfig = (~name, ~variants) => {
+  name,
+  variants,
+  schema: S.enum(variants),
+  default: switch variants->Belt.Array.get(0) {
+  | Some(v) => v
+  | None => Js.Exn.raiseError("No variants defined for enum " ++ name)
+  },
+}
 
 type effectInput
 type effectOutput
@@ -172,6 +197,7 @@ type effectArgs = {
 type effect = {
   name: string,
   handler: effectArgs => promise<effectOutput>,
+  mutable callsCount: int,
 }
 
 @genType.import(("./Types.ts", "Invalid"))

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 */