@lossless.org/client 0.1.0

package/dist_ts/objectstorage/classes.file.js

@@ -0,0 +1,255 @@
+import * as plugins from './plugins.js';
+import * as helpers from './helpers.js';
+import * as interfaces from './interfaces.js';
+import { Directory } from './classes.directory.js';
+import { MetaData } from './classes.metadata.js';
+/**
+ * represents a file in a directory
+ */
+export class File {
+    // STATIC
+    /**
+     * creates a file in draft mode
+     * you need to call .save() to store it in object storage
+     * @param optionsArg
+     */
+    static async create(optionsArg) {
+        const contents = typeof optionsArg.contents === 'string'
+            ? Buffer.from(optionsArg.contents, optionsArg.encoding)
+            : optionsArg.contents;
+        const file = new File({
+            directoryRefArg: optionsArg.directory,
+            fileName: optionsArg.name,
+        });
+        if (contents instanceof plugins.stream.Readable) {
+            await optionsArg.directory.fastPutStream({
+                path: optionsArg.name,
+                stream: contents,
+            });
+        }
+        else {
+            await optionsArg.directory.fastPut({
+                path: optionsArg.name,
+                contents: contents,
+            });
+        }
+        return file;
+    }
+    // INSTANCE
+    parentDirectoryRef;
+    name;
+    /**
+     * get the full path to the file
+     * @returns the full path to the file
+     */
+    getBasePath() {
+        return plugins.path.join(this.parentDirectoryRef.getBasePath(), this.name);
+    }
+    constructor(optionsArg) {
+        this.parentDirectoryRef = optionsArg.directoryRefArg;
+        this.name = optionsArg.fileName;
+    }
+    async getContentsAsString() {
+        const fileBuffer = await this.getContents();
+        return fileBuffer.toString();
+    }
+    async getContents() {
+        const resultBuffer = await this.parentDirectoryRef.bucketRef.fastGet({
+            path: this.getBasePath(),
+        });
+        return resultBuffer;
+    }
+    async getReadStream(typeArg) {
+        const readStream = this.parentDirectoryRef.bucketRef.fastGetStream({
+            path: this.getBasePath(),
+        }, typeArg);
+        return readStream;
+    }
+    /**
+     * deletes this file
+     */
+    async delete(optionsArg) {
+        optionsArg = {
+            ...{
+                mode: 'permanent',
+            },
+            ...optionsArg,
+        };
+        if (optionsArg.mode === 'permanent') {
+            await this.parentDirectoryRef.bucketRef.fastRemove({
+                path: this.getBasePath(),
+            });
+            if (!this.name.endsWith('.metadata')) {
+                if (await this.hasMetaData()) {
+                    const metadata = await this.getMetaData();
+                    await metadata.metadataFile.delete(optionsArg);
+                }
+            }
+        }
+        else if (optionsArg.mode === 'trash') {
+            const metadata = await this.getMetaData();
+            await metadata.storeCustomMetaData({
+                key: 'recycle',
+                value: {
+                    deletedAt: Date.now(),
+                    originalPath: this.getBasePath(),
+                },
+            });
+            const trash = await this.parentDirectoryRef.bucketRef.getTrash();
+            const trashDir = await trash.getTrashDir();
+            await this.move({
+                directory: trashDir,
+                path: await trash.getTrashKeyByOriginalBasePath(this.getBasePath()),
+            });
+        }
+        await this.parentDirectoryRef.listFiles();
+    }
+    /**
+     * restores
+     */
+    async restore(optionsArg = {}) {
+        optionsArg = {
+            useOriginalPath: (() => {
+                return optionsArg.toPath ? false : true;
+            })(),
+            overwrite: false,
+            ...optionsArg,
+        };
+        const metadata = await this.getMetaData();
+        const moveToPath = optionsArg.toPath || (await metadata.getCustomMetaData({
+            key: 'recycle'
+        })).originalPath;
+        await metadata.deleteCustomMetaData({
+            key: 'recycle'
+        });
+        await this.move({
+            path: moveToPath,
+        });
+    }
+    /**
+     * allows locking the file
+     * @param optionsArg
+     */
+    async lock(optionsArg) {
+        const metadata = await this.getMetaData();
+        await metadata.setLock({
+            lock: 'locked',
+            expires: Date.now() + (optionsArg?.timeoutMillis || 1000),
+        });
+    }
+    /**
+     * actively unlocks a file
+     *
+     */
+    async unlock(optionsArg) {
+        const metadata = await this.getMetaData();
+        await metadata.removeLock({
+            force: optionsArg?.force || false,
+        });
+    }
+    async updateWithContents(optionsArg) {
+        if (optionsArg.contents instanceof plugins.stream.Readable ||
+            optionsArg.contents instanceof ReadableStream) {
+            await this.parentDirectoryRef.bucketRef.fastPutStream({
+                path: this.getBasePath(),
+                readableStream: optionsArg.contents,
+                overwrite: true,
+            });
+        }
+        else if (Buffer.isBuffer(optionsArg.contents)) {
+            await this.parentDirectoryRef.bucketRef.fastPut({
+                path: this.getBasePath(),
+                contents: optionsArg.contents,
+                overwrite: true,
+            });
+        }
+        else if (typeof optionsArg.contents === 'string') {
+            await this.parentDirectoryRef.bucketRef.fastPut({
+                path: this.getBasePath(),
+                contents: Buffer.from(optionsArg.contents, optionsArg.encoding),
+                overwrite: true,
+            });
+        }
+    }
+    /**
+     * moves the file to another directory
+     */
+    async move(pathDescriptorArg) {
+        let moveToPath = '';
+        const isDirectory = await this.parentDirectoryRef.bucketRef.isDirectory(pathDescriptorArg);
+        if (isDirectory) {
+            moveToPath = await helpers.reducePathDescriptorToPath({
+                ...pathDescriptorArg,
+                path: plugins.path.join(pathDescriptorArg.path, this.name),
+            });
+        }
+        else {
+            moveToPath = await helpers.reducePathDescriptorToPath(pathDescriptorArg);
+        }
+        // lets move the file
+        await this.parentDirectoryRef.bucketRef.fastMove({
+            sourcePath: this.getBasePath(),
+            destinationPath: moveToPath,
+            overwrite: true,
+        });
+        // lets move the metadatafile
+        if (!this.name.endsWith('.metadata')) {
+            const metadata = await this.getMetaData();
+            await this.parentDirectoryRef.bucketRef.fastMove({
+                sourcePath: metadata.metadataFile.getBasePath(),
+                destinationPath: moveToPath + '.metadata',
+                overwrite: true,
+            });
+        }
+        // lets update references of this
+        const baseDirectory = await this.parentDirectoryRef.bucketRef.getBaseDirectory();
+        this.parentDirectoryRef = await baseDirectory.getSubDirectoryByName(await helpers.reducePathDescriptorToPath(pathDescriptorArg), {
+            couldBeFilePath: true,
+        });
+        this.name = pathDescriptorArg.path;
+    }
+    async hasMetaData() {
+        if (!this.name.endsWith('.metadata')) {
+            const hasMetadataBool = MetaData.hasMetaData({
+                file: this,
+            });
+            return hasMetadataBool;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * allows updating the metadata of a file
+     * @param updatedMetadata
+     */
+    async getMetaData() {
+        if (this.name.endsWith('.metadata')) {
+            throw new Error('metadata files cannot have metadata');
+        }
+        const metadata = await MetaData.createForFile({
+            file: this,
+        });
+        return metadata;
+    }
+    /**
+     * gets the contents as json
+     */
+    async getJsonData() {
+        const json = await this.getContentsAsString();
+        const parsed = await JSON.parse(json);
+        return parsed;
+    }
+    async writeJsonData(dataArg) {
+        await this.updateWithContents({
+            contents: JSON.stringify(dataArg),
+        });
+    }
+    async getMagicBytes(optionsArg) {
+        return this.parentDirectoryRef.bucketRef.getMagicBytes({
+            path: this.getBasePath(),
+            length: optionsArg.length,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.file.js","sourceRoot":"","sources":["../../ts/objectstorage/classes.file.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,41 @@
+import type { Bucket } from './classes.bucket.js';
+export interface IListCursorOptions {
+    pageSize?: number;
+}
+export interface IListCursorResult {
+    keys: string[];
+    done: boolean;
+}
+/**
+ * ListCursor provides explicit pagination control for listing objects in a bucket.
+ * Useful for UI pagination, resumable operations, and manual batch processing.
+ */
+export declare class ListCursor {
+    private bucket;
+    private prefix;
+    private continuationToken?;
+    private exhausted;
+    private pageSize;
+    constructor(bucket: Bucket, prefix: string, options?: IListCursorOptions);
+    /**
+     * Fetch the next page of object keys
+     * @returns Object with keys array and done flag
+     */
+    next(): Promise<IListCursorResult>;
+    /**
+     * Check if there are more pages to fetch
+     */
+    hasMore(): boolean;
+    /**
+     * Reset the cursor to start from the beginning
+     */
+    reset(): void;
+    /**
+     * Get the current continuation token (for saving/restoring state)
+     */
+    getToken(): string | undefined;
+    /**
+     * Set the continuation token (for resuming from a saved state)
+     */
+    setToken(token: string | undefined): void;
+}

package/dist_ts/objectstorage/classes.listcursor.js

@@ -0,0 +1,67 @@
+// classes.listcursor.ts
+import * as plugins from './plugins.js';
+/**
+ * ListCursor provides explicit pagination control for listing objects in a bucket.
+ * Useful for UI pagination, resumable operations, and manual batch processing.
+ */
+export class ListCursor {
+    bucket;
+    prefix;
+    continuationToken;
+    exhausted = false;
+    pageSize;
+    constructor(bucket, prefix, options = {}) {
+        this.bucket = bucket;
+        this.prefix = prefix;
+        this.pageSize = options.pageSize || 1000;
+    }
+    /**
+     * Fetch the next page of object keys
+     * @returns Object with keys array and done flag
+     */
+    async next() {
+        if (this.exhausted) {
+            return { keys: [], done: true };
+        }
+        const command = new plugins.s3.ListObjectsV2Command({
+            Bucket: this.bucket.name,
+            Prefix: this.prefix,
+            MaxKeys: this.pageSize,
+            ContinuationToken: this.continuationToken,
+        });
+        const response = await this.bucket.smartbucketRef.storageClient.send(command);
+        const keys = (response.Contents || [])
+            .map((obj) => obj.Key)
+            .filter((key) => !!key);
+        this.continuationToken = response.NextContinuationToken;
+        this.exhausted = !this.continuationToken;
+        return { keys, done: this.exhausted };
+    }
+    /**
+     * Check if there are more pages to fetch
+     */
+    hasMore() {
+        return !this.exhausted;
+    }
+    /**
+     * Reset the cursor to start from the beginning
+     */
+    reset() {
+        this.continuationToken = undefined;
+        this.exhausted = false;
+    }
+    /**
+     * Get the current continuation token (for saving/restoring state)
+     */
+    getToken() {
+        return this.continuationToken;
+    }
+    /**
+     * Set the continuation token (for resuming from a saved state)
+     */
+    setToken(token) {
+        this.continuationToken = token;
+        this.exhausted = !token;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,57 @@
+import * as plugins from './plugins.js';
+import { File } from './classes.file.js';
+export declare class MetaData {
+    static hasMetaData(optionsArg: {
+        file: File;
+    }): Promise<boolean>;
+    static createForFile(optionsArg: {
+        file: File;
+    }): Promise<MetaData>;
+    /**
+     * the file that contains the metadata
+     */
+    metadataFile: File;
+    /**
+     * the file that the metadata is for
+     */
+    fileRef: File;
+    getFileType(optionsArg?: {
+        useFileExtension?: boolean;
+        useMagicBytes?: boolean;
+    }): Promise<plugins.smartmime.IFileTypeResult | undefined>;
+    /**
+     * gets the size of the fileRef
+     */
+    getSizeInBytes(): Promise<number>;
+    private prefixCustomMetaData;
+    storeCustomMetaData<T = any>(optionsArg: {
+        key: string;
+        value: T;
+    }): Promise<void>;
+    getCustomMetaData<T = any>(optionsArg: {
+        key: string;
+    }): Promise<T>;
+    deleteCustomMetaData(optionsArg: {
+        key: string;
+    }): Promise<void>;
+    /**
+     * set a lock on the ref file
+     * @param optionsArg
+     */
+    setLock(optionsArg: {
+        lock: string;
+        expires: number;
+    }): Promise<void>;
+    /**
+     * remove the lock on the ref file
+     * @param optionsArg
+     */
+    removeLock(optionsArg: {
+        force: boolean;
+    }): Promise<void>;
+    checkLocked(): Promise<boolean>;
+    getLockInfo(): Promise<{
+        lock: string;
+        expires: number;
+    }>;
+}

package/dist_ts/objectstorage/classes.metadata.js

@@ -0,0 +1,113 @@
+import * as plugins from './plugins.js';
+import { File } from './classes.file.js';
+export class MetaData {
+    static async hasMetaData(optionsArg) {
+        // try finding the existing metadata file; return false if it doesn't exist
+        try {
+            const existingFile = await optionsArg.file.parentDirectoryRef.getFile({
+                path: optionsArg.file.name + '.metadata',
+            });
+            return !!existingFile;
+        }
+        catch (error) {
+            const message = error?.message || '';
+            const isNotFound = message.includes('File not found') ||
+                error?.name === 'NotFound' ||
+                error?.$metadata?.httpStatusCode === 404;
+            if (isNotFound) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    // static
+    static async createForFile(optionsArg) {
+        const metaData = new MetaData();
+        metaData.fileRef = optionsArg.file;
+        // lets find the existing metadata file
+        metaData.metadataFile = await metaData.fileRef.parentDirectoryRef.getFile({
+            path: metaData.fileRef.name + '.metadata',
+            createWithContents: '{}',
+        });
+        return metaData;
+    }
+    // instance
+    /**
+     * the file that contains the metadata
+     */
+    metadataFile;
+    /**
+     * the file that the metadata is for
+     */
+    fileRef;
+    async getFileType(optionsArg) {
+        if ((optionsArg && optionsArg.useFileExtension) || !optionsArg) {
+            const fileType = await plugins.smartmime.detectMimeType({
+                path: this.fileRef.name,
+            });
+            return fileType;
+        }
+        if (optionsArg && optionsArg.useMagicBytes) {
+            const fileType = await plugins.smartmime.detectMimeType({
+                buffer: await this.fileRef.getMagicBytes({
+                    length: 100,
+                })
+            });
+            return fileType;
+        }
+        throw new Error('optionsArg.useFileExtension and optionsArg.useMagicBytes cannot both be false');
+    }
+    /**
+     * gets the size of the fileRef
+     */
+    async getSizeInBytes() {
+        const stat = await this.fileRef.parentDirectoryRef.bucketRef.fastStat({
+            path: this.fileRef.getBasePath(),
+        });
+        return stat.ContentLength;
+    }
+    prefixCustomMetaData = 'custom_';
+    async storeCustomMetaData(optionsArg) {
+        const data = await this.metadataFile.getJsonData();
+        data[this.prefixCustomMetaData + optionsArg.key] = optionsArg.value;
+        await this.metadataFile.writeJsonData(data);
+    }
+    async getCustomMetaData(optionsArg) {
+        const data = await this.metadataFile.getJsonData();
+        return data[this.prefixCustomMetaData + optionsArg.key];
+    }
+    async deleteCustomMetaData(optionsArg) {
+        const data = await this.metadataFile.getJsonData();
+        delete data[this.prefixCustomMetaData + optionsArg.key];
+        await this.metadataFile.writeJsonData(data);
+    }
+    /**
+     * set a lock on the ref file
+     * @param optionsArg
+     */
+    async setLock(optionsArg) {
+        const data = await this.metadataFile.getJsonData();
+        data.lock = optionsArg.lock;
+        data.lockExpires = optionsArg.expires;
+        await this.metadataFile.writeJsonData(data);
+    }
+    /**
+     * remove the lock on the ref file
+     * @param optionsArg
+     */
+    async removeLock(optionsArg) {
+        const data = await this.metadataFile.getJsonData();
+        delete data.lock;
+        delete data.lockExpires;
+        await this.metadataFile.writeJsonData(data);
+    }
+    async checkLocked() {
+        const data = await this.metadataFile.getJsonData();
+        return data.lock && data.lockExpires > Date.now();
+    }
+    async getLockInfo() {
+        const data = await this.metadataFile.getJsonData();
+        return { lock: data.lock, expires: data.lockExpires };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,57 @@
+import * as plugins from './plugins.js';
+import { Bucket } from './classes.bucket.js';
+import type { ISmartBucketReadinessOptions, TSmartBucketReadinessResult } from './interfaces.js';
+export declare class SmartBucket {
+    config: plugins.tsclass.storage.IStorageDescriptor;
+    private currentStorageClient;
+    private ownedStorageClient;
+    private lifecycleState;
+    private lifecycleEpoch;
+    private activeReadinessControllers;
+    private retiredStorageClients;
+    private storageClientMutationInProgress;
+    private closePromise;
+    private operationCloseStarted;
+    private operationCloseSettlement;
+    /**
+     * The current S3 client used by bucket operations.
+     */
+    get storageClient(): plugins.s3.S3Client;
+    /**
+     * Changes the current S3 client without transferring lifecycle ownership.
+     */
+    set storageClient(storageClientArg: plugins.s3.S3Client);
+    /** @deprecated Use storageClient instead */
+    get s3Client(): plugins.s3.S3Client;
+    /**
+     * the constructor of SmartBucket
+     */
+    constructor(configArg: plugins.tsclass.storage.IStorageDescriptor, clientOptions?: {
+        forcePathStyle?: boolean;
+    });
+    createBucket(bucketNameArg: string): Promise<Bucket>;
+    removeBucket(bucketName: string): Promise<void>;
+    getBucketByName(bucketNameArg: string): Promise<Bucket>;
+    /**
+     * Check if a bucket exists
+     */
+    bucketExists(bucketNameArg: string): Promise<boolean>;
+    /**
+     * Transfers exclusive lifecycle ownership of an S3 client to this SmartBucket.
+     */
+    replaceStorageClient(storageClientArg: plugins.s3.S3Client): void;
+    /**
+     * Performs a bounded, read-only round trip to verify bucket readiness.
+     */
+    checkReadiness(bucketNameArg: string, optionsArg?: ISmartBucketReadinessOptions): Promise<TSmartBucketReadinessResult>;
+    /**
+     * Cancels active readiness and object operations before closing the owned S3 client.
+     */
+    close(): Promise<void>;
+    private isStorageClient;
+    private abortActiveReadinessProbes;
+    private sendReadinessProbe;
+    private getReadinessLifecycleReason;
+    private getStaleReadinessReason;
+    private createReadinessFailure;
+}