@peerbit/document 15.0.13 → 15.0.14

package/dist/src/program.js

@@ -32,7 +32,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { BorshError, field, serialize, variant, } from "@dao-xyz/borsh";
+import { BorshError, deserialize, field, serialize, variant, } from "@dao-xyz/borsh";
 import { AccessError } from "@peerbit/crypto";
 import { Context, NotFoundError, } from "@peerbit/document-interface";
 import { extractDocumentFieldSimple, initializeDocumentRust, planDocumentContext, planDocumentContextBatch, tryPlanDocumentContext, tryPlanDocumentContextBatch, } from "./native-rust.js";
@@ -41,6 +41,7 @@ import { Entry, EntryType, LamportClock, ShallowEntry, ShallowMeta, Timestamp, e
 import { logger as loggerFn } from "@peerbit/logger";
 import { Program } from "@peerbit/program";
 import { SharedLog, } from "@peerbit/shared-log";
+import { detachCanPerformCallbackProperties, detachEntryPayloadForCallback, } from "./callback-detachment.js";
 import { MAX_BATCH_SIZE } from "./constants.js";
 import { BORSH_ENCODING_OPERATION, DeleteOperation, PutOperation, PutWithKeyOperation, coerceDeleteOperation, isDeleteOperation, isPutOperation, } from "./operation.js";
 import { createCanPerformPolicyEvaluator, createCanPerformDeletePolicyEvaluator, getCanPerformPolicyDescriptor, canPerformPolicyDeleteFieldPaths, canPerformPolicyNeedsDeleteValue, canPerformPolicyNeedsPreviousEntries, canPerformPolicyPutNeedsEntryPublicKeys, canPerformPolicySignedByFieldPaths, } from "./policy.js";
@@ -392,9 +393,16 @@ let Documents = (() => {
         _documentChangeListenerTrackingInitialized = false;
         _documentBackend;
         _canAppendDecodedDocuments = new WeakMap();
+        acceptPutOperation(operation, document, hasDocument) {
+            if (hasDocument) {
+                this._canAppendDecodedDocuments.set(operation, document);
+            }
+            return operation;
+        }
         _nativeDocumentIdExtractionPlan;
         _nativeDocumentFieldExtractionPlans;
         _hasLogTrim = false;
+        _hasCustomIdResolver = false;
         idResolver;
         domain;
         strictHistory;
@@ -418,6 +426,70 @@ let Documents = (() => {
                 ? new NativeDocumentBackend(this.createNativeDocumentBackendContext())
                 : new CompatDocumentBackend(this.putCompatDocumentBackend.bind(this), this.putManyCompatDocumentBackend.bind(this), this.delCompatDocumentBackend.bind(this));
         }
+        detachDomainEntryCallback(domain) {
+            const boundMethods = new Map();
+            const detachedFromEntry = (entry) => {
+                const fromEntry = Reflect.get(domain, "fromEntry", domain);
+                return Reflect.apply(fromEntry, domain, [
+                    entry instanceof Entry
+                        ? detachEntryPayloadForCallback(entry)
+                        : entry,
+                ]);
+            };
+            const facade = Object.create(Object.getPrototypeOf(domain));
+            let callbackDomain;
+            callbackDomain = new Proxy(facade, {
+                get(_target, property) {
+                    if (property === "fromEntry") {
+                        return detachedFromEntry;
+                    }
+                    if (property === "valueOf") {
+                        return () => callbackDomain;
+                    }
+                    const value = Reflect.get(domain, property, domain);
+                    if (property === "constructor" || typeof value !== "function") {
+                        return value;
+                    }
+                    const existing = boundMethods.get(property);
+                    if (existing && existing.source === value) {
+                        return existing.bound;
+                    }
+                    const bound = value.bind(domain);
+                    boundMethods.set(property, { source: value, bound });
+                    return bound;
+                },
+                set(_target, property, value) {
+                    return Reflect.set(domain, property, value, domain);
+                },
+                has(_target, property) {
+                    return Reflect.has(domain, property);
+                },
+                ownKeys() {
+                    return Reflect.ownKeys(domain);
+                },
+                getOwnPropertyDescriptor(_target, property) {
+                    const descriptor = Reflect.getOwnPropertyDescriptor(domain, property);
+                    if (!descriptor) {
+                        return undefined;
+                    }
+                    if (property === "fromEntry") {
+                        return "value" in descriptor
+                            ? {
+                                ...descriptor,
+                                value: detachedFromEntry,
+                                configurable: true,
+                            }
+                            : {
+                                ...descriptor,
+                                get: () => detachedFromEntry,
+                                configurable: true,
+                            };
+                    }
+                    return { ...descriptor, configurable: true };
+                },
+            });
+            return callbackDomain;
+        }
         createNativeDocumentBackendContext() {
             return {
                 assertPlainPutSupported: (doc, options) => {
@@ -1216,6 +1288,7 @@ let Documents = (() => {
                 (typeof idProperty === "string"
                     ? (obj) => obj[idProperty]
                     : (obj) => indexerTypes.extractFieldValue(obj, idProperty));
+            this._hasCustomIdResolver = options.id != null;
             this.idResolver = idResolver;
             this.strictHistory = options.strictHistory ?? false;
             this._hasLogTrim = options.log?.trim != null;
@@ -1252,7 +1325,9 @@ let Documents = (() => {
             // B12: the historical document->log compatibility mapping (6 -> log v8,
             // 7 -> log v9) is retired; the rejection at the top of open() fires for
             // any defined value before this point.
-            this.domain = options.domain?.(this);
+            this.domain = options.domain
+                ? this.detachDomainEntryCallback(options.domain(this))
+                : undefined;
             let keepFunction;
             if (options?.keep === "self") {
                 this.keepCache = new Set();
@@ -1293,7 +1368,16 @@ let Documents = (() => {
                 };
             }
             else {
-                keepFunction = options?.keep;
+                const keep = options?.keep;
+                keepFunction = keep
+                    ? function (entry) {
+                        return Reflect.apply(keep, this, [
+                            entry instanceof Entry
+                                ? detachEntryPayloadForCallback(entry)
+                                : entry,
+                        ]);
+                    }
+                    : undefined;
             }
             await this.log.open({
                 encoding: BORSH_ENCODING_OPERATION,
@@ -1316,7 +1400,7 @@ let Documents = (() => {
                 distributionDebounceTime: options?.distributionDebounceTime,
                 strictFullReplicaFallback: false,
                 domain: options?.domain
-                    ? () => options.domain(this)
+                    ? () => this.detachDomainEntryCallback(options.domain(this))
                     : undefined,
                 eagerBlocks: options?.eagerBlocks,
                 fanout: options?.fanout,
@@ -1375,41 +1459,41 @@ let Documents = (() => {
                 return false;
             }
             try {
-                let operation = l0;
+                const operation = l0;
                 if (this._optionCanPerform) {
                     if (this._optionCanPerformNativePolicy && this.isNativeMode()) {
                         return this.nativeCanPerformAllowsAppend(this._optionCanPerformNativePolicy, operation, entry, reference?.document);
                     }
-                    let document = reference?.document;
-                    if (!document) {
-                        if (isPutOperation(l0)) {
-                            document =
-                                this._canAppendDecodedDocuments.get(l0) ??
-                                    this._index.valueEncoding.decoder(l0.data);
-                            if (!document) {
-                                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");
+                    let document;
+                    if (isPutOperation(l0)) {
+                        const cachedDocument = this._canAppendDecodedDocuments.get(l0);
+                        this._canAppendDecodedDocuments.delete(l0);
+                        document =
+                            cachedDocument ??
+                                this._index.valueEncoding.decoder(new Uint8Array(l0.data));
+                        if (!document) {
+                            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");
+                    }
                     const previousEntries = this._optionCanPerformNativePolicy &&
                         isPutOperation(operation) &&
                         canPerformPolicyNeedsPreviousEntries(this._optionCanPerformNativePolicy)
-                        ? await this.resolveCanPerformPreviousEntries(entry)
+                        ? (await this.resolveCanPerformPreviousEntries(entry)).map(detachEntryPayloadForCallback)
                         : undefined;
                     const deleteValue = this._optionCanPerformNativePolicy &&
                         isDeleteOperation(operation) &&
                         canPerformPolicyNeedsDeleteValue(this._optionCanPerformNativePolicy)
                         ? await this.resolveCanPerformDeleteValue(operation)
                         : undefined;
-                    if (!(await this._optionCanPerform(isPutOperation(operation)
+                    if (!(await this._optionCanPerform(detachCanPerformCallbackProperties(isPutOperation(operation)
                         ? {
                             type: "put",
                             value: document,
@@ -1422,7 +1506,7 @@ let Documents = (() => {
                             value: deleteValue,
                             operation,
                             entry: entry,
-                        }))) {
+                        })))) {
                         return false;
                     }
                 }
@@ -1485,6 +1569,9 @@ let Documents = (() => {
             }
             return entries;
         }
+        detachDocumentValueForCallback(document) {
+            return this._index.valueEncoding.decoder(this._index.valueEncoding.encoder(document));
+        }
         async resolveCanPerformDeleteValue(operation, options) {
             const key = operation.key instanceof indexerTypes.IdKey
                 ? operation.key
@@ -1496,11 +1583,11 @@ let Documents = (() => {
             }
             const indexedDocument = await this.getLocalIdentityDocumentByHead(existingHead);
             if (indexedDocument) {
-                return indexedDocument;
+                return this.detachDocumentValueForCallback(indexedDocument);
             }
             const indexedPolicyDocument = await this.getLocalIndexedDocumentForNativeDeletePolicy(key);
             if (indexedPolicyDocument) {
-                return indexedPolicyDocument;
+                return deserialize(serialize(indexedPolicyDocument), this._index.indexedType);
             }
             if (options?.allowEntryFallback === false) {
                 return;
@@ -1512,7 +1599,7 @@ let Documents = (() => {
             if (!isPutOperation(existingOperation)) {
                 return;
             }
-            return this._index.valueEncoding.decoder(existingOperation.data);
+            return this._index.valueEncoding.decoder(new Uint8Array(existingOperation.data));
         }
         async _canAppend(entry, reference) {
             const resolve = async (history) => {
@@ -1554,9 +1641,13 @@ let Documents = (() => {
                 if (isPutOperation(operation)) {
                     // check nexts
                     const putOperation = operation;
+                    let decodedDocumentForCanPerform;
+                    let hasDecodedDocumentForCanPerform = false;
                     let keyValue;
                     if (reference?.document) {
-                        keyValue = this.idResolver(reference.document);
+                        keyValue = this.idResolver(this._hasCustomIdResolver
+                            ? this.index.valueEncoding.decoder(new Uint8Array(putOperation.data))
+                            : reference.document);
                     }
                     else {
                         keyValue = await this.getNativeDocumentIdFromPutOperation(putOperation);
@@ -1564,8 +1655,13 @@ let Documents = (() => {
                             if (this.isNativeMode()) {
                                 return false;
                             }
-                            const value = this.index.valueEncoding.decoder(putOperation.data);
-                            this._canAppendDecodedDocuments.set(putOperation, value);
+                            const value = this.index.valueEncoding.decoder(this._hasCustomIdResolver || this._optionCanPerform
+                                ? new Uint8Array(putOperation.data)
+                                : putOperation.data);
+                            if (this._optionCanPerform && !this._hasCustomIdResolver) {
+                                decodedDocumentForCanPerform = value;
+                                hasDecodedDocumentForCanPerform = true;
+                            }
                             keyValue = this.idResolver(value);
                         }
                     }
@@ -1596,7 +1692,7 @@ let Documents = (() => {
                             if (entry.meta.next.length > 0) {
                                 return false; // can not append to immutable document
                             }
-                            return putOperation;
+                            return this.acceptPutOperation(putOperation, decodedDocumentForCanPerform, hasDecodedDocumentForCanPerform);
                         }
                         else {
                             if (this.strictHistory) {
@@ -1605,7 +1701,7 @@ let Documents = (() => {
                                     return false;
                                 }
                                 if (entry.meta.next[0] === existingContext.head) {
-                                    return putOperation;
+                                    return this.acceptPutOperation(putOperation, decodedDocumentForCanPerform, hasDecodedDocumentForCanPerform);
                                 }
                                 const prevEntry = await this.log.log.entryIndex.get(existingContext.head);
                                 if (!prevEntry) {
@@ -1614,16 +1710,19 @@ let Documents = (() => {
                                     return false;
                                 }
                                 const referenceHistoryCorrectly = await pointsToHistory(prevEntry);
-                                return referenceHistoryCorrectly ? putOperation : false;
+                                return referenceHistoryCorrectly
+                                    ? this.acceptPutOperation(putOperation, decodedDocumentForCanPerform, hasDecodedDocumentForCanPerform)
+                                    : false;
                             }
                             else {
-                                return putOperation;
+                                return this.acceptPutOperation(putOperation, decodedDocumentForCanPerform, hasDecodedDocumentForCanPerform);
                             }
                         }
                     }
                     else {
                         // Keep existing behavior: next pointers may express document dependencies.
                     }
+                    return this.acceptPutOperation(putOperation, decodedDocumentForCanPerform, hasDecodedDocumentForCanPerform);
                 }
                 else if (isDeleteOperation(operation)) {
                     if (entry.meta.next.length !== 1) {
@@ -1671,7 +1770,6 @@ let Documents = (() => {
                 else {
                     throw new Error("Unsupported operation");
                 }
-                return operation;
             }
             catch (error) {
                 if (error instanceof AccessError) {
@@ -3404,12 +3502,15 @@ let Documents = (() => {
                                 }
                             }
                         }
-                        let value = (isReferencedAppendEntry && reference?.document) ||
-                            this.index.valueEncoding.decoder(payload.data);
+                        let value = isReferencedAppendEntry && reference?.document
+                            ? reference.document
+                            : this.index.valueEncoding.decoder(new Uint8Array(payload.data));
                         // get index key from value
                         const key = isReferencedAppendEntry && reference?.key
                             ? reference.key
-                            : indexerTypes.toId(this.idResolver(value));
+                            : indexerTypes.toId(this.idResolver(this._hasCustomIdResolver
+                                ? this.index.valueEncoding.decoder(new Uint8Array(payload.data))
+                                : value));
                         // document is already updated with more recent entry
                         if (modified.has(key.primitive)) {
                             // Duplicate ids deliberately retain the scalar boundary until