@push.rocks/smartbucket/dist_ts/classes.bucket.js

A TypeScript library providing a cloud-agnostic interface for managing object storage with functionalities like bucket management, file and directory operations, and advanced features such as metadata handling and file locking.

// classes.bucket.ts
import * as plugins from './plugins.js';
import * as helpers from './helpers.js';
import * as interfaces from './interfaces.js';
import { SmartBucket } from './classes.smartbucket.js';
import { Directory } from './classes.directory.js';
import { File } from './classes.file.js';
import { Trash } from './classes.trash.js';
/**
 * The bucket class exposes the basic functionality of a bucket.
 * The functions of the bucket alone are enough to
 * operate in S3 basic fashion on blobs of data.
 */
export class Bucket {
    static async getBucketByName(smartbucketRef, bucketNameArg) {
        const command = new plugins.s3.ListBucketsCommand({});
        const buckets = await smartbucketRef.s3Client.send(command);
        const foundBucket = buckets.Buckets.find((bucket) => bucket.Name === bucketNameArg);
        if (foundBucket) {
            console.log(`bucket with name ${bucketNameArg} exists.`);
            console.log(`Taking this as base for new Bucket instance`);
            return new this(smartbucketRef, bucketNameArg);
        }
        else {
            console.log(`did not find bucket by name: ${bucketNameArg}`);
            return null;
        }
    }
    static async createBucketByName(smartbucketRef, bucketName) {
        const command = new plugins.s3.CreateBucketCommand({ Bucket: bucketName });
        await smartbucketRef.s3Client.send(command).catch((e) => console.log(e));
        return new Bucket(smartbucketRef, bucketName);
    }
    static async removeBucketByName(smartbucketRef, bucketName) {
        const command = new plugins.s3.DeleteBucketCommand({ Bucket: bucketName });
        await smartbucketRef.s3Client.send(command).catch((e) => console.log(e));
    }
    constructor(smartbucketRef, bucketName) {
        this.smartbucketRef = smartbucketRef;
        this.name = bucketName;
    }
    /**
     * gets the base directory of the bucket
     */
    async getBaseDirectory() {
        return new Directory(this, null, '');
    }
    /**
     * gets the trash directory
     */
    async getTrash() {
        const trash = new Trash(this);
        return trash;
    }
    async getDirectoryFromPath(pathDescriptorArg) {
        if (!pathDescriptorArg.path && !pathDescriptorArg.directory) {
            return this.getBaseDirectory();
        }
        const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptorArg);
        const baseDirectory = await this.getBaseDirectory();
        return await baseDirectory.getSubDirectoryByNameStrict(checkPath, {
            getEmptyDirectory: true,
        });
    }
    // ===============
    // Fast Operations
    // ===============
    /**
     * store file
     */
    async fastPut(optionsArg) {
        try {
            const reducedPath = await helpers.reducePathDescriptorToPath(optionsArg);
            const exists = await this.fastExists({ path: reducedPath });
            if (exists && !optionsArg.overwrite) {
                const errorText = `Object already exists at path '${reducedPath}' in bucket '${this.name}'.`;
                console.error(errorText);
                return null;
            }
            else if (exists && optionsArg.overwrite) {
                console.log(`Overwriting existing object at path '${reducedPath}' in bucket '${this.name}'.`);
            }
            else {
                console.log(`Creating new object at path '${reducedPath}' in bucket '${this.name}'.`);
            }
            const command = new plugins.s3.PutObjectCommand({
                Bucket: this.name,
                Key: reducedPath,
                Body: optionsArg.contents,
            });
            await this.smartbucketRef.s3Client.send(command);
            console.log(`Object '${reducedPath}' has been successfully stored in bucket '${this.name}'.`);
            const parsedPath = plugins.path.parse(reducedPath);
            return new File({
                directoryRefArg: await this.getDirectoryFromPath({
                    path: parsedPath.dir,
                }),
                fileName: parsedPath.base,
            });
        }
        catch (error) {
            console.error(`Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`, error);
            throw error;
        }
    }
    async fastPutStrict(...args) {
        const file = await this.fastPut(...args);
        if (!file) {
            throw new Error(`File not stored at path '${args[0].path}'`);
        }
        return file;
    }
    /**
     * get file
     */
    async fastGet(optionsArg) {
        const done = plugins.smartpromise.defer();
        let completeFile;
        const replaySubject = await this.fastGetReplaySubject(optionsArg);
        const subscription = replaySubject.subscribe({
            next: (chunk) => {
                if (completeFile) {
                    completeFile = Buffer.concat([completeFile, chunk]);
                }
                else {
                    completeFile = chunk;
                }
            },
            complete: () => {
                done.resolve();
                subscription.unsubscribe();
            },
            error: (err) => {
                console.log(err);
            },
        });
        await done.promise;
        return completeFile;
    }
    /**
     * good when time to first byte is important
     * and multiple subscribers are expected
     * @param optionsArg
     * @returns
     */
    async fastGetReplaySubject(optionsArg) {
        const command = new plugins.s3.GetObjectCommand({
            Bucket: this.name,
            Key: optionsArg.path,
        });
        const response = await this.smartbucketRef.s3Client.send(command);
        const replaySubject = new plugins.smartrx.rxjs.ReplaySubject();
        // Convert the stream to a format that supports piping
        const stream = response.Body; // SdkStreamMixin includes readable stream
        if (typeof stream.pipe === 'function') {
            const duplexStream = new plugins.smartstream.SmartDuplex({
                writeFunction: async (chunk) => {
                    replaySubject.next(chunk);
                    return;
                },
                finalFunction: async (cb) => {
                    replaySubject.complete();
                    return;
                },
            });
            stream.pipe(duplexStream);
        }
        return replaySubject;
    }
    async fastGetStream(optionsArg, typeArg = 'nodestream') {
        const command = new plugins.s3.GetObjectCommand({
            Bucket: this.name,
            Key: optionsArg.path,
        });
        const response = await this.smartbucketRef.s3Client.send(command);
        const stream = response.Body; // SdkStreamMixin includes readable stream
        const duplexStream = new plugins.smartstream.SmartDuplex({
            writeFunction: async (chunk) => {
                return chunk;
            },
            finalFunction: async (cb) => {
                return null;
            },
        });
        if (typeof stream.pipe === 'function') {
            stream.pipe(duplexStream);
        }
        if (typeArg === 'nodestream') {
            return duplexStream;
        }
        if (typeArg === 'webstream') {
            return (await duplexStream.getWebStreams()).readable;
        }
        throw new Error('unknown typeArg');
    }
    /**
     * store file as stream
     */
    async fastPutStream(optionsArg) {
        try {
            const exists = await this.fastExists({ path: optionsArg.path });
            if (exists && !optionsArg.overwrite) {
                console.error(`Object already exists at path '${optionsArg.path}' in bucket '${this.name}'.`);
                return;
            }
            else if (exists && optionsArg.overwrite) {
                console.log(`Overwriting existing object at path '${optionsArg.path}' in bucket '${this.name}'.`);
            }
            else {
                console.log(`Creating new object at path '${optionsArg.path}' in bucket '${this.name}'.`);
            }
            const command = new plugins.s3.PutObjectCommand({
                Bucket: this.name,
                Key: optionsArg.path,
                Body: optionsArg.readableStream,
                Metadata: optionsArg.nativeMetadata,
            });
            await this.smartbucketRef.s3Client.send(command);
            console.log(`Object '${optionsArg.path}' has been successfully stored in bucket '${this.name}'.`);
        }
        catch (error) {
            console.error(`Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`, error);
            throw error;
        }
    }
    async fastCopy(optionsArg) {
        try {
            const targetBucketName = optionsArg.targetBucket ? optionsArg.targetBucket.name : this.name;
            // Retrieve current object information to use in copy conditions
            const currentObjInfo = await this.smartbucketRef.s3Client.send(new plugins.s3.HeadObjectCommand({
                Bucket: this.name,
                Key: optionsArg.sourcePath,
            }));
            // Prepare new metadata
            const newNativeMetadata = {
                ...(optionsArg.deleteExistingNativeMetadata ? {} : currentObjInfo.Metadata),
                ...optionsArg.nativeMetadata,
            };
            // Define the copy operation
            const copySource = `${this.name}/${optionsArg.sourcePath}`;
            const command = new plugins.s3.CopyObjectCommand({
                Bucket: targetBucketName,
                CopySource: copySource,
                Key: optionsArg.destinationPath || optionsArg.sourcePath,
                Metadata: newNativeMetadata,
                MetadataDirective: optionsArg.deleteExistingNativeMetadata ? 'REPLACE' : 'COPY',
            });
            await this.smartbucketRef.s3Client.send(command);
        }
        catch (err) {
            console.error('Error updating metadata:', err);
            throw err; // rethrow to allow caller to handle
        }
    }
    /**
     * Move object from one path to another within the same bucket or to another bucket
     */
    async fastMove(optionsArg) {
        try {
            const destinationBucket = optionsArg.targetBucket || this;
            const exists = await destinationBucket.fastExists({
                path: optionsArg.destinationPath,
            });
            if (exists && !optionsArg.overwrite) {
                console.error(`Object already exists at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
                return;
            }
            else if (exists && optionsArg.overwrite) {
                console.log(`Overwriting existing object at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
            }
            else {
                console.log(`Moving object to path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
            }
            await this.fastCopy(optionsArg);
            await this.fastRemove({ path: optionsArg.sourcePath });
            console.log(`Object '${optionsArg.sourcePath}' has been successfully moved to '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
        }
        catch (error) {
            console.error(`Error moving object from '${optionsArg.sourcePath}' to '${optionsArg.destinationPath}':`, error);
            throw error;
        }
    }
    /**
     * removeObject
     */
    async fastRemove(optionsArg) {
        const command = new plugins.s3.DeleteObjectCommand({
            Bucket: this.name,
            Key: optionsArg.path,
        });
        await this.smartbucketRef.s3Client.send(command);
    }
    /**
     * check whether file exists
     * @param optionsArg
     * @returns
     */
    async fastExists(optionsArg) {
        try {
            const command = new plugins.s3.HeadObjectCommand({
                Bucket: this.name,
                Key: optionsArg.path,
            });
            await this.smartbucketRef.s3Client.send(command);
            console.log(`Object '${optionsArg.path}' exists in bucket '${this.name}'.`);
            return true;
        }
        catch (error) {
            if (error?.name === 'NotFound') {
                console.log(`Object '${optionsArg.path}' does not exist in bucket '${this.name}'.`);
                return false;
            }
            else {
                console.error('Error checking object existence:', error);
                throw error; // Rethrow if it's not a NotFound error to handle unexpected issues
            }
        }
    }
    /**
     * deletes this bucket
     */
    async delete() {
        await this.smartbucketRef.s3Client.send(new plugins.s3.DeleteBucketCommand({ Bucket: this.name }));
    }
    async fastStat(pathDescriptor) {
        const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
        const command = new plugins.s3.HeadObjectCommand({
            Bucket: this.name,
            Key: checkPath,
        });
        return this.smartbucketRef.s3Client.send(command);
    }
    async isDirectory(pathDescriptor) {
        const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
        const command = new plugins.s3.ListObjectsV2Command({
            Bucket: this.name,
            Prefix: checkPath,
            Delimiter: '/',
        });
        const { CommonPrefixes } = await this.smartbucketRef.s3Client.send(command);
        return !!CommonPrefixes && CommonPrefixes.length > 0;
    }
    async isFile(pathDescriptor) {
        const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
        const command = new plugins.s3.ListObjectsV2Command({
            Bucket: this.name,
            Prefix: checkPath,
            Delimiter: '/',
        });
        const { Contents } = await this.smartbucketRef.s3Client.send(command);
        return !!Contents && Contents.length > 0;
    }
    async getMagicBytes(optionsArg) {
        try {
            const command = new plugins.s3.GetObjectCommand({
                Bucket: this.name,
                Key: optionsArg.path,
                Range: `bytes=0-${optionsArg.length - 1}`,
            });
            const response = await this.smartbucketRef.s3Client.send(command);
            const chunks = [];
            const stream = response.Body; // SdkStreamMixin includes readable stream
            for await (const chunk of stream) {
                chunks.push(chunk);
            }
            return Buffer.concat(chunks);
        }
        catch (error) {
            console.error(`Error retrieving magic bytes from object at path '${optionsArg.path}' in bucket '${this.name}':`, error);
            throw error;
        }
    }
    async cleanAllContents() {
        try {
            // Define the command type explicitly
            const listCommandInput = {
                Bucket: this.name,
            };
            let isTruncated = true;
            let continuationToken = undefined;
            while (isTruncated) {
                // Add the continuation token to the input if present
                const listCommand = new plugins.s3.ListObjectsV2Command({
                    ...listCommandInput,
                    ContinuationToken: continuationToken,
                });
                // Explicitly type the response
                const response = await this.smartbucketRef.s3Client.send(listCommand);
                console.log(`Cleaning contents of bucket '${this.name}': Now deleting ${response.Contents?.length} items...`);
                if (response.Contents && response.Contents.length > 0) {
                    // Delete objects in batches, mapping each item to { Key: string }
                    const deleteCommand = new plugins.s3.DeleteObjectsCommand({
                        Bucket: this.name,
                        Delete: {
                            Objects: response.Contents.map((item) => ({ Key: item.Key })),
                            Quiet: true,
                        },
                    });
                    await this.smartbucketRef.s3Client.send(deleteCommand);
                }
                // Update continuation token and truncation status
                isTruncated = response.IsTruncated || false;
                continuationToken = response.NextContinuationToken;
            }
            console.log(`All contents in bucket '${this.name}' have been deleted.`);
        }
        catch (error) {
            console.error(`Error cleaning contents of bucket '${this.name}':`, error);
            throw error;
        }
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.bucket.js","sourceRoot":"","sources":["../ts/classes.bucket.ts"],"names":[],"mappings":"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"}