envio 3.0.0-alpha.2 → 3.0.0-alpha.3

package/src/UserContext.res

@@ -0,0 +1,356 @@
+let codegenHelpMessage = `Rerun 'pnpm dev' to update generated code after schema.graphql changes.`
+
+type contextParams = {
+  item: Internal.item,
+  checkpointId: float,
+  inMemoryStore: InMemoryStore.t,
+  loadManager: LoadManager.t,
+  persistence: Persistence.t,
+  isPreload: bool,
+  shouldSaveHistory: bool,
+  chains: Internal.chains,
+  config: Config.t,
+  mutable isResolved: bool,
+}
+
+// We don't want to expose the params to the user
+// so instead of storing _params on the context object,
+// we use an external WeakMap
+let paramsByThis: Utils.WeakMap.t<unknown, contextParams> = Utils.WeakMap.make()
+
+let effectContextPrototype = %raw(`Object.create(null)`)
+Utils.Object.defineProperty(
+  effectContextPrototype,
+  "log",
+  {
+    get: () => {
+      (paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))).item->Logging.getUserLogger
+    },
+  },
+)
+%%raw(`
+var EffectContext = function(params, defaultShouldCache, callEffect) {
+  paramsByThis.set(this, params);
+  this.effect = callEffect;
+  this.cache = defaultShouldCache;
+};
+EffectContext.prototype = effectContextPrototype;
+`)
+
+@new
+external makeEffectContext: (
+  contextParams,
+  ~defaultShouldCache: bool,
+  ~callEffect: (Internal.effect, Internal.effectInput) => promise<Internal.effectOutput>,
+) => Internal.effectContext = "EffectContext"
+
+let initEffect = (params: contextParams) => {
+  let rec callEffect = (effect: Internal.effect, input: Internal.effectInput) => {
+    let effectContext = makeEffectContext(
+      params,
+      ~defaultShouldCache=effect.defaultShouldCache,
+      ~callEffect,
+    )
+    let effectArgs: Internal.effectArgs = {
+      input,
+      context: effectContext,
+      cacheKey: input->S.reverseConvertOrThrow(effect.input)->Utils.Hash.makeOrThrow,
+    }
+    LoadLayer.loadEffect(
+      ~loadManager=params.loadManager,
+      ~persistence=params.persistence,
+      ~effect,
+      ~effectArgs,
+      ~inMemoryStore=params.inMemoryStore,
+      ~shouldGroup=params.isPreload,
+      ~item=params.item,
+    )
+  }
+  callEffect
+}
+
+type entityContextParams = {
+  ...contextParams,
+  entityConfig: Internal.entityConfig,
+}
+
+let getWhereTraps: Utils.Proxy.traps<entityContextParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let entityConfig = params.entityConfig
+    if prop->Js.typeof !== "string" {
+      Js.Exn.raiseError(
+        `Invalid context.${entityConfig.name}.getWhere access by a non-string property.`,
+      )
+    } else {
+      let dbFieldName = prop->(Utils.magic: unknown => string)
+      switch entityConfig.table->Table.getFieldByDbName(dbFieldName) {
+      | None =>
+        Js.Exn.raiseError(
+          `Invalid context.${entityConfig.name}.getWhere.${dbFieldName} - the field doesn't exist. ${codegenHelpMessage}`,
+        )
+      | Some(field) =>
+        let fieldValueSchema = switch field {
+        | Field({fieldSchema}) => fieldSchema
+        | DerivedFrom(_) => S.string->S.toUnknown
+        }
+        {
+          Envio.eq: fieldValue =>
+            LoadLayer.loadByField(
+              ~loadManager=params.loadManager,
+              ~persistence=params.persistence,
+              ~operator=Eq,
+              ~entityConfig,
+              ~fieldName=dbFieldName,
+              ~fieldValueSchema,
+              ~inMemoryStore=params.inMemoryStore,
+              ~shouldGroup=params.isPreload,
+              ~item=params.item,
+              ~fieldValue,
+            ),
+          gt: fieldValue =>
+            LoadLayer.loadByField(
+              ~loadManager=params.loadManager,
+              ~persistence=params.persistence,
+              ~operator=Gt,
+              ~entityConfig,
+              ~fieldName=dbFieldName,
+              ~fieldValueSchema,
+              ~inMemoryStore=params.inMemoryStore,
+              ~shouldGroup=params.isPreload,
+              ~item=params.item,
+              ~fieldValue,
+            ),
+          lt: fieldValue =>
+            LoadLayer.loadByField(
+              ~loadManager=params.loadManager,
+              ~persistence=params.persistence,
+              ~operator=Lt,
+              ~entityConfig,
+              ~fieldName=dbFieldName,
+              ~fieldValueSchema,
+              ~inMemoryStore=params.inMemoryStore,
+              ~shouldGroup=params.isPreload,
+              ~item=params.item,
+              ~fieldValue,
+            ),
+        }->Utils.magic
+      }
+    }
+  },
+}
+
+let noopSet = (_entity: Internal.entity) => ()
+let noopDeleteUnsafe = (_entityId: string) => ()
+
+let entityTraps: Utils.Proxy.traps<entityContextParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+
+    let set = params.isPreload
+      ? noopSet
+      : (entity: Internal.entity) => {
+          params.inMemoryStore
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
+          ->InMemoryTable.Entity.set(
+            Set({
+              entityId: entity.id,
+              checkpointId: params.checkpointId,
+              entity,
+            }),
+            ~shouldSaveHistory=params.shouldSaveHistory,
+          )
+        }
+
+    switch prop {
+    | "get" =>
+      (
+        entityId =>
+          LoadLayer.loadById(
+            ~loadManager=params.loadManager,
+            ~persistence=params.persistence,
+            ~entityConfig=params.entityConfig,
+            ~inMemoryStore=params.inMemoryStore,
+            ~shouldGroup=params.isPreload,
+            ~item=params.item,
+            ~entityId,
+          )
+      )->Utils.magic
+    | "getWhere" => params->Utils.Proxy.make(getWhereTraps)->Utils.magic
+    | "getOrThrow" =>
+      (
+        (entityId, ~message=?) =>
+          LoadLayer.loadById(
+            ~loadManager=params.loadManager,
+            ~persistence=params.persistence,
+            ~entityConfig=params.entityConfig,
+            ~inMemoryStore=params.inMemoryStore,
+            ~shouldGroup=params.isPreload,
+            ~item=params.item,
+            ~entityId,
+          )->Promise.thenResolve(entity => {
+            switch entity {
+            | Some(entity) => entity
+            | None =>
+              Js.Exn.raiseError(
+                message->Belt.Option.getWithDefault(
+                  `Entity '${params.entityConfig.name}' with ID '${entityId}' is expected to exist.`,
+                ),
+              )
+            }
+          })
+      )->Utils.magic
+    | "getOrCreate" =>
+      (
+        (entity: Internal.entity) =>
+          LoadLayer.loadById(
+            ~loadManager=params.loadManager,
+            ~persistence=params.persistence,
+            ~entityConfig=params.entityConfig,
+            ~inMemoryStore=params.inMemoryStore,
+            ~shouldGroup=params.isPreload,
+            ~item=params.item,
+            ~entityId=entity.id,
+          )->Promise.thenResolve(storageEntity => {
+            switch storageEntity {
+            | Some(entity) => entity
+            | None => {
+                set(entity)
+                entity
+              }
+            }
+          })
+      )->Utils.magic
+    | "set" => set->Utils.magic
+    | "deleteUnsafe" =>
+      if params.isPreload {
+        noopDeleteUnsafe
+      } else {
+        entityId => {
+          params.inMemoryStore
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
+          ->InMemoryTable.Entity.set(
+            Delete({
+              entityId,
+              checkpointId: params.checkpointId,
+            }),
+            ~shouldSaveHistory=params.shouldSaveHistory,
+          )
+        }
+      }->Utils.magic
+    | _ => Js.Exn.raiseError(`Invalid context.${params.entityConfig.name}.${prop} operation.`)
+    }
+  },
+}
+
+let handlerTraps: Utils.Proxy.traps<contextParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+    if params.isResolved {
+      Utils.Error.make(
+        `Impossible to access context.${prop} after the handler is resolved. Make sure you didn't miss an await in the handler.`,
+      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
+    }
+    switch prop {
+    | "log" =>
+      (params.isPreload ? Logging.noopLogger : params.item->Logging.getUserLogger)->Utils.magic
+    | "effect" =>
+      initEffect((params :> contextParams))->(
+        Utils.magic: (
+          (Internal.effect, Internal.effectInput) => promise<Internal.effectOutput>
+        ) => unknown
+      )
+
+    | "isPreload" => params.isPreload->Utils.magic
+    | "chains" => params.chains->Utils.magic
+    | "chain" =>
+      let chainId = params.item->Internal.getItemChainId
+      params.chains->Utils.Dict.dangerouslyGetByIntNonOption(chainId)->Utils.magic
+    | _ =>
+      switch params.config.userEntitiesByName->Utils.Dict.dangerouslyGetNonOption(prop) {
+      | Some(entityConfig) =>
+        {
+          item: params.item,
+          isPreload: params.isPreload,
+          inMemoryStore: params.inMemoryStore,
+          loadManager: params.loadManager,
+          persistence: params.persistence,
+          shouldSaveHistory: params.shouldSaveHistory,
+          checkpointId: params.checkpointId,
+          chains: params.chains,
+          isResolved: params.isResolved,
+          config: params.config,
+          entityConfig,
+        }
+        ->Utils.Proxy.make(entityTraps)
+        ->Utils.magic
+      | None =>
+        Js.Exn.raiseError(`Invalid context access by '${prop}' property. ${codegenHelpMessage}`)
+      }
+    }
+  },
+}
+
+let getHandlerContext = (params: contextParams): Internal.handlerContext => {
+  params->Utils.Proxy.make(handlerTraps)->Utils.magic
+}
+
+// Contract register context creation
+type contractRegisterParams = {
+  item: Internal.item,
+  onRegister: (~item: Internal.item, ~contractAddress: Address.t, ~contractName: string) => unit,
+  config: Config.t,
+  mutable isResolved: bool,
+}
+
+let contractRegisterTraps: Utils.Proxy.traps<contractRegisterParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+    if params.isResolved {
+      Utils.Error.make(
+        `Impossible to access context.${prop} after the contract register is resolved. Make sure you didn't miss an await in the handler.`,
+      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
+    }
+    switch prop {
+    | "log" => params.item->Logging.getUserLogger->Utils.magic
+    | _ =>
+      // Use the pre-built mapping for efficient lookup
+      switch params.config.addContractNameToContractNameMapping->Utils.Dict.dangerouslyGetNonOption(
+        prop,
+      ) {
+      | Some(contractName) => {
+          let addFunction = (contractAddress: Address.t) => {
+            let validatedAddress = if params.config.ecosystem.name === Evm {
+              // The value is passed from the user-land,
+              // so we need to validate and checksum/lowercase the address.
+              if params.config.lowercaseAddresses {
+                contractAddress->Address.Evm.fromAddressLowercaseOrThrow
+              } else {
+                contractAddress->Address.Evm.fromAddressOrThrow
+              }
+            } else {
+              // TODO: Ideally we should do the same for other ecosystems
+              contractAddress
+            }
+
+            params.onRegister(~item=params.item, ~contractAddress=validatedAddress, ~contractName)
+          }
+
+          addFunction->Utils.magic
+        }
+      | None =>
+        Js.Exn.raiseError(`Invalid context access by '${prop}' property. ${codegenHelpMessage}`)
+      }
+    }
+  },
+}
+
+let getContractRegisterContext = (params: contractRegisterParams) => {
+  params
+  ->Utils.Proxy.make(contractRegisterTraps)
+  ->Utils.magic
+}
+
+let getContractRegisterArgs = (params: contractRegisterParams): Internal.contractRegisterArgs => {
+  event: (params.item->Internal.castUnsafeEventItem).event,
+  context: getContractRegisterContext(params),
+}

package/src/UserContext.res.mjs

@@ -0,0 +1,238 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Table from "./db/Table.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Address from "./Address.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Internal from "./Internal.res.mjs";
+import * as LoadLayer from "./LoadLayer.res.mjs";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
+import * as InMemoryTable from "./InMemoryTable.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var codegenHelpMessage = "Rerun 'pnpm dev' to update generated code after schema.graphql changes.";
+
+var paramsByThis = new WeakMap();
+
+var effectContextPrototype = (Object.create(null));
+
+Object.defineProperty(effectContextPrototype, "log", {
+      get: (function () {
+          return Logging.getUserLogger(paramsByThis.get(this).item);
+        })
+    });
+
+var EffectContext = function(params, defaultShouldCache, callEffect) {
+  paramsByThis.set(this, params);
+  this.effect = callEffect;
+  this.cache = defaultShouldCache;
+};
+EffectContext.prototype = effectContextPrototype;
+;
+
+function initEffect(params) {
+  var callEffect = function (effect, input) {
+    var effectContext = new EffectContext(params, effect.defaultShouldCache, callEffect);
+    var effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+    var effectArgs = {
+      input: input,
+      context: effectContext,
+      cacheKey: effectArgs_cacheKey
+    };
+    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.inMemoryStore, params.isPreload, params.item);
+  };
+  return callEffect;
+}
+
+var getWhereTraps = {
+  get: (function (params, prop) {
+      var entityConfig = params.entityConfig;
+      if (typeof prop !== "string") {
+        return Js_exn.raiseError("Invalid context." + entityConfig.name + ".getWhere access by a non-string property.");
+      }
+      var field = Table.getFieldByDbName(entityConfig.table, prop);
+      if (field === undefined) {
+        return Js_exn.raiseError("Invalid context." + entityConfig.name + ".getWhere." + prop + " - the field doesn't exist. " + codegenHelpMessage);
+      }
+      var fieldValueSchema;
+      fieldValueSchema = field.TAG === "Field" ? field._0.fieldSchema : S$RescriptSchema.string;
+      return {
+              eq: (function (fieldValue) {
+                  return LoadLayer.loadByField(params.loadManager, params.persistence, "Eq", entityConfig, params.inMemoryStore, prop, fieldValueSchema, params.isPreload, params.item, fieldValue);
+                }),
+              gt: (function (fieldValue) {
+                  return LoadLayer.loadByField(params.loadManager, params.persistence, "Gt", entityConfig, params.inMemoryStore, prop, fieldValueSchema, params.isPreload, params.item, fieldValue);
+                }),
+              lt: (function (fieldValue) {
+                  return LoadLayer.loadByField(params.loadManager, params.persistence, "Lt", entityConfig, params.inMemoryStore, prop, fieldValueSchema, params.isPreload, params.item, fieldValue);
+                })
+            };
+    })
+};
+
+function noopSet(_entity) {
+  
+}
+
+function noopDeleteUnsafe(_entityId) {
+  
+}
+
+var entityTraps = {
+  get: (function (params, prop) {
+      var set = params.isPreload ? noopSet : (function (entity) {
+            InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+                  type: "SET",
+                  entityId: entity.id,
+                  entity: entity,
+                  checkpointId: params.checkpointId
+                }, params.shouldSaveHistory, undefined);
+          });
+      switch (prop) {
+        case "deleteUnsafe" :
+            if (params.isPreload) {
+              return noopDeleteUnsafe;
+            } else {
+              return function (entityId) {
+                InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+                      type: "DELETE",
+                      entityId: entityId,
+                      checkpointId: params.checkpointId
+                    }, params.shouldSaveHistory, undefined);
+              };
+            }
+        case "get" :
+            return function (entityId) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId);
+            };
+        case "getOrCreate" :
+            return function (entity) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entity.id).then(function (storageEntity) {
+                          if (storageEntity !== undefined) {
+                            return storageEntity;
+                          } else {
+                            set(entity);
+                            return entity;
+                          }
+                        });
+            };
+        case "getOrThrow" :
+            return function (entityId, message) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId).then(function (entity) {
+                          if (entity !== undefined) {
+                            return entity;
+                          } else {
+                            return Js_exn.raiseError(Belt_Option.getWithDefault(message, "Entity '" + params.entityConfig.name + "' with ID '" + entityId + "' is expected to exist."));
+                          }
+                        });
+            };
+        case "getWhere" :
+            return new Proxy(params, getWhereTraps);
+        case "set" :
+            return set;
+        default:
+          return Js_exn.raiseError("Invalid context." + params.entityConfig.name + "." + prop + " operation.");
+      }
+    })
+};
+
+var handlerTraps = {
+  get: (function (params, prop) {
+      if (params.isResolved) {
+        ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error("Impossible to access context." + prop + " after the handler is resolved. Make sure you didn't miss an await in the handler."));
+      }
+      switch (prop) {
+        case "chain" :
+            var chainId = Internal.getItemChainId(params.item);
+            return params.chains[chainId];
+        case "chains" :
+            return params.chains;
+        case "effect" :
+            return initEffect(params);
+        case "isPreload" :
+            return params.isPreload;
+        case "log" :
+            if (params.isPreload) {
+              return Logging.noopLogger;
+            } else {
+              return Logging.getUserLogger(params.item);
+            }
+        default:
+          var entityConfig = params.config.userEntitiesByName[prop];
+          if (entityConfig !== undefined) {
+            return new Proxy({
+                        item: params.item,
+                        checkpointId: params.checkpointId,
+                        inMemoryStore: params.inMemoryStore,
+                        loadManager: params.loadManager,
+                        persistence: params.persistence,
+                        isPreload: params.isPreload,
+                        shouldSaveHistory: params.shouldSaveHistory,
+                        chains: params.chains,
+                        config: params.config,
+                        isResolved: params.isResolved,
+                        entityConfig: entityConfig
+                      }, entityTraps);
+          } else {
+            return Js_exn.raiseError("Invalid context access by '" + prop + "' property. " + codegenHelpMessage);
+          }
+      }
+    })
+};
+
+function getHandlerContext(params) {
+  return new Proxy(params, handlerTraps);
+}
+
+var contractRegisterTraps = {
+  get: (function (params, prop) {
+      if (params.isResolved) {
+        ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error("Impossible to access context." + prop + " after the contract register is resolved. Make sure you didn't miss an await in the handler."));
+      }
+      if (prop === "log") {
+        return Logging.getUserLogger(params.item);
+      }
+      var contractName = params.config.addContractNameToContractNameMapping[prop];
+      if (contractName !== undefined) {
+        return function (contractAddress) {
+          var validatedAddress = params.config.ecosystem.name === "evm" ? (
+              params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
+            ) : contractAddress;
+          params.onRegister(params.item, validatedAddress, contractName);
+        };
+      } else {
+        return Js_exn.raiseError("Invalid context access by '" + prop + "' property. " + codegenHelpMessage);
+      }
+    })
+};
+
+function getContractRegisterContext(params) {
+  return new Proxy(params, contractRegisterTraps);
+}
+
+function getContractRegisterArgs(params) {
+  return {
+          event: params.item.event,
+          context: new Proxy(params, contractRegisterTraps)
+        };
+}
+
+export {
+  codegenHelpMessage ,
+  paramsByThis ,
+  effectContextPrototype ,
+  initEffect ,
+  getWhereTraps ,
+  noopSet ,
+  noopDeleteUnsafe ,
+  entityTraps ,
+  handlerTraps ,
+  getHandlerContext ,
+  contractRegisterTraps ,
+  getContractRegisterContext ,
+  getContractRegisterArgs ,
+}
+/* paramsByThis Not a pure module */

package/src/bindings/DateFns.res

@@ -0,0 +1,71 @@
+/**
+Formats: 
+hh:mm:ss         | 00:00:00
+do MMM ''yy      | 1st Jan '21
+ha do MMM ''yy   | 8PM 1st Jan '21
+ha               | 8PM
+iii              | Tues
+iii MMM          | Tues Jan
+MMM              | Jan
+`)
+*/
+type dateFormats =
+  | @as("HH:mm:ss") HoursMinSec
+  | @as("ha") Hour
+  | @as("do MMM ''yy") DayMonthYear
+  | @as("ha do MMM ''yy") HourDayMonthYear
+  | @as("h:mma do MMM ''yy") HourMinDayMonthYear
+  | @as("iii") DayName
+  | @as("iii MMM") DayNameMonth
+  | @as("do MMM") DayMonth
+  | @as("MMM") Month
+  | @as("h:mma") HourMin
+
+@module("date-fns") external format: (Js.Date.t, dateFormats) => string = "format"
+
+type formatDistanceToNowOptions = {includeSeconds: bool}
+@module("date-fns")
+external formatDistanceToNow: Js.Date.t => string = "formatDistanceToNow"
+
+@module("date-fns")
+external formatDistance: (Js.Date.t, Js.Date.t) => string = "formatDistance"
+
+@module("date-fns")
+external formatDistanceWithOptions: (Js.Date.t, Js.Date.t, formatDistanceToNowOptions) => string =
+  "formatDistance"
+
+@module("date-fns")
+external formatDistanceToNowWithOptions: (Js.Date.t, formatDistanceToNowOptions) => string =
+  "formatDistanceToNow"
+
+let formatDistanceToNowWithSeconds = (date: Js.Date.t) =>
+  date->formatDistanceToNowWithOptions({includeSeconds: true})
+
+type durationTimeFormat = {
+  years: int,
+  months: int,
+  weeks: int,
+  days: int,
+  hours: int,
+  minutes: int,
+  seconds: int,
+}
+
+@module("date-fns")
+external formatRelative: (Js.Date.t, Js.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}
+
+@module("date-fns")
+external intervalToDuration: interval => durationTimeFormat = "intervalToDuration"
+
+//helper to convert millis elapsed to duration object
+let durationFromMillis = (millis: int) =>
+  intervalToDuration({start: 0->Utils.magic, end: millis->Utils.magic})
+
+@module("date-fns") external fromUnixTime: float => Js.Date.t = "fromUnixTime"

package/src/bindings/DateFns.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DateFns from "date-fns";
+
+function formatDistanceToNowWithSeconds(date) {
+  return DateFns.formatDistanceToNow(date, {
+              includeSeconds: true
+            });
+}
+
+function durationFromMillis(millis) {
+  return DateFns.intervalToDuration({
+              start: 0,
+              end: millis
+            });
+}
+
+export {
+  formatDistanceToNowWithSeconds ,
+  durationFromMillis ,
+}
+/* date-fns Not a pure module */