envio/src/HandlerRegister.res.mjs

A latency and sync speed optimized, developer friendly blockchain data indexer.

// Generated by ReScript, PLEASE EDIT WITH CARE

import * as Utils from "./Utils.res.mjs";
import * as Logging from "./Logging.res.mjs";
import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";

let version = Utils.EnvioPackage.value.version;

let existing = globalThis.__envioRegistry;

let registry;

if (existing == null) {
  let fresh_eventRegistrations = {};
  let fresh_activeRegistration = {
    contents: undefined
  };
  let fresh_preRegistered = [];
  let fresh = {
    version: version,
    eventRegistrations: fresh_eventRegistrations,
    activeRegistration: fresh_activeRegistration,
    preRegistered: fresh_preRegistered
  };
  globalThis.__envioRegistry = fresh;
  registry = fresh;
} else {
  registry = existing.version === version ? existing : Stdlib_JsError.throwWithMessage(`Multiple incompatible envio versions loaded in the same process: ` + existing.version + ` and ` + version + `. Deduplicate the 'envio' dependency in your project.`);
}

let eventRegistrations = registry.eventRegistrations;

function getKey(contractName, eventName) {
  return contractName + "." + eventName;
}

function get(contractName, eventName) {
  let existing = eventRegistrations[getKey(contractName, eventName)];
  if (existing !== undefined) {
    return existing;
  } else {
    return {
      handler: undefined,
      contractRegister: undefined,
      eventOptions: undefined
    };
  }
}

function set(contractName, eventName, registration) {
  eventRegistrations[getKey(contractName, eventName)] = registration;
}

let activeRegistration = registry.activeRegistration;

let preRegistered = registry.preRegistered;

function withRegistration(fn) {
  let r = activeRegistration.contents;
  if (r !== undefined) {
    if (r.finished) {
      return Stdlib_JsError.throwWithMessage("The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.");
    } else {
      return fn(r);
    }
  } else {
    preRegistered.push(fn);
    return;
  }
}

function startRegistration(ecosystem) {
  let r = {
    ecosystem: ecosystem,
    registrations: {
      onBlockByChainId: {}
    },
    finished: false
  };
  activeRegistration.contents = r;
  while (preRegistered.length !== 0) {
    let fn = preRegistered.pop();
    if (fn !== undefined) {
      fn(r);
    }
  };
}

function finishRegistration() {
  let r = activeRegistration.contents;
  if (r !== undefined) {
    r.finished = true;
    return r.registrations;
  } else {
    return Stdlib_JsError.throwWithMessage("The indexer has not started registering handlers, so can't finish it.");
  }
}

function isPendingRegistration() {
  let r = activeRegistration.contents;
  if (r !== undefined) {
    return !r.finished;
  } else {
    return false;
  }
}

function throwIfFinishedRegistration(methodName) {
  let match = activeRegistration.contents;
  if (match === undefined) {
    return;
  }
  let match$1 = match.finished;
  if (match$1) {
    return Stdlib_JsError.throwWithMessage(`Cannot call \`indexer.` + methodName + `\` after the indexer has started. Make sure all handlers are registered at the top level of your handler module.`);
  }
}

function registerOnBlock(name, chainId, interval, startBlock, endBlock, handler) {
  withRegistration(registration => {
    let onBlockByChainId = registration.registrations.onBlockByChainId;
    let key = chainId.toString();
    let index = Stdlib_Option.mapOr(onBlockByChainId[key], 0, configs => configs.length);
    Utils.Dict.push(onBlockByChainId, key, {
      index: index,
      name: name,
      chainId: chainId,
      startBlock: startBlock,
      endBlock: endBlock,
      interval: interval,
      handler: handler
    });
  });
}

function getHandler(contractName, eventName) {
  return get(contractName, eventName).handler;
}

function getContractRegister(contractName, eventName) {
  return get(contractName, eventName).contractRegister;
}

function getOnEventWhere(contractName, eventName) {
  return Stdlib_Option.flatMap(get(contractName, eventName).eventOptions, value => value.where);
}

function isWildcard(contractName, eventName) {
  return Stdlib_Option.getOr(Stdlib_Option.flatMap(get(contractName, eventName).eventOptions, value => value.wildcard), false);
}

function hasRegistration(contractName, eventName) {
  let r = get(contractName, eventName);
  if (Stdlib_Option.isSome(r.handler)) {
    return true;
  } else {
    return Stdlib_Option.isSome(r.contractRegister);
  }
}

function raiseDuplicateRegistration(contractName, eventName, msg, logger) {
  let fullMsg = msg + " for " + contractName + "." + eventName;
  Logging.childError(Logging.createChildFrom(logger, {
    contractName: contractName,
    eventName: eventName
  }), fullMsg);
  return Stdlib_JsError.throwWithMessage(fullMsg);
}

function eventOptionsMatch(existing, incoming) {
  if (existing !== undefined) {
    if (incoming !== undefined && existing.wildcard === incoming.wildcard) {
      let a = existing.where;
      let b = incoming.where;
      if (a !== undefined) {
        if (b !== undefined) {
          if (typeof a === "function" || typeof b === "function") {
            return a === b;
          } else {
            return Primitive_object.equal(a, b);
          }
        } else {
          return false;
        }
      } else {
        return b === undefined;
      }
    } else {
      return false;
    }
  } else {
    return incoming === undefined;
  }
}

function setEventOptions(contractName, eventName, eventOptions, loggerOpt) {
  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
  if (eventOptions === undefined) {
    return;
  }
  let t = get(contractName, eventName);
  let existingValue = t.eventOptions;
  if (existingValue !== undefined) {
    if (!eventOptionsMatch(existingValue, eventOptions)) {
      return raiseDuplicateRegistration(contractName, eventName, "Cannot register handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
    } else {
      return;
    }
  } else {
    return set(contractName, eventName, {
      handler: t.handler,
      contractRegister: t.contractRegister,
      eventOptions: eventOptions
    });
  }
}

function setHandler(contractName, eventName, handler, eventOptions, loggerOpt) {
  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
  withRegistration(_registration => {
    let t = get(contractName, eventName);
    let prevHandler = t.handler;
    if (prevHandler !== undefined) {
      let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
      if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
        return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
      }
      let composedHandler = async args => {
        await prevHandler(args);
        return await handler(args);
      };
      return set(contractName, eventName, {
        handler: composedHandler,
        contractRegister: t.contractRegister,
        eventOptions: t.eventOptions
      });
    }
    setEventOptions(contractName, eventName, eventOptions, logger);
    let t$1 = get(contractName, eventName);
    set(contractName, eventName, {
      handler: handler,
      contractRegister: t$1.contractRegister,
      eventOptions: t$1.eventOptions
    });
  });
}

function setContractRegister(contractName, eventName, contractRegister, eventOptions, loggerOpt) {
  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
  withRegistration(_registration => {
    let t = get(contractName, eventName);
    let prevContractRegister = t.contractRegister;
    if (prevContractRegister !== undefined) {
      let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
      if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
        return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
      }
      let composedContractRegister = async args => {
        await prevContractRegister(args);
        return await contractRegister(args);
      };
      return set(contractName, eventName, {
        handler: t.handler,
        contractRegister: composedContractRegister,
        eventOptions: t.eventOptions
      });
    }
    setEventOptions(contractName, eventName, eventOptions, logger);
    let t$1 = get(contractName, eventName);
    set(contractName, eventName, {
      handler: t$1.handler,
      contractRegister: contractRegister,
      eventOptions: t$1.eventOptions
    });
  });
}

export {
  startRegistration,
  isPendingRegistration,
  finishRegistration,
  throwIfFinishedRegistration,
  setHandler,
  setContractRegister,
  getHandler,
  getContractRegister,
  getOnEventWhere,
  isWildcard,
  hasRegistration,
  registerOnBlock,
}
/* existing Not a pure module */