chore: estate-wide metadata and submodule sync (2026-04-20)

Author: hyperpolymath

quandledb/frontend/lib/bs/.sourcedirs.json

@@ -0,0 +1 @@
+{"cmt_scan":[{"also_scan_build_root":true,"build_root":"lib/bs","scan_dirs":["src"]}],"dirs":["src"],"generated":[],"pkgs":[["@rescript/react","/var/mnt/eclipse/repos/nextgen-databases/quandledb/frontend/node_modules/.deno/@rescript+react@0.14.2/node_modules/@rescript/react"]],"version":2}

quandledb/frontend/lib/bs/build.ninja

@@ -0,0 +1,8 @@
+{
+  "version": "12.2.0",
+  "bsc_path": "/var/mnt/eclipse/repos/nextgen-databases/quandledb/frontend/node_modules/.deno/@rescript+linux-x64@12.2.0/node_modules/@rescript/linux-x64/bin/bsc.exe",
+  "bsc_hash": "ca03c46847ff55e2a2115049975f546b655fceff6fc10e34645da2e812314070",
+  "rescript_config_hash": "79ad88940d912192046b850f2bd286dcfe87c6153de832d852da542baaea544c",
+  "runtime_path": "/var/mnt/eclipse/repos/nextgen-databases/quandledb/frontend/node_modules/.deno/@rescript+runtime@12.2.0/node_modules/@rescript/runtime",
+  "generated_at": "1775993930151"
+}

quandledb/frontend/lib/bs/compiler-info.json

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
+
+// HTTP API client for QuandleDB server
+
+let baseUrl = ""
+
+// Type-safe Fetch API bindings (no Obj.magic)
+type fetchResponse
+@val external fetch: (string, 'a) => promise<fetchResponse> = "fetch"
+@get external responseOk: fetchResponse => bool = "ok"
+@get external responseStatus: fetchResponse => int = "status"
+@send external responseJson: fetchResponse => promise<Js.Json.t> = "json"
+@send external responseText: fetchResponse => promise<string> = "text"
+
+let fetchJson = async (url: string): result<Js.Json.t, string> => {
+  try {
+    let resp = await fetch(url, {"method": "GET"})
+    if responseOk(resp) {
+      let data = await responseJson(resp)
+      Ok(data)
+    } else {
+      let body = await responseText(resp)
+      Error(`HTTP ${Belt.Int.toString(responseStatus(resp))}: ${body}`)
+    }
+  } catch {
+  | exn => Error(Js.String2.make(exn))
+  }
+}
+
+let fetchKnots = async (~filters: Types.filters=Types.emptyFilters): result<
+  Types.knotListResponse,
+  string,
+> => {
+  let params = []
+
+  switch filters.crossingNumber {
+  | Some(cn) =>
+    let _ = Js.Array2.push(params, "crossing_number=" ++ Belt.Int.toString(cn))
+  | None => ()
+  }
+
+  switch filters.genus {
+  | Some(g) =>
+    let _ = Js.Array2.push(params, "genus=" ++ Belt.Int.toString(g))
+  | None => ()
+  }
+
+  if filters.nameSearch != "" {
+    let _ = Js.Array2.push(
+      params,
+      "name=" ++ Js.Global.encodeURIComponent(filters.nameSearch),
+    )
+  }
+
+  let queryStr = if Belt.Array.length(params) > 0 {
+    "?" ++ Js.Array2.joinWith(params, "&")
+  } else {
+    ""
+  }
+
+  let result = await fetchJson(baseUrl ++ "/api/knots" ++ queryStr)
+  switch result {
+  | Ok(json) => Decoders.decodeKnotList(json)
+  | Error(e) => Error(e)
+  }
+}
+
+let fetchKnot = async (name: string): result<Types.knot, string> => {
+  let result = await fetchJson(
+    baseUrl ++ "/api/knots/" ++ Js.Global.encodeURIComponent(name),
+  )
+  switch result {
+  | Ok(json) => Decoders.decodeKnot(json)
+  | Error(e) => Error(e)
+  }
+}
+
+let fetchStatistics = async (): result<Types.statistics, string> => {
+  let result = await fetchJson(baseUrl ++ "/api/statistics")
+  switch result {
+  | Ok(json) => Decoders.decodeStatistics(json)
+  | Error(e) => Error(e)
+  }
+}
+
+let postQuery = async (
+  ~src: string,
+  ~format: string="auto",
+  ~maxRows: int=1000,
+): result<Types.queryResponse, Types.queryError> => {
+  try {
+    let bodyObj = Js.Dict.empty()
+    Js.Dict.set(bodyObj, "query",    Js.Json.string(src))
+    Js.Dict.set(bodyObj, "format",   Js.Json.string(format))
+    Js.Dict.set(bodyObj, "max_rows", Js.Json.number(Belt.Int.toFloat(maxRows)))
+    let bodyStr = Js.Json.stringify(Js.Json.object_(bodyObj))
+
+    let resp = await fetch(baseUrl ++ "/api/query", {
+      "method": "POST",
+      "headers": {"Content-Type": "application/json"},
+      "body": bodyStr,
+    })
+    let json = await responseJson(resp)
+
+    if responseOk(resp) {
+      switch Decoders.decodeQueryResponse(json) {
+      | Ok(r) => Ok(r)
+      | Error(e) =>
+        Error({Types.errorKind: "decode_error", message: e, line: None, col: None})
+      }
+    } else {
+      Error(Decoders.decodeQueryError(json))
+    }
+  } catch {
+  | exn =>
+    Error({
+      Types.errorKind: "network_error",
+      message: Js.String2.make(exn),
+      line: None,
+      col: None,
+    })
+  }
+}

quandledb/frontend/lib/bs/src/Api.ast

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
+
+// QuandleDB — top-level application component
+// Manages routing, state, and API interaction.
+
+type model = {
+  route: Route.t,
+  stats: Types.remoteData<Types.statistics, string>,
+  knots: Types.remoteData<Types.knotListResponse, string>,
+  knotDetail: Types.remoteData<Types.knot, string>,
+  filters: Types.filters,
+}
+
+type msg =
+  | NavigateTo(Route.t)
+  | UrlChanged
+  | GotStatistics(result<Types.statistics, string>)
+  | GotKnots(result<Types.knotListResponse, string>)
+  | GotKnotDetail(result<Types.knot, string>)
+  | SetFilters(Types.filters)
+
+@val external pushState: (Js.Nullable.t<string>, string, string) => unit = "history.pushState"
+@val external addWindowEventListener: (string, 'a => unit) => unit = "window.addEventListener"
+@val external removeWindowEventListener: (string, 'a => unit) => unit = "window.removeEventListener"
+
+@react.component
+let make = () => {
+  let (model, dispatch) = React.useReducer((model: model, msg: msg) =>
+    switch msg {
+    | NavigateTo(route) => {
+        pushState(Js.Nullable.null, "", Route.toPath(route))
+        {...model, route}
+      }
+    | UrlChanged => {...model, route: Route.fromUrl()}
+    | GotStatistics(Ok(stats)) => {...model, stats: Success(stats)}
+    | GotStatistics(Error(err)) => {...model, stats: Failure(err)}
+    | GotKnots(Ok(knots)) => {...model, knots: Success(knots)}
+    | GotKnots(Error(err)) => {...model, knots: Failure(err)}
+    | GotKnotDetail(Ok(knot)) => {...model, knotDetail: Success(knot)}
+    | GotKnotDetail(Error(err)) => {...model, knotDetail: Failure(err)}
+    | SetFilters(filters) => {...model, filters, knots: Loading}
+    }
+  , {
+    route: Route.fromUrl(),
+    stats: NotAsked,
+    knots: NotAsked,
+    knotDetail: NotAsked,
+    filters: Types.emptyFilters,
+  })
+
+  // Listen for popstate (browser back/forward)
+  React.useEffect0(() => {
+    let handler = _ => dispatch(UrlChanged)
+    addWindowEventListener("popstate", handler)
+    Some(() => removeWindowEventListener("popstate", handler))
+  })
+
+  // Fetch data when route changes
+  React.useEffect1(() => {
+    switch model.route {
+    | Dashboard =>
+      if model.stats == NotAsked {
+        let _ = {
+          open Promise
+          Api.fetchStatistics()->then(result => {
+            dispatch(GotStatistics(result))
+            resolve()
+          })
+        }
+      }
+    | KnotList =>
+      if model.knots == NotAsked {
+        let _ = {
+          open Promise
+          Api.fetchKnots()->then(result => {
+            dispatch(GotKnots(result))
+            resolve()
+          })
+        }
+      }
+    | KnotDetail(name) => {
+        let _ = {
+          open Promise
+          Api.fetchKnot(name)->then(result => {
+            dispatch(GotKnotDetail(result))
+            resolve()
+          })
+        }
+      }
+    | Query => ()
+    | NotFound => ()
+    }
+    None
+  }, [model.route])
+
+  // Refetch knots when filters change
+  React.useEffect1(() => {
+    if model.route == KnotList {
+      let _ = {
+        open Promise
+        Api.fetchKnots(~filters=model.filters)->then(result => {
+          dispatch(GotKnots(result))
+          resolve()
+        })
+      }
+    }
+    None
+  }, [model.filters])
+
+  let navigate = (route: Route.t) => dispatch(NavigateTo(route))
+
+  <div className="app">
+    <View_Helpers.NavBar currentRoute={model.route} onNavigate=navigate />
+    <main className="content">
+      {switch model.route {
+      | Dashboard => <Page_Dashboard stats={model.stats} onNavigate=navigate />
+      | KnotList =>
+        <Page_KnotList
+          knots={model.knots}
+          filters={model.filters}
+          onFilterChange={f => dispatch(SetFilters(f))}
+          onNavigate=navigate
+        />
+      | KnotDetail(_) =>
+        <Page_KnotDetail knot={model.knotDetail} onNavigate=navigate />
+      | Query => <Page_Query />
+      | NotFound =>
+        <div className="not-found">
+          <h1> {React.string("404 - Not Found")} </h1>
+          <p> {React.string("The page you are looking for does not exist.")} </p>
+          <button className="btn-primary" onClick={_ => navigate(Dashboard)}>
+            {React.string("Go Home")}
+          </button>
+        </div>
+      }}
+    </main>
+    <footer className="app-footer">
+      <p> {React.string("QuandleDB — Powered by Skein.jl")} </p>
+    </footer>
+  </div>
+}