@peerbit/document 15.0.12 → 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) => {
@@ -1027,9 +1099,11 @@ let Documents = (() => {
          * Those callers must keep throwing: outside change delivery, a closed index is
          * a caller error, not a state to paper over.
          */
-        getLocalIndexedContextForChange(key) {
+        getLocalIndexedContextForChange(key, orderedSession) {
             try {
-                const result = this.getLocalIndexedContext(key);
+                const result = (orderedSession
+                    ? orderedSession.get(key, { shape: INDEX_CONTEXT_SHAPE })
+                    : this.getLocalIndexedContext(key));
                 return (isPromiseLike(result)
                     ? result.catch((error) => this.recoverClosedIndexContextRead(error))
                     : result);
@@ -1214,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;
@@ -1250,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();
@@ -1291,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,
@@ -1314,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,
@@ -1373,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,
@@ -1420,7 +1506,7 @@ let Documents = (() => {
                             value: deleteValue,
                             operation,
                             entry: entry,
-                        }))) {
+                        })))) {
                         return false;
                     }
                 }
@@ -1483,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
@@ -1494,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;
@@ -1510,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) => {
@@ -1552,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);
@@ -1562,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);
                         }
                     }
@@ -1594,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) {
@@ -1603,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) {
@@ -1612,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) {
@@ -1669,7 +1770,6 @@ let Documents = (() => {
                 else {
                     throw new Error("Unsupported operation");
                 }
-                return operation;
             }
             catch (error) {
                 if (error instanceof AccessError) {
@@ -3320,6 +3420,15 @@ let Documents = (() => {
         }
         async handleChanges(change, reference) {
             logger.trace("handleChanges called", change);
+            if (reference == null &&
+                change.added.length >= 2 &&
+                !this.isNativeMode() &&
+                this._index.canUseOrderedWriteSession()) {
+                return this._index.withOrderedWriteSession((orderedSession) => this.handleChangesInOrder(change, reference, orderedSession));
+            }
+            return this.handleChangesInOrder(change, reference);
+        }
+        async handleChangesInOrder(change, reference, orderedSession) {
             const isAppendOperation = change?.added.length === 1 ? !!change.added[0] : false;
             const removedSet = new Map();
             for (const r of change.removed) {
@@ -3348,6 +3457,7 @@ let Documents = (() => {
             let modified = new Set();
             for (const item of sortedEntries) {
                 if (!item) {
+                    await orderedSession?.flush();
                     continue;
                 }
                 try {
@@ -3358,6 +3468,7 @@ let Documents = (() => {
                         ? reference.operation
                         : await this.getAppendOperation(item);
                     if (!payload) {
+                        await orderedSession?.flush();
                         continue;
                     }
                     if (isPutOperation(payload) && !removedSet.has(item.hash)) {
@@ -3391,14 +3502,20 @@ 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
+                            // their callback and event semantics are proven independently.
+                            await orderedSession?.flush();
                             continue;
                         }
                         // if no casual ordering is used, use timestamps to order docs
@@ -3408,7 +3525,7 @@ let Documents = (() => {
                                 ? reference.existing
                                 : this.isNativeMode()
                                     ? this.getNativeModeIndexedContext(key) || null
-                                    : (await this.getLocalIndexedContextForChange(key)) || null;
+                                    : (await this.getLocalIndexedContextForChange(key, orderedSession)) || null;
                         if (!this.strictHistory && existing) {
                             // if immutable use oldest, else use newest
                             let shouldIgnoreChange = this.immutable
@@ -3417,9 +3534,16 @@ let Documents = (() => {
                                 : existing.value.__context.modified >
                                     item.meta.clock.timestamp.wallTime;
                             if (shouldIgnoreChange) {
+                                await orderedSession?.flush();
                                 continue;
                             }
                         }
+                        const useOrderedWrite = orderedSession != null &&
+                            existing == null &&
+                            !(value instanceof Program);
+                        if (!useOrderedWrite) {
+                            await orderedSession?.flush();
+                        }
                         // Program specific
                         if (value instanceof Program) {
                             // if replicator, then open
@@ -3433,13 +3557,14 @@ let Documents = (() => {
                             modified.add(key.primitive);
                             continue;
                         }
-                        const { context, indexable } = await this._index.put(value, key, item, existing);
+                        const { context, indexable } = await this._index.put(value, key, item, existing, useOrderedWrite ? orderedSession : undefined);
                         documentsChanged?.added.push(coerceWithIndexed(coerceWithContext(value, context), indexable));
                         modified.add(key.primitive);
                     }
                     else if ((isDeleteOperation(payload) && !removedSet.has(item.hash)) ||
                         isPutOperation(payload) ||
                         removedSet.has(item.hash)) {
+                        await orderedSession?.flush();
                         if (!documentsChanged &&
                             (await this.collectRemovedPutChangeFromNativeId(payload, modified))) {
                             continue;
@@ -3453,11 +3578,13 @@ let Documents = (() => {
                 }
                 catch (error) {
                     if (error instanceof AccessError) {
+                        await orderedSession?.flush();
                         continue;
                     }
                     throw error;
                 }
             }
+            await orderedSession?.flush();
             if (canRemoveByIndexedHead && change.removed.length > 0) {
                 const handled = await this.collectRemovedDocumentChangesFromIndexedHeads(change.removed, modified);
                 const remainingRemoved = change.removed.filter((entry) => !handled.has(entry.hash));