@peerbit/document-proxy 0.0.0-e209d2e

package/dist/src/client.js

@@ -0,0 +1,748 @@
+import { deserialize, serialize } from "@dao-xyz/borsh";
+import { createProxyFromService } from "@dao-xyz/borsh-rpc";
+import { createMessagePortTransport, } from "@peerbit/canonical-client";
+import { Context, IterationRequest, PushUpdatesMode, ResultIndexedValue, ResultValue, Results, } from "@peerbit/document-interface";
+import * as indexerTypes from "@peerbit/indexer-interface";
+import { createSharedLogProxyFromService, } from "@peerbit/shared-log-proxy/client";
+import { coercePeerRefsToHashes, } from "@peerbit/stream-interface";
+import { Bytes, DocumentsChange, DocumentsCountRequest, DocumentsGetRequest, DocumentsIndexPutRequest, DocumentsIndexResult, DocumentsIterateRequest, DocumentsIteratorBatch, DocumentsIteratorService, DocumentsIteratorUpdate, DocumentsPutWithContextRequest, DocumentsRemoteOptions, DocumentsService, DocumentsWaitForRequest, OpenDocumentsRequest, } from "./protocol.js";
+const ensureCustomEvent = () => {
+    if (typeof globalThis.CustomEvent === "function") {
+        return;
+    }
+    class CustomEventPolyfill extends Event {
+        detail;
+        constructor(type, params) {
+            super(type, params);
+            this.detail = params?.detail;
+        }
+    }
+    globalThis.CustomEvent = CustomEventPolyfill;
+};
+const asInstanceOf = (value, type) => {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    if (value instanceof type) {
+        return value;
+    }
+    return Object.assign(Object.create(type.prototype), value);
+};
+const coerceWithContext = (value, context) => {
+    if (value && typeof value === "object") {
+        value.__context = context;
+    }
+    return value;
+};
+const coerceWithIndexed = (value, indexed) => {
+    if (value && typeof value === "object") {
+        value.__indexed = indexed;
+    }
+    return value;
+};
+const normalizeUpdates = (updates) => {
+    if (!updates) {
+        return { emitUpdates: false };
+    }
+    if (updates === true) {
+        return { merge: true, emitUpdates: true };
+    }
+    if (typeof updates === "string") {
+        if (updates === "local") {
+            return { merge: true, emitUpdates: true };
+        }
+        if (updates === "remote") {
+            return { push: PushUpdatesMode.STREAM, emitUpdates: true };
+        }
+        if (updates === "all") {
+            return { merge: true, push: PushUpdatesMode.STREAM, emitUpdates: true };
+        }
+        return { emitUpdates: false };
+    }
+    if (typeof updates === "object") {
+        const hasMerge = Object.prototype.hasOwnProperty.call(updates, "merge");
+        const merge = hasMerge
+            ? updates.merge === false
+                ? undefined
+                : true
+            : true;
+        const push = typeof updates.push === "number"
+            ? updates.push
+            : updates.push
+                ? PushUpdatesMode.STREAM
+                : undefined;
+        const emitUpdates = !!(updates.notify || updates.onBatch || merge || push);
+        return { push, merge, emitUpdates };
+    }
+    return { emitUpdates: false };
+};
+const toRemoteOptions = (remote) => {
+    if (!remote || typeof remote === "boolean")
+        return undefined;
+    const waitTimeoutMs = typeof remote.wait === "object" ? remote.wait?.timeout : undefined;
+    return new DocumentsRemoteOptions({
+        strategy: remote.strategy,
+        timeoutMs: remote.timeout,
+        from: remote.from,
+        reachEager: remote.reach?.eager,
+        waitTimeoutMs,
+    });
+};
+export const openDocuments = async (properties) => {
+    ensureCustomEvent();
+    const channel = await properties.client.openPort("@peerbit/document", serialize(new OpenDocumentsRequest({
+        id: properties.id,
+        type: properties.typeName,
+    })));
+    const transport = createMessagePortTransport(channel, {
+        requestTimeoutMs: (method) => {
+            if (method === "waitFor" || method === "indexWaitFor")
+                return undefined;
+            return 30_000;
+        },
+    });
+    const raw = createProxyFromService(DocumentsService, transport);
+    const logService = await raw.openLog();
+    const log = await createSharedLogProxyFromService(logService);
+    let closed = false;
+    const decodeChangeValue = (result) => {
+        if (!result.value)
+            return undefined;
+        const value = deserialize(result.value, properties.type);
+        coerceWithContext(value, result.context);
+        const indexType = properties.indexType ?? properties.type;
+        if (result.indexed && indexType) {
+            const indexed = deserialize(result.indexed, indexType);
+            coerceWithIndexed(value, indexed);
+        }
+        return value;
+    };
+    const decodeChange = (change) => {
+        return {
+            added: (change.added ?? []).map(decodeChangeValue).filter(Boolean),
+            removed: (change.removed ?? [])
+                .map(decodeChangeValue)
+                .filter(Boolean),
+        };
+    };
+    const changes = new EventTarget();
+    const onChange = (e) => {
+        const detail = decodeChange(e.detail);
+        changes.dispatchEvent(new CustomEvent("change", { detail }));
+    };
+    raw.changes.addEventListener("change", onChange);
+    const coerceIdKey = (id) => {
+        return id instanceof indexerTypes.IdKey ? id : indexerTypes.toId(id);
+    };
+    const createGetRequest = (id, options, resolveOverride) => {
+        if (options?.signal?.aborted) {
+            throw new Error("AbortError");
+        }
+        const resolve = resolveOverride !== undefined
+            ? resolveOverride !== false
+            : options?.resolve !== false;
+        const remoteOption = options?.remote;
+        const remoteOptions = toRemoteOptions(remoteOption);
+        const remote = typeof remoteOption === "boolean"
+            ? remoteOption
+            : remoteOption
+                ? true
+                : undefined;
+        return {
+            resolve: resolve,
+            request: new DocumentsGetRequest({
+                id: coerceIdKey(id),
+                resolve,
+                local: options?.local,
+                remote,
+                remoteOptions,
+                waitForMs: options?.waitFor,
+            }),
+        };
+    };
+    const fetchValue = async (id, options, resolveOverride) => {
+        const { request, resolve } = createGetRequest(id, options, resolveOverride);
+        const result = await raw.get(request);
+        if (!result)
+            return undefined;
+        return decodeIndexResult(result, resolve);
+    };
+    const get = async (id, options) => {
+        return fetchValue(id, options, true);
+    };
+    const idPath = indexerTypes.getIdProperty(properties.indexType ?? properties.type) ??
+        ["id"];
+    const resolveId = (value) => {
+        let candidate = value;
+        if (candidate && typeof candidate === "object") {
+            if ("__indexed" in candidate && candidate.__indexed) {
+                candidate = candidate.__indexed;
+            }
+        }
+        const resolved = indexerTypes.extractFieldValue(candidate, idPath);
+        return indexerTypes.toId(resolved);
+    };
+    const decodeIndexResult = (result, resolve) => {
+        const context = result.context;
+        const indexType = properties.indexType ?? properties.type;
+        if (resolve !== false) {
+            if (!result.value)
+                return undefined;
+            const value = deserialize(result.value, properties.type);
+            coerceWithContext(value, context);
+            if (result.indexed && indexType) {
+                const indexed = deserialize(result.indexed, indexType);
+                coerceWithIndexed(value, indexed);
+            }
+            return value;
+        }
+        if (result.indexed && indexType) {
+            const indexed = deserialize(result.indexed, indexType);
+            coerceWithContext(indexed, context);
+            return indexed;
+        }
+        return undefined;
+    };
+    const decodeIteratorBatch = (batch, resolve) => {
+        const items = (batch.results ?? [])
+            .map((result) => decodeIndexResult(result, resolve))
+            .filter(Boolean);
+        return { items, done: batch.done };
+    };
+    const decodeUpdateResults = (update, resolve) => {
+        return (update.results ?? [])
+            .map((result) => decodeIndexResult(result, resolve))
+            .filter(Boolean);
+    };
+    const toNumber = (value) => {
+        return typeof value === "bigint" ? Number(value) : value;
+    };
+    const randomId = () => {
+        if (typeof crypto !== "undefined" &&
+            typeof crypto.randomUUID === "function") {
+            return crypto.randomUUID();
+        }
+        return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    };
+    const abortError = () => new Error("AbortError");
+    const createWaitForRequest = (peers, options, requestId) => {
+        if (options?.signal?.aborted) {
+            throw new Error("AbortError");
+        }
+        const hashes = coercePeerRefsToHashes(peers);
+        return new DocumentsWaitForRequest({
+            peers: hashes,
+            seek: options?.seek,
+            timeoutMs: options?.timeout,
+            requestId,
+        });
+    };
+    const waitFor = async (peers, options) => {
+        const signal = options?.signal;
+        const requestId = signal ? randomId() : undefined;
+        const request = createWaitForRequest(peers, options, requestId);
+        const call = raw.waitFor(request);
+        if (!signal || !requestId) {
+            return call;
+        }
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                signal.removeEventListener("abort", onAbort);
+            };
+            const onAbort = () => {
+                cleanup();
+                void raw.cancelWait(requestId).catch(() => { });
+                reject(abortError());
+            };
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+            call.then((value) => {
+                cleanup();
+                resolve(value);
+            }, (error) => {
+                cleanup();
+                reject(error);
+            });
+        });
+    };
+    const indexWaitFor = async (peers, options) => {
+        const signal = options?.signal;
+        const requestId = signal ? randomId() : undefined;
+        const request = createWaitForRequest(peers, options, requestId);
+        const call = raw.indexWaitFor(request);
+        if (!signal || !requestId) {
+            return call;
+        }
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                signal.removeEventListener("abort", onAbort);
+            };
+            const onAbort = () => {
+                cleanup();
+                void raw.cancelWait(requestId).catch(() => { });
+                reject(abortError());
+            };
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+            call.then((value) => {
+                cleanup();
+                resolve(value);
+            }, (error) => {
+                cleanup();
+                reject(error);
+            });
+        });
+    };
+    const indexSize = async () => {
+        const size = await raw.indexSize();
+        return toNumber(size);
+    };
+    const index = {
+        get: async (id, options) => {
+            return fetchValue(id, options);
+        },
+        getDetailed: async (id, options) => {
+            const resolve = options?.resolve !== undefined ? options.resolve !== false : true;
+            const remoteOption = options?.remote;
+            const remoteOptions = toRemoteOptions(remoteOption);
+            const remote = typeof remoteOption === "boolean"
+                ? remoteOption
+                : remoteOption
+                    ? true
+                    : undefined;
+            const result = await raw.get(new DocumentsGetRequest({
+                id: coerceIdKey(id),
+                resolve,
+                local: options?.local,
+                remote,
+                remoteOptions,
+            }));
+            if (!result)
+                return undefined;
+            if (resolve) {
+                const value = decodeIndexResult(result, true);
+                if (!value)
+                    return undefined;
+                const entry = new ResultValue({
+                    source: result.value,
+                    context: result.context,
+                    value,
+                });
+                return [new Results({ results: [entry], kept: 0n })];
+            }
+            const indexed = decodeIndexResult(result, false);
+            if (!indexed)
+                return undefined;
+            const entry = new ResultIndexedValue({
+                source: result.indexed ?? new Uint8Array(),
+                indexed,
+                entries: [],
+                context: result.context,
+            });
+            return [new Results({ results: [entry], kept: 0n })];
+        },
+        resolveId,
+        iterate: (query, options) => {
+            const updates = normalizeUpdates(options?.updates);
+            const remoteOption = options?.remote;
+            const remoteOptions = toRemoteOptions(remoteOption);
+            let remote = typeof remoteOption === "boolean"
+                ? remoteOption
+                : remoteOption
+                    ? true
+                    : undefined;
+            let replicate = typeof remoteOption === "object" && remoteOption?.replicate
+                ? true
+                : false;
+            if (updates.push && remote !== false) {
+                remote = true;
+                replicate = true;
+            }
+            const queryObject = query;
+            const isQueryWrapper = !!queryObject &&
+                typeof queryObject === "object" &&
+                !Array.isArray(queryObject) &&
+                ("query" in queryObject ||
+                    ("sort" in queryObject &&
+                        Object.keys(queryObject).every((k) => k === "sort" || k === "query")));
+            const queryValue = isQueryWrapper ? queryObject.query : queryObject;
+            const sortValue = isQueryWrapper ? queryObject.sort : undefined;
+            const request = query instanceof IterationRequest
+                ? query
+                : new IterationRequest({
+                    query: queryValue,
+                    sort: sortValue,
+                    fetch: options?.fetch ?? 10,
+                    resolve: options?.resolve !== false,
+                    replicate: options?.resolve !== false ? false : replicate,
+                });
+            const resolveBool = options?.resolve !== undefined
+                ? options.resolve !== false
+                : request.resolve !== false;
+            const resolve = resolveBool;
+            if (options?.resolve !== undefined) {
+                request.resolve = resolveBool;
+            }
+            if (!resolve && replicate && request.replicate !== true) {
+                request.replicate = true;
+            }
+            if (updates.emitUpdates) {
+                request.pushUpdates = updates.push;
+                request.mergeUpdates = updates.merge;
+            }
+            const emitUpdates = updates.emitUpdates ||
+                request.pushUpdates != null ||
+                request.mergeUpdates != null;
+            const iterateRequest = new DocumentsIterateRequest({
+                request,
+                local: options?.local,
+                remote,
+                remoteOptions,
+                closePolicy: options?.closePolicy,
+                emitUpdates,
+            });
+            let done = false;
+            let updatesListener;
+            const abortSignal = options?.signal;
+            let abortListener;
+            const proxyPromise = raw.iterate(iterateRequest);
+            const createIterator = (service) => {
+                if (updates.emitUpdates &&
+                    options?.updates &&
+                    typeof options.updates === "object") {
+                    const updateConfig = options.updates;
+                    updatesListener = (event) => {
+                        const detail = event?.detail;
+                        if (!detail)
+                            return;
+                        const reason = detail.reason;
+                        if (updateConfig.notify) {
+                            updateConfig.notify(reason);
+                        }
+                        if (updateConfig.onBatch && detail.results?.length) {
+                            const items = decodeUpdateResults(detail, resolve);
+                            if (items.length) {
+                                updateConfig.onBatch(items, { reason });
+                            }
+                        }
+                    };
+                    service.updates.addEventListener("update", updatesListener);
+                }
+                const iterator = {
+                    next: async (amount) => {
+                        if (abortSignal?.aborted) {
+                            throw abortError();
+                        }
+                        const batch = await service.next(amount);
+                        const decoded = decodeIteratorBatch(batch, resolve);
+                        done = decoded.done;
+                        return decoded.items;
+                    },
+                    pending: async () => {
+                        if (abortSignal?.aborted) {
+                            throw abortError();
+                        }
+                        const pending = await service.pending();
+                        return pending != null ? Number(pending) : undefined;
+                    },
+                    done: () => done,
+                    all: async () => {
+                        if (abortSignal?.aborted) {
+                            throw abortError();
+                        }
+                        const out = [];
+                        while (!done) {
+                            const next = await iterator.next(options?.fetch ?? 10);
+                            out.push(...next);
+                        }
+                        return out;
+                    },
+                    first: async () => {
+                        if (abortSignal?.aborted) {
+                            throw abortError();
+                        }
+                        const next = await iterator.next(1);
+                        return next[0];
+                    },
+                    close: async () => {
+                        done = true;
+                        if (abortSignal && abortListener) {
+                            abortSignal.removeEventListener("abort", abortListener);
+                        }
+                        if (updatesListener) {
+                            service.updates.removeEventListener("update", updatesListener);
+                        }
+                        await service.close();
+                    },
+                    [Symbol.asyncIterator]: () => {
+                        return {
+                            next: async () => {
+                                const items = await iterator.next(1);
+                                if (items.length === 0) {
+                                    return { done: true, value: undefined };
+                                }
+                                return { done: false, value: items[0] };
+                            },
+                            return: async () => {
+                                await iterator.close();
+                                return { done: true, value: undefined };
+                            },
+                        };
+                    },
+                };
+                return iterator;
+            };
+            let iterator;
+            abortListener = () => {
+                void iterator.close();
+            };
+            iterator = {
+                next: async (amount) => {
+                    if (abortSignal?.aborted) {
+                        throw abortError();
+                    }
+                    const service = await proxyPromise;
+                    Object.assign(iterator, createIterator(service));
+                    return iterator.next(amount);
+                },
+                pending: async () => {
+                    if (abortSignal?.aborted) {
+                        throw abortError();
+                    }
+                    const service = await proxyPromise;
+                    Object.assign(iterator, createIterator(service));
+                    return iterator.pending();
+                },
+                done: () => done,
+                all: async () => {
+                    if (abortSignal?.aborted) {
+                        throw abortError();
+                    }
+                    const service = await proxyPromise;
+                    Object.assign(iterator, createIterator(service));
+                    return iterator.all();
+                },
+                first: async () => {
+                    if (abortSignal?.aborted) {
+                        throw abortError();
+                    }
+                    const service = await proxyPromise;
+                    Object.assign(iterator, createIterator(service));
+                    return iterator.first();
+                },
+                close: async () => {
+                    const service = await proxyPromise;
+                    Object.assign(iterator, createIterator(service));
+                    return iterator.close();
+                },
+                [Symbol.asyncIterator]: () => {
+                    return {
+                        next: async () => {
+                            if (abortSignal?.aborted) {
+                                throw abortError();
+                            }
+                            const service = await proxyPromise;
+                            Object.assign(iterator, createIterator(service));
+                            const iter = iterator[Symbol.asyncIterator]();
+                            return iter.next();
+                        },
+                        return: async () => {
+                            if (abortSignal?.aborted) {
+                                return { done: true, value: undefined };
+                            }
+                            const service = await proxyPromise;
+                            Object.assign(iterator, createIterator(service));
+                            const iter = iterator[Symbol.asyncIterator]();
+                            return iter.return
+                                ? iter.return()
+                                : { done: true, value: undefined };
+                        },
+                    };
+                },
+            };
+            if (abortSignal) {
+                if (abortSignal.aborted) {
+                    throw abortError();
+                }
+                abortSignal.addEventListener("abort", abortListener, { once: true });
+            }
+            return iterator;
+        },
+        search: async (query, options) => {
+            const iterator = index.iterate(query, {
+                resolve: options?.resolve,
+                local: options?.local,
+                remote: options?.remote,
+                fetch: options?.fetch ?? 0xffffffff,
+            });
+            const out = await iterator.all();
+            await iterator.close();
+            const seen = new Set();
+            return out.filter((item) => {
+                const id = resolveId(item).primitive;
+                if (seen.has(String(id)))
+                    return false;
+                seen.add(String(id));
+                return true;
+            });
+        },
+        getSize: indexSize,
+        waitFor: indexWaitFor,
+    };
+    const countByIterate = async (query) => {
+        const iterator = index.iterate(query ? { query } : undefined, {
+            resolve: false,
+            fetch: 100,
+            local: true,
+            remote: false,
+        });
+        let total = 0;
+        while (!iterator.done()) {
+            const batch = await iterator.next(100);
+            total += batch.length;
+        }
+        await iterator.close();
+        return total;
+    };
+    const toCountEstimate = (estimate) => ({
+        estimate,
+        errorMargin: undefined,
+    });
+    async function count(options) {
+        const approximate = options?.approximate === true || typeof options?.approximate === "object";
+        if (options?.query) {
+            const total = await countByIterate(options.query);
+            return approximate ? toCountEstimate(total) : total;
+        }
+        const total = await raw.count(new DocumentsCountRequest({ approximate }));
+        const estimate = toNumber(total);
+        return approximate ? toCountEstimate(estimate) : estimate;
+    }
+    class WrappedIndexedType {
+        __context;
+        constructor(value, context) {
+            Object.assign(this, value);
+            this.__context = context;
+        }
+    }
+    const putWithContext = async (value, id, context) => {
+        const ctx = context instanceof Context ? context : new Context(context);
+        const request = new DocumentsPutWithContextRequest({
+            value: new Bytes({ value: serialize(value) }),
+            id: coerceIdKey(id),
+            context: ctx,
+        });
+        await raw.putWithContext(request);
+    };
+    const indexPut = async (value) => {
+        const ctx = value?.__context;
+        if (!ctx) {
+            throw new Error("Missing __context for index.put");
+        }
+        const context = ctx instanceof Context ? ctx : new Context(ctx);
+        const indexType = properties.indexType ?? properties.type;
+        const stripped = { ...value };
+        delete stripped.__context;
+        const indexed = asInstanceOf(stripped, indexType);
+        const request = new DocumentsIndexPutRequest({
+            indexed: serialize(indexed),
+            context,
+        });
+        await raw.indexPut(request);
+    };
+    const createIndexIterator = (iterator) => {
+        const toIndexedResult = (value) => ({
+            id: resolveId(value),
+            value,
+        });
+        return {
+            next: async (amount) => {
+                const batch = await iterator.next(amount);
+                return batch.map(toIndexedResult);
+            },
+            all: async () => {
+                const batch = await iterator.all();
+                return batch.map(toIndexedResult);
+            },
+            done: () => iterator.done(),
+            pending: async () => {
+                const pending = await iterator.pending();
+                return pending ?? 0;
+            },
+            close: async () => {
+                await iterator.close();
+            },
+        };
+    };
+    index.putWithContext = putWithContext;
+    index.wrappedIndexedType = WrappedIndexedType;
+    index.index = {
+        count: async (options) => {
+            return countByIterate(options?.query);
+        },
+        getSize: indexSize,
+        get: async (id, _options) => {
+            const value = await fetchValue(id, {
+                resolve: false,
+                local: true,
+                remote: false,
+            });
+            return value
+                ? { id: coerceIdKey(id), value: value }
+                : undefined;
+        },
+        iterate: (request, _options) => {
+            const iterator = index.iterate(request, {
+                resolve: false,
+                local: true,
+                remote: false,
+            });
+            return createIndexIterator(iterator);
+        },
+        put: indexPut,
+    };
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        raw.changes.removeEventListener("change", onChange);
+        try {
+            await log.close();
+            await raw.close();
+        }
+        finally {
+            channel.close?.();
+        }
+    };
+    const proxy = {
+        raw,
+        log,
+        events: changes,
+        changes,
+        index,
+        put: async (doc) => raw.put(new Bytes({ value: serialize(doc) })),
+        get,
+        del: async (id) => raw.del(coerceIdKey(id)),
+        count,
+        waitFor,
+        recover: async () => {
+            await raw.recover();
+        },
+        close,
+    };
+    Object.defineProperty(proxy, "closed", {
+        get: () => closed,
+        set: (value) => {
+            closed = value;
+        },
+        enumerable: true,
+    });
+    return proxy;
+};
+//# sourceMappingURL=client.js.map