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

package/src/bindings/DateFns.res

@@ -21,24 +21,24 @@ type dateFormats =
   | @as("MMM") Month
   | @as("h:mma") HourMin
 
-@module("date-fns") external format: (Js.Date.t, dateFormats) => string = "format"
+@module("date-fns") external format: (Date.t, dateFormats) => string = "format"
 
 type formatDistanceToNowOptions = {includeSeconds: bool}
 @module("date-fns")
-external formatDistanceToNow: Js.Date.t => string = "formatDistanceToNow"
+external formatDistanceToNow: Date.t => string = "formatDistanceToNow"
 
 @module("date-fns")
-external formatDistance: (Js.Date.t, Js.Date.t) => string = "formatDistance"
+external formatDistance: (Date.t, Date.t) => string = "formatDistance"
 
 @module("date-fns")
-external formatDistanceWithOptions: (Js.Date.t, Js.Date.t, formatDistanceToNowOptions) => string =
+external formatDistanceWithOptions: (Date.t, Date.t, formatDistanceToNowOptions) => string =
   "formatDistance"
 
 @module("date-fns")
-external formatDistanceToNowWithOptions: (Js.Date.t, formatDistanceToNowOptions) => string =
+external formatDistanceToNowWithOptions: (Date.t, formatDistanceToNowOptions) => string =
   "formatDistanceToNow"
 
-let formatDistanceToNowWithSeconds = (date: Js.Date.t) =>
+let formatDistanceToNowWithSeconds = (date: Date.t) =>
   date->formatDistanceToNowWithOptions({includeSeconds: true})
 
 type durationTimeFormat = {
@@ -52,14 +52,14 @@ type durationTimeFormat = {
 }
 
 @module("date-fns")
-external formatRelative: (Js.Date.t, Js.Date.t) => string = "formatRelative"
+external formatRelative: (Date.t, Date.t) => string = "formatRelative"
 
 type durationFormatOutput = {format: array<string>}
 
 @module("date-fns")
 external formatDuration: (durationTimeFormat, durationFormatOutput) => string = "formatDuration"
 
-type interval = {start: Js_date.t, end: Js_date.t}
+type interval = {start: Date.t, end: Date.t}
 
 @module("date-fns")
 external intervalToDuration: interval => durationTimeFormat = "intervalToDuration"
@@ -67,8 +67,8 @@ external intervalToDuration: interval => durationTimeFormat = "intervalToDuratio
 //helper to convert millis elapsed to duration object
 let durationFromMillis = (millis: int) =>
   intervalToDuration({
-    start: 0->(Utils.magic: int => Js_date.t),
-    end: millis->(Utils.magic: int => Js_date.t),
+    start: 0->(Utils.magic: int => Date.t),
+    end: millis->(Utils.magic: int => Date.t),
   })
 
-@module("date-fns") external fromUnixTime: float => Js.Date.t = "fromUnixTime"
+@module("date-fns") external fromUnixTime: float => Date.t = "fromUnixTime"

package/src/bindings/DateFns.res.mjs

@@ -4,19 +4,19 @@ import * as DateFns from "date-fns";
 
 function formatDistanceToNowWithSeconds(date) {
   return DateFns.formatDistanceToNow(date, {
-              includeSeconds: true
-            });
+    includeSeconds: true
+  });
 }
 
 function durationFromMillis(millis) {
   return DateFns.intervalToDuration({
-              start: 0,
-              end: millis
-            });
+    start: 0,
+    end: millis
+  });
 }
 
 export {
-  formatDistanceToNowWithSeconds ,
-  durationFromMillis ,
+  formatDistanceToNowWithSeconds,
+  durationFromMillis,
 }
 /* date-fns Not a pure module */

package/src/bindings/EventSource.res.mjs

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 
-var Fetch = {};
+let Fetch = {};
 
 export {
-  Fetch ,
+  Fetch,
 }
 /* No side effect */

package/src/bindings/Express.res

@@ -2,9 +2,6 @@
 
 type app
 
-// "default" &  seem to conflict a bit right now
-// https://github.com/rescript-lang/rescript-compiler/issues/5004
-@module external makeCjs: unit => app = "express"
 @module("express") external make: unit => app = "default"
 
 type req = private {
@@ -28,11 +25,11 @@ type middleware = (req, res, unit => unit) => unit
 type server
 
 @send external listen: (app, int) => server = "listen"
-@send external onError: (server, @as("error") _, Js.Exn.t => unit) => unit = "on"
+@send external onError: (server, @as("error") _, JsExn.t => unit) => unit = "on"
 
 // res methods
 @send external sendStatus: (res, int) => unit = "sendStatus"
 @send external set: (res, string, string) => unit = "set"
-@send external json: (res, Js.Json.t) => unit = "json"
+@send external json: (res, JSON.t) => unit = "json"
 @send external endWithData: (res, 'a) => res = "end"
 @send external setHeader: (res, string, string) => unit = "setHeader"

package/src/bindings/Hrtime.res

@@ -17,8 +17,8 @@ let secToMilli = (sec: seconds): milliseconds => sec *. 1_000.
 
 let nanoToTimeTuple = (nano: nanoseconds): timeTuple => {
   let factor = 1_000_000_000.
-  let seconds = Js.Math.floor_float(nano /. factor)
-  let nanos = mod_float(nano, factor)
+  let seconds = Math.floor(nano /. factor)
+  let nanos = Float.mod(nano, factor)
   (seconds, nanos)
 }
 

package/src/bindings/Hrtime.res.mjs

@@ -10,20 +10,20 @@ function secToMilli(sec) {
 }
 
 function nanoToTimeTuple(nano) {
-  var seconds = Math.floor(nano / 1000000000);
-  var nanos = nano % 1000000000;
+  let seconds = Math.floor(nano / 1000000000);
+  let nanos = nano % 1000000000;
   return [
-          seconds,
-          nanos
-        ];
+    seconds,
+    nanos
+  ];
 }
 
 function timeElapsedToNewRef(elapsed, ref) {
-  var match = nanoToTimeTuple(elapsed[1] + ref[1]);
+  let match = nanoToTimeTuple(elapsed[1] + ref[1]);
   return [
-          elapsed[0] + ref[0] + match[0],
-          match[1]
-        ];
+    elapsed[0] + ref[0] + match[0],
+    match[1]
+  ];
 }
 
 function toMillis(param) {
@@ -34,12 +34,10 @@ function toSeconds(param) {
   return param[0] + param[1] / 1000000000;
 }
 
-function toSecondsFloat(elapsed) {
-  return toSeconds(elapsed);
-}
+let toSecondsFloat = toSeconds;
 
-function toInt($$float) {
-  return $$float | 0;
+function toInt(float) {
+  return float | 0;
 }
 
 function floatFromMillis(v) {
@@ -66,27 +64,27 @@ function timeSince(prim) {
   return process.hrtime(prim);
 }
 
-var intFromMillis = toInt;
+let intFromMillis = toInt;
 
-var intFromNanos = toInt;
+let intFromNanos = toInt;
 
-var intFromSeconds = toInt;
+let intFromSeconds = toInt;
 
 export {
-  makeTimer ,
-  timeSince ,
-  nanoToMilli ,
-  secToMilli ,
-  timeElapsedToNewRef ,
-  toMillis ,
-  toSeconds ,
-  toSecondsFloat ,
-  intFromMillis ,
-  intFromNanos ,
-  intFromSeconds ,
-  floatFromMillis ,
-  floatFromSeconds ,
-  millisBetween ,
-  secondsBetween ,
+  makeTimer,
+  timeSince,
+  nanoToMilli,
+  secToMilli,
+  timeElapsedToNewRef,
+  toMillis,
+  toSeconds,
+  toSecondsFloat,
+  intFromMillis,
+  intFromNanos,
+  intFromSeconds,
+  floatFromMillis,
+  floatFromSeconds,
+  millisBetween,
+  secondsBetween,
 }
 /* No side effect */

package/src/bindings/Lodash.res.mjs

@@ -7,6 +7,6 @@ function cloneDeep(prim) {
 }
 
 export {
-  cloneDeep ,
+  cloneDeep,
 }
 /* ./vendored-lodash-fns.js Not a pure module */

package/src/bindings/NodeJs.res

@@ -41,9 +41,10 @@ module Util = {
 }
 
 module Process = {
-  type t = {env: Js.Dict.t<string>, execArgv: array<string>}
+  type t = {env: dict<string>, execArgv: array<string>}
   @module external process: t = "process"
   @module("process") external cwd: unit => string = "cwd"
+  @get external execPath: t => string = "execPath"
 }
 
 module ChildProcess = {
@@ -53,7 +54,7 @@ module ChildProcess = {
     shell?: string,
   }
 
-  type callback = (~error: Js.null<exn>, ~stdout: string, ~stderr: string) => unit
+  type callback = (~error: Null.t<exn>, ~stdout: string, ~stderr: string) => unit
 
   @module("child_process")
   external exec: (string, callback) => unit = "exec"
@@ -105,17 +106,21 @@ module WorkerThreads = {
   @module("worker_threads") external isMainThread: bool = "isMainThread"
 
   // Worker data passed from main thread
-  @module("worker_threads") external workerData: Js.Nullable.t<'a> = "workerData"
+  @module("worker_threads") external workerData: Nullable.t<'a> = "workerData"
 
   // MessagePort for communication with parent
   type messagePort
-  @module("worker_threads") external parentPort: Js.Nullable.t<messagePort> = "parentPort"
+  @module("worker_threads") external parentPort: Nullable.t<messagePort> = "parentPort"
   @send external postMessage: (messagePort, 'a) => unit = "postMessage"
   @send external onPortMessage: (messagePort, @as("message") _, 'a => unit) => unit = "on"
 
   // Worker class for spawning workers
   type worker
-  type workerOptions = {workerData?: Js.Json.t, execArgv?: array<string>}
+  type workerOptions = {
+    workerData?: JSON.t,
+    execArgv?: array<string>,
+    env?: dict<string>,
+  }
 
   @new @module("worker_threads")
   external makeWorker: (string, workerOptions) => worker = "Worker"
@@ -152,10 +157,10 @@ module Fs = {
       ~filepath: Path.t,
       ~content: string,
       ~options: writeFileOptions=?,
-    ) => Js.Promise.t<unit> = "appendFile"
+    ) => promise<unit> = "appendFile"
 
     @module("fs") @scope("promises")
-    external access: Path.t => Js.Promise.t<unit> = "access"
+    external access: Path.t => promise<unit> = "access"
 
     type encoding = | @as("utf8") Utf8
 
@@ -163,9 +168,9 @@ module Fs = {
     external readFile: (~filepath: Path.t, ~encoding: encoding) => promise<string> = "readFile"
 
     @module("fs") @scope("promises")
-    external mkdir: (~path: Path.t, ~options: mkdirOptions=?) => Js.Promise.t<unit> = "mkdir"
+    external mkdir: (~path: Path.t, ~options: mkdirOptions=?) => promise<unit> = "mkdir"
 
     @module("fs") @scope("promises")
-    external readdir: Path.t => Js.Promise.t<array<string>> = "readdir"
+    external readdir: Path.t => promise<array<string>> = "readdir"
   }
 }

package/src/bindings/NodeJs.res.mjs

@@ -6,51 +6,51 @@ import * as Util from "util";
 
 function inspectObj(a) {
   return Util.inspect(a, {
-              showHidden: false,
-              depth: null,
-              colors: true
-            });
+    showHidden: false,
+    depth: null,
+    colors: true
+  });
 }
 
-var Util$1 = {
+let Util$1 = {
   inspectObj: inspectObj
 };
 
-var Process = {};
+let Process = {};
 
-var ChildProcess = {};
+let ChildProcess = {};
 
-var Url$1 = {};
+let Url$1 = {};
 
-var ImportMeta = {};
+let ImportMeta = {};
 
-var Module = {};
+let Module = {};
 
 function getDirname(importMeta) {
   return Path.dirname(Url.fileURLToPath(importMeta.url));
 }
 
-var Path$1 = {
+let Path$1 = {
   getDirname: getDirname
 };
 
-var WorkerThreads = {};
+let WorkerThreads = {};
 
-var Promises = {};
+let Promises = {};
 
-var Fs = {
+let Fs = {
   Promises: Promises
 };
 
 export {
   Util$1 as Util,
-  Process ,
-  ChildProcess ,
+  Process,
+  ChildProcess,
   Url$1 as Url,
-  ImportMeta ,
-  Module ,
+  ImportMeta,
+  Module,
   Path$1 as Path,
-  WorkerThreads ,
-  Fs ,
+  WorkerThreads,
+  Fs,
 }
 /* url Not a pure module */

package/src/bindings/Pino.res

@@ -7,7 +7,6 @@ type logLevelBuiltin = [
   | #fatal
   | #silent
 ]
-@genType
 type logLevelUser = [
   | // NOTE: pino does better when these are all lowercase - some parts of the code lower case logs.
   #udebug
@@ -19,7 +18,6 @@ type logLevel = [logLevelBuiltin | logLevelUser]
 
 type pinoMessageBlob
 type pinoMessageBlobWithError
-@genType
 type t = {
   trace: pinoMessageBlob => unit,
   debug: pinoMessageBlob => unit,
@@ -73,12 +71,12 @@ module Transport = {
 type hooks = {logMethod: (array<string>, string, logLevel) => unit}
 
 type formatters = {
-  level: (string, int) => Js.Json.t,
-  bindings: Js.Json.t => Js.Json.t,
-  log: Js.Json.t => Js.Json.t,
+  level: (string, int) => JSON.t,
+  bindings: JSON.t => JSON.t,
+  log: JSON.t => JSON.t,
 }
 
-type serializers = {err: Js.Json.t => Js.Json.t}
+type serializers = {err: JSON.t => JSON.t}
 
 type options = {
   name?: string,
@@ -87,14 +85,14 @@ type options = {
   useOnlyCustomLevels?: bool,
   depthLimit?: int,
   edgeLimit?: int,
-  mixin?: unit => Js.Json.t,
-  mixinMergeStrategy?: (Js.Json.t, Js.Json.t) => Js.Json.t,
+  mixin?: unit => JSON.t,
+  mixinMergeStrategy?: (JSON.t, JSON.t) => JSON.t,
   redact?: array<string>,
   hooks?: hooks,
   formatters?: formatters,
   serializers?: serializers,
   msgPrefix?: string,
-  base?: Js.Json.t,
+  base?: JSON.t,
   enabled?: bool,
   crlf?: bool,
   timestamp?: bool,
@@ -159,7 +157,7 @@ module MultiStreamLogger = {
 
   let makeStreams = (~userLogLevel, ~formatter, ~logFile, ~defaultFileLogLevel) => {
     let stream = {
-      stream: {write: v => formatter(v)->Js.log},
+      stream: {write: v => formatter(v)->Console.log},
       level: userLogLevel,
     }
     let maybeFileStream = logFile->Belt.Option.mapWithDefault([], dest => [

package/src/bindings/Pino.res.mjs

@@ -2,9 +2,8 @@
 
 import * as Pino from "pino";
 import * as Utils from "../Utils.res.mjs";
-import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
 import * as PinoPretty from "pino-pretty";
 import EcsPinoFormat from "@elastic/ecs-pino-format";
 
@@ -14,16 +13,16 @@ function createPinoMessage(message) {
 
 function createPinoMessageWithError(message, err) {
   return {
-          msg: message,
-          err: Utils.prettifyExn(err)
-        };
+    msg: message,
+    err: Utils.prettifyExn(err)
+  };
 }
 
 function makeTransportOptions(v) {
   return v;
 }
 
-var Transport = {
+let Transport = {
   makeTransportOptions: makeTransportOptions
 };
 
@@ -35,50 +34,48 @@ function make(prim) {
   return EcsPinoFormat(prim);
 }
 
-var ECS = {
+let ECS = {
   make: make
 };
 
 function makeFormatter(logLevels) {
-  var customColors = "fatal:bgRed,error:red,warn:yellow,info:green,udebug:bgBlue,uinfo:bgGreen,uwarn:bgYellow,uerror:bgRed,debug:blue,trace:gray";
-  var match = ("ENVIO_TEST_LOGGING_FORMAT" in process.env);
+  let customColors = "fatal:bgRed,error:red,warn:yellow,info:green,udebug:bgBlue,uinfo:bgGreen,uwarn:bgYellow,uerror:bgRed,debug:blue,trace:gray";
+  let match = ("ENVIO_TEST_LOGGING_FORMAT" in process.env);
   return PinoPretty.prettyFactory(match !== undefined ? ({
-                  customLevels: logLevels,
-                  customColors: customColors,
-                  colorize: true
-                }) : ({
-                  customLevels: logLevels,
-                  customColors: customColors
-                }));
+      customLevels: logLevels,
+      customColors: customColors,
+      colorize: true
+    }) : ({
+      customLevels: logLevels,
+      customColors: customColors
+    }));
 }
 
 function makeStreams(userLogLevel, formatter, logFile, defaultFileLogLevel) {
-  var stream_stream = {
-    write: (function (v) {
-        console.log(formatter(v));
-      })
+  let stream_stream = {
+    write: v => {
+      console.log(formatter(v));
+    }
   };
-  var stream = {
+  let stream = {
     stream: stream_stream,
     level: userLogLevel
   };
-  var maybeFileStream = Belt_Option.mapWithDefault(logFile, [], (function (dest) {
-          return [{
-                    stream: Pino.destination({
-                          dest: dest,
-                          sync: false,
-                          mkdir: true
-                        }),
-                    level: defaultFileLogLevel
-                  }];
-        }));
+  let maybeFileStream = Belt_Option.mapWithDefault(logFile, [], dest => [{
+      stream: Pino.destination({
+        dest: dest,
+        sync: false,
+        mkdir: true
+      }),
+      level: defaultFileLogLevel
+    }]);
   return Belt_Array.concat([stream], maybeFileStream);
 }
 
 function make$1(userLogLevel, customLevels, logFile, options, defaultFileLogLevel) {
-  var options$1;
+  let options$1;
   if (options !== undefined) {
-    var newrecord = Caml_obj.obj_dup(options);
+    let newrecord = {...options};
     newrecord.customLevels = customLevels;
     newrecord.level = userLogLevel;
     options$1 = newrecord;
@@ -88,23 +85,23 @@ function make$1(userLogLevel, customLevels, logFile, options, defaultFileLogLeve
       customLevels: customLevels
     };
   }
-  var formatter = makeFormatter(customLevels);
-  var ms = Pino.multistream(makeStreams(userLogLevel, formatter, logFile, defaultFileLogLevel));
+  let formatter = makeFormatter(customLevels);
+  let ms = Pino.multistream(makeStreams(userLogLevel, formatter, logFile, defaultFileLogLevel));
   return Pino.pino(options$1, ms);
 }
 
-var MultiStreamLogger = {
+let MultiStreamLogger = {
   makeFormatter: makeFormatter,
   makeStreams: makeStreams,
   make: make$1
 };
 
 export {
-  createPinoMessage ,
-  createPinoMessageWithError ,
-  Transport ,
-  createChildParams ,
-  ECS ,
-  MultiStreamLogger ,
+  createPinoMessage,
+  createPinoMessageWithError,
+  Transport,
+  createChildParams,
+  ECS,
+  MultiStreamLogger,
 }
 /* pino Not a pure module */

package/src/bindings/Postgres.res

@@ -1,6 +1,3 @@
-// Only needed for some old tests
-// Remove @genType in the future
-@genType.import(("postgres", "Sql"))
 type sql
 
 type undefinedTransform = | @as(undefined) Undefined | @as(null) Null
@@ -21,7 +18,7 @@ type buffer
 type secureContext
 
 type onread = {
-  buffer: Js.Nullable.t<array<int>> => array<int>,
+  buffer: Nullable.t<array<int>> => array<int>,
   callback: (int, array<int>) => unit,
 }
 
@@ -36,7 +33,7 @@ type tlsConnectOptions = {
   pskCallback?: unit => unit,
   @as("ALPNProtocols") alpnProtocols?: array<string>, //| array<Buffer> | array<typedArray> | array<DataView> | Buffer | typedArray | DataView,
   servername?: string,
-  checkServerIdentity?: 'a. (string, 'a) => option<Js.Exn.t>,
+  checkServerIdentity?: 'a. (string, 'a) => option<JsExn.t>,
   session?: buffer,
   minDHSize?: int /* Default: 1024 */,
   highWaterMark?: int /* Default: 16 * 1024 */,

package/src/bindings/Postgres.res.mjs

@@ -2,16 +2,16 @@
 
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
-var sslOptionsSchema = S$RescriptSchema.$$enum([
-      true,
-      false,
-      "require",
-      "allow",
-      "prefer",
-      "verify-full"
-    ]);
+let sslOptionsSchema = S$RescriptSchema.$$enum([
+  true,
+  false,
+  "require",
+  "allow",
+  "prefer",
+  "verify-full"
+]);
 
 export {
-  sslOptionsSchema ,
+  sslOptionsSchema,
 }
 /* sslOptionsSchema Not a pure module */

package/src/bindings/PromClient.res

@@ -18,10 +18,23 @@ type metricValue = {
 type metricInstance = {get: unit => promise<{"values": array<metricValue>}>}
 @send external getSingleMetric: (registry, string) => option<metricInstance> = "getSingleMetric"
 @send external resetMetrics: registry => unit = "resetMetrics"
+@send external clear: registry => unit = "clear"
+
+// Idempotent metric creation: if the metric already exists in the
+// registry (e.g., module loaded twice via different pnpm paths),
+// return the existing one instead of throwing.
+let getOrCreate = (name: string, create: unit => 'a): 'a => {
+  switch defaultRegister->getSingleMetric(name) {
+  | Some(existing) => existing->(Utils.magic: metricInstance => 'a)
+  | None => create()
+  }
+}
 
 module Counter = {
   type counter
-  @new @module("prom-client") external makeCounter: customMetric<'a> => counter = "Counter"
+  @new @module("prom-client") external makeCounterUnsafe: customMetric<'a> => counter = "Counter"
+  let makeCounter = (config: customMetric<'a>): counter =>
+    getOrCreate(config["name"], () => makeCounterUnsafe(config))
 
   @send external inc: counter => unit = "inc"
   @send external incMany: (counter, int) => unit = "inc"
@@ -31,7 +44,9 @@ module Counter = {
 
 module Gauge = {
   type gauge
-  @new @module("prom-client") external makeGauge: customMetric<'a> => gauge = "Gauge"
+  @new @module("prom-client") external makeGaugeUnsafe: customMetric<'a> => gauge = "Gauge"
+  let makeGauge = (config: customMetric<'a>): gauge =>
+    getOrCreate(config["name"], () => makeGaugeUnsafe(config))
 
   @send external inc: gauge => unit = "inc"
   @send external incMany: (gauge, int) => unit = "inc"