envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/vendored/Rest.res

@@ -16,7 +16,7 @@ module Exn = {
   @new
   external makeError: string => error = "Error"
 
-  let raiseAny = (any: 'any): 'a => any->Obj.magic->raise
+  let raiseAny = (any: 'any): 'a => any->Obj.magic->throw
 
   let raiseError: error => 'a = raiseAny
 }
@@ -25,25 +25,11 @@ module Obj = {
   external magic: 'a => 'b = "%identity"
 }
 
-module Promise = {
-  type t<+'a> = promise<'a>
-
-  @send
-  external thenResolve: (t<'a>, 'a => 'b) => t<'b> = "then"
-}
-
 module Option = {
   let unsafeSome: 'a => option<'a> = Obj.magic
   let unsafeUnwrap: option<'a> => 'a = Obj.magic
 }
 
-module Dict = {
-  @inline
-  let has = (dict, key) => {
-    dict->Js.Dict.unsafeGet(key)->(Obj.magic: 'a => bool)
-  }
-}
-
 let panic = (message, ~params: option<{..}>=?) => {
   let error = Exn.makeError(`[rescript-rest] ${message}`)
   switch params {
@@ -78,15 +64,15 @@ module ApiFetcher = {
     // Note: contentType might be null
     if (
       contentType->Obj.magic &&
-      contentType->Js.String2.includes("application/") &&
-      contentType->Js.String2.includes("json")
+      contentType->String.includes("application/") &&
+      contentType->String.includes("json")
     ) {
       {
         status: result["status"],
         data: await result["json"](),
         headers: result["headers"],
       }
-    } else if contentType->Obj.magic && contentType->Js.String2.includes("text/") {
+    } else if contentType->Obj.magic && contentType->String.includes("text/") {
       {
         status: result["status"],
         data: await result["text"](),
@@ -206,19 +192,19 @@ module Response = {
     if map->Dict.has(key) {
       panic(`Response for the "${key}" status registered multiple times`)
     } else {
-      map->Js.Dict.set(key, builder->(Obj.magic: builder<'output> => t<'output>))
+      map->Dict.set(key, builder->(Obj.magic: builder<'output> => t<'output>))
     }
   }
 
   @inline
   let find = (map: dict<t<'output>>, responseStatus: int): option<t<'output>> => {
     (map
-    ->Js.Dict.unsafeGet(responseStatus->(Obj.magic: int => string))
+    ->Dict.getUnsafe(responseStatus->(Obj.magic: int => string))
     ->(Obj.magic: t<'output> => bool) ||
     map
-    ->Js.Dict.unsafeGet((responseStatus / 100)->(Obj.magic: int => string) ++ "XX")
+    ->Dict.getUnsafe((responseStatus / 100)->(Obj.magic: int => string) ++ "XX")
     ->(Obj.magic: t<'output> => bool) ||
-    map->Js.Dict.unsafeGet("default")->(Obj.magic: t<'output> => bool))
+    map->Dict.getUnsafe("default")->(Obj.magic: t<'output> => bool))
       ->(Obj.magic: bool => option<t<'output>>)
   }
 }
@@ -294,28 +280,28 @@ type route<'input, 'output> = unit => definition<'input, 'output>
 
 let rec parsePath = (path: string, ~pathItems, ~pathParams) => {
   if path !== "" {
-    switch path->Js.String2.indexOf("{") {
-    | -1 => pathItems->Js.Array2.push(Static(path))->ignore
+    switch path->String.indexOf("{") {
+    | -1 => pathItems->Array.push(Static(path))->ignore
     | paramStartIdx =>
-      switch path->Js.String2.indexOf("}") {
+      switch path->String.indexOf("}") {
       | -1 => panic("Path contains an unclosed parameter")
       | paramEndIdx =>
         if paramStartIdx > paramEndIdx {
           panic("Path parameter is not enclosed in curly braces")
         }
-        let paramName = Js.String2.slice(path, ~from=paramStartIdx + 1, ~to_=paramEndIdx)
+        let paramName = String.slice(path, ~start=paramStartIdx + 1, ~end=paramEndIdx)
         if paramName === "" {
           panic("Path parameter name cannot be empty")
         }
         let param = {name: paramName}
 
         pathItems
-        ->Js.Array2.push(Static(Js.String2.slice(path, ~from=0, ~to_=paramStartIdx)))
+        ->Array.push(Static(String.slice(path, ~start=0, ~end=paramStartIdx)))
         ->ignore
-        pathItems->Js.Array2.push(Param(param))->ignore
-        pathParams->Js.Dict.set(paramName, param)->ignore
+        pathItems->Array.push(Param(param))->ignore
+        pathParams->Dict.set(paramName, param)->ignore
 
-        parsePath(Js.String2.sliceToEnd(path, ~from=paramEndIdx + 1), ~pathItems, ~pathParams)
+        parsePath(String.slice(path, ~start=paramEndIdx + 1), ~pathItems, ~pathParams)
       }
     }
   }
@@ -342,7 +328,7 @@ let coerceSchema = schema => {
     | Float => {
         parser: unknown => {
           let float = %raw(`+unknown`)
-          if Js.Float.isNaN(float) {
+          if Float.isNaN(float) {
             unknown
           } else {
             float->Obj.magic
@@ -360,7 +346,7 @@ let coerceSchema = schema => {
 
 let stripInPlace = schema => (schema->S.classify->Obj.magic)["unknownKeys"] = S.Strip
 let getSchemaField = (schema, fieldName): option<S.item> =>
-  (schema->S.classify->Obj.magic)["fields"]->Js.Dict.unsafeGet(fieldName)
+  (schema->S.classify->Obj.magic)["fields"]->Dict.getUnsafe(fieldName)
 
 type typeValidation = (unknown, ~inputVar: string) => string
 let removeTypeValidationInPlace = schema => (schema->Obj.magic)["f"] = ()
@@ -385,7 +371,7 @@ let bearerAuthSchema = S.string->S.transform(s => {
     `Bearer ${token}`
   },
   parser: string => {
-    switch string->Js.String2.split(" ") {
+    switch string->String.split(" ") {
     | ["Bearer", token] => token
     | _ => s.fail("Invalid Bearer token")
     }
@@ -397,7 +383,7 @@ let basicAuthSchema = S.string->S.transform(s => {
     `Basic ${token}`
   },
   parser: string => {
-    switch string->Js.String2.split(" ") {
+    switch string->String.split(" ") {
     | ["Basic", token] => token
     | _ => s.fail("Invalid Basic token")
     }
@@ -432,8 +418,8 @@ let params = route => {
           emptyData: false,
           schema: outputSchema,
         }
-        let responsesMap = Js.Dict.empty()
-        responsesMap->Js.Dict.set("200", response)
+        let responsesMap = Dict.make()
+        responsesMap->Dict.set("200", response)
         {
           method: Post,
           path,
@@ -451,7 +437,7 @@ let params = route => {
         }
       } else {
         let pathItems = []
-        let pathParams = Js.Dict.empty()
+        let pathParams = Dict.make()
         parsePath(definition.path, ~pathItems, ~pathParams)
 
         // Don't use ref, since it creates an unnecessary object
@@ -482,7 +468,7 @@ let params = route => {
               s.field("body", schema)
             },
             header: (fieldName, schema) => {
-              s.nested("headers").field(fieldName->Js.String2.toLowerCase, coerceSchema(schema))
+              s.nested("headers").field(fieldName->String.toLowerCase, coerceSchema(schema))
             },
             query: (fieldName, schema) => {
               s.nested("query").field(fieldName, coerceSchema(schema))
@@ -525,9 +511,9 @@ let params = route => {
           }
         }
 
-        let responsesMap = Js.Dict.empty()
+        let responsesMap = Dict.make()
         let responses = []
-        definition.responses->Js.Array2.forEach(r => {
+        definition.responses->Array.forEach(r => {
           let builder: Response.builder<unknown> = {
             emptyData: true,
           }
@@ -539,7 +525,7 @@ let params = route => {
               s.tag("status", status)
             }
             let header = (fieldName, schema) => {
-              s.nested("headers").field(fieldName->Js.String2.toLowerCase, coerceSchema(schema))
+              s.nested("headers").field(fieldName->String.toLowerCase, coerceSchema(schema))
             }
             let definition = r({
               status,
@@ -591,11 +577,11 @@ let params = route => {
           }
           builder.schema = Option.unsafeSome(schema)
           responses
-          ->Js.Array2.push(builder->(Obj.magic: Response.builder<unknown> => Response.t<unknown>))
+          ->Array.push(builder->(Obj.magic: Response.builder<unknown> => Response.t<unknown>))
           ->ignore
         })
 
-        if responses->Js.Array2.length === 0 {
+        if responses->Array.length === 0 {
           panic("At least single response should be registered")
         }
 
@@ -603,7 +589,7 @@ let params = route => {
           method: definition.method,
           path: definition.path,
           inputSchema,
-          outputSchema: S.union(responses->Js.Array2.map(r => r.schema)),
+          outputSchema: S.union(responses->Array.map(r => r.schema)),
           responses,
           pathItems,
           responsesMap,
@@ -637,22 +623,22 @@ type client = {
  * This should be fully compatible with the "qs" library, but more optimised and without the need to add a dependency
  */
 let rec tokeniseValue = (key, value, ~append) => {
-  if Js.Array2.isArray(value) {
+  if Array.isArray(value) {
     value
     ->(Obj.magic: unknown => array<unknown>)
-    ->Js.Array2.forEachi((v, idx) => {
-      tokeniseValue(`${key}[${idx->Js.Int.toString}]`, v, ~append)
+    ->Array.forEachWithIndex((v, idx) => {
+      tokeniseValue(`${key}[${idx->Int.toString}]`, v, ~append)
     })
   } else if value === %raw(`null`) {
     append(key, "")
   } else if value === %raw(`void 0`) {
     ()
-  } else if Js.typeof(value) === "object" {
+  } else if typeof(value) === #object {
     let dict = value->(Obj.magic: unknown => dict<unknown>)
     dict
-    ->Js.Dict.keys
-    ->Js.Array2.forEach(k => {
-      tokeniseValue(`${key}[${encodeURIComponent(k)}]`, dict->Js.Dict.unsafeGet(k), ~append)
+    ->Dict.keysToArray
+    ->Array.forEach(k => {
+      tokeniseValue(`${key}[${encodeURIComponent(k)}]`, dict->Dict.getUnsafe(k), ~append)
     })
   } else {
     append(key, value->(Obj.magic: unknown => string))
@@ -663,12 +649,12 @@ let rec tokeniseValue = (key, value, ~append) => {
 let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQuery=false) => {
   let path = ref(baseUrl)
 
-  for idx in 0 to pathItems->Js.Array2.length - 1 {
-    let pathItem = pathItems->Js.Array2.unsafe_get(idx)
+  for idx in 0 to pathItems->Array.length - 1 {
+    let pathItem = pathItems->Array.getUnsafe(idx)
     switch pathItem {
     | Static(static) => path := path.contents ++ static
     | Param({name}) =>
-      switch (maybeParams->Obj.magic && maybeParams->Js.Dict.unsafeGet(name)->Obj.magic)
+      switch (maybeParams->Obj.magic && maybeParams->Dict.getUnsafe(name)->Obj.magic)
         ->(Obj.magic: bool => option<string>) {
       | Some(param) => path := path.contents ++ param
       | None => panic(`Path parameter "${name}" is not defined in input`)
@@ -682,13 +668,13 @@ let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQue
       let queryItems = []
 
       let append = (key, value) => {
-        let _ = queryItems->Js.Array2.push(key ++ "=" ++ encodeURIComponent(value))
+        let _ = queryItems->Array.push(key ++ "=" ++ encodeURIComponent(value))
       }
 
-      let queryNames = query->Js.Dict.keys
-      for idx in 0 to queryNames->Js.Array2.length - 1 {
-        let queryName = queryNames->Js.Array2.unsafe_get(idx)
-        let value = query->Js.Dict.unsafeGet(queryName)
+      let queryNames = query->Dict.keysToArray
+      for idx in 0 to queryNames->Array.length - 1 {
+        let queryName = queryNames->Array.getUnsafe(idx)
+        let value = query->Dict.getUnsafe(queryName)
         let key = encodeURIComponent(queryName)
         if value !== %raw(`void 0`) {
           switch jsonQuery {
@@ -699,17 +685,17 @@ let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQue
             append(
               key,
               if (
-                Js.typeof(value) === "string" && {
+                typeof(value) === #string && {
                     let value = value->(Obj.magic: unknown => string)
                     value !== "true" &&
                     value !== "false" &&
                     value !== "null" &&
-                    Js.Float.isNaN(Js.Float.fromString(value))
+                    Float.isNaN(Float.parseFloat(value))
                   }
               ) {
                 value->(Obj.magic: unknown => string)
               } else {
-                value->(Obj.magic: unknown => Js.Json.t)->Js.Json.stringify
+                value->(Obj.magic: unknown => JSON.t)->JSON.stringify
               },
             )
           | false => tokeniseValue(key, value, ~append)
@@ -717,8 +703,8 @@ let getCompletePath = (~baseUrl, ~pathItems, ~maybeQuery, ~maybeParams, ~jsonQue
         }
       }
 
-      if queryItems->Js.Array2.length > 0 {
-        path := path.contents ++ "?" ++ queryItems->Js.Array2.joinWith("&")
+      if queryItems->Array.length > 0 {
+        path := path.contents ++ "?" ++ queryItems->Array.joinUnsafe("&")
       }
     }
   }
@@ -791,10 +777,10 @@ let fetch = (type input response, route: route<input, response>, input, ~client=
   })->Promise.thenResolve(fetcherResponse => {
     switch responsesMap->Response.find(fetcherResponse.status) {
     | None =>
-      let error = ref(`Unexpected response status "${fetcherResponse.status->Js.Int.toString}"`)
+      let error = ref(`Unexpected response status "${fetcherResponse.status->Int.toString}"`)
       if (
         fetcherResponse.data->Obj.magic &&
-          Js.typeof((fetcherResponse.data->Obj.magic)["message"]) === "string"
+          typeof((fetcherResponse.data->Obj.magic)["message"]) === #string
       ) {
         error :=
           error.contents ++ ". Message: " ++ (fetcherResponse.data->Obj.magic)["message"]->Obj.magic