@lossless.org/client 0.1.0

package/dist_ts/objectstorage/classes.smartbucket.js

@@ -0,0 +1,357 @@
+// classes.smartbucket.ts
+import * as plugins from './plugins.js';
+import { Bucket } from './classes.bucket.js';
+import { normalizeStorageDescriptor } from './helpers.js';
+import { beginOperationLifecycleClose, commitOperationLifecycleClient, completeOperationLifecycleClose, registerOperationLifecycle, reserveOperationLifecycleClientMutation, rollbackOperationLifecycleClientMutation, } from './internal.exactupload.capability.js';
+const readinessDefaultTimeoutMs = 2_000;
+const readinessMaximumTimeoutMs = 30_000;
+export class SmartBucket {
+    config;
+    currentStorageClient;
+    ownedStorageClient;
+    lifecycleState = 'open';
+    lifecycleEpoch = 0;
+    activeReadinessControllers = new Set();
+    retiredStorageClients = new WeakSet();
+    storageClientMutationInProgress = false;
+    closePromise;
+    operationCloseStarted = false;
+    operationCloseSettlement;
+    /**
+     * The current S3 client used by bucket operations.
+     */
+    get storageClient() {
+        return this.currentStorageClient;
+    }
+    /**
+     * Changes the current S3 client without transferring lifecycle ownership.
+     */
+    set storageClient(storageClientArg) {
+        if (!this.isStorageClient(storageClientArg)) {
+            throw new TypeError('storageClient must provide send() and destroy() methods.');
+        }
+        if (this.lifecycleState !== 'open') {
+            throw new Error(`Cannot assign storageClient while SmartBucket is ${this.lifecycleState}.`);
+        }
+        if (this.storageClientMutationInProgress) {
+            throw new Error('Cannot assign storageClient during another client change.');
+        }
+        if (storageClientArg === this.currentStorageClient) {
+            return;
+        }
+        if (this.retiredStorageClients.has(storageClientArg)) {
+            throw new Error('Cannot reuse a storageClient retired by this SmartBucket.');
+        }
+        this.storageClientMutationInProgress = true;
+        let mutationReserved = false;
+        try {
+            reserveOperationLifecycleClientMutation(this);
+            mutationReserved = true;
+            this.lifecycleEpoch++;
+            this.abortActiveReadinessProbes();
+            this.currentStorageClient = storageClientArg;
+            commitOperationLifecycleClient(this, storageClientArg);
+            mutationReserved = false;
+        }
+        finally {
+            if (mutationReserved) {
+                rollbackOperationLifecycleClientMutation(this);
+            }
+            this.storageClientMutationInProgress = false;
+        }
+    }
+    /** @deprecated Use storageClient instead */
+    get s3Client() {
+        return this.currentStorageClient;
+    }
+    /**
+     * the constructor of SmartBucket
+     */
+    constructor(configArg, clientOptions = {}) {
+        this.config = configArg;
+        // Use the normalizer to handle various endpoint formats
+        const { normalized } = normalizeStorageDescriptor(configArg);
+        this.currentStorageClient = new plugins.s3.S3Client({
+            endpoint: normalized.endpointUrl,
+            region: normalized.region,
+            credentials: normalized.credentials,
+            forcePathStyle: clientOptions.forcePathStyle ?? normalized.forcePathStyle,
+        });
+        this.ownedStorageClient = this.currentStorageClient;
+        registerOperationLifecycle(this, this.currentStorageClient);
+    }
+    async createBucket(bucketNameArg) {
+        const bucket = await Bucket.createBucketByName(this, bucketNameArg);
+        return bucket;
+    }
+    async removeBucket(bucketName) {
+        await Bucket.removeBucketByName(this, bucketName);
+    }
+    async getBucketByName(bucketNameArg) {
+        return Bucket.getBucketByName(this, bucketNameArg);
+    }
+    /**
+     * Check if a bucket exists
+     */
+    async bucketExists(bucketNameArg) {
+        const command = new plugins.s3.ListBucketsCommand({});
+        const buckets = await this.currentStorageClient.send(command);
+        return buckets.Buckets?.some(bucket => bucket.Name === bucketNameArg) ?? false;
+    }
+    /**
+     * Transfers exclusive lifecycle ownership of an S3 client to this SmartBucket.
+     */
+    replaceStorageClient(storageClientArg) {
+        if (!this.isStorageClient(storageClientArg)) {
+            throw new TypeError('storageClient must provide send() and destroy() methods.');
+        }
+        if (this.lifecycleState !== 'open') {
+            throw new Error(`Cannot replace storageClient while SmartBucket is ${this.lifecycleState}.`);
+        }
+        if (this.storageClientMutationInProgress) {
+            throw new Error('Cannot replace storageClient during another client change.');
+        }
+        if (this.retiredStorageClients.has(storageClientArg)) {
+            throw new Error('Cannot reuse a storageClient retired by this SmartBucket.');
+        }
+        if (storageClientArg === this.currentStorageClient &&
+            storageClientArg === this.ownedStorageClient) {
+            return;
+        }
+        this.storageClientMutationInProgress = true;
+        let mutationReserved = false;
+        try {
+            reserveOperationLifecycleClientMutation(this);
+            mutationReserved = true;
+            if (storageClientArg !== this.ownedStorageClient) {
+                const previousOwnedStorageClient = this.ownedStorageClient;
+                try {
+                    previousOwnedStorageClient.destroy();
+                }
+                catch (error) {
+                    // A throwing destroy has an unknown partial-teardown outcome. Keep
+                    // the lifecycle reserved so no later operation can reuse it.
+                    mutationReserved = false;
+                    this.lifecycleState = 'closing';
+                    this.lifecycleEpoch++;
+                    this.abortActiveReadinessProbes();
+                    this.operationCloseSettlement = beginOperationLifecycleClose(this);
+                    this.operationCloseStarted = true;
+                    throw error;
+                }
+                this.retiredStorageClients.add(previousOwnedStorageClient);
+                this.ownedStorageClient = storageClientArg;
+            }
+            this.currentStorageClient = storageClientArg;
+            commitOperationLifecycleClient(this, storageClientArg);
+            mutationReserved = false;
+            this.lifecycleEpoch++;
+            this.abortActiveReadinessProbes();
+        }
+        finally {
+            if (mutationReserved) {
+                rollbackOperationLifecycleClientMutation(this);
+            }
+            this.storageClientMutationInProgress = false;
+        }
+    }
+    /**
+     * Performs a bounded, read-only round trip to verify bucket readiness.
+     */
+    async checkReadiness(bucketNameArg, optionsArg = {}) {
+        const startedAt = performance.now();
+        if (typeof bucketNameArg !== 'string' ||
+            bucketNameArg.length === 0 ||
+            bucketNameArg.trim() !== bucketNameArg) {
+            throw new TypeError('Readiness bucketName must be a non-empty trimmed string.');
+        }
+        const timeoutMs = optionsArg.timeoutMs ?? readinessDefaultTimeoutMs;
+        if (!Number.isSafeInteger(timeoutMs) ||
+            timeoutMs <= 0 ||
+            timeoutMs > readinessMaximumTimeoutMs) {
+            throw new TypeError(`Readiness timeoutMs must be a positive safe integer no greater than ${readinessMaximumTimeoutMs}.`);
+        }
+        const lifecycleReason = this.getReadinessLifecycleReason();
+        if (lifecycleReason) {
+            return this.createReadinessFailure(lifecycleReason, startedAt);
+        }
+        if (this.storageClientMutationInProgress) {
+            return this.createReadinessFailure('unavailable', startedAt);
+        }
+        const callerSignal = optionsArg.signal;
+        if (callerSignal?.aborted) {
+            return this.createReadinessFailure('aborted', startedAt);
+        }
+        const lifecycleEpoch = this.lifecycleEpoch;
+        const storageClient = this.currentStorageClient;
+        const readinessController = new AbortController();
+        let abortSource;
+        const abortForCaller = () => {
+            if (!abortSource) {
+                abortSource = 'caller';
+            }
+            readinessController.abort();
+        };
+        callerSignal?.addEventListener('abort', abortForCaller, { once: true });
+        const deadlineTimer = setTimeout(() => {
+            if (!abortSource) {
+                abortSource = 'deadline';
+            }
+            readinessController.abort();
+        }, timeoutMs);
+        this.activeReadinessControllers.add(readinessController);
+        let sendOutcome;
+        try {
+            sendOutcome = await this.sendReadinessProbe(storageClient, bucketNameArg, readinessController.signal);
+        }
+        finally {
+            clearTimeout(deadlineTimer);
+            callerSignal?.removeEventListener('abort', abortForCaller);
+            this.activeReadinessControllers.delete(readinessController);
+        }
+        const staleReason = this.getStaleReadinessReason(lifecycleEpoch, storageClient);
+        if (staleReason) {
+            return this.createReadinessFailure(staleReason, startedAt);
+        }
+        if (sendOutcome === 'aborted') {
+            if (abortSource === 'caller') {
+                return this.createReadinessFailure('aborted', startedAt);
+            }
+            if (abortSource === 'deadline') {
+                return this.createReadinessFailure('timeout', startedAt);
+            }
+            return this.createReadinessFailure('unavailable', startedAt);
+        }
+        if (sendOutcome === 'unavailable') {
+            return this.createReadinessFailure('unavailable', startedAt);
+        }
+        return {
+            ready: true,
+            status: 'ready',
+            durationMs: performance.now() - startedAt,
+        };
+    }
+    /**
+     * Cancels active readiness and object operations before closing the owned S3 client.
+     */
+    close() {
+        if (this.storageClientMutationInProgress) {
+            throw new Error('Cannot close SmartBucket during a storageClient change.');
+        }
+        if (this.closePromise) {
+            return this.closePromise;
+        }
+        let resolveClose;
+        let rejectClose;
+        const closePromise = new Promise((resolve, reject) => {
+            resolveClose = resolve;
+            rejectClose = reject;
+        });
+        this.closePromise = closePromise;
+        if (!this.operationCloseStarted) {
+            this.lifecycleState = 'closing';
+            this.lifecycleEpoch++;
+            this.abortActiveReadinessProbes();
+            this.operationCloseSettlement = beginOperationLifecycleClose(this);
+            this.operationCloseStarted = true;
+        }
+        const finishClose = () => {
+            try {
+                this.ownedStorageClient.destroy();
+                completeOperationLifecycleClose(this);
+                this.lifecycleState = 'closed';
+                resolveClose();
+            }
+            catch (error) {
+                rejectClose(error);
+            }
+        };
+        if (this.operationCloseSettlement) {
+            void this.operationCloseSettlement.then(finishClose);
+        }
+        else {
+            finishClose();
+        }
+        void closePromise.catch(() => {
+            if (this.closePromise === closePromise) {
+                this.closePromise = undefined;
+            }
+        });
+        return closePromise;
+    }
+    isStorageClient(storageClientArg) {
+        if (typeof storageClientArg !== 'object' || storageClientArg === null) {
+            return false;
+        }
+        const storageClientCandidate = storageClientArg;
+        return (typeof storageClientCandidate.send === 'function' &&
+            typeof storageClientCandidate.destroy === 'function');
+    }
+    abortActiveReadinessProbes() {
+        for (const readinessController of [...this.activeReadinessControllers]) {
+            readinessController.abort();
+        }
+    }
+    sendReadinessProbe(storageClientArg, bucketNameArg, signalArg) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const settle = (outcomeArg) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                signalArg.removeEventListener('abort', abortReadinessProbe);
+                resolve(outcomeArg);
+            };
+            const abortReadinessProbe = () => {
+                settle('aborted');
+            };
+            signalArg.addEventListener('abort', abortReadinessProbe, { once: true });
+            if (signalArg.aborted) {
+                abortReadinessProbe();
+                return;
+            }
+            try {
+                const providerPromise = storageClientArg.send(new plugins.s3.HeadBucketCommand({
+                    Bucket: bucketNameArg,
+                }), {
+                    abortSignal: signalArg,
+                });
+                void providerPromise.then(() => settle('ready'), () => settle('unavailable'));
+            }
+            catch {
+                settle('unavailable');
+            }
+        });
+    }
+    getReadinessLifecycleReason() {
+        switch (this.lifecycleState) {
+            case 'open':
+                return undefined;
+            case 'closing':
+                return 'closing';
+            case 'closed':
+                return 'closed';
+        }
+    }
+    getStaleReadinessReason(lifecycleEpochArg, storageClientArg) {
+        const lifecycleReason = this.getReadinessLifecycleReason();
+        if (lifecycleReason) {
+            return lifecycleReason;
+        }
+        if (this.lifecycleEpoch !== lifecycleEpochArg ||
+            this.currentStorageClient !== storageClientArg) {
+            return 'unavailable';
+        }
+        return undefined;
+    }
+    createReadinessFailure(reasonArg, startedAtArg) {
+        return {
+            ready: false,
+            status: 'unavailable',
+            reason: reasonArg,
+            durationMs: performance.now() - startedAtArg,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smartbucket.js","sourceRoot":"","sources":["../../ts/objectstorage/classes.smartbucket.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+import * as interfaces from './interfaces.js';
+import type { Bucket } from './classes.bucket.js';
+import type { Directory } from './classes.directory.js';
+import type { File } from './classes.file.js';
+export declare class Trash {
+    bucketRef: Bucket;
+    constructor(bucketRefArg: Bucket);
+    getTrashDir(): Promise<Directory>;
+    getTrashedFileByOriginalName(pathDescriptor: interfaces.IPathDecriptor): Promise<File>;
+    getTrashKeyByOriginalBasePath(originalPath: string): Promise<string>;
+}

package/dist_ts/objectstorage/classes.trash.js

@@ -0,0 +1,22 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces.js';
+import * as helpers from './helpers.js';
+export class Trash {
+    bucketRef;
+    constructor(bucketRefArg) {
+        this.bucketRef = bucketRefArg;
+    }
+    async getTrashDir() {
+        return this.bucketRef.getDirectoryFromPath({ path: '.trash' });
+    }
+    async getTrashedFileByOriginalName(pathDescriptor) {
+        const trashDir = await this.getTrashDir();
+        const originalPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+        const trashKey = await this.getTrashKeyByOriginalBasePath(originalPath);
+        return trashDir.getFile({ path: trashKey });
+    }
+    async getTrashKeyByOriginalBasePath(originalPath) {
+        return plugins.smartstring.base64.encode(originalPath);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy50cmFzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL29iamVjdHN0b3JhZ2UvY2xhc3Nlcy50cmFzaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEtBQUssVUFBVSxNQUFNLGlCQUFpQixDQUFDO0FBQzlDLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBTXhDLE1BQU0sT0FBTyxLQUFLO0lBQ1QsU0FBUyxDQUFTO0lBRXpCLFlBQVksWUFBb0I7UUFDOUIsSUFBSSxDQUFDLFNBQVMsR0FBRyxZQUFZLENBQUM7SUFDaEMsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUFXO1FBQ3RCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxvQkFBb0IsQ0FBQyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFFTSxLQUFLLENBQUMsNEJBQTRCLENBQUMsY0FBeUM7UUFDakYsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDMUMsTUFBTSxZQUFZLEdBQUcsTUFBTSxPQUFPLENBQUMsMEJBQTBCLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDOUUsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsNkJBQTZCLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDeEUsT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVNLEtBQUssQ0FBQyw2QkFBNkIsQ0FBRSxZQUFvQjtRQUM5RCxPQUFPLE9BQU8sQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUN6RCxDQUFDO0NBQ0YifQ==

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

@@ -0,0 +1,79 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces.js';
+import type { Bucket } from './classes.bucket.js';
+import { EventEmitter } from 'node:events';
+/**
+ * BucketWatcher monitors a storage bucket for changes (add/modify/delete)
+ * using a polling-based approach. Designed to follow the SmartdataDbWatcher pattern.
+ *
+ * @example
+ * ```typescript
+ * const watcher = bucket.createWatcher({ prefix: 'uploads/', pollIntervalMs: 3000 });
+ *
+ * // RxJS Observable pattern
+ * watcher.changeSubject.subscribe((change) => {
+ *   console.log('Change:', change);
+ * });
+ *
+ * // EventEmitter pattern
+ * watcher.on('change', (change) => console.log(change));
+ * watcher.on('error', (err) => console.error(err));
+ *
+ * await watcher.start();
+ * await watcher.readyDeferred.promise; // Wait for initial state
+ *
+ * // Later...
+ * await watcher.stop();
+ * ```
+ */
+export declare class BucketWatcher extends EventEmitter {
+    /** Deferred that resolves when initial state is built and watcher is ready */
+    readyDeferred: plugins.smartpromise.Deferred<void>;
+    /** Observable for receiving change events (supports RxJS operators) */
+    changeSubject: plugins.smartrx.rxjs.Observable<interfaces.IStorageChangeEvent | interfaces.IStorageChangeEvent[]>;
+    private rawSubject;
+    private previousState;
+    private pollIntervalId;
+    private isPolling;
+    private isStopped;
+    private readonly bucketRef;
+    private readonly prefix;
+    private readonly pollIntervalMs;
+    private readonly bufferTimeMs?;
+    private readonly includeInitial;
+    private readonly pageSize;
+    constructor(bucketRef: Bucket, options?: interfaces.IBucketWatcherOptions);
+    /**
+     * Start watching the bucket for changes
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watching the bucket
+     */
+    stop(): Promise<void>;
+    /**
+     * Alias for stop() - for consistency with other APIs
+     */
+    close(): Promise<void>;
+    /**
+     * Build the initial state by listing all objects with metadata
+     */
+    private buildInitialState;
+    /**
+     * Poll for changes by comparing current state against previous state
+     */
+    private poll;
+    /**
+     * Detect changes between current and previous state
+     */
+    private detectChanges;
+    /**
+     * Emit a change event via both RxJS Subject and EventEmitter
+     */
+    private emitChange;
+    /**
+     * List objects with full metadata (ETag, Size, LastModified)
+     * This is a private method that yields full _Object data, not just keys
+     */
+    private listObjectsWithMetadata;
+}