timely-diag.html

<script src="https://github.com/tonsky/datascript/releases/download/0.18.2/datascript-0.18.2.min.js"></script>
<script type="text/javascript">

const d = datascript;

const schema = {
  "db/ident":          {":db/unique": ":db.unique/identity"},
  
  "operator/name":     {":db/cardinality": ":db.cardinality/one"},
  "operator/address":  {":db/unique": ":db.unique/identity"},
  "channel/id":        {":db/unique": ":db.unique/identity"},
  // "channel/from":        {":db/cardinality": ":db.cardinality/one"},
  "channel/from":      {
    ":db/valueType": ":db.type/ref",
    ":db/cardinality": ":db.cardinality/one",
  },
  "channel/from-port": {":db/cardinality": ":db.cardinality/one"},
  // "channel/to":        {":db/cardinality": ":db.cardinality/one"},
  "channel/to":        {
    ":db/valueType": ":db.type/ref",
    ":db/cardinality": ":db.cardinality/one",
  },
  "channel/to-port":   {":db/cardinality": ":db.cardinality/one"},
  "channel/subgraph?": {":db/cardinality": ":db.cardinality/one"},

  "ui/query": {":db/cardinality": ":db.cardinality/one"},
};

const conn = d.create_conn(schema);

function operate_to_tx(event) {
  return {
    "operator/name": event.name,
    "operator/address": event.addr,
  }
}

function tx_to_operate(entity) {
  return {
    name: entity["operator/name"],
    addr: entity["operator/address"],
  };
}

function channel_to_tx(event) {
  return {
    "channel/id": event.id,
    "channel/subgraph?": event.subgraph,
    // "channel/from": event.from_addr,
    "channel/from": {"operator/address": event.from_addr},
    "channel/from-port": event.from_port,
    "channel/to": {"operator/address": event.to_addr},
    // "channel/to": event.to_addr,
    "channel/to-port": event.to_port,
  };
}

function tx_to_channel(entity) {
  return {
    id: entity["channel/id"],
    subgraph: entity["channel/subgraph?"],
    from_addr: entity["channel/from"]["operator/address"],
    from_port: entity["channel/from-port"],
    to_addr: entity["channel/to"]["operator/address"],
    to_port: entity["channel/to-port"],
  };
}

function match_address(address, prefix_string) {
  const address_string = JSON.stringify(address);
  return address_string.startsWith(prefix_string);
}

function on_query(query) {
  d.transact(conn, [{
    "db/ident": ":ui",
    "ui/query": query,
  }]);
}

Object.defineProperty(Array.prototype, 'sortBy', {
  enumerable: false,
  value: function (keyFn) {
    return this.sort((x, y) => {
      const xval = keyFn(x)
      const yval = keyFn(y)

      if (xval < yval) {
        return -1
      } else if (xval > yval) {
        return 1
      } else {
        return 0
      }
    });
  }
});

function render_db(db) {
  
  svg.selectAll("*").remove();

  g = new dagreD3.graphlib.Graph({compound:true});
  g.setGraph({
    nodesep: 10,
    ranksep: 10,
  });

  const ui = d.entity(db, ["db/ident", ":ui"]);
  let operate = d.q(
    `[:find [(pull ?op [*]) ...] 
      :where [?op "operator/address" ?addr]]`, db);

  if (ui !== null) {
    operate = operate.filter(op => match_address(op["operator/address"], ui.get("ui/query")));
  }

  const channel = d.q(
    `[:find [(pull ?chan ["channel/id" 
                          {"channel/from" ["operator/address"]}
                          "channel/from-port"
                          {"channel/to" ["operator/address"]}
                          "channel/to-port"
                          "channel/subgraph?"]) ...] 
      :where [?chan "channel/id" _]]`, db);

  run(operate.sortBy(op => op["id"]).map(tx_to_operate), channel.sortBy(chan => chan["id"]).map(tx_to_channel));
}

// Load dataset.
d.transact(conn, operate.map(operate_to_tx));
d.transact(conn, channel.map(channel_to_tx));

d.listen(conn, txLog => render_db(txLog.db_after));

console.log("DataScript ready.");

</script>