@lossless.org/client 0.1.0

package/dist_ts/objectstorage/internal.exactupload.capability.d.ts

@@ -0,0 +1,40 @@
+import * as plugins from './plugins.js';
+import type { IExactPathPurgeCapability, IExactUploadCapability, TExactPathPurgeVersioningMode } from './interfaces.js';
+interface ISmartBucketCapabilityRef {
+    readonly storageClient: plugins.s3.S3Client;
+}
+interface IBucketCapabilityRef {
+    name: string;
+    smartbucketRef: ISmartBucketCapabilityRef;
+}
+export interface IExactUploadOperation {
+    readonly bucketName: string;
+    readonly client: plugins.s3.S3Client;
+    readonly signal: AbortSignal;
+    registerOwnedIndependentAbort(abortControllerArg: AbortController, disposeArg: () => void): () => void;
+    assertLifecycleCurrent(): void;
+    assertCurrent(): void;
+    finish(): void;
+}
+export interface IBasicBucketOperation extends IExactUploadOperation {
+    runProvider<T>(sendArg: () => Promise<T>, optionsArg?: {
+        disposeLateResult?: (resultArg: T) => void | Promise<void>;
+    }): Promise<T>;
+}
+export interface IExactPathPurgeOperation extends IExactUploadOperation {
+    readonly versioningMode: TExactPathPurgeVersioningMode;
+}
+export declare const registerOperationLifecycle: (smartbucketRefArg: ISmartBucketCapabilityRef, storageClientArg: plugins.s3.S3Client) => void;
+export declare const reserveOperationLifecycleClientMutation: (smartbucketRefArg: ISmartBucketCapabilityRef) => void;
+export declare const commitOperationLifecycleClient: (smartbucketRefArg: ISmartBucketCapabilityRef, storageClientArg: plugins.s3.S3Client) => void;
+export declare const rollbackOperationLifecycleClientMutation: (smartbucketRefArg: ISmartBucketCapabilityRef) => void;
+export declare const beginOperationLifecycleClose: (smartbucketRefArg: ISmartBucketCapabilityRef) => Promise<void> | undefined;
+export declare const completeOperationLifecycleClose: (smartbucketRefArg: ISmartBucketCapabilityRef) => void;
+export declare const beginBasicBucketOperation: (bucketRefArg: IBucketCapabilityRef, callerSignalArg?: AbortSignal) => IBasicBucketOperation;
+export declare const beginExactUploadProbeOperation: (bucketRefArg: IBucketCapabilityRef, callerSignalArg?: AbortSignal) => IExactUploadOperation;
+export declare const beginExactPathPurgeProbeOperation: (bucketRefArg: IBucketCapabilityRef, callerSignalArg?: AbortSignal) => IExactUploadOperation;
+export declare const mintExactUploadCapability: (bucketRefArg: IBucketCapabilityRef, operationArg: IExactUploadOperation) => IExactUploadCapability;
+export declare const beginExactUploadCapabilityOperation: (bucketRefArg: IBucketCapabilityRef, capabilityArg: IExactUploadCapability, callerSignalArg?: AbortSignal) => IExactUploadOperation;
+export declare const mintExactPathPurgeCapability: (bucketRefArg: IBucketCapabilityRef, operationArg: IExactUploadOperation, versioningModeArg: TExactPathPurgeVersioningMode) => IExactPathPurgeCapability;
+export declare const beginExactPathPurgeCapabilityOperation: (bucketRefArg: IBucketCapabilityRef, capabilityArg: IExactPathPurgeCapability, callerSignalArg?: AbortSignal) => IExactPathPurgeOperation;
+export {};

package/dist_ts/objectstorage/internal.exactupload.capability.js

@@ -0,0 +1,382 @@
+import * as plugins from './plugins.js';
+const lifecycleRecords = new WeakMap();
+const capabilityBindings = new WeakMap();
+const purgeCapabilityBindings = new WeakMap();
+const operationCloseSettlementTimeoutMs = 35_000;
+const basicOperationLateDisposalTimeoutMs = 5_000;
+const abortAndDisposeIndependentWork = (activeOperationArg, causeArg) => {
+    for (const ownedAbort of activeOperationArg.ownedIndependentAborts) {
+        ownedAbort.abortController.abort(causeArg);
+        ownedAbort.dispose();
+    }
+    activeOperationArg.ownedIndependentAborts.clear();
+};
+const getLifecycleRecord = (smartbucketRefArg) => {
+    const lifecycleRecord = lifecycleRecords.get(smartbucketRefArg);
+    if (!lifecycleRecord) {
+        throw new Error('The Bucket is not attached to a lifecycle-managed SmartBucket.');
+    }
+    return lifecycleRecord;
+};
+const assertOpenLifecycle = (lifecycleRecordArg) => {
+    if (lifecycleRecordArg.state !== 'open') {
+        throw new Error(`The SmartBucket operation lifecycle is ${lifecycleRecordArg.state}.`);
+    }
+    if (lifecycleRecordArg.clientMutationReserved) {
+        throw new Error('The SmartBucket storageClient is changing.');
+    }
+};
+export const registerOperationLifecycle = (smartbucketRefArg, storageClientArg) => {
+    if (lifecycleRecords.has(smartbucketRefArg)) {
+        throw new Error('The SmartBucket operation lifecycle is already registered.');
+    }
+    lifecycleRecords.set(smartbucketRefArg, {
+        state: 'open',
+        generation: 0,
+        storageClient: storageClientArg,
+        activeOperations: new Set(),
+        clientMutationReserved: false,
+    });
+};
+export const reserveOperationLifecycleClientMutation = (smartbucketRefArg) => {
+    const lifecycleRecord = getLifecycleRecord(smartbucketRefArg);
+    assertOpenLifecycle(lifecycleRecord);
+    if (lifecycleRecord.activeOperations.size > 0) {
+        throw new Error('Cannot change storageClient while a lifecycle-managed operation is active.');
+    }
+    lifecycleRecord.clientMutationReserved = true;
+};
+export const commitOperationLifecycleClient = (smartbucketRefArg, storageClientArg) => {
+    const lifecycleRecord = getLifecycleRecord(smartbucketRefArg);
+    if (lifecycleRecord.state !== 'open' || !lifecycleRecord.clientMutationReserved) {
+        throw new Error('The SmartBucket storageClient mutation was not reserved.');
+    }
+    lifecycleRecord.generation++;
+    lifecycleRecord.storageClient = storageClientArg;
+    lifecycleRecord.clientMutationReserved = false;
+};
+export const rollbackOperationLifecycleClientMutation = (smartbucketRefArg) => {
+    const lifecycleRecord = getLifecycleRecord(smartbucketRefArg);
+    if (lifecycleRecord.state === 'open') {
+        lifecycleRecord.clientMutationReserved = false;
+    }
+};
+export const beginOperationLifecycleClose = (smartbucketRefArg) => {
+    const lifecycleRecord = getLifecycleRecord(smartbucketRefArg);
+    if (lifecycleRecord.state === 'closed') {
+        return undefined;
+    }
+    lifecycleRecord.state = 'closing';
+    lifecycleRecord.generation++;
+    const lifecycleAbortCause = new Error('The SmartBucket lifecycle closed during an object operation.');
+    const activeSettlements = [];
+    for (const activeOperation of lifecycleRecord.activeOperations) {
+        activeSettlements.push(activeOperation.settlement);
+        activeOperation.abortController.abort(lifecycleAbortCause);
+    }
+    if (activeSettlements.length === 0) {
+        return undefined;
+    }
+    const settleAllOperations = Promise.allSettled(activeSettlements).then(() => undefined);
+    return new Promise((resolveArg) => {
+        const settlementDeadline = setTimeout(() => {
+            for (const activeOperation of lifecycleRecord.activeOperations) {
+                activeOperation.forceFinish(lifecycleAbortCause);
+            }
+            resolveArg();
+        }, operationCloseSettlementTimeoutMs);
+        void settleAllOperations.then(() => {
+            clearTimeout(settlementDeadline);
+            resolveArg();
+        });
+    });
+};
+export const completeOperationLifecycleClose = (smartbucketRefArg) => {
+    const lifecycleRecord = getLifecycleRecord(smartbucketRefArg);
+    lifecycleRecord.state = 'closed';
+    for (const activeOperation of lifecycleRecord.activeOperations) {
+        activeOperation.forceFinish(new Error('The SmartBucket operation lifecycle is closed.'));
+    }
+    lifecycleRecords.delete(smartbucketRefArg);
+};
+const assertBindingCurrent = (bindingArg) => {
+    const lifecycleRecord = getLifecycleRecord(bindingArg.smartbucketRef);
+    assertOpenLifecycle(lifecycleRecord);
+    if (bindingArg.bucketRef.smartbucketRef !== bindingArg.smartbucketRef ||
+        bindingArg.bucketRef.name !== bindingArg.bucketName ||
+        lifecycleRecord.generation !== bindingArg.lifecycleGeneration ||
+        lifecycleRecord.storageClient !== bindingArg.storageClient ||
+        bindingArg.smartbucketRef.storageClient !== bindingArg.storageClient) {
+        throw new Error('The exact upload capability is invalid or stale.');
+    }
+};
+const beginOperation = (bindingArg, callerSignalArg) => {
+    assertBindingCurrent(bindingArg);
+    const lifecycleRecord = getLifecycleRecord(bindingArg.smartbucketRef);
+    const operationAbortController = new AbortController();
+    let settleOperation;
+    const operationSettlement = new Promise((resolveArg) => {
+        settleOperation = resolveArg;
+    });
+    const abortForCaller = () => {
+        operationAbortController.abort(callerSignalArg?.reason ?? new Error('The object operation was aborted.'));
+    };
+    let callerAbortListenerReleased = false;
+    const releaseCallerAbortListener = () => {
+        if (callerAbortListenerReleased) {
+            return;
+        }
+        callerAbortListenerReleased = true;
+        callerSignalArg?.removeEventListener('abort', abortForCaller);
+    };
+    let finishRequested = false;
+    let pendingProviderCount = 0;
+    let settled = false;
+    const settleIfFinished = () => {
+        if (!finishRequested || pendingProviderCount > 0 || settled) {
+            return;
+        }
+        settled = true;
+        activeOperation.releaseCallerAbortListener();
+        lifecycleRecord.activeOperations.delete(activeOperation);
+        activeOperation.settle();
+    };
+    const activeOperation = {
+        abortController: operationAbortController,
+        ownedIndependentAborts: new Set(),
+        settlement: operationSettlement,
+        settle: settleOperation,
+        releaseCallerAbortListener,
+        forceFinish: (causeArg) => {
+            if (settled) {
+                return;
+            }
+            finishRequested = true;
+            pendingProviderCount = 0;
+            abortAndDisposeIndependentWork(activeOperation, causeArg);
+            settleIfFinished();
+        },
+    };
+    lifecycleRecord.activeOperations.add(activeOperation);
+    callerSignalArg?.addEventListener('abort', abortForCaller, { once: true });
+    if (callerSignalArg?.aborted) {
+        abortForCaller();
+    }
+    return {
+        bucketName: bindingArg.bucketName,
+        client: bindingArg.storageClient,
+        signal: operationAbortController.signal,
+        registerOwnedIndependentAbort(abortControllerArg, disposeArg) {
+            this.assertLifecycleCurrent();
+            const ownedAbort = {
+                abortController: abortControllerArg,
+                dispose: disposeArg,
+            };
+            activeOperation.ownedIndependentAborts.add(ownedAbort);
+            let released = false;
+            return () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                activeOperation.ownedIndependentAborts.delete(ownedAbort);
+            };
+        },
+        assertLifecycleCurrent() {
+            if (lifecycleRecord.state === 'closed' ||
+                !lifecycleRecord.activeOperations.has(activeOperation) ||
+                bindingArg.bucketRef.smartbucketRef !== bindingArg.smartbucketRef ||
+                bindingArg.bucketRef.name !== bindingArg.bucketName ||
+                lifecycleRecord.storageClient !== bindingArg.storageClient ||
+                bindingArg.smartbucketRef.storageClient !== bindingArg.storageClient) {
+                throw new Error('The object operation lifecycle or storage client is stale.');
+            }
+        },
+        assertCurrent() {
+            if (operationAbortController.signal.aborted) {
+                throw operationAbortController.signal.reason;
+            }
+            assertBindingCurrent(bindingArg);
+        },
+        runProvider(sendArg, optionsArg = {}) {
+            this.assertCurrent();
+            pendingProviderCount++;
+            return new Promise((resolveArg, rejectArg) => {
+                let publicSettled = false;
+                const settlePublic = (outcomeArg) => {
+                    if (publicSettled) {
+                        return;
+                    }
+                    publicSettled = true;
+                    operationAbortController.signal.removeEventListener('abort', abortPublicWait);
+                    if ('result' in outcomeArg) {
+                        resolveArg(outcomeArg.result);
+                    }
+                    else {
+                        rejectArg(outcomeArg.error);
+                    }
+                };
+                const abortPublicWait = () => {
+                    settlePublic({
+                        error: operationAbortController.signal.reason
+                            ?? new Error('The bucket operation was aborted.'),
+                    });
+                };
+                operationAbortController.signal.addEventListener('abort', abortPublicWait, {
+                    once: true,
+                });
+                let providerPromise;
+                try {
+                    providerPromise = sendArg();
+                }
+                catch (error) {
+                    pendingProviderCount--;
+                    settleIfFinished();
+                    settlePublic({ error });
+                    return;
+                }
+                void providerPromise.then(async (resultArg) => {
+                    if (operationAbortController.signal.aborted
+                        && optionsArg.disposeLateResult) {
+                        const disposal = Promise.resolve()
+                            .then(() => optionsArg.disposeLateResult(resultArg));
+                        void disposal.catch(() => undefined);
+                        let disposalDeadline;
+                        try {
+                            await Promise.race([
+                                disposal.catch(() => undefined),
+                                new Promise((resolveDisposalArg) => {
+                                    disposalDeadline = setTimeout(resolveDisposalArg, basicOperationLateDisposalTimeoutMs);
+                                }),
+                            ]);
+                        }
+                        finally {
+                            if (disposalDeadline) {
+                                clearTimeout(disposalDeadline);
+                            }
+                        }
+                    }
+                    pendingProviderCount--;
+                    settleIfFinished();
+                    if (operationAbortController.signal.aborted) {
+                        abortPublicWait();
+                    }
+                    else {
+                        settlePublic({ result: resultArg });
+                    }
+                }, (errorArg) => {
+                    pendingProviderCount--;
+                    settleIfFinished();
+                    if (operationAbortController.signal.aborted) {
+                        abortPublicWait();
+                    }
+                    else {
+                        settlePublic({ error: errorArg });
+                    }
+                });
+                if (operationAbortController.signal.aborted) {
+                    abortPublicWait();
+                }
+            });
+        },
+        finish() {
+            if (finishRequested) {
+                return;
+            }
+            finishRequested = true;
+            abortAndDisposeIndependentWork(activeOperation, new Error('The object operation finished.'));
+            settleIfFinished();
+        },
+    };
+};
+export const beginBasicBucketOperation = (bucketRefArg, callerSignalArg) => {
+    const smartbucketRef = bucketRefArg.smartbucketRef;
+    const lifecycleRecord = getLifecycleRecord(smartbucketRef);
+    const binding = {
+        bucketRef: bucketRefArg,
+        bucketName: bucketRefArg.name,
+        smartbucketRef,
+        storageClient: lifecycleRecord.storageClient,
+        lifecycleGeneration: lifecycleRecord.generation,
+    };
+    return beginOperation(binding, callerSignalArg);
+};
+export const beginExactUploadProbeOperation = (bucketRefArg, callerSignalArg) => {
+    const smartbucketRef = bucketRefArg.smartbucketRef;
+    const lifecycleRecord = getLifecycleRecord(smartbucketRef);
+    const binding = {
+        bucketRef: bucketRefArg,
+        bucketName: bucketRefArg.name,
+        smartbucketRef,
+        storageClient: lifecycleRecord.storageClient,
+        lifecycleGeneration: lifecycleRecord.generation,
+    };
+    return beginOperation(binding, callerSignalArg);
+};
+export const beginExactPathPurgeProbeOperation = (bucketRefArg, callerSignalArg) => {
+    const smartbucketRef = bucketRefArg.smartbucketRef;
+    const lifecycleRecord = getLifecycleRecord(smartbucketRef);
+    const binding = {
+        bucketRef: bucketRefArg,
+        bucketName: bucketRefArg.name,
+        smartbucketRef,
+        storageClient: lifecycleRecord.storageClient,
+        lifecycleGeneration: lifecycleRecord.generation,
+    };
+    return beginOperation(binding, callerSignalArg);
+};
+export const mintExactUploadCapability = (bucketRefArg, operationArg) => {
+    operationArg.assertCurrent();
+    const smartbucketRef = bucketRefArg.smartbucketRef;
+    const lifecycleRecord = getLifecycleRecord(smartbucketRef);
+    const capability = Object.freeze({});
+    capabilityBindings.set(capability, {
+        bucketRef: bucketRefArg,
+        bucketName: operationArg.bucketName,
+        smartbucketRef,
+        storageClient: operationArg.client,
+        lifecycleGeneration: lifecycleRecord.generation,
+    });
+    return capability;
+};
+export const beginExactUploadCapabilityOperation = (bucketRefArg, capabilityArg, callerSignalArg) => {
+    if (typeof capabilityArg !== 'object' ||
+        capabilityArg === null) {
+        throw new Error('The exact upload capability is invalid or stale.');
+    }
+    const binding = capabilityBindings.get(capabilityArg);
+    if (!binding || binding.bucketRef !== bucketRefArg) {
+        throw new Error('The exact upload capability is invalid or stale.');
+    }
+    return beginOperation(binding, callerSignalArg);
+};
+export const mintExactPathPurgeCapability = (bucketRefArg, operationArg, versioningModeArg) => {
+    operationArg.assertCurrent();
+    const smartbucketRef = bucketRefArg.smartbucketRef;
+    const lifecycleRecord = getLifecycleRecord(smartbucketRef);
+    const capability = Object.freeze({});
+    purgeCapabilityBindings.set(capability, {
+        bucketRef: bucketRefArg,
+        bucketName: operationArg.bucketName,
+        smartbucketRef,
+        storageClient: operationArg.client,
+        lifecycleGeneration: lifecycleRecord.generation,
+        versioningMode: versioningModeArg,
+    });
+    return capability;
+};
+export const beginExactPathPurgeCapabilityOperation = (bucketRefArg, capabilityArg, callerSignalArg) => {
+    if (typeof capabilityArg !== 'object' || capabilityArg === null) {
+        throw new Error('The exact-path purge capability is invalid or stale.');
+    }
+    const binding = purgeCapabilityBindings.get(capabilityArg);
+    if (!binding || binding.bucketRef !== bucketRefArg) {
+        throw new Error('The exact-path purge capability is invalid or stale.');
+    }
+    const operation = beginOperation(binding, callerSignalArg);
+    return {
+        ...operation,
+        versioningMode: binding.versioningMode,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal.exactupload.capability.js","sourceRoot":"","sources":["../../ts/objectstorage/internal.exactupload.capability.ts"],"names":[],"mappings":"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"}

package/dist_ts/objectstorage/internal.exactupload.operations.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+import type { IExactUploadCapabilityProbeOptions, IExactUploadResult, IFastPutStreamExactOptions, TExactUploadCapabilityProbeResult } from './interfaces.js';
+interface IExactUploadBucketRef {
+    name: string;
+    smartbucketRef: {
+        readonly storageClient: plugins.s3.S3Client;
+    };
+}
+export declare const probeExactUploadCapability: (bucketRefArg: IExactUploadBucketRef, optionsArg: IExactUploadCapabilityProbeOptions) => Promise<TExactUploadCapabilityProbeResult>;
+export declare const fastPutStreamExact: (bucketRefArg: IExactUploadBucketRef, optionsArg: IFastPutStreamExactOptions) => Promise<IExactUploadResult>;
+export {};