@peerbit/document 10.0.4 → 10.1.0

package/dist/src/program.js

@@ -1,11 +1,36 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
 import { BorshError, field, serialize, variant, } from "@dao-xyz/borsh";
 import { AccessError, SignatureWithKey } from "@peerbit/crypto";
@@ -18,578 +43,595 @@ import { SharedLog, } from "@peerbit/shared-log";
 import { MAX_BATCH_SIZE } from "./constants.js";
 import { BORSH_ENCODING_OPERATION, DeleteOperation, PutOperation, PutWithKeyOperation, coerceDeleteOperation, isDeleteOperation, isPutOperation, } from "./operation.js";
 import { DocumentIndex, coerceWithContext, coerceWithIndexed, } from "./search.js";
-const logger = loggerFn({ module: "document" });
+const logger = loggerFn("peerbit:program:document");
+const warn = logger.newScope("warn");
 export class OperationError extends Error {
     constructor(message) {
         super(message);
     }
 }
-let Documents = class Documents extends Program {
-    log;
-    immutable; // "Can I overwrite a document?"
-    _index;
-    _clazz;
-    _optionCanPerform;
-    idResolver;
-    domain;
-    strictHistory;
-    canOpen;
-    compatibility;
-    constructor(properties) {
-        super();
-        this.log = new SharedLog(properties);
-        this.immutable = properties?.immutable ?? false;
-        this._index = properties?.index || new DocumentIndex();
-    }
-    get index() {
-        return this._index;
-    }
-    async maybeSubprogramOpen(value) {
-        if (await this.canOpen(value)) {
-            return (await this.node.open(value, {
-                parent: this,
-                existing: "reuse",
-            })); // TODO types
+let Documents = (() => {
+    let _classDecorators = [variant("documents")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Program;
+    let _log_decorators;
+    let _log_initializers = [];
+    let _log_extraInitializers = [];
+    let _immutable_decorators;
+    let _immutable_initializers = [];
+    let _immutable_extraInitializers = [];
+    let __index_decorators;
+    let __index_initializers = [];
+    let __index_extraInitializers = [];
+    var Documents = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _log_decorators = [field({ type: SharedLog })];
+            _immutable_decorators = [field({ type: "bool" })];
+            __index_decorators = [field({ type: DocumentIndex })];
+            __esDecorate(null, null, _log_decorators, { kind: "field", name: "log", static: false, private: false, access: { has: obj => "log" in obj, get: obj => obj.log, set: (obj, value) => { obj.log = value; } }, metadata: _metadata }, _log_initializers, _log_extraInitializers);
+            __esDecorate(null, null, _immutable_decorators, { kind: "field", name: "immutable", static: false, private: false, access: { has: obj => "immutable" in obj, get: obj => obj.immutable, set: (obj, value) => { obj.immutable = value; } }, metadata: _metadata }, _immutable_initializers, _immutable_extraInitializers);
+            __esDecorate(null, null, __index_decorators, { kind: "field", name: "_index", static: false, private: false, access: { has: obj => "_index" in obj, get: obj => obj._index, set: (obj, value) => { obj._index = value; } }, metadata: _metadata }, __index_initializers, __index_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Documents = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        return value;
-    }
-    keepCache = undefined;
-    async open(options) {
-        this._clazz = options.type;
-        this.canOpen = options.canOpen;
-        /* eslint-disable */
-        if (Program.isPrototypeOf(this._clazz)) {
-            if (!this.canOpen) {
-                throw new Error("Document store needs to be opened with canOpen option when the document type is a Program");
-            }
+        log = __runInitializers(this, _log_initializers, void 0);
+        immutable = (__runInitializers(this, _log_extraInitializers), __runInitializers(this, _immutable_initializers, void 0)); // "Can I overwrite a document?"
+        _index = (__runInitializers(this, _immutable_extraInitializers), __runInitializers(this, __index_initializers, void 0));
+        _clazz = __runInitializers(this, __index_extraInitializers);
+        _optionCanPerform;
+        idResolver;
+        domain;
+        strictHistory;
+        canOpen;
+        compatibility;
+        constructor(properties) {
+            super();
+            this.log = new SharedLog(properties);
+            this.immutable = properties?.immutable ?? false;
+            this._index = properties?.index || new DocumentIndex();
         }
-        this._optionCanPerform = options.canPerform;
-        const idProperty = options.index?.idProperty ||
-            indexerTypes.getIdProperty(this._clazz) ||
-            "id";
-        const idResolver = options.id ||
-            (typeof idProperty === "string"
-                ? (obj) => obj[idProperty]
-                : (obj) => indexerTypes.extractFieldValue(obj, idProperty));
-        this.idResolver = idResolver;
-        this.compatibility = options.compatibility;
-        this.strictHistory = options.strictHistory ?? false;
-        await this._index.open({
-            documentEvents: this.events,
-            log: this.log,
-            canRead: options?.index?.canRead,
-            canSearch: options.index?.canSearch,
-            documentType: this._clazz,
-            transform: options.index,
-            indexBy: idProperty,
-            compatibility: options.compatibility,
-            cache: options?.index?.cache,
-            replicate: async (query, results) => {
-                // here we arrive for all the results we want to persist.
-                let mergeSegments = this.domain?.canProjectToOneSegment(query);
-                await this.log.join(results.results
-                    .flat()
-                    .map((x) => x instanceof ResultIndexedValue && x.entries.length > 0
-                    ? x.entries[0]
-                    : x.context.head), { replicate: { assumeSynced: true, mergeSegments } });
-            },
-            dbType: this.constructor,
-            maybeOpen: this.maybeSubprogramOpen.bind(this),
-            prefetch: options.index?.prefetch,
-            includeIndexed: options.index?.includeIndexed,
-        });
-        // document v6 and below need log compatibility of v8 or below
-        // document v7 needs log compatibility of v9
-        let logCompatiblity = undefined;
-        if (options.compatibility === 6) {
-            logCompatiblity = 8;
+        get index() {
+            return this._index;
         }
-        else if (options.compatibility === 7) {
-            logCompatiblity = 9;
+        async maybeSubprogramOpen(value) {
+            if (await this.canOpen(value)) {
+                return (await this.node.open(value, {
+                    parent: this,
+                    existing: "reuse",
+                })); // TODO types
+            }
+            return value;
         }
-        this.domain = options.domain?.(this);
-        let keepFunction;
-        if (options?.keep === "self") {
-            this.keepCache = new Set();
-            keepFunction = async (e) => {
-                if (this.keepCache?.has(e.hash)) {
-                    return true;
-                }
-                let signatures = undefined;
-                if (e instanceof Entry) {
-                    signatures = e.signatures;
-                }
-                else {
-                    const entry = await this.log.log.get(e.hash);
-                    signatures = entry?.signatures;
-                }
-                if (!signatures) {
-                    return false;
+        keepCache = undefined;
+        async open(options) {
+            this._clazz = options.type;
+            this.canOpen = options.canOpen;
+            /* eslint-disable */
+            if (Program.isPrototypeOf(this._clazz)) {
+                if (!this.canOpen) {
+                    throw new Error("Document store needs to be opened with canOpen option when the document type is a Program");
                 }
-                for (const signature of signatures) {
-                    if (signature.publicKey.equals(this.node.identity.publicKey)) {
-                        this.keepCache?.add(e.hash);
+            }
+            this._optionCanPerform = options.canPerform;
+            const idProperty = options.index?.idProperty ||
+                indexerTypes.getIdProperty(this._clazz) ||
+                "id";
+            const idResolver = options.id ||
+                (typeof idProperty === "string"
+                    ? (obj) => obj[idProperty]
+                    : (obj) => indexerTypes.extractFieldValue(obj, idProperty));
+            this.idResolver = idResolver;
+            this.compatibility = options.compatibility;
+            this.strictHistory = options.strictHistory ?? false;
+            await this._index.open({
+                documentEvents: this.events,
+                log: this.log,
+                canRead: options?.index?.canRead,
+                canSearch: options.index?.canSearch,
+                documentType: this._clazz,
+                transform: options.index,
+                indexBy: idProperty,
+                compatibility: options.compatibility,
+                cache: options?.index?.cache,
+                replicate: async (query, results) => {
+                    // here we arrive for all the results we want to persist.
+                    let mergeSegments = this.domain?.canProjectToOneSegment(query);
+                    await this.log.join(results.results
+                        .flat()
+                        .map((x) => x instanceof ResultIndexedValue && x.entries.length > 0
+                        ? x.entries[0]
+                        : x.context.head), { replicate: { assumeSynced: true, mergeSegments } });
+                },
+                dbType: this.constructor,
+                maybeOpen: this.maybeSubprogramOpen.bind(this),
+                prefetch: options.index?.prefetch,
+                includeIndexed: options.index?.includeIndexed,
+            });
+            // document v6 and below need log compatibility of v8 or below
+            // document v7 needs log compatibility of v9
+            let logCompatiblity = undefined;
+            if (options.compatibility === 6) {
+                logCompatiblity = 8;
+            }
+            else if (options.compatibility === 7) {
+                logCompatiblity = 9;
+            }
+            this.domain = options.domain?.(this);
+            let keepFunction;
+            if (options?.keep === "self") {
+                this.keepCache = new Set();
+                keepFunction = async (e) => {
+                    if (this.keepCache?.has(e.hash)) {
                         return true;
                     }
-                }
-                return false; // TODO also cache this?
-            };
-        }
-        else {
-            keepFunction = options?.keep;
-        }
-        await this.log.open({
-            encoding: BORSH_ENCODING_OPERATION,
-            canReplicate: options?.canReplicate,
-            canAppend: this.canAppend.bind(this),
-            onChange: this.handleChanges.bind(this),
-            trim: options?.log?.trim,
-            replicate: options?.replicate,
-            replicas: options?.replicas,
-            domain: (options?.domain
-                ? (log) => options.domain(this)
-                : undefined), /// TODO types,
-            compatibility: logCompatiblity,
-            keep: keepFunction,
-        });
-    }
-    async recover() {
-        return this.log.recover();
-    }
-    async _resolveEntry(history, options) {
-        return typeof history === "string"
-            ? (await this.log.log.get(history, options)) ||
-                (await Entry.fromMultihash(this.log.log.blocks, history, options))
-            : history;
-    }
-    async canAppend(entry, reference) {
-        const l0 = await this._canAppend(entry, reference);
-        if (!l0) {
-            return false;
-        }
-        try {
-            let operation = l0;
-            let document = reference?.document;
-            if (!document) {
-                if (isPutOperation(l0)) {
-                    document = this._index.valueEncoding.decoder(l0.data);
-                    if (!document) {
+                    let signatures = undefined;
+                    if (e instanceof Entry) {
+                        signatures = e.signatures;
+                    }
+                    else {
+                        const entry = await this.log.log.get(e.hash);
+                        signatures = entry?.signatures;
+                    }
+                    if (!signatures) {
                         return false;
                     }
-                }
-                else if (isDeleteOperation(l0)) {
-                    // Nothing to do here by default
-                    // checking if the document exists is not necessary
-                    // since it might already be deleted
-                }
-                else {
-                    throw new Error("Unsupported operation");
-                }
-            }
-            if (this._optionCanPerform) {
-                if (!(await this._optionCanPerform(isPutOperation(operation)
-                    ? {
-                        type: "put",
-                        value: document,
-                        operation,
-                        entry: entry,
+                    for (const signature of signatures) {
+                        if (signature.publicKey.equals(this.node.identity.publicKey)) {
+                            this.keepCache?.add(e.hash);
+                            return true;
+                        }
                     }
-                    : {
-                        type: "delete",
-                        operation,
-                        entry: entry,
-                    }))) {
-                    return false;
-                }
+                    return false; // TODO also cache this?
+                };
             }
-        }
-        catch (error) {
-            if (error instanceof BorshError) {
-                logger.warn("Received payload that could not be decoded, skipping");
-                return false;
+            else {
+                keepFunction = options?.keep;
             }
-            throw error;
+            await this.log.open({
+                encoding: BORSH_ENCODING_OPERATION,
+                canReplicate: options?.canReplicate,
+                canAppend: this.canAppend.bind(this),
+                onChange: this.handleChanges.bind(this),
+                trim: options?.log?.trim,
+                replicate: options?.replicate,
+                replicas: options?.replicas,
+                domain: (options?.domain
+                    ? (log) => options.domain(this)
+                    : undefined), /// TODO types,
+                compatibility: logCompatiblity,
+                keep: keepFunction,
+            });
         }
-        return true;
-    }
-    async _canAppend(entry, reference) {
-        const resolve = async (history) => {
+        async recover() {
+            return this.log.recover();
+        }
+        async _resolveEntry(history, options) {
             return typeof history === "string"
-                ? this.log.log.get(history) ||
-                    (await Entry.fromMultihash(this.log.log.blocks, history))
+                ? (await this.log.log.get(history, options)) ||
+                    (await Entry.fromMultihash(this.log.log.blocks, history, options))
                 : history;
-        };
-        const pointsToHistory = async (history) => {
-            // make sure nexts only points to this document at some point in history
-            let current = await resolve(history);
-            const next = entry.meta.next[0];
-            while (current?.hash &&
-                next !== current?.hash &&
-                current.meta.next.length > 0) {
-                current = await this.log.log.get(current.meta.next[0]);
-            }
-            if (current?.hash === next) {
-                return true; // Ok, we are pointing this new edit to some exising point in time of the old document
+        }
+        async canAppend(entry, reference) {
+            const l0 = await this._canAppend(entry, reference);
+            if (!l0) {
+                return false;
             }
-            return false;
-        };
-        try {
-            entry.init({
-                encoding: this.log.log.encoding,
-                keychain: this.node.services.keychain,
-            });
-            const operation = reference?.operation ||
-                /* entry._payload instanceof DecryptedThing
-                    ? entry.payload.getValue(entry.encoding)
-                    :  */ (await entry.getPayloadValue()); // TODO implement sync api for resolving entries that does not deep decryption
-            if (isPutOperation(operation)) {
-                // check nexts
-                const putOperation = operation;
-                let value = reference?.document ??
-                    this.index.valueEncoding.decoder(putOperation.data);
-                const keyValue = this.idResolver(value);
-                const key = indexerTypes.toId(keyValue);
-                const existingDocument = (await this.index.getDetailed(key, {
-                    resolve: false,
-                    local: true,
-                    remote: this.immutable ? { strategy: "fallback" } : false,
-                }))?.[0]?.results[0];
-                if (existingDocument && existingDocument.context.head !== entry.hash) {
-                    //  econd condition can false if we reset the operation log, while not  resetting the index. For example when doing .recover
-                    if (this.immutable) {
-                        // key already exist but pick the oldest entry
-                        // this is because we can not overwrite same id if immutable
-                        if (existingDocument.context.created <
-                            entry.meta.clock.timestamp.wallTime) {
+            try {
+                let operation = l0;
+                let document = reference?.document;
+                if (!document) {
+                    if (isPutOperation(l0)) {
+                        document = this._index.valueEncoding.decoder(l0.data);
+                        if (!document) {
                             return false;
                         }
-                        if (entry.meta.next.length > 0) {
-                            return false; // can not append to immutable document
-                        }
-                        return putOperation;
+                    }
+                    else if (isDeleteOperation(l0)) {
+                        // Nothing to do here by default
+                        // checking if the document exists is not necessary
+                        // since it might already be deleted
                     }
                     else {
-                        if (this.strictHistory) {
-                            // make sure that the next pointer exist and points to the existing documents
-                            if (entry.meta.next.length !== 1) {
+                        throw new Error("Unsupported operation");
+                    }
+                }
+                if (this._optionCanPerform) {
+                    if (!(await this._optionCanPerform(isPutOperation(operation)
+                        ? {
+                            type: "put",
+                            value: document,
+                            operation,
+                            entry: entry,
+                        }
+                        : {
+                            type: "delete",
+                            operation,
+                            entry: entry,
+                        }))) {
+                        return false;
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof BorshError) {
+                    warn("Received payload that could not be decoded, skipping");
+                    return false;
+                }
+                throw error;
+            }
+            return true;
+        }
+        async _canAppend(entry, reference) {
+            const resolve = async (history) => {
+                return typeof history === "string"
+                    ? this.log.log.get(history) ||
+                        (await Entry.fromMultihash(this.log.log.blocks, history))
+                    : history;
+            };
+            const pointsToHistory = async (history) => {
+                // make sure nexts only points to this document at some point in history
+                let current = await resolve(history);
+                const next = entry.meta.next[0];
+                while (current?.hash &&
+                    next !== current?.hash &&
+                    current.meta.next.length > 0) {
+                    current = await this.log.log.get(current.meta.next[0]);
+                }
+                if (current?.hash === next) {
+                    return true; // Ok, we are pointing this new edit to some exising point in time of the old document
+                }
+                return false;
+            };
+            try {
+                entry.init({
+                    encoding: this.log.log.encoding,
+                    keychain: this.node.services.keychain,
+                });
+                const operation = reference?.operation ||
+                    /* entry._payload instanceof DecryptedThing
+                        ? entry.payload.getValue(entry.encoding)
+                        :  */ (await entry.getPayloadValue()); // TODO implement sync api for resolving entries that does not deep decryption
+                if (isPutOperation(operation)) {
+                    // check nexts
+                    const putOperation = operation;
+                    let value = reference?.document ??
+                        this.index.valueEncoding.decoder(putOperation.data);
+                    const keyValue = this.idResolver(value);
+                    const key = indexerTypes.toId(keyValue);
+                    const existingDocument = (await this.index.getDetailed(key, {
+                        resolve: false,
+                        local: true,
+                        remote: this.immutable ? { strategy: "fallback" } : false,
+                    }))?.[0]?.results[0];
+                    if (existingDocument && existingDocument.context.head !== entry.hash) {
+                        //  econd condition can false if we reset the operation log, while not  resetting the index. For example when doing .recover
+                        if (this.immutable) {
+                            // key already exist but pick the oldest entry
+                            // this is because we can not overwrite same id if immutable
+                            if (existingDocument.context.created <
+                                entry.meta.clock.timestamp.wallTime) {
                                 return false;
                             }
-                            const prevEntry = await this.log.log.entryIndex.get(existingDocument.context.head);
-                            if (!prevEntry) {
-                                logger.error("Failed to find previous entry for document edit: " +
-                                    entry.hash);
-                                return false;
+                            if (entry.meta.next.length > 0) {
+                                return false; // can not append to immutable document
                             }
-                            const referenceHistoryCorrectly = await pointsToHistory(prevEntry);
-                            return referenceHistoryCorrectly ? putOperation : false;
+                            return putOperation;
                         }
                         else {
-                            return putOperation;
+                            if (this.strictHistory) {
+                                // make sure that the next pointer exist and points to the existing documents
+                                if (entry.meta.next.length !== 1) {
+                                    return false;
+                                }
+                                const prevEntry = await this.log.log.entryIndex.get(existingDocument.context.head);
+                                if (!prevEntry) {
+                                    logger.error("Failed to find previous entry for document edit: " +
+                                        entry.hash);
+                                    return false;
+                                }
+                                const referenceHistoryCorrectly = await pointsToHistory(prevEntry);
+                                return referenceHistoryCorrectly ? putOperation : false;
+                            }
+                            else {
+                                return putOperation;
+                            }
                         }
                     }
+                    else {
+                        // TODO should re reject next pointers to other documents?
+                        // like if (entry.meta.next.length > 0) { return false; }
+                        // for now the default behaviour will allow us to build document dependencies
+                    }
+                }
+                else if (isDeleteOperation(operation)) {
+                    if (entry.meta.next.length !== 1) {
+                        return false;
+                    }
+                    const existingDocument = (await this.index.getDetailed(operation.key, {
+                        resolve: false,
+                        local: true,
+                        remote: this.immutable,
+                    }))?.[0]?.results[0];
+                    if (!existingDocument) {
+                        // already deleted
+                        return coerceDeleteOperation(operation); // assume ok
+                    }
+                    let doc = await this.log.log.get(existingDocument.context.head);
+                    if (!doc) {
+                        logger.error("Failed to find Document from head");
+                        return false;
+                    }
+                    if (await pointsToHistory(doc)) {
+                        // references the existing document
+                        return coerceDeleteOperation(operation);
+                    }
+                    return false;
                 }
                 else {
-                    // TODO should re reject next pointers to other documents?
-                    // like if (entry.meta.next.length > 0) { return false; }
-                    // for now the default behaviour will allow us to build document dependencies
+                    throw new Error("Unsupported operation");
                 }
+                return operation;
             }
-            else if (isDeleteOperation(operation)) {
-                if (entry.meta.next.length !== 1) {
+            catch (error) {
+                if (error instanceof AccessError) {
+                    return false; // we cant index because we can not decrypt
+                }
+                else if (error instanceof BorshError) {
+                    warn("Received payload that could not be decoded, skipping");
                     return false;
                 }
-                const existingDocument = (await this.index.getDetailed(operation.key, {
+                throw error;
+            }
+        }
+        async put(doc, options) {
+            const keyValue = this.idResolver(doc);
+            // type check the key
+            indexerTypes.checkId(keyValue);
+            const ser = serialize(doc);
+            if (ser.length > MAX_BATCH_SIZE) {
+                throw new Error(`Document is too large (${ser.length * 1e-6}) mb). Needs to be less than ${MAX_BATCH_SIZE * 1e-6} mb`);
+            }
+            const existingDocument = options?.unique
+                ? undefined
+                : (await this._index.getDetailed(keyValue, {
                     resolve: false,
                     local: true,
-                    remote: this.immutable,
+                    remote: options?.checkRemote
+                        ? { replicate: options?.replicate }
+                        : false, // only query remote if we know they exist
                 }))?.[0]?.results[0];
-                if (!existingDocument) {
-                    // already deleted
-                    return coerceDeleteOperation(operation); // assume ok
-                }
-                let doc = await this.log.log.get(existingDocument.context.head);
-                if (!doc) {
-                    logger.error("Failed to find Document from head");
-                    return false;
+            let operation;
+            if (this.compatibility === 6) {
+                if (typeof keyValue === "string") {
+                    operation = new PutWithKeyOperation({
+                        key: keyValue,
+                        data: ser,
+                    });
                 }
-                if (await pointsToHistory(doc)) {
-                    // references the existing document
-                    return coerceDeleteOperation(operation);
+                else {
+                    throw new Error("Key must be a string in compatibility mode v6");
                 }
-                return false;
             }
             else {
-                throw new Error("Unsupported operation");
-            }
-            return operation;
-        }
-        catch (error) {
-            if (error instanceof AccessError) {
-                return false; // we cant index because we can not decrypt
-            }
-            else if (error instanceof BorshError) {
-                logger.warn("Received payload that could not be decoded, skipping");
-                return false;
+                operation = new PutOperation({
+                    data: ser,
+                });
             }
-            throw error;
-        }
-    }
-    async put(doc, options) {
-        const keyValue = this.idResolver(doc);
-        // type check the key
-        indexerTypes.checkId(keyValue);
-        const ser = serialize(doc);
-        if (ser.length > MAX_BATCH_SIZE) {
-            throw new Error(`Document is too large (${ser.length * 1e-6}) mb). Needs to be less than ${MAX_BATCH_SIZE * 1e-6} mb`);
+            const appended = await this.log.append(operation, {
+                ...options,
+                meta: {
+                    next: existingDocument
+                        ? [await this._resolveEntry(existingDocument.context.head)]
+                        : [],
+                    ...options?.meta,
+                },
+                canAppend: (entry) => {
+                    return this.canAppend(entry, { document: doc, operation });
+                },
+                onChange: (change) => {
+                    return this.handleChanges(change, { document: doc, operation });
+                },
+                replicate: options?.replicate,
+            });
+            this.keepCache?.add(appended.entry.hash);
+            return appended;
         }
-        const existingDocument = options?.unique
-            ? undefined
-            : (await this._index.getDetailed(keyValue, {
+        async del(id, options) {
+            const key = indexerTypes.toId(id);
+            const existing = (await this._index.getDetailed(key, {
                 resolve: false,
                 local: true,
-                remote: options?.checkRemote
-                    ? { replicate: options?.replicate }
-                    : false, // only query remote if we know they exist
+                remote: { replicate: options?.replicate },
             }))?.[0]?.results[0];
-        let operation;
-        if (this.compatibility === 6) {
-            if (typeof keyValue === "string") {
-                operation = new PutWithKeyOperation({
-                    key: keyValue,
-                    data: ser,
-                });
-            }
-            else {
-                throw new Error("Key must be a string in compatibility mode v6");
+            if (!existing) {
+                throw new NotFoundError(`No entry with key '${key.primitive}' in the database`);
             }
-        }
-        else {
-            operation = new PutOperation({
-                data: ser,
+            this.keepCache?.delete(existing.value.__context.head);
+            const entry = await this._resolveEntry(existing.context.head, {
+                remote: true,
+            });
+            return this.log.append(new DeleteOperation({
+                key,
+            }), {
+                ...options,
+                meta: {
+                    next: [entry],
+                    type: EntryType.CUT,
+                    ...options?.meta,
+                },
             });
         }
-        const appended = await this.log.append(operation, {
-            ...options,
-            meta: {
-                next: existingDocument
-                    ? [await this._resolveEntry(existingDocument.context.head)]
-                    : [],
-                ...options?.meta,
-            },
-            canAppend: (entry) => {
-                return this.canAppend(entry, { document: doc, operation });
-            },
-            onChange: (change) => {
-                return this.handleChanges(change, { document: doc, operation });
-            },
-            replicate: options?.replicate,
-        });
-        this.keepCache?.add(appended.entry.hash);
-        return appended;
-    }
-    async del(id, options) {
-        const key = indexerTypes.toId(id);
-        const existing = (await this._index.getDetailed(key, {
-            resolve: false,
-            local: true,
-            remote: { replicate: options?.replicate },
-        }))?.[0]?.results[0];
-        if (!existing) {
-            throw new NotFoundError(`No entry with key '${key.primitive}' in the database`);
-        }
-        this.keepCache?.delete(existing.value.__context.head);
-        const entry = await this._resolveEntry(existing.context.head, {
-            remote: true,
-        });
-        return this.log.append(new DeleteOperation({
-            key,
-        }), {
-            ...options,
-            meta: {
-                next: [entry],
-                type: EntryType.CUT,
-                ...options?.meta,
-            },
-        });
-    }
-    async handleChanges(change, reference) {
-        const isAppendOperation = change?.added.length === 1 ? !!change.added[0] : false;
-        const removedSet = new Map();
-        for (const r of change.removed) {
-            removedSet.set(r.hash, r);
-        }
-        const sortedEntries = [
-            ...change.added.map((x) => x.entry),
-            ...((await Promise.all(change.removed.map((x) => x instanceof Entry ? x : this.log.log.entryIndex.get(x.hash)))) || []),
-        ]; // TODO assert sorting
-        /*  const sortedEntries = [...change.added, ...(removed || [])]
-                    .sort(this.log.log.sortFn)
-                    .reverse(); // sort so we get newest to oldest */
-        // There might be a case where change.added and change.removed contains the same document id. Usaully because you use the "trim" option
-        // in combinatpion with inserting the same document. To mitigate this, we loop through the changes and modify the behaviour for this
-        let documentsChanged = {
-            added: [],
-            removed: [],
-        };
-        let modified = new Set();
-        for (const item of sortedEntries) {
-            if (!item) {
-                continue;
+        async handleChanges(change, reference) {
+            logger.trace("handleChanges called", change);
+            const isAppendOperation = change?.added.length === 1 ? !!change.added[0] : false;
+            const removedSet = new Map();
+            for (const r of change.removed) {
+                removedSet.set(r.hash, r);
             }
-            try {
-                const payload = 
-                /* item._payload instanceof DecryptedThing
-                    ? item.payload.getValue(item.encoding)
-                    :  */ await item.getPayloadValue(); // TODO implement sync api for resolving entries that does not deep decryption
-                if (isPutOperation(payload) && !removedSet.has(item.hash)) {
-                    let value = (isAppendOperation &&
-                        reference?.operation === payload &&
-                        reference?.document) ||
-                        this.index.valueEncoding.decoder(payload.data);
-                    // get index key from value
-                    const keyObject = this.idResolver(value);
-                    const key = indexerTypes.toId(keyObject);
-                    // document is already updated with more recent entry
-                    if (modified.has(key.primitive)) {
-                        continue;
-                    }
-                    // if no casual ordering is used, use timestamps to order docs
-                    let existing = reference?.unique
-                        ? null
-                        : (await this._index.index.get(key)) || null;
-                    if (!this.strictHistory && existing) {
-                        // if immutable use oldest, else use newest
-                        let shouldIgnoreChange = this.immutable
-                            ? existing.value.__context.modified <
-                                item.meta.clock.timestamp.wallTime
-                            : existing.value.__context.modified >
-                                item.meta.clock.timestamp.wallTime;
-                        if (shouldIgnoreChange) {
-                            continue;
-                        }
-                    }
-                    // Program specific
-                    if (value instanceof Program) {
-                        // if replicator, then open
-                        value = await this.maybeSubprogramOpen(value);
-                    }
-                    const { context, indexable } = await this._index.put(value, key, item, existing);
-                    documentsChanged.added.push(coerceWithIndexed(coerceWithContext(value, context), indexable));
-                    modified.add(key.primitive);
+            const sortedEntries = [
+                ...change.added.map((x) => x.entry),
+                ...((await Promise.all(change.removed.map((x) => x instanceof Entry ? x : this.log.log.entryIndex.get(x.hash)))) || []),
+            ]; // TODO assert sorting
+            /*  const sortedEntries = [...change.added, ...(removed || [])]
+                        .sort(this.log.log.sortFn)
+                        .reverse(); // sort so we get newest to oldest */
+            // There might be a case where change.added and change.removed contains the same document id. Usaully because you use the "trim" option
+            // in combinatpion with inserting the same document. To mitigate this, we loop through the changes and modify the behaviour for this
+            let documentsChanged = {
+                added: [],
+                removed: [],
+            };
+            let modified = new Set();
+            for (const item of sortedEntries) {
+                if (!item) {
+                    continue;
                 }
-                else if ((isDeleteOperation(payload) && !removedSet.has(item.hash)) ||
-                    isPutOperation(payload) ||
-                    removedSet.has(item.hash)) {
-                    let value;
-                    let key;
-                    if (isPutOperation(payload)) {
-                        const valueWithoutContext = this.index.valueEncoding.decoder(payload.data);
-                        key = indexerTypes.toId(this.idResolver(valueWithoutContext));
+                try {
+                    const payload = 
+                    /* item._payload instanceof DecryptedThing
+                        ? item.payload.getValue(item.encoding)
+                        :  */ await item.getPayloadValue(); // TODO implement sync api for resolving entries that does not deep decryption
+                    if (isPutOperation(payload) && !removedSet.has(item.hash)) {
+                        let value = (isAppendOperation &&
+                            reference?.operation === payload &&
+                            reference?.document) ||
+                            this.index.valueEncoding.decoder(payload.data);
+                        // get index key from value
+                        const keyObject = this.idResolver(value);
+                        const key = indexerTypes.toId(keyObject);
                         // document is already updated with more recent entry
                         if (modified.has(key.primitive)) {
                             continue;
                         }
-                        // we try to fetch it anyway, because we need the context for the events
-                        const document = await this._index.get(key, {
-                            local: true,
-                            remote: false,
-                        });
-                        if (!document) {
-                            continue;
+                        // if no casual ordering is used, use timestamps to order docs
+                        let existing = reference?.unique
+                            ? null
+                            : (await this._index.index.get(key)) || null;
+                        if (!this.strictHistory && existing) {
+                            // if immutable use oldest, else use newest
+                            let shouldIgnoreChange = this.immutable
+                                ? existing.value.__context.modified <
+                                    item.meta.clock.timestamp.wallTime
+                                : existing.value.__context.modified >
+                                    item.meta.clock.timestamp.wallTime;
+                            if (shouldIgnoreChange) {
+                                continue;
+                            }
                         }
-                        value = document;
+                        // Program specific
+                        if (value instanceof Program) {
+                            // if replicator, then open
+                            value = await this.maybeSubprogramOpen(value);
+                        }
+                        const { context, indexable } = await this._index.put(value, key, item, existing);
+                        documentsChanged.added.push(coerceWithIndexed(coerceWithContext(value, context), indexable));
+                        modified.add(key.primitive);
                     }
-                    else if (isDeleteOperation(payload)) {
-                        key = coerceDeleteOperation(payload).key;
-                        // document is already updated with more recent entry
-                        if (modified.has(key.primitive)) {
-                            continue;
+                    else if ((isDeleteOperation(payload) && !removedSet.has(item.hash)) ||
+                        isPutOperation(payload) ||
+                        removedSet.has(item.hash)) {
+                        let value;
+                        let key;
+                        if (isPutOperation(payload)) {
+                            const valueWithoutContext = this.index.valueEncoding.decoder(payload.data);
+                            key = indexerTypes.toId(this.idResolver(valueWithoutContext));
+                            // document is already updated with more recent entry
+                            if (modified.has(key.primitive)) {
+                                continue;
+                            }
+                            // we try to fetch it anyway, because we need the context for the events
+                            const document = await this._index.get(key, {
+                                local: true,
+                                remote: false,
+                            });
+                            if (!document) {
+                                continue;
+                            }
+                            value = document;
                         }
-                        const document = await this._index.get(key, {
-                            local: true,
-                            remote: false,
-                        });
-                        if (!document) {
-                            continue;
+                        else if (isDeleteOperation(payload)) {
+                            key = coerceDeleteOperation(payload).key;
+                            // document is already updated with more recent entry
+                            if (modified.has(key.primitive)) {
+                                continue;
+                            }
+                            const document = await this._index.get(key, {
+                                local: true,
+                                remote: false,
+                            });
+                            if (!document) {
+                                continue;
+                            }
+                            value = document;
+                        }
+                        else {
+                            throw new Error("Unexpected");
+                        }
+                        documentsChanged.removed.push(value);
+                        if (value instanceof Program &&
+                            value.closed !== true &&
+                            value.parents.includes(this)) {
+                            await value.drop(this);
                         }
-                        value = document;
+                        // update index
+                        await this._index.del(key);
+                        modified.add(key.primitive);
                     }
                     else {
-                        throw new Error("Unexpected");
+                        // Unknown operation
+                        throw new OperationError("Unknown operation");
                     }
-                    documentsChanged.removed.push(value);
-                    if (value instanceof Program &&
-                        value.closed !== true &&
-                        value.parents.includes(this)) {
-                        await value.drop(this);
-                    }
-                    // update index
-                    await this._index.del(key);
-                    modified.add(key.primitive);
-                }
-                else {
-                    // Unknown operation
-                    throw new OperationError("Unknown operation");
                 }
-            }
-            catch (error) {
-                if (error instanceof AccessError) {
-                    continue;
+                catch (error) {
+                    if (error instanceof AccessError) {
+                        continue;
+                    }
+                    throw error;
                 }
-                throw error;
             }
+            this.events.dispatchEvent(new CustomEvent("change", { detail: documentsChanged }));
         }
-        this.events.dispatchEvent(new CustomEvent("change", { detail: documentsChanged }));
-    }
-    // approximate the amount of documents that exists globally
-    async count(options) {
-        let isReplicating = await this.log.isReplicating();
-        if (!isReplicating) {
-            // fetch a subset of posts
-            const iterator = this.index.iterate({ query: options?.query }, {
-                remote: {
-                    reach: typeof options?.approximate === "object"
-                        ? options?.approximate.scope
-                        : undefined,
-                },
-                resolve: false,
+        // approximate the amount of documents that exists globally
+        async count(options) {
+            let isReplicating = await this.log.isReplicating();
+            if (!isReplicating) {
+                // fetch a subset of posts
+                const iterator = this.index.iterate({ query: options?.query }, {
+                    remote: {
+                        reach: typeof options?.approximate === "object"
+                            ? options?.approximate.scope
+                            : undefined,
+                    },
+                    resolve: false,
+                });
+                const one = await iterator.next(1);
+                const left = (await iterator.pending()) ?? 0;
+                await iterator.close();
+                return one.length + left;
+            }
+            let totalHeadCount = await this.log.countHeads({ approximate: true }); /* -
+                (this.keepCache?.size || 0); TODO adjust for keep fn */
+            let totalAssignedHeads = await this.log.countAssignedHeads({
+                strict: false,
             });
-            const one = await iterator.next(1);
-            const left = (await iterator.pending()) ?? 0;
-            await iterator.close();
-            return one.length + left;
-        }
-        let totalHeadCount = await this.log.countHeads({ approximate: true }); /* -
-            (this.keepCache?.size || 0); TODO adjust for keep fn */
-        let totalAssignedHeads = await this.log.countAssignedHeads({
-            strict: false,
-        });
-        let indexedDocumentsCount = await this.index.index.count({
-            query: options?.query,
-        });
-        if (totalAssignedHeads == 0) {
-            return indexedDocumentsCount; // TODO is this really expected?
+            let indexedDocumentsCount = await this.index.index.count({
+                query: options?.query,
+            });
+            if (totalAssignedHeads == 0) {
+                return indexedDocumentsCount; // TODO is this really expected?
+            }
+            const nonDeletedDocumentsRatio = indexedDocumentsCount / totalAssignedHeads; // [0, 1]
+            let expectedAmountOfDocuments = totalHeadCount * nonDeletedDocumentsRatio; // if total heads count is 100 and 80% is actual documents, then 80 pieces of non-deleted documents should exist
+            return Math.round(expectedAmountOfDocuments);
         }
-        const nonDeletedDocumentsRatio = indexedDocumentsCount / totalAssignedHeads; // [0, 1]
-        let expectedAmountOfDocuments = totalHeadCount * nonDeletedDocumentsRatio; // if total heads count is 100 and 80% is actual documents, then 80 pieces of non-deleted documents should exist
-        return Math.round(expectedAmountOfDocuments);
-    }
-};
-__decorate([
-    field({ type: SharedLog }),
-    __metadata("design:type", SharedLog)
-], Documents.prototype, "log", void 0);
-__decorate([
-    field({ type: "bool" }),
-    __metadata("design:type", Boolean)
-], Documents.prototype, "immutable", void 0);
-__decorate([
-    field({ type: DocumentIndex }),
-    __metadata("design:type", DocumentIndex)
-], Documents.prototype, "_index", void 0);
-Documents = __decorate([
-    variant("documents"),
-    __metadata("design:paramtypes", [Object])
-], Documents);
+    };
+    return Documents = _classThis;
+})();
 export { Documents };
 //# sourceMappingURL=program.js.map