envio 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/Utils.res

@@ -1,6 +1,7 @@
 @@directive("import packageJson from '../package.json' with { type: 'json' }")
 
 external magic: 'a => 'b = "%identity"
+@val external floatToInt: float => int = "Math.trunc"
 
 @val external importPath: string => promise<unknown> = "import"
 
@@ -32,6 +33,19 @@ module Object = {
 
   @val @scope("Object")
   external defineProperty: ('obj, string, propertyDescriptor<'a>) => 'obj = "defineProperty"
+
+  // Property descriptor with required value field (no boxing)
+  type enumerablePropertyDescriptor<'a> = {
+    enumerable: bool,
+    value: 'a,
+  }
+
+  @val @scope("Object")
+  external definePropertyWithValue: ('obj, string, enumerablePropertyDescriptor<'a>) => 'obj =
+    "defineProperty"
+
+  @val @scope("Object")
+  external createNullObject: (@as(json`null`) _, unit) => 'a = "create"
 }
 
 module Error = {
@@ -82,6 +96,17 @@ module Dict = {
    */
   external dangerouslyGetNonOption: (dict<'a>, string) => option<'a> = ""
 
+  let getOrInsertEmptyDict = (dict, key) => {
+    switch dict->dangerouslyGetNonOption(key) {
+    | Some(d) => d
+    | None => {
+        let d = Js.Dict.empty()
+        dict->Js.Dict.set(key, d)
+        d
+      }
+    }
+  }
+
   @get_index
   /**
     It's the same as `Js.Dict.get` but it doesn't have runtime overhead to check if the key exists.
@@ -175,6 +200,15 @@ module Dict = {
     }
   `)
 
+  let unsafeDeleteUndefinedFieldsInPlace: 'a => unit = %raw(`(dict) => {
+      for (var key in dict) {
+        if (dict[key] === undefined) {
+          delete dict[key];
+        }
+      }
+    }
+  `)
+
   let updateImmutable: (
     dict<'a>,
     string,
@@ -194,7 +228,7 @@ module Dict = {
 module Math = {
   let minOptInt = (a, b) =>
     switch (a, b) {
-    | (Some(a), Some(b)) => Pervasives.min(a, b)->Some
+    | (Some(a), Some(b)) => Some(a < b ? a : b)
     | (Some(a), None) => Some(a)
     | (None, Some(b)) => Some(b)
     | (None, None) => None
@@ -325,8 +359,10 @@ Helper to check if a value exists in an array
   }
 
   let last = (arr: array<'a>): option<'a> => arr->Belt.Array.get(arr->Array.length - 1)
+  let first = (arr: array<'a>): option<'a> => arr->Belt.Array.get(0)
 
   let lastUnsafe = (arr: array<'a>): 'a => arr->Belt.Array.getUnsafe(arr->Array.length - 1)
+  let firstUnsafe = (arr: array<'a>): 'a => arr->Js.Array2.unsafe_get(0)
 
   let findReverseWithIndex = (arr: array<'a>, fn: 'a => bool): option<('a, int)> => {
     let rec loop = (index: int) => {
@@ -413,6 +449,28 @@ String.replaceAll("the cat and the dog", "the", "this") == "this cat and this do
   external replaceAll: (string, string, string) => string = "replaceAll"
 }
 
+module Url = {
+  /**
+  Extracts the hostname from a URL string.
+  Returns None if the URL doesn't have a valid http:// or https:// protocol.
+  */
+  let getHostFromUrl = (url: string) => {
+    // Regular expression requiring protocol and capturing hostname
+    // - (https?:\/\/) : Required http:// or https:// (capturing group)
+    // - ([^\/?]+) : Capture hostname (one or more characters that aren't / or ?)
+    // - .* : Match rest of the string
+    let regex = %re("/https?:\/\/([^\/?]+).*/")
+    switch Js.Re.exec_(regex, url) {
+    | Some(result) =>
+      switch Js.Re.captures(result)->Belt.Array.get(1) {
+      | Some(host) => host->Js.Nullable.toOption
+      | None => None
+      }
+    | None => None
+    }
+  }
+}
+
 module Result = {
   let forEach = (result, fn) => {
     switch result {
@@ -440,31 +498,6 @@ external queueMicrotask: (unit => unit) => unit = "queueMicrotask"
 module Schema = {
   let variantTag = S.union([S.string, S.object(s => s.field("TAG", S.string))])
 
-  let getNonOptionalFieldNames = schema => {
-    let acc = []
-    switch schema->S.classify {
-    | Object({items}) =>
-      items->Js.Array2.forEach(item => {
-        switch item.schema->S.classify {
-        // Check for null, since we generate S.null schema for db serializing
-        // In the future it should be changed to Option only
-        | Null(_) => ()
-        | Option(_) => ()
-        | _ => acc->Js.Array2.push(item.location)->ignore
-        }
-      })
-    | _ => ()
-    }
-    acc
-  }
-
-  let getCapitalizedFieldNames = schema => {
-    switch schema->S.classify {
-    | Object({items}) => items->Js.Array2.map(item => item.location->String.capitalize)
-    | _ => []
-    }
-  }
-
   // Don't use S.unknown, since it's not serializable to json
   // In a nutshell, this is completely unsafe.
   let dbDate =
@@ -472,6 +505,12 @@ module Schema = {
     ->(magic: S.t<Js.Json.t> => S.t<Js.Date.t>)
     ->S.preprocess(_ => {serializer: date => date->magic->Js.Date.toISOString})
 
+  // ClickHouse expects timestamps as numbers (milliseconds), not ISO strings
+  let clickHouseDate =
+    S.json(~validate=false)
+    ->(magic: S.t<Js.Json.t> => S.t<Js.Date.t>)
+    ->S.preprocess(_ => {serializer: date => date->magic->Js.Date.getTime})
+
   // When trying to serialize data to Json pg type, it will fail with
   // PostgresError: column "params" is of type json but expression is of type boolean
   // If there's bool or null on the root level. It works fine as object field values.
@@ -545,6 +584,13 @@ module Set = {
 
   external toArray: t<'a> => array<'a> = "Array.from"
 
+  @send
+  external intersection: (t<'value>, t<'value>) => t<'value> = "intersection"
+
+  let immutableAdd: (t<'a>, 'a) => t<'a> = %raw(`(set, value) => {
+    return new Set([...set, value])
+  }`)
+
   /*
    * Iteration methods
    */
@@ -578,6 +624,18 @@ external entries: t<'value> => Js_iterator.t<('value, 'value)> = "entries"
   external forEachWithSet: (t<'value>, ('value, 'value, t<'value>) => unit) => unit = "forEach"
 }
 
+// Typed-key dictionary backed by Js.Dict. Keys must be @unboxed string variants.
+module Record = {
+  type t<'key, 'value>
+
+  external fromDict: Js.Dict.t<'value> => t<'key, 'value> = "%identity"
+  let fromArray: array<('key, 'value)> => t<'key, 'value> = pairs =>
+    pairs->(magic: array<('key, 'value)> => array<(string, 'value)>)->Js.Dict.fromArray->fromDict
+
+  @get_index external getUnsafe: (t<'key, 'value>, 'key) => 'value = ""
+  @get_index external get: (t<'key, 'value>, 'key) => option<'value> = ""
+}
+
 module WeakMap = {
   type t<'k, 'v> = Js.WeakMap.t<'k, 'v>
 
@@ -587,6 +645,19 @@ module WeakMap = {
   @send external unsafeGet: (t<'k, 'v>, 'k) => 'v = "get"
   @send external has: (t<'k, 'v>, 'k) => bool = "has"
   @send external set: (t<'k, 'v>, 'k, 'v) => t<'k, 'v> = "set"
+
+  let memoize = (fn: 'k => 'v): ('k => 'v) => {
+    let cache = make()
+    key =>
+      switch cache->get(key) {
+      | Some(v) => v
+      | None => {
+          let v = fn(key)
+          let _ = cache->set(key, v)
+          v
+        }
+      }
+  }
 }
 
 module Map = {

package/src/Utils.res.mjs

@@ -3,6 +3,7 @@ import packageJson from '../package.json' with { type: 'json' }
 
 import * as $$Array from "rescript/lib/es6/array.js";
 import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
 import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as Caml_array from "rescript/lib/es6/caml_array.js";
@@ -71,6 +72,16 @@ var Tuple = {
   get: get
 };
 
+function getOrInsertEmptyDict(dict, key) {
+  var d = dict[key];
+  if (d !== undefined) {
+    return d;
+  }
+  var d$1 = {};
+  dict[key] = d$1;
+  return d$1;
+}
+
 var has = ((dict, key) => key in dict);
 
 function push(dict, key, value) {
@@ -151,6 +162,14 @@ var deleteInPlace = ((dict, key) => {
       delete dict[key];
     });
 
+var unsafeDeleteUndefinedFieldsInPlace = ((dict) => {
+      for (var key in dict) {
+        if (dict[key] === undefined) {
+          delete dict[key];
+        }
+      }
+    });
+
 var updateImmutable = ((dict, key, value) => ({...dict, [key]: value}));
 
 var shallowCopy = ((dict) => ({...dict}));
@@ -160,6 +179,7 @@ var incrementByInt = ((dict, key) => {
   });
 
 var Dict = {
+  getOrInsertEmptyDict: getOrInsertEmptyDict,
   has: has,
   push: push,
   pushMany: pushMany,
@@ -172,6 +192,7 @@ var Dict = {
   size: size,
   isEmpty: isEmpty,
   deleteInPlace: deleteInPlace,
+  unsafeDeleteUndefinedFieldsInPlace: unsafeDeleteUndefinedFieldsInPlace,
   updateImmutable: updateImmutable,
   shallowCopy: shallowCopy,
   incrementByInt: incrementByInt
@@ -186,11 +207,11 @@ function minOptInt(a, b) {
     }
   }
   var a$1 = Caml_option.valFromOption(a);
-  if (b !== undefined) {
-    return Caml_option.some(Caml_obj.min(a$1, Caml_option.valFromOption(b)));
-  } else {
+  if (b === undefined) {
     return Caml_option.some(a$1);
   }
+  var b$1 = Caml_option.valFromOption(b);
+  return Caml_option.some(Caml_obj.lessthan(a$1, b$1) ? a$1 : b$1);
 }
 
 var $$Math = {
@@ -310,10 +331,18 @@ function last(arr) {
   return Belt_Array.get(arr, arr.length - 1 | 0);
 }
 
+function first(arr) {
+  return Belt_Array.get(arr, 0);
+}
+
 function lastUnsafe(arr) {
   return arr[arr.length - 1 | 0];
 }
 
+function firstUnsafe(arr) {
+  return arr[0];
+}
+
 function findReverseWithIndex(arr, fn) {
   var _index = arr.length - 1 | 0;
   while(true) {
@@ -366,7 +395,9 @@ var $$Array$1 = {
   awaitEach: awaitEach,
   removeAtIndex: removeAtIndex,
   last: last,
+  first: first,
   lastUnsafe: lastUnsafe,
+  firstUnsafe: firstUnsafe,
   findReverseWithIndex: findReverseWithIndex,
   interleave: interleave,
   fromAsyncIterator: fromAsyncIterator
@@ -380,6 +411,23 @@ var $$String = {
   capitalize: capitalize
 };
 
+function getHostFromUrl(url) {
+  var regex = /https?:\/\/([^\/?]+).*/;
+  var result = regex.exec(url);
+  if (result === null) {
+    return ;
+  }
+  var host = Belt_Array.get(result, 1);
+  if (host !== undefined) {
+    return Caml_option.nullable_to_opt(Caml_option.valFromOption(host));
+  }
+  
+}
+
+var Url = {
+  getHostFromUrl: getHostFromUrl
+};
+
 function forEach$1(result, fn) {
   if (result.TAG === "Ok") {
     fn(result._0);
@@ -405,42 +453,6 @@ var variantTag = S$RescriptSchema.union([
           })
     ]);
 
-function getNonOptionalFieldNames(schema) {
-  var acc = [];
-  var match = schema.t;
-  if (typeof match === "object" && match.TAG === "object") {
-    match.items.forEach(function (item) {
-          var match = item.schema.t;
-          if (typeof match !== "object") {
-            acc.push(item.location);
-            return ;
-          }
-          switch (match.TAG) {
-            case "option" :
-            case "null" :
-                return ;
-            default:
-              acc.push(item.location);
-              return ;
-          }
-        });
-  }
-  return acc;
-}
-
-function getCapitalizedFieldNames(schema) {
-  var match = schema.t;
-  if (typeof match !== "object") {
-    return [];
-  } else if (match.TAG === "object") {
-    return match.items.map(function (item) {
-                return capitalize(item.location);
-              });
-  } else {
-    return [];
-  }
-}
-
 var dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function (param) {
         return {
                 s: (function (date) {
@@ -449,6 +461,14 @@ var dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function
               };
       }));
 
+var clickHouseDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function (param) {
+        return {
+                s: (function (date) {
+                    return date.getTime();
+                  })
+              };
+      }));
+
 function coerceToJsonPgType(schema) {
   return S$RescriptSchema.preprocess(schema, (function (s) {
                 var match = s.schema.t;
@@ -482,9 +502,8 @@ function coerceToJsonPgType(schema) {
 
 var Schema = {
   variantTag: variantTag,
-  getNonOptionalFieldNames: getNonOptionalFieldNames,
-  getCapitalizedFieldNames: getCapitalizedFieldNames,
   dbDate: dbDate,
+  clickHouseDate: clickHouseDate,
   coerceToJsonPgType: coerceToJsonPgType
 };
 
@@ -500,11 +519,37 @@ function addMany(set, values) {
       });
 }
 
+var immutableAdd = ((set, value) => {
+    return new Set([...set, value])
+  });
+
 var $$Set = {
-  addMany: addMany
+  addMany: addMany,
+  immutableAdd: immutableAdd
+};
+
+var fromArray = Js_dict.fromArray;
+
+var Record = {
+  fromArray: fromArray
 };
 
-var $$WeakMap = {};
+function memoize(fn) {
+  var cache = new WeakMap();
+  return function (key) {
+    var v = cache.get(key);
+    if (v !== undefined) {
+      return Caml_option.valFromOption(v);
+    }
+    var v$1 = fn(key);
+    cache.set(key, v$1);
+    return v$1;
+  };
+}
+
+var $$WeakMap$1 = {
+  memoize: memoize
+};
 
 var $$Map = {};
 
@@ -625,12 +670,14 @@ export {
   UnsafeIntOperators ,
   $$Array$1 as $$Array,
   $$String ,
+  Url ,
   Result ,
   unwrapResultExn ,
   Schema ,
   getVariantsTags ,
   $$Set ,
-  $$WeakMap ,
+  Record ,
+  $$WeakMap$1 as $$WeakMap,
   $$Map ,
   $$Proxy ,
   Hash ,

package/src/bindings/BigInt.res

@@ -42,7 +42,17 @@ module Bitwise = {
   let logand = (a: bigint, b: bigint): bigint => %raw("a & b")
 }
 
+let arrayToStringArray: array<bigint> => array<string> = %raw(`(arr) => {
+  const res = new Array(arr.length);
+  for (let i = 0; i < arr.length; i++) {
+    res[i] = arr[i].toString();
+  }
+  return res;
+}`)
+
 let zero = fromInt(0)
+let toFloat: bigint => float = %raw(`(n) => Number(n)`)
+let toIntUnsafe: bigint => int = %raw(`(n) => Number(n)`)
 
 @genType
 let schema =

package/src/bindings/BigInt.res.mjs

@@ -96,8 +96,20 @@ var Bitwise = {
   logand: logand
 };
 
+var arrayToStringArray = ((arr) => {
+  const res = new Array(arr.length);
+  for (let i = 0; i < arr.length; i++) {
+    res[i] = arr[i].toString();
+  }
+  return res;
+});
+
 var zero = BigInt(0);
 
+var toFloat = ((n) => Number(n));
+
+var toIntUnsafe = ((n) => Number(n));
+
 var schema = S$RescriptSchema.transform(S$RescriptSchema.setName(S$RescriptSchema.string, "BigInt"), (function (s) {
         return {
                 p: (function (string) {
@@ -132,7 +144,10 @@ export {
   lt ,
   lte ,
   Bitwise ,
+  arrayToStringArray ,
   zero ,
+  toFloat ,
+  toIntUnsafe ,
   schema ,
   nativeSchema ,
 }