envio 2.13.0 → 2.14.0

package/README.md

@@ -18,6 +18,7 @@ Build a real-time API for your blockchain application in minutes.
 - Write JavaScript, TypeScript, or ReScript with automatically generated types
 - Detailed logging & Error messaging
 - [Hosted Service](https://docs.envio.dev/docs/HyperIndex/hosted-service) to take care of your infrastructure
+- Seamlessly integrate new chains and enhance reliability with the RPC data source
 
 ## Getting Started
 

package/evm.schema.json

@@ -272,13 +272,13 @@
       "type": "object",
       "properties": {
         "id": {
-          "description": "Public chain/network id",
+          "description": "The public blockchain network ID.",
           "type": "integer",
           "format": "uint64",
           "minimum": 0
         },
         "rpc_config": {
-          "description": "RPC Config that will be used to subscribe to blockchain data on this network (TIP: This is optional and in most cases does not need to be specified if the network is supported with HyperSync. We recommend using HyperSync instead of RPC for 100x speed-up)",
+          "description": "RPC configuration for utilizing as the network's data-source. Typically optional for chains with HyperSync support, which is highly recommended. HyperSync dramatically enhances performance, providing up to a 1000x speed boost over traditional RPC.",
           "anyOf": [
             {
               "$ref": "#/$defs/RpcConfig"
@@ -288,6 +288,17 @@
             }
           ]
         },
+        "rpc": {
+          "description": "RPC configuration for your indexer. If not specified otherwise, for networks supported by HyperSync, RPC serves as a fallback for added reliability. For others, it acts as the primary data-source. HyperSync offers significant performance improvements, up to a 1000x faster than traditional RPC.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/NetworkRpc"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "hypersync_config": {
           "description": "Optional HyperSync Config for additional fine-tuning",
           "anyOf": [
@@ -422,6 +433,116 @@
         "url"
       ]
     },
+    "NetworkRpc": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "$ref": "#/$defs/Rpc"
+        },
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Rpc"
+          }
+        }
+      ]
+    },
+    "Rpc": {
+      "type": "object",
+      "properties": {
+        "url": {
+          "description": "The RPC endpoint URL.",
+          "type": "string"
+        },
+        "for": {
+          "description": "Determines if this RPC is for historical sync, real-time chain indexing, or as a fallback.",
+          "$ref": "#/$defs/For"
+        },
+        "initial_block_interval": {
+          "description": "The starting interval in range of blocks per query",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        },
+        "backoff_multiplicative": {
+          "description": "After an RPC error, how much to scale back the number of blocks requested at once",
+          "type": [
+            "number",
+            "null"
+          ],
+          "format": "double"
+        },
+        "acceleration_additive": {
+          "description": "Without RPC errors or timeouts, how much to increase the number of blocks requested by for the next batch",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        },
+        "interval_ceiling": {
+          "description": "Do not further increase the block interval past this limit",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        },
+        "backoff_millis": {
+          "description": "After an error, how long to wait before retrying",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        },
+        "fallback_stall_timeout": {
+          "description": "If a fallback RPC is provided, the amount of time in ms to wait before kicking off the next provider",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        },
+        "query_timeout_millis": {
+          "description": "How long to wait before cancelling an RPC request",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "url",
+        "for"
+      ]
+    },
+    "For": {
+      "oneOf": [
+        {
+          "description": "Use RPC as the main data-source for both historical sync and real-time chain indexing.",
+          "type": "string",
+          "const": "sync"
+        },
+        {
+          "description": "Use RPC as a backup for the main data-source. Currently, it acts as a fallback when real-time indexing stalls, with potential for more cases in the future.",
+          "type": "string",
+          "const": "fallback"
+        }
+      ]
+    },
     "HypersyncConfig": {
       "type": "object",
       "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.13.0",
+  "version": "v2.14.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "repository": {
@@ -23,10 +23,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.13.0",
-    "envio-linux-arm64": "v2.13.0",
-    "envio-darwin-x64": "v2.13.0",
-    "envio-darwin-arm64": "v2.13.0"
+    "envio-linux-x64": "v2.14.0",
+    "envio-linux-arm64": "v2.14.0",
+    "envio-darwin-x64": "v2.14.0",
+    "envio-darwin-arm64": "v2.14.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.3",

package/src/Utils.res

@@ -92,6 +92,7 @@ module Math = {
     | (None, None) => None
     }
 }
+
 module Array = {
   @val external jsArrayCreate: int => array<'a> = "Array"
 
@@ -306,15 +307,11 @@ module Schema = {
   let coerceToJsonPgType = schema => {
     schema->S.preprocess(s => {
       switch s.schema->S.classify {
-      | Literal(Null(_))
-      | // This is a workaround for Fuel Bytes type
-      Unknown => {serializer: _ => %raw(`"null"`)}
-      | Null(_)
+      // This is a workaround for Fuel Bytes type
+      | Unknown => {serializer: _ => %raw(`"null"`)}
       | Bool => {
           serializer: unknown => {
-            if unknown === %raw(`null`) {
-              %raw(`"null"`)
-            } else if unknown === %raw(`false`) {
+            if unknown === %raw(`false`) {
               %raw(`"false"`)
             } else if unknown === %raw(`true`) {
               %raw(`"true"`)
@@ -339,7 +336,7 @@ module Set = {
   external make: unit => t<'value> = "Set"
 
   @ocaml.doc("Creates a new `Set` object.") @new
-  external fromEntries: array<'value> => t<'value> = "Set"
+  external fromArray: array<'value> => t<'value> = "Set"
 
   /*
    * Instance properties

package/src/bindings/Ethers.res

@@ -128,43 +128,17 @@ module JsonRpcProvider = {
     weight?: int,
   }
 
-  type fallbackProviderOptions = {
-    // How many providers must agree on a value before reporting
-    // back the response
-    // Note: Default the half of the providers weight, so we need to set it to accept result from the first rpc
-    quorum?: int,
-  }
-
   @module("ethers") @scope("ethers") @new
   external makeWithOptions: (~rpcUrl: string, ~network: Network.t, ~options: rpcOptions) => t =
     "JsonRpcProvider"
 
-  @module("ethers") @scope("ethers") @new
-  external makeFallbackProvider: (
-    ~providers: array<t>,
-    ~network: Network.t,
-    ~options: fallbackProviderOptions,
-  ) => t = "FallbackProvider"
-
   let makeStatic = (~rpcUrl: string, ~network: Network.t, ~priority=?, ~stallTimeout=?): t => {
     makeWithOptions(~rpcUrl, ~network, ~options={staticNetwork: network, ?priority, ?stallTimeout})
   }
 
-  let make = (~rpcUrls: array<string>, ~chainId: int, ~fallbackStallTimeout): t => {
+  let make = (~rpcUrl: string, ~chainId: int): t => {
     let network = Network.fromChainId(~chainId)
-    switch rpcUrls {
-    | [rpcUrl] => makeStatic(~rpcUrl, ~network)
-    | rpcUrls =>
-      makeFallbackProvider(
-        ~providers=rpcUrls->Js.Array2.mapi((rpcUrl, index) =>
-          makeStatic(~rpcUrl, ~network, ~priority=index, ~stallTimeout=fallbackStallTimeout)
-        ),
-        ~network,
-        ~options={
-          quorum: 1,
-        },
-      )
-    }
+    makeStatic(~rpcUrl, ~network)
   }
 
   @send
@@ -185,9 +159,6 @@ module JsonRpcProvider = {
     fields->Obj.magic
   }
 
-  @send
-  external getBlockNumber: t => promise<int> = "getBlockNumber"
-
   type block = {
     _difficulty: bigint,
     difficulty: int,

package/src/sources/HyperSyncJsonApi.res

@@ -360,13 +360,13 @@ module ResponseTypes = {
 let queryRoute = Rest.route(() => {
   path: "/query",
   method: Post,
-  variables: s => s.body(QueryTypes.postQueryBodySchema),
+  input: s => s.body(QueryTypes.postQueryBodySchema),
   responses: [s => s.data(ResponseTypes.queryResponseSchema)],
 })
 
 let heightRoute = Rest.route(() => {
   path: "/height",
   method: Get,
-  variables: _ => (),
+  input: _ => (),
   responses: [s => s.field("height", S.int)],
 })

package/src/sources/Rpc.res

@@ -4,7 +4,7 @@ let makeRpcRoute = (method: string, paramsSchema, resultSchema) => {
   Rest.route(() => {
     method: Post,
     path: "",
-    variables: s => {
+    input: s => {
       let _ = s.field("method", S.literal(method))
       let _ = s.field("id", idSchema)
       let _ = s.field("jsonrpc", versionSchema)

package/src/vendored/Rest.res

@@ -1,6 +1,6 @@
 /*
 Vendored from: https://github.com/DZakh/rescript-rest
-Version: 1.0.1
+Version: 2.0.0-rc.6
 
 IF EDITING THIS FILE, PLEASE LIST THE CHANGES BELOW
 
@@ -170,49 +170,50 @@ module Response = {
     data: 'value. S.t<'value> => 'value,
     field: 'value. (string, S.t<'value>) => 'value,
     header: 'value. (string, S.t<'value>) => 'value,
+    redirect: 'value. S.t<'value> => 'value,
   }
 
-  type t<'response> = {
+  type t<'output> = {
     // When it's empty, treat response as a default
     status: option<int>,
     description: option<string>,
     dataSchema: S.t<unknown>,
     emptyData: bool,
-    schema: S.t<'response>,
+    schema: S.t<'output>,
   }
 
-  type builder<'response> = {
+  type builder<'output> = {
     // When it's empty, treat response as a default
     mutable status?: int,
     mutable description?: string,
     mutable dataSchema?: S.t<unknown>,
     mutable emptyData: bool,
-    mutable schema?: S.t<'response>,
+    mutable schema?: S.t<'output>,
   }
 
   let register = (
-    map: dict<t<'response>>,
+    map: dict<t<'output>>,
     status: [< status | #default],
-    builder: builder<'response>,
+    builder: builder<'output>,
   ) => {
     let key = status->(Obj.magic: [< status | #default] => string)
     if map->Dict.has(key) {
       panic(`Response for the "${key}" status registered multiple times`)
     } else {
-      map->Js.Dict.set(key, builder->(Obj.magic: builder<'response> => t<'response>))
+      map->Js.Dict.set(key, builder->(Obj.magic: builder<'output> => t<'output>))
     }
   }
 
   @inline
-  let find = (map: dict<t<'response>>, responseStatus: int): option<t<'response>> => {
+  let find = (map: dict<t<'output>>, responseStatus: int): option<t<'output>> => {
     (map
     ->Js.Dict.unsafeGet(responseStatus->(Obj.magic: int => string))
-    ->(Obj.magic: t<'response> => bool) ||
+    ->(Obj.magic: t<'output> => bool) ||
     map
     ->Js.Dict.unsafeGet((responseStatus / 100)->(Obj.magic: int => string) ++ "XX")
-    ->(Obj.magic: t<'response> => bool) ||
-    map->Js.Dict.unsafeGet("default")->(Obj.magic: t<'response> => bool))
-      ->(Obj.magic: bool => option<t<'response>>)
+    ->(Obj.magic: t<'output> => bool) ||
+    map->Js.Dict.unsafeGet("default")->(Obj.magic: t<'output> => bool))
+      ->(Obj.magic: bool => option<t<'output>>)
   }
 }
 
@@ -242,26 +243,48 @@ type method =
   | @as("OPTIONS") Options
   | @as("TRACE") Trace
 
-type definition<'variables, 'response> = {
+type definition<'input, 'output> = {
   method: method,
   path: string,
-  variables: s => 'variables,
-  responses: array<Response.s => 'response>,
+  input: s => 'input,
+  responses: array<Response.s => 'output>,
   summary?: string,
   description?: string,
   deprecated?: bool,
+  operationId?: string,
+  tags?: array<string>,
+  // By default, all query parameters are encoded as strings, however, you can use the jsonQuery option to encode query parameters as typed JSON values.
+  jsonQuery?: bool,
+}
+
+type rpc<'input, 'output> = {
+  input: S.t<'input>,
+  output: S.t<'output>,
+  summary?: string,
+  description?: string,
+  deprecated?: bool,
+  operationId?: string,
+  tags?: array<string>,
 }
 
-type routeParams<'variables, 'response> = {
-  definition: definition<'variables, 'response>,
+type routeParams<'input, 'output> = {
+  method: method,
+  path: string,
   pathItems: array<pathItem>,
-  variablesSchema: S.t<'variables>,
-  responses: array<Response.t<'response>>,
-  responsesMap: dict<Response.t<'response>>,
+  inputSchema: S.t<'input>,
+  outputSchema: S.t<'output>,
+  responses: array<Response.t<'output>>,
+  responsesMap: dict<Response.t<'output>>,
   isRawBody: bool,
+  summary?: string,
+  description?: string,
+  deprecated?: bool,
+  operationId?: string,
+  tags?: array<string>,
+  jsonQuery?: bool,
 }
 
-type route<'variables, 'response> = unit => definition<'variables, 'response>
+type route<'input, 'output> = unit => definition<'input, 'output>
 
 let rec parsePath = (path: string, ~pathItems, ~pathParams) => {
   if path !== "" {
@@ -376,181 +399,230 @@ let basicAuthSchema = S.string->S.transform(s => {
 })
 
 let params = route => {
-  switch (route->Obj.magic)["_rest"]->(
-    Obj.magic: unknown => option<routeParams<'variables, 'response>>
-  ) {
+  switch (route->Obj.magic)["_rest"]->(Obj.magic: unknown => option<routeParams<'input, 'output>>) {
   | Some(params) => params
   | None => {
-      let routeDefinition = (
-        route->(Obj.magic: route<'variables, 'response> => route<unknown, unknown>)
-      )()
-
-      let pathItems = []
-      let pathParams = Js.Dict.empty()
-      parsePath(routeDefinition.path, ~pathItems, ~pathParams)
-
-      // Don't use ref, since it creates an unnecessary object
-      let isRawBody = %raw(`false`)
-
-      let variablesSchema = S.object(s => {
-        routeDefinition.variables({
-          field: (fieldName, schema) => {
-            s.nested("body").field(fieldName, schema)
-          },
-          body: schema => {
-            if schema->isNestedFlattenSupported {
-              s.nested("body").flatten(schema)
-            } else {
-              s.field("body", schema)
-            }
-          },
-          rawBody: schema => {
-            let isNonStringBased = switch schema->S.classify {
-            | Literal(String(_))
-            | String => false
-            | _ => true
-            }
-            if isNonStringBased {
-              panic("Only string-based schemas are allowed in rawBody")
-            }
-            let _ = %raw(`isRawBody = true`)
-            s.field("body", schema)
-          },
-          header: (fieldName, schema) => {
-            s.nested("headers").field(fieldName->Js.String2.toLowerCase, coerceSchema(schema))
-          },
-          query: (fieldName, schema) => {
-            s.nested("query").field(fieldName, coerceSchema(schema))
-          },
-          param: (fieldName, schema) => {
-            if !Dict.has(pathParams, fieldName) {
-              panic(`Path parameter "${fieldName}" is not defined in the path`)
-            }
-            s.nested("params").field(fieldName, coerceSchema(schema))
-          },
-          auth: auth => {
-            s.nested("headers").field(
-              "authorization",
-              switch auth {
-              | Bearer => bearerAuthSchema
-              | Basic => basicAuthSchema
-              },
-            )
-          },
-        })
-      })
-
-      {
-        // The variables input is guaranteed to be an object, so we reset the rescript-schema type filter here
-        variablesSchema->stripInPlace
-        variablesSchema->removeTypeValidationInPlace
-        switch variablesSchema->getSchemaField("headers") {
-        | Some({schema}) =>
-          schema->stripInPlace
-          schema->removeTypeValidationInPlace
-        | None => ()
-        }
-        switch variablesSchema->getSchemaField("params") {
-        | Some({schema}) => schema->removeTypeValidationInPlace
-        | None => ()
+      let definition = (route->(Obj.magic: route<'input, 'output> => route<unknown, unknown>))()
+
+      let params = if (definition->Obj.magic)["output"] {
+        let definition =
+          definition->(Obj.magic: definition<unknown, unknown> => rpc<unknown, unknown>)
+        let path =
+          `/` ++
+          switch definition.operationId {
+          | Some(p) => p
+          | None => (route->Obj.magic)["name"]
+          }
+        let inputSchema = S.object(s => s.field("body", definition.input))
+        inputSchema->stripInPlace
+        inputSchema->removeTypeValidationInPlace
+        let outputSchema = S.object(s => s.field("data", definition.output))
+        outputSchema->stripInPlace
+        outputSchema->removeTypeValidationInPlace
+        let response: Response.t<unknown> = {
+          status: Some(200),
+          description: None,
+          dataSchema: definition.input,
+          emptyData: false,
+          schema: outputSchema,
         }
-        switch variablesSchema->getSchemaField("query") {
-        | Some({schema}) => schema->removeTypeValidationInPlace
-        | None => ()
+        let responsesMap = Js.Dict.empty()
+        responsesMap->Js.Dict.set("200", response)
+        {
+          method: Post,
+          path,
+          inputSchema,
+          outputSchema,
+          responses: [response],
+          responsesMap,
+          pathItems: [Static(path)],
+          isRawBody: false,
+          summary: ?definition.summary,
+          description: ?definition.description,
+          deprecated: ?definition.deprecated,
+          operationId: ?definition.operationId,
+          tags: ?definition.tags,
         }
-      }
+      } else {
+        let pathItems = []
+        let pathParams = Js.Dict.empty()
+        parsePath(definition.path, ~pathItems, ~pathParams)
 
-      let responsesMap = Js.Dict.empty()
-      let responses = []
-      routeDefinition.responses->Js.Array2.forEach(r => {
-        let builder: Response.builder<unknown> = {
-          emptyData: true,
-        }
-        let schema = S.object(s => {
-          let definition = r({
-            status: status => {
-              builder.status = Some(status)
-              let status = status->(Obj.magic: int => Response.status)
-              responsesMap->Response.register(status, builder)
-              s.tag("status", status)
-            },
-            description: d => builder.description = Some(d),
+        // Don't use ref, since it creates an unnecessary object
+        let isRawBody = %raw(`false`)
+
+        let inputSchema = S.object(s => {
+          definition.input({
             field: (fieldName, schema) => {
-              builder.emptyData = false
-              s.nested("data").field(fieldName, schema)
+              s.nested("body").field(fieldName, schema)
             },
-            data: schema => {
-              builder.emptyData = false
+            body: schema => {
               if schema->isNestedFlattenSupported {
-                s.nested("data").flatten(schema)
+                s.nested("body").flatten(schema)
               } else {
-                s.field("data", schema)
+                s.field("body", schema)
+              }
+            },
+            rawBody: schema => {
+              let isNonStringBased = switch schema->S.classify {
+              | Literal(String(_))
+              | String => false
+              | _ => true
               }
+              if isNonStringBased {
+                panic("Only string-based schemas are allowed in rawBody")
+              }
+              let _ = %raw(`isRawBody = true`)
+              s.field("body", schema)
             },
             header: (fieldName, schema) => {
               s.nested("headers").field(fieldName->Js.String2.toLowerCase, coerceSchema(schema))
             },
+            query: (fieldName, schema) => {
+              s.nested("query").field(fieldName, coerceSchema(schema))
+            },
+            param: (fieldName, schema) => {
+              if !Dict.has(pathParams, fieldName) {
+                panic(`Path parameter "${fieldName}" is not defined in the path`)
+              }
+              s.nested("params").field(fieldName, coerceSchema(schema))
+            },
+            auth: auth => {
+              s.nested("headers").field(
+                "authorization",
+                switch auth {
+                | Bearer => bearerAuthSchema
+                | Basic => basicAuthSchema
+                },
+              )
+            },
           })
-          if builder.emptyData {
-            s.tag("data", %raw(`null`))
-          }
-          definition
         })
-        if builder.status === None {
-          responsesMap->Response.register(#default, builder)
-        }
-        schema->stripInPlace
-        schema->removeTypeValidationInPlace
-        let dataSchema = (schema->getSchemaField("data")->Option.unsafeUnwrap).schema
-        builder.dataSchema = dataSchema->Option.unsafeSome
-        switch dataSchema->S.classify {
-        | Literal(_) => {
-            let dataTypeValidation = dataSchema->unsafeGetTypeValidationInPlace
-            schema->setTypeValidationInPlace((b, ~inputVar) =>
-              dataTypeValidation(b, ~inputVar=`${inputVar}.data`)
-            )
+
+        {
+          // The input input is guaranteed to be an object, so we reset the rescript-schema type filter here
+          inputSchema->stripInPlace
+          inputSchema->removeTypeValidationInPlace
+          switch inputSchema->getSchemaField("headers") {
+          | Some({schema}) =>
+            schema->stripInPlace
+            schema->removeTypeValidationInPlace
+          | None => ()
+          }
+          switch inputSchema->getSchemaField("params") {
+          | Some({schema}) => schema->removeTypeValidationInPlace
+          | None => ()
+          }
+          switch inputSchema->getSchemaField("query") {
+          | Some({schema}) => schema->removeTypeValidationInPlace
+          | None => ()
           }
-        | _ => ()
         }
-        switch schema->getSchemaField("headers") {
-        | Some({schema}) =>
+
+        let responsesMap = Js.Dict.empty()
+        let responses = []
+        definition.responses->Js.Array2.forEach(r => {
+          let builder: Response.builder<unknown> = {
+            emptyData: true,
+          }
+          let schema = S.object(s => {
+            let status = status => {
+              builder.status = Some(status)
+              let status = status->(Obj.magic: int => Response.status)
+              responsesMap->Response.register(status, builder)
+              s.tag("status", status)
+            }
+            let header = (fieldName, schema) => {
+              s.nested("headers").field(fieldName->Js.String2.toLowerCase, coerceSchema(schema))
+            }
+            let definition = r({
+              status,
+              redirect: schema => {
+                status(307)
+                header("location", coerceSchema(schema))
+              },
+              description: d => builder.description = Some(d),
+              field: (fieldName, schema) => {
+                builder.emptyData = false
+                s.nested("data").field(fieldName, schema)
+              },
+              data: schema => {
+                builder.emptyData = false
+                if schema->isNestedFlattenSupported {
+                  s.nested("data").flatten(schema)
+                } else {
+                  s.field("data", schema)
+                }
+              },
+              header,
+            })
+            if builder.emptyData {
+              s.tag("data", %raw(`null`))
+            }
+            definition
+          })
+          if builder.status === None {
+            responsesMap->Response.register(#default, builder)
+          }
           schema->stripInPlace
           schema->removeTypeValidationInPlace
-        | None => ()
+          let dataSchema = (schema->getSchemaField("data")->Option.unsafeUnwrap).schema
+          builder.dataSchema = dataSchema->Option.unsafeSome
+          switch dataSchema->S.classify {
+          | Literal(_) => {
+              let dataTypeValidation = dataSchema->unsafeGetTypeValidationInPlace
+              schema->setTypeValidationInPlace((b, ~inputVar) =>
+                dataTypeValidation(b, ~inputVar=`${inputVar}.data`)
+              )
+            }
+          | _ => ()
+          }
+          switch schema->getSchemaField("headers") {
+          | Some({schema}) =>
+            schema->stripInPlace
+            schema->removeTypeValidationInPlace
+          | None => ()
+          }
+          builder.schema = Option.unsafeSome(schema)
+          responses
+          ->Js.Array2.push(builder->(Obj.magic: Response.builder<unknown> => Response.t<unknown>))
+          ->ignore
+        })
+
+        if responses->Js.Array2.length === 0 {
+          panic("At least single response should be registered")
         }
-        builder.schema = Option.unsafeSome(schema)
-        responses
-        ->Js.Array2.push(builder->(Obj.magic: Response.builder<unknown> => Response.t<unknown>))
-        ->ignore
-      })
 
-      if responses->Js.Array2.length === 0 {
-        panic("At least single response should be registered")
+        {
+          method: definition.method,
+          path: definition.path,
+          inputSchema,
+          outputSchema: S.union(responses->Js.Array2.map(r => r.schema)),
+          responses,
+          pathItems,
+          responsesMap,
+          isRawBody,
+          summary: ?definition.summary,
+          description: ?definition.description,
+          deprecated: ?definition.deprecated,
+          operationId: ?definition.operationId,
+          tags: ?definition.tags,
+          jsonQuery: ?definition.jsonQuery,
+        }
       }
 
-      let params = {
-        definition: routeDefinition,
-        variablesSchema,
-        responses,
-        pathItems,
-        responsesMap,
-        isRawBody,
-      }
       (route->Obj.magic)["_rest"] = params
-      params->(Obj.magic: routeParams<unknown, unknown> => routeParams<'variables, 'response>)
+      params->(Obj.magic: routeParams<unknown, unknown> => routeParams<'input, 'output>)
     }
   }
 }
 
-external route: (unit => definition<'variables, 'response>) => route<'variables, 'response> =
-  "%identity"
+external route: (unit => definition<'input, 'output>) => route<'input, 'output> = "%identity"
+external rpc: (unit => rpc<'input, 'output>) => route<'input, 'output> = "%identity"
 
 type client = {
-  call: 'variables 'response. (route<'variables, 'response>, 'variables) => promise<'response>,
   baseUrl: string,
   fetcher: ApiFetcher.t,
-  // By default, all query parameters are encoded as strings, however, you can use the jsonQuery option to encode query parameters as typed JSON values.
-  jsonQuery: bool,
 }
 
 /**
@@ -582,7 +654,7 @@ let rec tokeniseValue = (key, value, ~append) => {
 }
 
 // Inspired by https://github.com/ts-rest/ts-rest/blob/7792ef7bdc352e84a4f5766c53f984a9d630c60e/libs/ts-rest/core/src/lib/client.ts#L347
-let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQuery) => {
+let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQuery=false) => {
   let path = ref(baseUrl)
 
   for idx in 0 to pathItems->Js.Array2.length - 1 {
@@ -593,7 +665,7 @@ let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQue
       switch (maybeParams->Obj.magic && maybeParams->Js.Dict.unsafeGet(name)->Obj.magic)
         ->(Obj.magic: bool => option<string>) {
       | Some(param) => path := path.contents ++ param
-      | None => panic(`Path parameter "${name}" is not defined in variables`)
+      | None => panic(`Path parameter "${name}" is not defined in input`)
       }
     }
   }
@@ -648,20 +720,46 @@ let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQue
   path.contents
 }
 
-let fetch = (
-  type variables response,
-  route: route<variables, response>,
-  baseUrl,
-  variables,
-  ~fetcher=ApiFetcher.default,
-  ~jsonQuery=false,
-) => {
-  let route = route->(Obj.magic: route<variables, response> => route<unknown, unknown>)
-  let variables = variables->(Obj.magic: variables => unknown)
+let url = (route, input, ~baseUrl="") => {
+  let {pathItems, inputSchema} = route->params
+  let data = input->S.reverseConvertOrThrow(inputSchema)->Obj.magic
+  getCompletePath(
+    ~baseUrl,
+    ~pathItems,
+    ~maybeQuery=data["query"],
+    ~maybeParams=data["params"],
+    ~jsonQuery=false,
+  )
+}
 
-  let {definition, variablesSchema, responsesMap, pathItems, isRawBody} = route->params
+type global = {
+  @as("c")
+  mutable client: option<client>,
+}
 
-  let data = variables->S.reverseConvertOrThrow(variablesSchema)->Obj.magic
+let global = {
+  client: None,
+}
+
+let fetch = (type input response, route: route<input, response>, input, ~client=?) => {
+  let route = route->(Obj.magic: route<input, response> => route<unknown, unknown>)
+  let input = input->(Obj.magic: input => unknown)
+
+  let {path, method, ?jsonQuery, inputSchema, responsesMap, pathItems, isRawBody} = route->params
+
+  let client = switch client {
+  | Some(client) => client
+  | None =>
+    switch global.client {
+    | Some(client) => client
+    | None =>
+      panic(
+        `Client is not set for the ${path} fetch request. Please, use Rest.setGlobalClient or pass a client explicitly to the Rest.fetch arguments`,
+      )
+    }
+  }
+
+  let data = input->S.reverseConvertOrThrow(inputSchema)->Obj.magic
 
   if data["body"] !== %raw(`void 0`) {
     if !isRawBody {
@@ -673,17 +771,17 @@ let fetch = (
     data["headers"]["content-type"] = "application/json"
   }
 
-  fetcher({
+  client.fetcher({
     body: data["body"],
     headers: data["headers"],
     path: getCompletePath(
-      ~baseUrl,
+      ~baseUrl=client.baseUrl,
       ~pathItems,
       ~maybeQuery=data["query"],
       ~maybeParams=data["params"],
-      ~jsonQuery,
+      ~jsonQuery?,
     ),
-    method: (definition.method :> string),
+    method: (method :> string),
   })->Promise.thenResolve(fetcherResponse => {
     switch responsesMap->Response.find(fetcherResponse.status) {
     | None =>
@@ -716,12 +814,17 @@ let fetch = (
   })
 }
 
-let client = (~baseUrl, ~fetcher=ApiFetcher.default, ~jsonQuery=false) => {
-  let call = (route, variables) => route->fetch(baseUrl, variables, ~fetcher, ~jsonQuery)
+let client = (baseUrl, ~fetcher=ApiFetcher.default) => {
   {
     baseUrl,
     fetcher,
-    call,
-    jsonQuery,
+  }
+}
+
+let setGlobalClient = (baseUrl, ~fetcher=?) => {
+  switch global.client {
+  | Some(_) =>
+    panic("There's already a global client defined. You can have only one global client at a time.")
+  | None => global.client = Some(client(baseUrl, ~fetcher?))
   }
 }

package/src/vendored/Rest.resi

@@ -1,6 +1,6 @@
 /*
 Vendored from: https://github.com/DZakh/rescript-rest
-Version: 1.0.1
+Version: 2.0.0-rc.6
 
 IF EDITING THIS FILE, PLEASE LIST THE CHANGES BELOW
 
@@ -10,22 +10,6 @@ here
 
 @@uncurried
 
-module ApiFetcher: {
-  type args = {body: option<unknown>, headers: option<dict<unknown>>, method: string, path: string}
-  type response = {data: unknown, status: int, headers: dict<unknown>}
-  type t = args => promise<response>
-
-  // Inspired by https://github.com/ts-rest/ts-rest/blob/7792ef7bdc352e84a4f5766c53f984a9d630c60e/libs/ts-rest/core/src/lib/client.ts#L102
-  /**
-  * Default fetch api implementation:
-  *
-  * Can be used as a reference for implementing your own fetcher,
-  * or used in the "api" field of ClientArgs to allow you to hook
-  * into the request to run custom logic
-  */
-  let default: t
-}
-
 module Response: {
   type numiricStatus = [
     | #100
@@ -94,13 +78,13 @@ module Response: {
     | numiricStatus
   ]
 
-  type t<'response> = {
+  type t<'output> = {
     // When it's empty, treat response as a default
     status: option<int>,
     description: option<string>,
     dataSchema: S.t<unknown>,
     emptyData: bool,
-    schema: S.t<'response>,
+    schema: S.t<'output>,
   }
 
   type s = {
@@ -109,6 +93,7 @@ module Response: {
     data: 'value. S.t<'value> => 'value,
     field: 'value. (string, S.t<'value>) => 'value,
     header: 'value. (string, S.t<'value>) => 'value,
+    redirect: 'value. S.t<'value> => 'value,
   }
 }
 
@@ -134,49 +119,83 @@ type method =
   | @as("OPTIONS") Options
   | @as("TRACE") Trace
 
-type definition<'variables, 'response> = {
+type definition<'input, 'output> = {
   method: method,
   path: string,
-  variables: s => 'variables,
-  responses: array<Response.s => 'response>,
+  input: s => 'input,
+  responses: array<Response.s => 'output>,
   summary?: string,
   description?: string,
   deprecated?: bool,
+  operationId?: string,
+  tags?: array<string>,
+  // By default, all query parameters are encoded as strings, however, you can use the jsonQuery option to encode query parameters as typed JSON values.
+  jsonQuery?: bool,
 }
 
-type route<'variables, 'response>
+type rpc<'input, 'output> = {
+  input: S.t<'input>,
+  output: S.t<'output>,
+  summary?: string,
+  description?: string,
+  deprecated?: bool,
+  operationId?: string,
+  tags?: array<string>,
+}
+
+type route<'input, 'output>
 
 type pathParam = {name: string}
 @unboxed
 type pathItem = Static(string) | Param(pathParam)
 
-type routeParams<'variables, 'response> = {
-  definition: definition<'variables, 'response>,
+type routeParams<'input, 'output> = {
+  method: method,
+  path: string,
   pathItems: array<pathItem>,
-  variablesSchema: S.t<'variables>,
-  responses: array<Response.t<'response>>,
-  responsesMap: dict<Response.t<'response>>,
+  inputSchema: S.t<'input>,
+  outputSchema: S.t<'output>,
+  responses: array<Response.t<'output>>,
+  responsesMap: dict<Response.t<'output>>,
   isRawBody: bool,
+  summary?: string,
+  description?: string,
+  deprecated?: bool,
+  operationId?: string,
+  tags?: array<string>,
+  jsonQuery?: bool,
 }
 
-let params: route<'variables, 'response> => routeParams<'variables, 'response>
+let params: route<'input, 'output> => routeParams<'input, 'output>
+
+external route: (unit => definition<'input, 'output>) => route<'input, 'output> = "%identity"
+external rpc: (unit => rpc<'input, 'output>) => route<'input, 'output> = "%identity"
 
-external route: (unit => definition<'variables, 'response>) => route<'variables, 'response> =
-  "%identity"
+module ApiFetcher: {
+  type args = {body: option<unknown>, headers: option<dict<unknown>>, method: string, path: string}
+  type response = {data: unknown, status: int, headers: dict<unknown>}
+  type t = args => promise<response>
+
+  // Inspired by https://github.com/ts-rest/ts-rest/blob/7792ef7bdc352e84a4f5766c53f984a9d630c60e/libs/ts-rest/core/src/lib/client.ts#L102
+  /**
+  * Default fetch api implementation:
+  *
+  * Can be used as a reference for implementing your own fetcher,
+  * or used in the "api" field of ClientArgs to allow you to hook
+  * into the request to run custom logic
+  */
+  let default: t
+}
 
 type client = {
-  call: 'variables 'response. (route<'variables, 'response>, 'variables) => promise<'response>,
   baseUrl: string,
   fetcher: ApiFetcher.t,
-  jsonQuery: bool,
 }
 
-let client: (~baseUrl: string, ~fetcher: ApiFetcher.t=?, ~jsonQuery: bool=?) => client
+let url: (route<'input, 'output>, 'input, ~baseUrl: string=?) => string
+
+let client: (string, ~fetcher: ApiFetcher.t=?) => client
+
+let setGlobalClient: (string, ~fetcher: ApiFetcher.t=?) => unit
 
-let fetch: (
-  route<'variables, 'response>,
-  string,
-  'variables,
-  ~fetcher: ApiFetcher.t=?,
-  ~jsonQuery: bool=?,
-) => promise<'response>
+let fetch: (route<'input, 'output>, 'input, ~client: client=?) => promise<'output>