datahike 0.8.1877 → 0.8.1879

package/remote/index.js

@@ -1,3 +1,523 @@
-require('./datahike.js');
-var root = (typeof self !== 'undefined' ? self : global);
-module.exports = root['datahike']['js']['remote'];
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asOf = asOf;
+exports.branch = branch;
+exports.branchAsDb = branchAsDb;
+exports.branches = branches;
+exports.commitAsDb = commitAsDb;
+exports.commitId = commitId;
+exports.connect = connect;
+exports.createDatabase = createDatabase;
+exports.databaseExists = databaseExists;
+exports.datoms = datoms;
+exports.db = db;
+exports.deleteBranch = deleteBranch;
+exports.deleteDatabase = deleteDatabase;
+exports.entity = entity;
+exports.entityDb = entityDb;
+exports.gcStorage = gcStorage;
+exports.history = history;
+exports.indexRange = indexRange;
+exports.loadEntities = loadEntities;
+exports.mergeDb = mergeDb;
+exports.metrics = metrics;
+exports.parentCommitIds = parentCommitIds;
+exports.pull = pull;
+exports.pullMany = pullMany;
+exports.q = q;
+exports.queryStats = queryStats;
+exports.release = release;
+exports.reverseSchema = reverseSchema;
+exports.rseekDatoms = rseekDatoms;
+exports.schema = schema;
+exports.seekDatoms = seekDatoms;
+exports.since = since;
+exports.transact = transact;
+exports.validAll = validAll;
+exports.validAt = validAt;
+exports.validBetween = validBetween;
+exports.validDuring = validDuring;
+exports.isPromise = isPromise;
+exports.listen = listen;
+exports.randomUuid = randomUuid;
+exports.unlisten = unlisten;
+exports.uuid = uuid;
+const tagSymbol = Symbol("datahike.tag");
+const rawSymbol = Symbol("datahike.raw");
+const peerSymbol = Symbol("datahike.peer");
+const uuidSymbol = Symbol("datahike.uuid");
+const handleTags = new Set([
+    "!datahike/Connection",
+    "!datahike/DB",
+    "!datahike/HistoricalDB",
+    "!datahike/SinceDB",
+    "!datahike/AsOfDB",
+    "!datahike/Entity",
+    "!datahike/TxReport",
+]);
+function taggedObject(tag, raw, peer) {
+    const decoded = decodeValue(raw, peer);
+    const value = decoded !== null && typeof decoded === "object" && !Array.isArray(decoded)
+        ? { ...decoded }
+        : { value: decoded };
+    Object.defineProperties(value, {
+        [tagSymbol]: { value: tag },
+        [rawSymbol]: { value: raw },
+        [peerSymbol]: { value: peer },
+    });
+    return value;
+}
+function isTaggedObject(value) {
+    return value !== null && typeof value === "object" && tagSymbol in value;
+}
+function isUuid(value) {
+    return value !== null && typeof value === "object" && uuidSymbol in value;
+}
+function decodeValue(value, peer) {
+    if (Array.isArray(value)) {
+        if (value.length === 2 && typeof value[0] === "string") {
+            const tag = value[0];
+            const payload = value[1];
+            if (handleTags.has(tag))
+                return taggedObject(tag, payload, peer);
+            switch (tag) {
+                case "!kw":
+                    return `:${String(payload)}`;
+                case "!sym":
+                    return String(payload);
+                case "!set":
+                    return Array.isArray(payload) ? payload.map((item) => decodeValue(item, peer)) : [];
+                case "!uuid":
+                    return String(payload);
+                case "!date":
+                    return new Date(Number(payload));
+                case "!datahike/Datom": {
+                    const [e, a, v, tx, added] = payload.map((item) => decodeValue(item, peer));
+                    return { e, a, v, tx, added };
+                }
+            }
+        }
+        return value.map((item) => decodeValue(item, peer));
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, decodeValue(item, peer)]));
+    }
+    return value;
+}
+function encodeValue(value) {
+    if (isTaggedObject(value))
+        return [value[tagSymbol], value[rawSymbol]];
+    if (isUuid(value))
+        return ["!uuid", value.value];
+    if (value instanceof Date)
+        return ["!date", String(value.getTime())];
+    if (typeof value === "string") {
+        if (value.startsWith("\\:"))
+            return value.slice(1);
+        if (value.startsWith(":"))
+            return ["!kw", value.slice(1)];
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(encodeValue);
+    if (value instanceof Set)
+        return ["!set", Array.from(value, encodeValue)];
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key.startsWith(":") ? key.slice(1) : key,
+            encodeValue(item),
+        ]));
+    }
+    return value;
+}
+function peerFromArgs(args) {
+    const peers = new Set();
+    const first = args[0];
+    if (first !== null && typeof first === "object") {
+        const peer = first["remote-peer"] ??
+            first[":remote-peer"] ??
+            first[peerSymbol];
+        if (peer)
+            peers.add(peer);
+    }
+    for (const arg of args.slice(1)) {
+        if (isTaggedObject(arg) && arg[peerSymbol])
+            peers.add(arg[peerSymbol]);
+    }
+    if (peers.size !== 1) {
+        throw new Error(peers.size === 0
+            ? "No remote-peer found in arguments."
+            : "Arguments refer to more than one remote-peer.");
+    }
+    return peers.values().next().value;
+}
+function withoutCredentials(args) {
+    return args.map((arg) => {
+        if (arg === null || typeof arg !== "object" || Array.isArray(arg) || isTaggedObject(arg))
+            return arg;
+        const copy = { ...arg };
+        for (const key of ["remote-peer", ":remote-peer", "writer", ":writer"]) {
+            const value = copy[key];
+            if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+                const nested = { ...value };
+                delete nested.token;
+                delete nested[":token"];
+                copy[key] = nested;
+            }
+        }
+        return copy;
+    });
+}
+function normalizeSetArguments(route, args) {
+    const copy = [...args];
+    if ((route === "force-branch" && Array.isArray(copy[2])) ||
+        (route === "merge-db" && Array.isArray(copy[1]))) {
+        const index = route === "force-branch" ? 2 : 1;
+        copy[index] = new Set(copy[index]);
+    }
+    return copy;
+}
+function base64url(bytes) {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    let encoded = "";
+    for (let index = 0; index < bytes.length; index += 3) {
+        const value = (bytes[index] << 16) |
+            ((bytes[index + 1] ?? 0) << 8) |
+            (bytes[index + 2] ?? 0);
+        encoded += alphabet[(value >>> 18) & 63] + alphabet[(value >>> 12) & 63];
+        if (index + 1 < bytes.length)
+            encoded += alphabet[(value >>> 6) & 63];
+        if (index + 2 < bytes.length)
+            encoded += alphabet[value & 63];
+    }
+    return encoded;
+}
+async function responseValue(response, target, peer) {
+    const text = await response.text();
+    let decoded = null;
+    if (text) {
+        try {
+            decoded = decodeValue(JSON.parse(text), peer);
+        }
+        catch (cause) {
+            throw new Error(`Undecodable response from ${target}`, { cause });
+        }
+    }
+    if (!response.ok) {
+        const error = new Error(decoded?.msg ?? `HTTP ${response.status} from ${target}`);
+        Object.assign(error, decoded?.["ex-data"] ?? {}, { status: response.status, url: target });
+        throw error;
+    }
+    return decoded;
+}
+async function request(route, readable, args, create = false) {
+    const peer = peerFromArgs(args);
+    const encoded = new TextEncoder().encode(JSON.stringify(encodeValue(normalizeSetArguments(route, withoutCredentials(args)))));
+    const asGet = readable && encoded.byteLength <= 2048;
+    const base = `${peer.url}/${route}`;
+    const target = asGet ? `${base}?args=${base64url(encoded)}&f=json` : base;
+    const headers = { Accept: "application/json" };
+    if (!asGet)
+        headers["Content-Type"] = "application/json";
+    if (peer.token)
+        headers.Authorization = `token ${peer.token}`;
+    const response = await fetch(target, {
+        method: asGet ? "GET" : "POST",
+        headers,
+        ...(asGet ? {} : { body: encoded }),
+    });
+    const result = await responseValue(response, target, peer);
+    if (create && result !== null && typeof result === "object")
+        result["remote-peer"] = peer;
+    return result;
+}
+function uuid(value) {
+    const out = { value };
+    Object.defineProperty(out, uuidSymbol, { value: true });
+    return out;
+}
+function randomUuid() {
+    const bytes = new Uint8Array(16);
+    if (globalThis.crypto?.getRandomValues)
+        globalThis.crypto.getRandomValues(bytes);
+    else
+        for (let index = 0; index < bytes.length; index++)
+            bytes[index] = Math.floor(Math.random() * 256);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return uuid(`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`);
+}
+function isPromise(value) {
+    return value instanceof Promise;
+}
+const listeners = new Map();
+function connectionParts(conn) {
+    if (!isTaggedObject(conn) || conn[tagSymbol] !== "!datahike/Connection" || !conn[peerSymbol]) {
+        throw new Error("listen requires a remote connection handle.");
+    }
+    const storeId = decodeValue(conn[rawSymbol], conn[peerSymbol]);
+    const [store, branch = ":db"] = Array.isArray(storeId) ? storeId : [storeId, ":db"];
+    return { peer: conn[peerSymbol], store: String(store), branch: String(branch).replace(/^:/, "") };
+}
+function listenerId(conn, key) {
+    const { peer, store } = connectionParts(conn);
+    return `${peer.url}\0${store}\0${key}`;
+}
+function stopListener(id, listener) {
+    listener.stopped = true;
+    if (listener.timer !== undefined)
+        clearTimeout(listener.timer);
+    listener.controller?.abort();
+    if (listeners.get(id) === listener)
+        listeners.delete(id);
+}
+function remoteDbFromHead(conn, rawData) {
+    const { peer } = connectionParts(conn);
+    const raw = {
+        "store-id": [rawData["store-id"], rawData.branch],
+        "commit-id": rawData["commit-id"],
+        "max-eid": rawData["max-eid"],
+        "max-tx": rawData["max-tx"],
+    };
+    return taggedObject("!datahike/DB", raw, peer);
+}
+function deliverEvent(id, listener, event, raw) {
+    if (listener.stopped || listeners.get(id) !== listener)
+        return;
+    const { peer } = connectionParts(listener.conn);
+    const data = decodeValue(raw, peer);
+    const rawData = raw;
+    if (event === "report") {
+        listener.lastCommit = data["commit-id"];
+        listener.callback({
+            "db-after": remoteDbFromHead(listener.conn, rawData),
+            "db-before": null,
+            tempids: data.tempids,
+            "commit-id": data["commit-id"],
+            ...(Object.hasOwn(data, "tx-data") ? { "tx-data": data["tx-data"] } : {}),
+            ...(data.truncated ? { truncated: true } : {}),
+        });
+    }
+    else if (event === "resync" || event === "coalesced") {
+        listener.lastCommit = data["commit-id"];
+        listener.callback({ resync: true, "db-after": remoteDbFromHead(listener.conn, rawData) });
+    }
+    else if (event === "deleted") {
+        listener.callback({ deleted: true });
+        stopListener(id, listener);
+    }
+}
+function parseFrame(id, listener, frame) {
+    let event;
+    const data = [];
+    for (const line of frame.split("\n")) {
+        if (!line || line.startsWith(":"))
+            continue;
+        if (line.startsWith("event:"))
+            event = line.slice(6).trim();
+        else if (line.startsWith("data:"))
+            data.push(line.slice(5).trimStart());
+    }
+    if (event && data.length)
+        deliverEvent(id, listener, event, JSON.parse(data.join("\n")));
+}
+async function readStream(id, listener, body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let pending = "";
+    while (!listener.stopped) {
+        const result = await reader.read();
+        if (result.done)
+            break;
+        const raw = pending + decoder.decode(result.value, { stream: true });
+        const trailingCr = raw.endsWith("\r");
+        const complete = trailingCr ? raw.slice(0, -1) : raw;
+        const frames = complete.replace(/\r\n?/g, "\n").split("\n\n");
+        pending = frames.pop() + (trailingCr ? "\r" : "");
+        for (const frame of frames)
+            if (frame)
+                parseFrame(id, listener, frame);
+    }
+    if (listener.stopped)
+        await reader.cancel();
+}
+function reconnect(id, listener) {
+    if (listener.stopped || listeners.get(id) !== listener)
+        return;
+    const delay = listener.backoff;
+    listener.backoff = Math.min(30_000, delay * 2);
+    listener.timer = setTimeout(() => {
+        listener.timer = undefined;
+        void connectListener(id, listener);
+    }, delay);
+}
+async function connectListener(id, listener) {
+    if (listener.stopped || listeners.get(id) !== listener)
+        return;
+    const { peer, store, branch } = connectionParts(listener.conn);
+    const query = new URLSearchParams({ store, branch });
+    if (listener.lastCommit)
+        query.set("since", listener.lastCommit);
+    const target = `${peer.url}/listen?${query}`;
+    const controller = new AbortController();
+    listener.controller = controller;
+    try {
+        const response = await fetch(target, {
+            method: "GET",
+            headers: {
+                Accept: "text/event-stream",
+                ...(peer.token ? { Authorization: `token ${peer.token}` } : {}),
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            if ([401, 403, 404].includes(response.status)) {
+                const error = new Error(`HTTP ${response.status} from ${target}`);
+                Object.assign(error, { status: response.status, url: target });
+                listener.callback({ error, status: response.status });
+                stopListener(id, listener);
+                return;
+            }
+            throw new Error(`HTTP ${response.status} from ${target}`);
+        }
+        listener.backoff = 500;
+        if (!response.body)
+            throw new Error(`No response body from ${target}`);
+        await readStream(id, listener, response.body);
+        reconnect(id, listener);
+    }
+    catch (error) {
+        if (!listener.stopped)
+            reconnect(id, listener);
+    }
+}
+function listen(conn, callback) {
+    const key = randomUuid().value;
+    const id = listenerId(conn, key);
+    const listener = { conn, callback, backoff: 500, stopped: false };
+    listeners.set(id, listener);
+    void connectListener(id, listener);
+    return key;
+}
+function unlisten(conn, key) {
+    const id = listenerId(conn, key);
+    const listener = listeners.get(id);
+    if (listener)
+        stopListener(id, listener);
+}
+// Generated from datahike.api.specification. DO NOT EDIT.
+function asOf(...args) {
+    return request("as-of", true, args, false);
+}
+function branch(...args) {
+    return request("branch", false, args, false);
+}
+function branchAsDb(...args) {
+    return request("branch-as-db", false, args, false);
+}
+function branches(...args) {
+    return request("branches", false, args, false);
+}
+function commitAsDb(...args) {
+    return request("commit-as-db", false, args, false);
+}
+function commitId(...args) {
+    return request("commit-id", true, args, false);
+}
+function connect(...args) {
+    return request("connect", false, args, false);
+}
+function createDatabase(...args) {
+    return request("create-database", false, args, true);
+}
+function databaseExists(...args) {
+    return request("database-exists", false, args, false);
+}
+function datoms(...args) {
+    return request("datoms", true, args, false);
+}
+function db(...args) {
+    return request("db", false, args, false);
+}
+function deleteBranch(...args) {
+    return request("delete-branch", false, args, false);
+}
+function deleteDatabase(...args) {
+    return request("delete-database", false, args, false);
+}
+function entity(...args) {
+    return request("entity", true, args, false);
+}
+function entityDb(...args) {
+    return request("entity-db", true, args, false);
+}
+function gcStorage(...args) {
+    return request("gc-storage", false, args, false);
+}
+function history(...args) {
+    return request("history", true, args, false);
+}
+function indexRange(...args) {
+    return request("index-range", true, args, false);
+}
+function loadEntities(...args) {
+    return request("load-entities", false, args, false);
+}
+function mergeDb(...args) {
+    return request("merge-db", false, args, false);
+}
+function metrics(...args) {
+    return request("metrics", true, args, false);
+}
+function parentCommitIds(...args) {
+    return request("parent-commit-ids", true, args, false);
+}
+function pull(...args) {
+    return request("pull", true, args, false);
+}
+function pullMany(...args) {
+    return request("pull-many", true, args, false);
+}
+function q(...args) {
+    return request("q", true, args, false);
+}
+function queryStats(...args) {
+    return request("query-stats", true, args, false);
+}
+function release(...args) {
+    return request("release", false, args, false);
+}
+function reverseSchema(...args) {
+    return request("reverse-schema", true, args, false);
+}
+function rseekDatoms(...args) {
+    return request("rseek-datoms", true, args, false);
+}
+function schema(...args) {
+    return request("schema", true, args, false);
+}
+function seekDatoms(...args) {
+    return request("seek-datoms", true, args, false);
+}
+function since(...args) {
+    return request("since", true, args, false);
+}
+function transact(...args) {
+    return request("transact", false, args, false);
+}
+function validAll(...args) {
+    return request("valid-all", true, args, false);
+}
+function validAt(...args) {
+    return request("valid-at", true, args, false);
+}
+function validBetween(...args) {
+    return request("valid-between", true, args, false);
+}
+function validDuring(...args) {
+    return request("valid-during", true, args, false);
+}
+exports.default = { asOf, branch, branchAsDb, branches, commitAsDb, commitId, connect, createDatabase, databaseExists, datoms, db, deleteBranch, deleteDatabase, entity, entityDb, gcStorage, history, indexRange, loadEntities, mergeDb, metrics, parentCommitIds, pull, pullMany, q, queryStats, release, reverseSchema, rseekDatoms, schema, seekDatoms, since, transact, validAll, validAt, validBetween, validDuring, isPromise, listen, randomUuid, unlisten, uuid };
+
+module.exports = exports.default;