<!doctype html>
<html lang="en" data-releases="../releases.json">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>cljs.git — ird-cljs, ClojureScript client for the ird API</title>
<style>
  :root {
    color-scheme: dark;
    --paper: #12161c; --ink: #e8edf2; --ink-soft: #9aa7b3;
    --line: #263241; --card: #182029; --code-bg: #1f2a36; --accent: #7fc4a8;
  }
  @media (prefers-color-scheme: light) {
    :root {
      color-scheme: light;
      --paper: #f8f9fa; --ink: #232a30; --ink-soft: #61707d;
      --line: #dde4ea; --card: #ffffff; --code-bg: #eef2f5; --accent: #35836a;
    }
  }
  * { margin: 0; padding: 0; box-sizing: border-box; }
  body {
    background: var(--paper); color: var(--ink);
    font: 16.5px/1.65 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
      "Helvetica Neue", Arial, sans-serif;
    padding: 64px 22px 90px;
  }
  main { max-width: 660px; margin: 0 auto; }
  h1 { font-size: 40px; font-weight: 600; letter-spacing: -.4px;
    font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
  .tag { margin: 14px 0 34px; font-size: 18px; color: var(--ink-soft); }
  h2 { font-size: 20px; font-weight: 600; margin: 36px 0 10px; }
  p { margin: 10px 0; }
  a { color: var(--accent); }
  pre {
    background: var(--card); border: 1px solid var(--line); border-radius: 10px;
    padding: 13px 16px; overflow-x: auto; margin: 14px 0;
    font: 14px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace;
  }
  code { font: 15px ui-monospace, SFMono-Regular, Menlo, monospace;
    background: var(--code-bg); border-radius: 5px; padding: 1px 6px; }
  pre code { background: none; padding: 0; }
  ul { padding-left: 22px; } li { margin: 6px 0; }
  footer { margin-top: 48px; padding-top: 20px; border-top: 1px solid var(--line);
    font-size: 14px; color: var(--ink-soft); }
  footer a { color: inherit; }
</style>
</head>
<body>
<main>
  <h1>cljs.git</h1>
  <p class="tag"><strong>ird-cljs</strong> — ClojureScript client for the
  <a href="https://api.ird.ro/openapi.json">ird public API</a> on Node.js: .ro
  domains, DNS, VPS, tunnels, IPFS, P2P apps, and async jobs. Every one of the
  API's 161 operations is a small documented function returning a core.async
  channel, verified one-to-one against the OpenAPI spec by the test suite.
  Source-only; runtime dependencies are ClojureScript and core.async.</p>

  <h2>Use as a dependency</h2>
  <p>No registry — add the git URL to your <code>deps.edn</code> and let
  shadow-cljs read it. Any of its Node targets works (<code>:node-script</code>,
  <code>:node-library</code>, <code>:esm</code> with
  <code>:keep-native-requires</code>); so does a vanilla ClojureScript build
  with <code>:target :nodejs</code>.</p>
  <pre><code>;; deps.edn
{:paths ["src"]
 :deps {ro.ird/ird-cljs {:git/url "https://ird.cod-sursa.ro/cljs.git"
                         :git/tag "<span data-rel="cljs.tag">v0.1.0</span>"
                         :git/sha "<span data-rel="cljs.tag_sha_short">cf4fe34</span>"}
        thheller/shadow-cljs {:mvn/version "3.5.0"}}}

;; shadow-cljs.edn  (shadow-cljs 3.5.0 in package.json devDependencies too)
{:deps true
 :builds {:app {:target :node-script :main my.app/main
                :output-to "out/app.js"}}}</code></pre>
  <p>That is the latest release. To track the newest commit instead, pin
  <code>:git/sha "<span data-rel="cljs.head">…</span>"</code> (or ask the mirror:
  <code>git ls-remote https://ird.cod-sursa.ro/cljs.git HEAD</code>). The same
  coordinates are machine-readable in
  <a href="../releases.json">releases.json</a>.</p>

  <h2>Clone</h2>
  <pre><code>git clone https://ird.cod-sursa.ro/cljs.git</code></pre>
  <p><a href="browse/">browse the source in your browser →</a></p>

  <h2>Quickstart</h2>
  <pre><code>(require '[cljs.core.async :refer [go &lt;!]]
         '[ird.async :refer [&lt;?]]
         '[ird.client :as ird]
         '[ird.domains :as domains]
         '[ird.errors :as err])

(def c (ird/make-client {:api-key (.. js/process -env -IRD_API_KEY)}))

;; every call returns a channel delivering one value:
;; the response map, or an ExceptionInfo
(go (let [r (&lt;! (domains/check c "example.ro"))]
      (if (err/error? r)
        (println "failed:" (ex-message r))
        (println (:status r)))))
;; =&gt; registered

;; or let &lt;? throw inside the go block
(go (try (println (:status (&lt;? (domains/check c "example.ro"))))
         (catch :default e (println "failed:" (ex-message e)))))</code></pre>
  <p>The full guide — authentication, errors as values, the domain safety gate,
  pagination, async jobs, IPFS uploads, the p2p mailbox, tests — is in the
  repo's <code>README.md</code>.</p>

  <h2>What's inside</h2>
  <ul>
    <li><code>src/ird/</code> — one namespace per API area
      (<code>domains</code>, <code>registrations</code>, <code>dns</code>,
      <code>vps</code>, <code>tunnels</code>, <code>ipfs</code>,
      <code>p2p</code>, <code>jobs</code>, …) over a small channel-based
      transport, plus <code>ird.async</code> (<code>&lt;?</code>,
      <code>go-try</code>) and the client-side domain gate</li>
    <li><code>spec/openapi.json</code> — the spec snapshot the client is
      verified against one-to-one by the coverage test</li>
    <li><code>test/ird/</code> — coverage, transport, gate, flow, mailbox and
      spec-validator tests (<code>npm test</code>, via shadow-cljs); live
      read-only tests opt-in with <code>npm run test:live</code></li>
  </ul>

  <h2>License</h2>
  <p>MIT.</p>

  <footer>
    part of <a href="https://ird.cod-sursa.ro/">ird.cod-sursa.ro</a> —
    public source, clonable straight from this domain.
  </footer>
</main>
<script>
// Fill release coordinates from the site's releases.json (written by the
// assembler from the mirrors it publishes); the static text is the fallback.
(function () {
  var els = document.querySelectorAll('[data-rel]');
  if (!els.length || !window.fetch) return;
  fetch(document.documentElement.getAttribute('data-releases') || 'releases.json')
    .then(function (r) { return r.ok ? r.json() : null; })
    .then(function (j) {
      if (!j || !j.apps) return;
      Array.prototype.forEach.call(els, function (el) {
        var k = el.getAttribute('data-rel').split('.'), a = j.apps[k[0]];
        var v = a && a[k[1]];
        if (typeof v === 'string' && v) el.textContent = v;
      });
    })
    .catch(function () {});
})();
</script>
</body>
</html>