@lossless.org/client 1.6.0 → 1.8.0

package/dist_ts/nosqldb/classes.session.js

@@ -1,5 +1,7 @@
 import * as plugins from './plugins.js';
-import { SmartdataPersistenceError, normalizeOrdinaryPersistenceError, } from './classes.persistence.js';
+import { SmartdataOperationDeadline, requireOperationSignal, requireOperationTimeoutMS, } from './classes.operationdeadline.js';
+import { assertDataOptions } from './classes.operationbudget.js';
+import { SmartdataPersistenceError, createSmartdataTimeoutError, isMongoDeadlineError, normalizeDeadlineError, normalizeOrdinaryPersistenceError, } from './classes.persistence.js';
 const bindings = new WeakMap();
 const bindingsByOwner = new WeakMap();
 const smartdataSessionInvalidationAggregateBrand = Symbol('smartdataSessionInvalidationAggregate');
@@ -21,63 +23,121 @@ const resolveBinding = (sessionArg, ownerArg) => {
     }
     return binding;
 };
+const normalizeTransactionOptions = (optionsArg) => {
+    if (optionsArg === undefined) {
+        return {};
+    }
+    const { timeoutMS, signal } = assertDataOptions(optionsArg, ['timeoutMS', 'signal']);
+    return {
+        timeoutMS: requireOperationTimeoutMS(timeoutMS, 'SmartData transaction timeoutMS'),
+        signal: requireOperationSignal(signal, 'SmartData transaction signal'),
+    };
+};
 const assertTransactionSucceeded = (bindingArg) => {
     if (bindingArg.transactionFailure) {
         throw bindingArg.transactionFailure.error;
     }
 };
 export class SmartdataSession {
-    async withTransaction(callbackArg) {
+    /**
+     * Runs `callbackArg` in a transaction, retrying it as the driver decides.
+     *
+     * `timeoutMS` bounds the whole transaction through the driver's client-side
+     * operation timeout. When it expires the call rejects with a
+     * `SmartdataPersistenceError` of code `timeout`: before the commit was sent
+     * nothing was committed, during the commit the outcome is unknown. When the
+     * deadline expires inside the callback, the driver's closing
+     * `abortTransaction` runs on a fresh deadline of the same length, so a
+     * stalled database settles the call within about twice `timeoutMS`.
+     *
+     * `signal` cancels the transaction. An abort before the call rejects with
+     * the abort reason at once. An abort while the callback runs interrupts the
+     * operation in flight on the session and refuses every later one with the
+     * reason; once the callback has settled, the driver's `abortTransaction`
+     * rolls the attempt back and the call rejects with the reason, even when
+     * the callback caught it, and no further attempt starts. The driver cannot
+     * cancel a commit in flight, so an abort that arrives after the commit was
+     * sent leaves the commit to its own outcome: the call returns the result
+     * when it committed, and rejects with `timeout` ("the commit outcome is
+     * unknown") when the deadline expired during it.
+     *
+     * Any operation on the session that its deadline or a signal interrupts
+     * fails the attempt: the call rolls it back and rejects with that
+     * operation's error even when the callback caught it.
+     */
+    async withTransaction(callbackArg, optionsArg) {
         if (typeof callbackArg !== 'function') {
             throw new SmartdataPersistenceError('invalid_argument', 'SmartData transaction callback must be a function.');
         }
+        const { timeoutMS, signal } = normalizeTransactionOptions(optionsArg);
         const binding = resolveBinding(this);
         if (binding.operationActive || binding.transactionActive) {
             throw new SmartdataPersistenceError('unsupported_operation', 'Parallel or nested SmartData session operations are not supported.');
         }
+        signal?.throwIfAborted();
         binding.transactionActive = true;
+        binding.transactionTimeoutMS = timeoutMS;
+        binding.transactionSignal = signal;
         let callbackError;
-        try {
-            return await binding.rawSession.withTransaction(async () => {
-                const attempt = Symbol('smartdataTransactionAttempt');
-                binding.transactionAttempt = attempt;
-                binding.transactionCallbackOpen = true;
-                binding.transactionUsesOrdinaryWrite = false;
-                binding.transactionFailure = undefined;
-                callbackError = undefined;
+        let commitReached = false;
+        const runAttempt = async () => {
+            const attempt = Symbol('smartdataTransactionAttempt');
+            binding.transactionAttempt = attempt;
+            binding.transactionCallbackOpen = true;
+            binding.transactionUsesOrdinaryWrite = false;
+            binding.transactionFailure = undefined;
+            callbackError = undefined;
+            commitReached = false;
+            try {
+                let result;
+                let callbackReturned = false;
                 try {
-                    let callbackReturned = false;
-                    try {
-                        const result = await transactionContext.run({ contextToken: binding.contextToken, attempt }, async () => callbackArg(this));
-                        callbackReturned = true;
-                        return result;
+                    // A retry the driver starts after an abort ends before the callback.
+                    signal?.throwIfAborted();
+                    result = await transactionContext.run({ contextToken: binding.contextToken, attempt }, async () => callbackArg(this));
+                    callbackReturned = true;
+                }
+                finally {
+                    const activeOperation = binding.operationActive
+                        ? binding.operationSettled
+                        : undefined;
+                    binding.transactionCallbackOpen = false;
+                    if (binding.transactionAttempt === attempt) {
+                        binding.transactionAttempt = undefined;
                     }
-                    finally {
-                        const activeOperation = binding.operationActive
-                            ? binding.operationSettled
-                            : undefined;
-                        binding.transactionCallbackOpen = false;
-                        if (binding.transactionAttempt === attempt) {
-                            binding.transactionAttempt = undefined;
-                        }
-                        if (activeOperation) {
-                            await activeOperation;
-                        }
-                        assertTransactionSucceeded(binding);
-                        if (callbackReturned && activeOperation) {
-                            throw new SmartdataPersistenceError('unsupported_operation', 'A SmartData transaction callback returned with an operation still active.');
-                        }
+                    if (activeOperation) {
+                        await activeOperation;
+                    }
+                    assertTransactionSucceeded(binding);
+                    if (callbackReturned && activeOperation) {
+                        throw new SmartdataPersistenceError('unsupported_operation', 'A SmartData transaction callback returned with an operation still active.');
                     }
                 }
-                catch (errorArg) {
-                    callbackError = errorArg;
-                    throw errorArg;
-                }
-            });
+                // An abort that arrived while the callback ran rolls the attempt back.
+                signal?.throwIfAborted();
+                // The driver commits next; a deadline that expires from here on
+                // leaves the commit outcome unknown.
+                commitReached = true;
+                return result;
+            }
+            catch (errorArg) {
+                callbackError = errorArg;
+                throw errorArg;
+            }
+        };
+        try {
+            return timeoutMS === undefined
+                ? await binding.rawSession.withTransaction(runAttempt)
+                : await binding.rawSession.withTransaction(runAttempt, { timeoutMS });
         }
         catch (errorArg) {
             if (errorArg === callbackError) {
-                throw errorArg;
+                throw normalizeDeadlineError(errorArg);
+            }
+            if (isMongoDeadlineError(errorArg)) {
+                throw createSmartdataTimeoutError(commitReached
+                    ? 'SmartData transaction exceeded its client deadline during commit; the commit outcome is unknown.'
+                    : 'SmartData transaction exceeded its client deadline before commit; nothing was committed.', errorArg);
             }
             if (binding.transactionUsesOrdinaryWrite) {
                 return normalizeOrdinaryPersistenceError(errorArg, 'SmartData transaction conflicts with a unique index.');
@@ -86,6 +146,8 @@ export class SmartdataSession {
         }
         finally {
             binding.transactionActive = false;
+            binding.transactionTimeoutMS = undefined;
+            binding.transactionSignal = undefined;
             binding.transactionUsesOrdinaryWrite = false;
             binding.transactionFailure = undefined;
         }
@@ -129,6 +191,13 @@ export const createSmartdataSession = (ownerArg) => {
 };
 export const acquireSmartdataSession = (sessionArg, ownerArg, optionsArg = {}) => {
     const binding = resolveBinding(sessionArg, ownerArg);
+    if (binding.transactionActive
+        && binding.transactionSignal?.aborted
+        && transactionContext.getStore()?.contextToken === binding.contextToken) {
+        // The transaction was cancelled: the attempt fails with the abort reason.
+        binding.transactionFailure ??= { error: binding.transactionSignal.reason };
+        throw binding.transactionSignal.reason;
+    }
     if (binding.transactionFailure) {
         throw new SmartdataPersistenceError('unsupported_operation', 'The SmartData transaction attempt has aborted and cannot accept further operations.');
     }
@@ -221,10 +290,67 @@ export const leaseOrdinarySmartdataSession = (sessionArg, ownerArg, optionsArg)
         ordinaryWrite: optionsArg.ordinaryWrite,
     });
 };
+/**
+ * The deadline and signal one operation runs under. Inside an owned
+ * transaction with a deadline, the transaction's deadline bounds the
+ * operation through the session, and the driver refuses a second one on the
+ * same session, so an explicit operation deadline is refused and a default
+ * one is dropped. Inside an owned transaction with a signal, the operation
+ * observes that signal beside its own.
+ */
+export const resolveSmartdataOperationDeadline = (sessionArg, optionsArg) => {
+    const binding = isSmartdataSession(sessionArg) ? bindings.get(sessionArg) : undefined;
+    const transactionSignal = binding?.transactionActive ? binding.transactionSignal : undefined;
+    const signals = [optionsArg.signal, transactionSignal].filter((signalArg) => signalArg !== undefined);
+    const signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    if (binding?.transactionTimeoutMS !== undefined) {
+        if (optionsArg.timeoutMS !== undefined) {
+            throw new SmartdataPersistenceError('invalid_argument', 'The SmartData transaction deadline bounds every operation inside it; omit the operation timeoutMS.');
+        }
+        return signal === undefined
+            ? SmartdataOperationDeadline.unbounded
+            : new SmartdataOperationDeadline(undefined, signal);
+    }
+    const timeoutMS = optionsArg.timeoutMS ?? optionsArg.defaultTimeoutMS;
+    return timeoutMS === undefined && signal === undefined
+        ? SmartdataOperationDeadline.unbounded
+        : new SmartdataOperationDeadline(timeoutMS, signal);
+};
+/**
+ * The error one operation on the session boundary rejects with: an expired
+ * driver deadline becomes the `timeout` persistence error, everything else
+ * passes through. An operation its deadline or signal interrupted inside an
+ * owned transaction also fails the transaction attempt, so `withTransaction`
+ * rolls it back and rejects with that error even when the callback caught it:
+ * whatever the interrupted command did inside the transaction is unknown.
+ */
+export const settleSmartdataOperationError = (sessionArg, deadlineArg, errorArg) => {
+    const error = normalizeDeadlineError(errorArg);
+    const binding = isSmartdataSession(sessionArg) ? bindings.get(sessionArg) : undefined;
+    const aborted = deadlineArg.signal?.aborted === true && errorArg === deadlineArg.signal.reason;
+    const expired = error instanceof SmartdataPersistenceError && error.code === 'timeout';
+    if (binding?.transactionActive && (aborted || expired)) {
+        binding.transactionFailure ??= { error };
+    }
+    return error;
+};
+/**
+ * Runs one model operation on the ordinary session boundary: the owned
+ * session lease, the operation's client deadline and signal, and the mapping
+ * of an expired driver deadline to the `timeout` persistence error.
+ */
 export const runWithOrdinarySmartdataSession = async (sessionArg, ownerArg, optionsArg, operationArg) => {
+    optionsArg.signal?.throwIfAborted();
     const lease = leaseOrdinarySmartdataSession(sessionArg, ownerArg, optionsArg);
+    let deadline;
     try {
-        return await operationArg(lease.rawSession);
+        deadline = resolveSmartdataOperationDeadline(sessionArg, optionsArg);
+        return await operationArg(lease.rawSession, deadline);
+    }
+    catch (errorArg) {
+        throw deadline
+            ? settleSmartdataOperationError(sessionArg, deadline, errorArg)
+            : normalizeDeadlineError(errorArg);
     }
     finally {
         lease.release();
@@ -269,4 +395,4 @@ const closeSessionBinding = async (bindingArg) => {
 export const unwrapSmartdataSessionInvalidationErrors = (errorArg) => errorArg instanceof SmartdataSessionInvalidationAggregateError
     ? errorArg.errors
     : undefined;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.session.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.session.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.session.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.session.ts"],"names":[],"mappings":"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"}

package/dist_ts/objectstorage/classes.bucket.d.ts

@@ -15,15 +15,51 @@ export interface IListObjectKeysPageResult {
     keys: string[];
     nextStartAfter?: string;
 }
+export interface IListObjectEntriesPageOptions extends IListObjectKeysPageOptions {
+    /** Optional caller-owned cancellation signal */
+    signal?: AbortSignal;
+}
+/**
+ * One object as ListObjectsV2 reported it when the page was listed.
+ * - `size`: the `Size` field, the object's byte length; HEAD reports the same
+ *   value as `ContentLength`.
+ * - `etag`: the `ETag` field without its surrounding double quotes; HEAD
+ *   reports the same entity tag, quoted. It identifies an object version, it
+ *   is not a content digest: AWS S3 derives it from the content MD5 only for
+ *   single-part uploads without SSE-KMS or SSE-C, and other providers define
+ *   it themselves.
+ * - `lastModified`: the `LastModified` field when the provider sends one.
+ */
+export interface IObjectListingEntry {
+    key: string;
+    size: number;
+    etag: string;
+    lastModified?: Date;
+}
+export interface IListObjectEntriesPageResult {
+    entries: IObjectListingEntry[];
+    nextStartAfter?: string;
+}
+export interface IListAllObjectEntriesOptions {
+    /** Entries fetched per ListObjectsV2 request, 1 to 1000 (default 1000) */
+    pageSize?: number;
+    /** Optional caller-owned cancellation signal */
+    signal?: AbortSignal;
+}
 /**
  * The bucket class exposes the basic functionality of a bucket.
  * The functions of the bucket alone are enough to
  * operate on blobs of data in an S3-compatible object store.
  */
 export declare class Bucket {
-    static getBucketByName(smartbucketRef: SmartBucket, bucketNameArg: string): Promise<Bucket>;
-    static createBucketByName(smartbucketRef: SmartBucket, bucketName: string): Promise<Bucket>;
-    static removeBucketByName(smartbucketRef: SmartBucket, bucketName: string): Promise<void>;
+    /**
+     * Returns a reference to an existing bucket, checked with one HeadBucket
+     * request. Rejects when the bucket does not exist or the credentials may
+     * not access it.
+     */
+    static getBucketByName(smartbucketRef: SmartBucket, bucketNameArg: string, optionsArg?: interfaces.IBucketRequestOptions): Promise<Bucket>;
+    static createBucketByName(smartbucketRef: SmartBucket, bucketName: string, optionsArg?: interfaces.IBucketRequestOptions): Promise<Bucket>;
+    static removeBucketByName(smartbucketRef: SmartBucket, bucketName: string, optionsArg?: interfaces.IBucketRequestOptions): Promise<void>;
     smartbucketRef: SmartBucket;
     name: string;
     constructor(smartbucketRef: SmartBucket, bucketName: string);
@@ -185,6 +221,28 @@ export declare class Bucket {
      * This requires a general-purpose S3 provider with UTF-8 byte-ordered keys.
      */
     listObjectKeysPage(optionsArg: IListObjectKeysPageOptions): Promise<IListObjectKeysPageResult>;
+    /**
+     * List one keyset page of objects with the size, ETag and last-modified time
+     * ListObjectsV2 already returns, so a caller needs no HEAD per object.
+     * Pagination, prefix, limit (1 to 1000) and `startAfter` behave exactly like
+     * `listObjectKeysPage()`: `nextStartAfter` is present only while the provider
+     * reports more entries. `signal` aborts the in-flight request and rejects with
+     * its reason. This requires a general-purpose S3 provider with UTF-8
+     * byte-ordered keys.
+     */
+    listObjectEntriesPage(optionsArg: IListObjectEntriesPageOptions): Promise<IListObjectEntriesPageResult>;
+    /**
+     * Iterate every object under a prefix with its size, ETag and last-modified
+     * time, one `listObjectEntriesPage()` request per page. No request is in
+     * flight while the caller holds an entry; breaking out stops the listing.
+     * @example
+     * ```ts
+     * for await (const entry of bucket.listAllObjectEntries('npm/', { signal })) {
+     *   console.log(entry.key, entry.size, entry.etag);
+     * }
+     * ```
+     */
+    listAllObjectEntries(prefix?: string, optionsArg?: IListAllObjectEntriesOptions): AsyncIterableIterator<IObjectListingEntry>;
     /**
      * Create a watcher for monitoring bucket changes (add/modify/delete)
      * @param options - Watcher options (prefix, pollIntervalMs, etc.)