payload 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

package/dist/collections/operations/utilities/createOperationRetryRequest.js

@@ -0,0 +1,683 @@
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isConcurrentShadowOperationError } from '../../../branching/createShadowRow.js';
+import { refreshBranchState, resetBranchState } from '../../../branching/resolveBranch.js';
+import { createPayloadRequest } from '../../../utilities/createPayloadRequest.js';
+import { isolateObjectProperty } from '../../../utilities/isolateObjectProperty.js';
+import { createIsolatedDeferredCleanupContext, deferredCleanupScopeContextKey } from '../../../utilities/transactionCallbacks.js';
+const createRetryCloneGraph = ()=>({
+        clonesByOriginal: new WeakMap(),
+        isRetrySafe: true,
+        originalsByClone: new WeakMap()
+    });
+const recordRetryClone = ({ clone, graph, original })=>{
+    graph.clonesByOriginal.set(original, clone);
+    graph.originalsByClone.set(clone, original);
+};
+const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+const maximumRetrySafeIndexedPropertyCount = 65_536;
+const markValueAsRetryUnsafe = ({ graph, value })=>{
+    graph.isRetrySafe = false;
+    recordRetryClone({
+        clone: value,
+        graph,
+        original: value
+    });
+};
+const isArrayIndexProperty = (key)=>{
+    if (typeof key !== 'string' || key === '') {
+        return false;
+    }
+    const index = Number(key);
+    return Number.isInteger(index) && index >= 0 && index < 4_294_967_295 && String(index) === key;
+};
+const isSupportedArrayBufferViewPrototype = ({ value })=>{
+    const prototype = Object.getPrototypeOf(value);
+    if (Buffer.isBuffer(value)) {
+        return prototype === Buffer.prototype;
+    }
+    if (value instanceof DataView) {
+        return prototype === DataView.prototype;
+    }
+    return Object.getPrototypeOf(prototype) === typedArrayPrototype;
+};
+const markUnsupportedSpecialObjectAsRetryUnsafe = ({ expectedPrototype, graph, isAllowedOwnProperty = ()=>false, value })=>{
+    const hasSupportedPrototype = expectedPrototype ? Object.getPrototypeOf(value) === expectedPrototype : isSupportedArrayBufferViewPrototype({
+        value: value
+    });
+    if (!hasSupportedPrototype) {
+        markValueAsRetryUnsafe({
+            graph,
+            value
+        });
+        return true;
+    }
+    const hasUnsupportedOwnProperty = Reflect.ownKeys(value).some((key)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return !descriptor || !isAllowedOwnProperty({
+            descriptor,
+            key
+        });
+    });
+    if (!hasUnsupportedOwnProperty) {
+        return false;
+    }
+    markValueAsRetryUnsafe({
+        graph,
+        value
+    });
+    return true;
+};
+const cloneRetrySafeValue = (value, graph = createRetryCloneGraph())=>{
+    if (typeof value === 'function') {
+        graph.isRetrySafe = false;
+        return value;
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const existingClone = graph.clonesByOriginal.get(value);
+    if (existingClone) {
+        return existingClone;
+    }
+    if (value instanceof Date) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: Date.prototype,
+            graph,
+            value
+        })) {
+            return value;
+        }
+        const clone = new Date(value);
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        return clone;
+    }
+    if (value instanceof RegExp) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: RegExp.prototype,
+            graph,
+            isAllowedOwnProperty: ({ descriptor, key })=>key === 'lastIndex' && 'value' in descriptor,
+            value
+        })) {
+            return value;
+        }
+        const clone = new RegExp(value.source, value.flags);
+        clone.lastIndex = value.lastIndex;
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        return clone;
+    }
+    if (value instanceof Headers) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: Headers.prototype,
+            graph,
+            value
+        })) {
+            return value;
+        }
+        const clone = new Headers(value);
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        return clone;
+    }
+    if (value instanceof URL) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: URL.prototype,
+            graph,
+            value
+        })) {
+            return value;
+        }
+        const clone = new URL(value);
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        return clone;
+    }
+    if (value instanceof URLSearchParams) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: URLSearchParams.prototype,
+            graph,
+            value
+        })) {
+            return value;
+        }
+        const clone = new URLSearchParams(value);
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        return clone;
+    }
+    if (isSharedArrayBuffer(value)) {
+        graph.isRetrySafe = false;
+        recordRetryClone({
+            clone: value,
+            graph,
+            original: value
+        });
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: ArrayBuffer.prototype,
+            graph,
+            value
+        })) {
+            return value;
+        }
+        const clone = structuredClone(value);
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        return clone;
+    }
+    if (ArrayBuffer.isView(value)) {
+        if (isSharedArrayBuffer(value.buffer)) {
+            graph.isRetrySafe = false;
+            recordRetryClone({
+                clone: value,
+                graph,
+                original: value
+            });
+            return value;
+        }
+        if (!isSupportedArrayBufferViewPrototype({
+            value
+        })) {
+            markValueAsRetryUnsafe({
+                graph,
+                value
+            });
+            return value;
+        }
+        const indexedPropertyCount = 'length' in value && typeof value.length === 'number' ? value.length : 0;
+        if (indexedPropertyCount > maximumRetrySafeIndexedPropertyCount) {
+            markValueAsRetryUnsafe({
+                graph,
+                value
+            });
+            return value;
+        }
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            graph,
+            isAllowedOwnProperty: ({ descriptor, key })=>isArrayIndexProperty(key) && 'value' in descriptor,
+            value
+        })) {
+            return value;
+        }
+        const clonedBuffer = cloneRetrySafeValue(value.buffer, graph);
+        const clone = createArrayBufferView({
+            buffer: clonedBuffer,
+            source: value
+        });
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        return clone;
+    }
+    if (Array.isArray(value)) {
+        if (value.length > maximumRetrySafeIndexedPropertyCount) {
+            markValueAsRetryUnsafe({
+                graph,
+                value
+            });
+            return value;
+        }
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: Array.prototype,
+            graph,
+            isAllowedOwnProperty: ({ descriptor, key })=>(key === 'length' || isArrayIndexProperty(key)) && 'value' in descriptor,
+            value
+        })) {
+            return value;
+        }
+        const clone = [];
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        for (const entry of value){
+            clone.push(cloneRetrySafeValue(entry, graph));
+        }
+        mirrorObjectIntegrity({
+            source: value,
+            target: clone
+        });
+        return clone;
+    }
+    if (value instanceof Map) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: Map.prototype,
+            graph,
+            value
+        })) {
+            return value;
+        }
+        const clone = new Map();
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        for (const [key, entry] of value){
+            clone.set(cloneRetrySafeValue(key, graph), cloneRetrySafeValue(entry, graph));
+        }
+        return clone;
+    }
+    if (value instanceof Set) {
+        if (markUnsupportedSpecialObjectAsRetryUnsafe({
+            expectedPrototype: Set.prototype,
+            graph,
+            value
+        })) {
+            return value;
+        }
+        const clone = new Set();
+        recordRetryClone({
+            clone,
+            graph,
+            original: value
+        });
+        for (const entry of value){
+            clone.add(cloneRetrySafeValue(entry, graph));
+        }
+        return clone;
+    }
+    if (hasUncloneableInternalState({
+        value
+    })) {
+        graph.isRetrySafe = false;
+        recordRetryClone({
+            clone: value,
+            graph,
+            original: value
+        });
+        return value;
+    }
+    const clone = Object.create(Object.getPrototypeOf(value));
+    recordRetryClone({
+        clone,
+        graph,
+        original: value
+    });
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor) {
+            continue;
+        }
+        if (!('value' in descriptor)) {
+            graph.isRetrySafe = false;
+        } else {
+            descriptor.value = cloneRetrySafeValue(descriptor.value, graph);
+        }
+        Object.defineProperty(clone, key, descriptor);
+    }
+    mirrorObjectIntegrity({
+        source: value,
+        target: clone
+    });
+    return clone;
+};
+const isSharedArrayBuffer = (value)=>typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer;
+const hasUncloneableInternalState = ({ value })=>{
+    let prototype = Object.getPrototypeOf(value);
+    while(prototype && prototype !== Object.prototype){
+        const constructor = prototype.constructor;
+        const constructorSource = typeof constructor === 'function' ? Function.prototype.toString.call(constructor) : '';
+        const hasPrototypeMethods = Reflect.ownKeys(prototype).some((key)=>key !== 'constructor');
+        if (constructorSource.includes('[native code]') || /#[a-z_$]/i.test(constructorSource) || hasPrototypeMethods) {
+            return true;
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return false;
+};
+const createArrayBufferView = ({ buffer, source })=>{
+    if (Buffer.isBuffer(source)) {
+        return Buffer.from(buffer, source.byteOffset, source.byteLength);
+    }
+    if (source instanceof DataView) {
+        return new DataView(buffer, source.byteOffset, source.byteLength);
+    }
+    const TypedArray = source.constructor;
+    return new TypedArray(buffer, source.byteOffset, source.length);
+};
+const mirrorObjectIntegrity = ({ source, target })=>{
+    if (Object.isFrozen(source)) {
+        Object.freeze(target);
+    } else if (Object.isSealed(source)) {
+        Object.seal(target);
+    } else if (!Object.isExtensible(source)) {
+        Object.preventExtensions(target);
+    }
+};
+const synchronizeRetrySafeValue = ({ allowUnprovenTargetReuse = false, deleteMissingProperties = true, originalsByClone, preservedMissingTargetKeys, source, synchronizedTargets = new WeakMap(), target })=>{
+    if (!source || typeof source !== 'object') {
+        return source;
+    }
+    const synchronizedTarget = synchronizedTargets.get(source);
+    const originalValue = originalsByClone.get(source);
+    const targetValue = originalValue ?? (allowUnprovenTargetReuse ? target : undefined);
+    if (source instanceof ArrayBuffer) {
+        const synchronizedBuffer = synchronizedTarget instanceof ArrayBuffer && synchronizedTarget.byteLength === source.byteLength ? synchronizedTarget : targetValue instanceof ArrayBuffer && targetValue.byteLength === source.byteLength ? targetValue : new ArrayBuffer(source.byteLength);
+        synchronizedTargets.set(source, synchronizedBuffer);
+        new Uint8Array(synchronizedBuffer).set(new Uint8Array(source));
+        return synchronizedBuffer;
+    }
+    if (synchronizedTarget) {
+        return synchronizedTarget;
+    }
+    if (Object.is(source, targetValue)) {
+        synchronizedTargets.set(source, targetValue);
+        return targetValue;
+    }
+    if (source instanceof Date) {
+        const synchronizedDate = targetValue instanceof Date ? targetValue : new Date(source);
+        synchronizedTargets.set(source, synchronizedDate);
+        synchronizedDate.setTime(source.getTime());
+        return synchronizedDate;
+    }
+    if (source instanceof RegExp) {
+        const synchronizedRegExp = targetValue instanceof RegExp && targetValue.source === source.source && targetValue.flags === source.flags ? targetValue : new RegExp(source.source, source.flags);
+        synchronizedTargets.set(source, synchronizedRegExp);
+        synchronizedRegExp.lastIndex = source.lastIndex;
+        return synchronizedRegExp;
+    }
+    if (source instanceof Headers) {
+        const synchronizedHeaders = targetValue instanceof Headers ? targetValue : new Headers();
+        synchronizedTargets.set(source, synchronizedHeaders);
+        for (const key of [
+            ...synchronizedHeaders.keys()
+        ]){
+            synchronizedHeaders.delete(key);
+        }
+        for (const [key, value] of source){
+            synchronizedHeaders.append(key, value);
+        }
+        return synchronizedHeaders;
+    }
+    if (source instanceof URL) {
+        const synchronizedURL = targetValue instanceof URL ? targetValue : new URL(source);
+        synchronizedTargets.set(source, synchronizedURL);
+        synchronizedURL.href = source.href;
+        return synchronizedURL;
+    }
+    if (source instanceof URLSearchParams) {
+        const synchronizedSearchParams = targetValue instanceof URLSearchParams ? targetValue : new URLSearchParams();
+        synchronizedTargets.set(source, synchronizedSearchParams);
+        for (const key of [
+            ...synchronizedSearchParams.keys()
+        ]){
+            synchronizedSearchParams.delete(key);
+        }
+        for (const [key, value] of source){
+            synchronizedSearchParams.append(key, value);
+        }
+        return synchronizedSearchParams;
+    }
+    if (ArrayBuffer.isView(source)) {
+        const sourceBuffer = source.buffer;
+        const synchronizedBufferFromGraph = synchronizedTargets.get(sourceBuffer);
+        const originalBuffer = originalsByClone.get(sourceBuffer);
+        const synchronizedBuffer = synchronizedBufferFromGraph instanceof ArrayBuffer ? synchronizedBufferFromGraph : ArrayBuffer.isView(targetValue) && targetValue.buffer instanceof ArrayBuffer ? targetValue.buffer : originalBuffer instanceof ArrayBuffer ? originalBuffer : new ArrayBuffer(sourceBuffer.byteLength);
+        synchronizedTargets.set(sourceBuffer, synchronizedBuffer);
+        const synchronizedView = ArrayBuffer.isView(targetValue) && targetValue.constructor === source.constructor && targetValue.byteLength === source.byteLength && targetValue.byteOffset === source.byteOffset ? targetValue : createArrayBufferView({
+            buffer: synchronizedBuffer,
+            source
+        });
+        synchronizedTargets.set(source, synchronizedView);
+        new Uint8Array(synchronizedView.buffer, synchronizedView.byteOffset, synchronizedView.byteLength).set(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));
+        return synchronizedView;
+    }
+    if (Array.isArray(source)) {
+        const synchronizedArray = Array.isArray(targetValue) ? targetValue : [];
+        synchronizedTargets.set(source, synchronizedArray);
+        for(let index = 0; index < source.length; index++){
+            const synchronizedEntry = synchronizeRetrySafeValue({
+                originalsByClone,
+                source: source[index],
+                synchronizedTargets,
+                target: synchronizedArray[index]
+            });
+            setSynchronizedProperty({
+                key: index,
+                target: synchronizedArray,
+                value: synchronizedEntry
+            });
+        }
+        setSynchronizedProperty({
+            key: 'length',
+            target: synchronizedArray,
+            value: source.length
+        });
+        mirrorObjectIntegrity({
+            source,
+            target: synchronizedArray
+        });
+        return synchronizedArray;
+    }
+    if (source instanceof Map) {
+        const synchronizedMap = targetValue instanceof Map ? targetValue : new Map();
+        synchronizedTargets.set(source, synchronizedMap);
+        const synchronizedEntries = [];
+        for (const [key, entry] of source){
+            const synchronizedKey = synchronizeRetrySafeValue({
+                originalsByClone,
+                source: key,
+                synchronizedTargets,
+                target: undefined
+            });
+            const synchronizedEntry = synchronizeRetrySafeValue({
+                originalsByClone,
+                source: entry,
+                synchronizedTargets,
+                target: synchronizedMap.get(synchronizedKey)
+            });
+            synchronizedEntries.push([
+                synchronizedKey,
+                synchronizedEntry
+            ]);
+        }
+        synchronizedMap.clear();
+        for (const [key, entry] of synchronizedEntries){
+            synchronizedMap.set(key, entry);
+        }
+        return synchronizedMap;
+    }
+    if (source instanceof Set) {
+        const synchronizedSet = targetValue instanceof Set ? targetValue : new Set();
+        synchronizedTargets.set(source, synchronizedSet);
+        const synchronizedEntries = [];
+        for (const entry of source){
+            synchronizedEntries.push(synchronizeRetrySafeValue({
+                originalsByClone,
+                source: entry,
+                synchronizedTargets,
+                target: undefined
+            }));
+        }
+        synchronizedSet.clear();
+        for (const entry of synchronizedEntries){
+            synchronizedSet.add(entry);
+        }
+        return synchronizedSet;
+    }
+    if (hasUncloneableInternalState({
+        value: source
+    })) {
+        synchronizedTargets.set(source, source);
+        return source;
+    }
+    const synchronizedObject = targetValue && typeof targetValue === 'object' && Object.getPrototypeOf(source) === Object.getPrototypeOf(targetValue) ? targetValue : Object.create(Object.getPrototypeOf(source));
+    synchronizedTargets.set(source, synchronizedObject);
+    const sourceRecord = source;
+    const targetRecord = synchronizedObject;
+    if (deleteMissingProperties) {
+        for (const key of Reflect.ownKeys(targetRecord)){
+            if (!Object.hasOwn(sourceRecord, key) && !preservedMissingTargetKeys?.has(key)) {
+                const descriptor = Object.getOwnPropertyDescriptor(targetRecord, key);
+                if (descriptor?.configurable !== false) {
+                    delete targetRecord[key];
+                }
+            }
+        }
+    }
+    for (const key of Reflect.ownKeys(sourceRecord)){
+        const synchronizedValue = synchronizeRetrySafeValue({
+            originalsByClone,
+            source: sourceRecord[key],
+            synchronizedTargets,
+            target: targetRecord[key]
+        });
+        setSynchronizedProperty({
+            key,
+            target: targetRecord,
+            value: synchronizedValue
+        });
+    }
+    mirrorObjectIntegrity({
+        source,
+        target: synchronizedObject
+    });
+    return synchronizedObject;
+};
+const setSynchronizedProperty = ({ key, target, value })=>{
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    const currentValue = Reflect.get(target, key);
+    if (Object.is(currentValue, value)) {
+        return;
+    }
+    if (!descriptor || ('value' in descriptor ? descriptor.writable !== false : descriptor.set !== undefined)) {
+        Reflect.set(target, key, value);
+    }
+};
+const retryRequestStateByRequest = new WeakMap();
+export const shouldRetryOperationRequest = ({ didOwnAttemptTransaction, didReachFinalCommit, error, hasCallerTransaction, isRetrySafe })=>isRetrySafe && !hasCallerTransaction && didOwnAttemptTransaction && (didReachFinalCommit || isConcurrentShadowOperationError(error));
+/** Applies mutable request changes from an attempt only after its database work succeeds. */ export const commitOperationRetryRequestContext = ({ req })=>{
+    const retryRequestState = retryRequestStateByRequest.get(req);
+    if (!retryRequestState) {
+        return;
+    }
+    const { originalReq, originalsByClone } = retryRequestState;
+    try {
+        const synchronizedTargets = new WeakMap();
+        originalReq.context = synchronizeRetrySafeValue({
+            allowUnprovenTargetReuse: true,
+            originalsByClone,
+            preservedMissingTargetKeys: new Set([
+                deferredCleanupScopeContextKey
+            ]),
+            source: createIsolatedDeferredCleanupContext({
+                req
+            }),
+            synchronizedTargets,
+            target: originalReq.context
+        });
+        if (req.responseHeaders) {
+            originalReq.responseHeaders = synchronizeRetrySafeValue({
+                originalsByClone,
+                source: req.responseHeaders,
+                synchronizedTargets,
+                target: originalReq.responseHeaders
+            });
+        } else {
+            delete originalReq.responseHeaders;
+        }
+    } catch (err) {
+        originalReq.payload.logger.error({
+            err,
+            msg: 'Failed to apply request state changes after committing an operation retry.'
+        });
+    } finally{
+        refreshBranchState(originalReq);
+        retryRequestStateByRequest.delete(req);
+    }
+};
+/** Creates a request whose mutable operation state cannot leak into another transaction attempt. */ export const createOperationRetryRequest = async ({ copyFileTempPath = false, req })=>{
+    req.context ??= {};
+    const cloneGraph = createRetryCloneGraph();
+    const retryReq = isolateObjectProperty(req, [
+        'branch',
+        'context',
+        'data',
+        'fallbackLocale',
+        'file',
+        'files',
+        'headers',
+        'locale',
+        'payloadDataLoader',
+        'payloadUploadSizes',
+        'query',
+        'responseHeaders',
+        'routeParams',
+        'searchParams',
+        'transactionID',
+        'user'
+    ]);
+    retryReq.context = cloneRetrySafeValue(createIsolatedDeferredCleanupContext({
+        req
+    }), cloneGraph);
+    retryReq.data = cloneRetrySafeValue(req.data, cloneGraph);
+    retryReq.file = cloneRetrySafeValue(req.file, cloneGraph);
+    retryReq.files = cloneRetrySafeValue(req.files, cloneGraph);
+    retryReq.headers = cloneRetrySafeValue(req.headers, cloneGraph);
+    retryReq.query = cloneRetrySafeValue(req.query, cloneGraph);
+    retryReq.responseHeaders = cloneRetrySafeValue(req.responseHeaders, cloneGraph);
+    retryReq.routeParams = cloneRetrySafeValue(req.routeParams, cloneGraph);
+    Reflect.set(retryReq, 'searchParams', cloneRetrySafeValue(req.searchParams, cloneGraph));
+    retryReq.user = cloneRetrySafeValue(req.user, cloneGraph);
+    if (!cloneGraph.isRetrySafe) {
+        return {
+            isRetrySafe: false,
+            req
+        };
+    }
+    delete retryReq.payloadDataLoader;
+    delete retryReq.payloadUploadSizes;
+    delete retryReq.transactionID;
+    resetBranchState(retryReq);
+    const fallbackLocale = req.fallbackLocale === false || typeof req.fallbackLocale === 'string' ? req.fallbackLocale : undefined;
+    const preparedReq = await createPayloadRequest({
+        fallbackLocale,
+        payload: req.payload,
+        req: retryReq
+    });
+    const sourceTempFilePath = preparedReq.file?.tempFilePath;
+    if (copyFileTempPath && sourceTempFilePath) {
+        const extension = path.extname(sourceTempFilePath);
+        const attemptTempFilePath = path.join(path.dirname(sourceTempFilePath), `${path.basename(sourceTempFilePath, extension)}-${randomUUID()}${extension}`);
+        await fs.copyFile(sourceTempFilePath, attemptTempFilePath, constants.COPYFILE_EXCL);
+        preparedReq.file.tempFilePath = attemptTempFilePath;
+    }
+    retryRequestStateByRequest.set(preparedReq, {
+        originalReq: req,
+        originalsByClone: cloneGraph.originalsByClone
+    });
+    return {
+        isRetrySafe: true,
+        req: preparedReq
+    };
+};
+
+//# sourceMappingURL=createOperationRetryRequest.js.map