3.0.21

changelog.md

@@ -0,0 +1,56 @@
+# Changelog
+
+## 2024-07-04 - 3.0.21 - fix(test)
+Update endpoint configuration in tests to use environment variable
+
+- Modified `qenv.yml` to include `S3_ENDPOINT` as a required environment variable.
+- Updated test files to fetch `S3_ENDPOINT` from environment instead of hardcoding.
+
+## 2024-06-19 - 3.0.20 - Fix and Stability Updates
+Improved overall stability and consistency.
+
+## 2024-06-18 - 3.0.18 - Delete Functions Consistency
+Ensured more consistency between delete methods and trash behavior.
+
+## 2024-06-17 - 3.0.17 to 3.0.16 - Fix and Update
+Routine updates and fixes performed.
+
+## 2024-06-11 - 3.0.15 to 3.0.14 - Fix and Update
+Routine updates and fixes performed.
+
+## 2024-06-10 - 3.0.13 - Trash Feature Completion
+Finished work on trash feature.
+
+## 2024-06-09 - 3.0.12 - Fix and Update
+Routine updates and fixes performed.
+
+## 2024-06-08 - 3.0.11 to 3.0.10 - Fix and Update
+Routine updates and fixes performed.
+
+## 2024-06-03 - 3.0.10 - Fix and Update
+Routine updates and fixes performed.
+
+## 2024-05-29 - 3.0.9 - Update Description
+Updated project description.
+
+## 2024-05-27 - 3.0.8 to 3.0.6 - Pathing and Core Updates
+Routine updates and fixes performed.
+  - S3 paths' pathing differences now correctly handled with a reducePath method.
+
+## 2024-05-21 - 3.0.5 to 3.0.4 - Fix and Update
+Routine updates and fixes performed.
+
+## 2024-05-17 - 3.0.3 to 3.0.2 - Fix and Update
+Routine updates and fixes performed.
+
+## 2024-05-17 - 3.0.0 - Major Release
+Introduced breaking changes in core and significant improvements.
+
+## 2024-05-05 - 2.0.5 - Breaking Changes
+Introduced breaking changes in core functionality.
+
+## 2024-04-14 - 2.0.4 - TSConfig Update
+Updated TypeScript configuration.
+
+## 2024-01-01 - 2.0.2 - Organization Scheme Update
+Switched to the new organizational scheme.

npmextra.json

@@ -8,25 +8,28 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartbucket",
-      "description": "A TypeScript library that offers simple, cloud-independent object storage with features like bucket creation, file management, and directory management.",
+      "description": "A TypeScript library offering simple and cloud-agnostic object storage with advanced features like bucket creation, file and directory management, and data streaming.",
       "npmPackagename": "@push.rocks/smartbucket",
       "license": "MIT",
       "keywords": [
+        "TypeScript",
         "cloud storage",
         "object storage",
-        "TypeScript",
+        "bucket creation",
-        "S3",
-        "minio",
         "file management",
         "directory management",
-        "bucket creation",
         "data streaming",
         "multi-cloud",
         "API",
         "unified storage",
+        "S3",
+        "minio",
+        "file locking",
+        "metadata",
         "buffer handling",
         "access key",
-        "secret key"
+        "secret key",
+        "cloud agnostic"
       ]
     }
   },

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@push.rocks/smartbucket",
-  "version": "3.0.4",
+  "version": "3.0.21",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@push.rocks/smartbucket",
-      "version": "3.0.4",
+      "version": "3.0.21",
       "license": "UNLICENSED",
       "dependencies": {
         "@push.rocks/smartpath": "^5.0.18",

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@push.rocks/smartbucket",
-  "version": "3.0.4",
+  "version": "3.0.21",
-  "description": "A TypeScript library that offers simple, cloud-independent object storage with features like bucket creation, file management, and directory management.",
+  "description": "A TypeScript library offering simple and cloud-agnostic object storage with advanced features like bucket creation, file and directory management, and data streaming.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -19,13 +19,15 @@
     "@push.rocks/tapbundle": "^5.0.23"
   },
   "dependencies": {
-    "@push.rocks/smartmime": "^2.0.0",
+    "@aws-sdk/client-s3": "^3.600.0",
+    "@push.rocks/smartmime": "^2.0.2",
     "@push.rocks/smartpath": "^5.0.18",
     "@push.rocks/smartpromise": "^4.0.3",
     "@push.rocks/smartrx": "^3.0.7",
-    "@push.rocks/smartstream": "^3.0.38",
+    "@push.rocks/smartstream": "^3.0.44",
-    "@tsclass/tsclass": "^4.0.54",
+    "@push.rocks/smartstring": "^4.0.15",
-    "minio": "^8.0.0"
+    "@push.rocks/smartunique": "^3.0.9",
+    "@tsclass/tsclass": "^4.0.60"
   },
   "private": false,
   "files": [
@@ -44,20 +46,28 @@
     "last 1 chrome versions"
   ],
   "keywords": [
+    "TypeScript",
     "cloud storage",
     "object storage",
-    "TypeScript",
+    "bucket creation",
-    "S3",
-    "minio",
     "file management",
     "directory management",
-    "bucket creation",
     "data streaming",
     "multi-cloud",
     "API",
     "unified storage",
+    "S3",
+    "minio",
+    "file locking",
+    "metadata",
     "buffer handling",
     "access key",
-    "secret key"
+    "secret key",
-  ]
+    "cloud agnostic"
+  ],
+  "homepage": "https://code.foss.global/push.rocks/smartbucket",
+  "repository": {
+    "type": "git",
+    "url": "https://code.foss.global/push.rocks/smartbucket.git"
+  }
 }

qenv.yml

@@ -1,3 +1,4 @@
 required:
   - S3_KEY
-  - S3_SECRET
+  - S3_SECRET
+  - S3_ENDPOINT

readme.md

@@ -1,9 +1,10 @@
 # @push.rocks/smartbucket
-A TypeScript library for simple cloud independent object storage with support for buckets, directories, and files.
+
+A TypeScript library for cloud-independent object storage, providing features like bucket creation, file and directory management, and data streaming.
 
 ## Install
 
-To install `@push.rocks/smartbucket`, you need to have Node.js and npm (Node Package Manager) installed on your system. If you have them installed, you can add `@push.rocks/smartbucket` to your project by running the following command in your project's root directory:
+To install `@push.rocks/smartbucket`, you need to have Node.js and npm (Node Package Manager) installed. If they are installed, you can add `@push.rocks/smartbucket` to your project by running the following command in your project's root directory:
 
 ```bash
 npm install @push.rocks/smartbucket --save
@@ -13,7 +14,7 @@ This command will download and install `@push.rocks/smartbucket` along with its
 
 ## Usage
 
-`@push.rocks/smartbucket` is a TypeScript module designed to provide simple cloud-independent object storage functionality. It wraps various cloud storage providers such as AWS S3, Google Cloud Storage, and others, offering a unified API to manage storage buckets and objects within those buckets. 
+`@push.rocks/smartbucket` is a TypeScript module designed to provide simple cloud-independent object storage functionality. It wraps various cloud storage providers such as AWS S3, Google Cloud Storage, and others, offering a unified API to manage storage buckets and objects within those buckets.
 
 In this guide, we will delve into the usage of SmartBucket, covering its full range of features from setting up the library to advanced usage scenarios.
 
@@ -48,7 +49,7 @@ const mySmartBucket = new SmartBucket({
   accessKey: "yourAccessKey",
   accessSecret: "yourSecretKey",
   endpoint: "yourEndpointURL",
-  port: 443,            // Default is 443, could be customized for specific endpoint
+  port: 443,            // Default is 443, can be customized for specific endpoint
   useSsl: true          // Defaults to true
 });
 ```
@@ -189,7 +190,7 @@ async function writeFileStream(bucketName: string, filePath: string, readableStr
 // Create a readable stream from a string
 const readable = new Readable();
 readable.push('Hello world streamed as a file!');
-readable.push(null); // Indicates end of the stream
+readable.push(null); // End of stream
 
 // Use the function
 writeFileStream("exampleBucket", "path/to/streamedObject.txt", readable);
@@ -197,7 +198,9 @@ writeFileStream("exampleBucket", "path/to/streamedObject.txt", readable);
 
 ### Working with Directories
 
-`@push.rocks/smartbucket` abstracts directories within buckets for easier object management. You can create, list, and delete directories using the `Directory` class.
+`@push.rocks/smartbucket` offers abstractions for directories within buckets for easier object management. You can create, list, and delete directories using the `Directory` class.
+
+To list the contents of a directory:
 
 ```typescript
 async function listDirectoryContents(bucketName: string, directoryPath: string) {
@@ -205,6 +208,7 @@ async function listDirectoryContents(bucketName: string, directoryPath: string)
   if (myBucket) {
     const baseDirectory: Directory = await myBucket.getBaseDirectory();
     const targetDirectory: Directory = await baseDirectory.getSubDirectoryByName(directoryPath);
+    
     console.log('Listing directories:');
     const directories = await targetDirectory.listDirectories();
     directories.forEach(dir => {
@@ -250,11 +254,11 @@ createFileInDirectory("exampleBucket", "some/directory", "newfile.txt", "Hello,
 
 #### Bucket Policies
 
-Manage bucket policies to control access permissions. This feature is dependent on the policies provided by the storage service (e.g., AWS S3, MinIO).
+Manage bucket policies to control access permissions. This feature depends on the policies provided by the storage service (e.g., AWS S3, MinIO).
 
 #### Object Metadata
 
-You can retrieve and modify object metadata. Metadata can be useful for storing additional information about an object.
+Retrieve and modify object metadata. Metadata can be useful for storing additional information about an object.
 
 To retrieve metadata:
 

test/test.trash.ts

@@ -0,0 +1,24 @@
+import { expect, expectAsync, tap } from '@push.rocks/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
+
+import * as smartbucket from '../ts/index.js';
+
+const testQenv = new Qenv('./', './.nogit/');
+
+let testSmartbucket: smartbucket.SmartBucket;
+let myBucket: smartbucket.Bucket;
+let baseDirectory: smartbucket.Directory;
+
+tap.test('should create a valid smartbucket', async () => {
+  testSmartbucket = new smartbucket.SmartBucket({
+    accessKey: await testQenv.getEnvVarOnDemand('S3_KEY'),
+    accessSecret: await testQenv.getEnvVarOnDemand('S3_SECRET'),
+    endpoint: await testQenv.getEnvVarOnDemand('S3_ENDPOINT'),
+  });
+  expect(testSmartbucket).toBeInstanceOf(smartbucket.SmartBucket);
+  myBucket = await testSmartbucket.getBucketByName('testzone');
+  expect(myBucket).toBeInstanceOf(smartbucket.Bucket);
+  expect(myBucket.name).toEqual('testzone');
+});
+
+export default tap.start();

test/test.ts

@@ -13,24 +13,22 @@ tap.test('should create a valid smartbucket', async () => {
   testSmartbucket = new smartbucket.SmartBucket({
     accessKey: await testQenv.getEnvVarOnDemand('S3_KEY'),
     accessSecret: await testQenv.getEnvVarOnDemand('S3_SECRET'),
-    endpoint: 's3.eu-central-1.wasabisys.com',
+    endpoint: await testQenv.getEnvVarOnDemand('S3_ENDPOINT'),
   });
-});
+  expect(testSmartbucket).toBeInstanceOf(smartbucket.SmartBucket);
-
-tap.skip.test('should create testbucket', async () => {
-  // await testSmartbucket.createBucket('testzone');
-});
-
-tap.skip.test('should remove testbucket', async () => {
-  // await testSmartbucket.removeBucket('testzone');
-});
-
-tap.test('should get a bucket', async () => {
   myBucket = await testSmartbucket.getBucketByName('testzone');
   expect(myBucket).toBeInstanceOf(smartbucket.Bucket);
   expect(myBucket.name).toEqual('testzone');
 });
 
+tap.skip.test('should create testbucket', async () => {
+  // await testSmartbucket.createBucket('testzone2');
+});
+
+tap.skip.test('should remove testbucket', async () => {
+  // await testSmartbucket.removeBucket('testzone2');
+});
+
 // Fast operations
 tap.test('should store data in bucket fast', async () => {
   await myBucket.fastPut({
@@ -45,7 +43,7 @@ tap.test('should get data in bucket', async () => {
   });
   const fileStringStream = await myBucket.fastGetStream({
     path: 'hithere/socool.txt',
-  });
+  }, 'nodestream');
   console.log(fileString);
 });
 
@@ -79,7 +77,7 @@ tap.test('prepare for directory style tests', async () => {
     contents: 'dir3/dir4/file1.txt content',
   });
   await myBucket.fastPut({
-    path: 'file1.txt',
+    path: '/file1.txt',
     contents: 'file1 content',
   });
 });

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@push.rocks/smartbucket',
-  version: '3.0.4',
+  version: '3.0.21',
-  description: 'A TypeScript library that offers simple, cloud-independent object storage with features like bucket creation, file management, and directory management.'
+  description: 'A TypeScript library offering simple and cloud-agnostic object storage with advanced features like bucket creation, file and directory management, and data streaming.'
 }

ts/classes.bucket.ts

@@ -1,13 +1,23 @@
+// 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 {
   public static async getBucketByName(smartbucketRef: SmartBucket, bucketNameArg: string) {
-    const buckets = await smartbucketRef.minioClient.listBuckets();
+    const command = new plugins.s3.ListBucketsCommand({});
-    const foundBucket = buckets.find((bucket) => {
+    const buckets = await smartbucketRef.s3Client.send(command);
-      return bucket.name === bucketNameArg;
+    const foundBucket = buckets.Buckets.find((bucket) => bucket.Name === bucketNameArg);
-    });
 
     if (foundBucket) {
       console.log(`bucket with name ${bucketNameArg} exists.`);
@@ -19,12 +29,14 @@ export class Bucket {
   }
 
   public static async createBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
-    await smartbucketRef.minioClient.makeBucket(bucketName, 'ams3').catch((e) => console.log(e));
+    const command = new plugins.s3.CreateBucketCommand({ Bucket: bucketName });
+    await smartbucketRef.s3Client.send(command).catch((e) => console.log(e));
     return new Bucket(smartbucketRef, bucketName);
   }
 
   public static async removeBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
-    await smartbucketRef.minioClient.removeBucket(bucketName).catch((e) => console.log(e));
+    const command = new plugins.s3.DeleteBucketCommand({ Bucket: bucketName });
+    await smartbucketRef.s3Client.send(command).catch((e) => console.log(e));
   }
 
   public smartbucketRef: SmartBucket;
@@ -38,10 +50,29 @@ export class Bucket {
   /**
    * gets the base directory of the bucket
    */
-  public async getBaseDirectory() {
+  public async getBaseDirectory(): Promise<Directory> {
     return new Directory(this, null, '');
   }
 
+  /**
+   * gets the trash directory
+   */
+  public async getTrash(): Promise<Trash> {
+    const trash = new Trash(this);
+    return trash;
+  }
+
+  public async getDirectoryFromPath(
+    pathDescriptorArg: interfaces.IPathDecriptor
+  ): Promise<Directory> {
+    if (!pathDescriptorArg.path && !pathDescriptorArg.directory) {
+      return this.getBaseDirectory();
+    }
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptorArg);
+    const baseDirectory = await this.getBaseDirectory();
+    return await baseDirectory.getSubDirectoryByName(checkPath);
+  }
+
   // ===============
   // Fast Operations
   // ===============
@@ -49,46 +80,58 @@ export class Bucket {
   /**
    * store file
    */
-  public async fastPut(optionsArg: {
+  public async fastPut(
-    path: string;
+    optionsArg: interfaces.IPathDecriptor & {
-    contents: string | Buffer;
+      contents: string | Buffer;
-    overwrite?: boolean;
+      overwrite?: boolean;
-  }): Promise<void> {
+    }
+  ): Promise<File> {
     try {
-      // Check if the object already exists
+      const reducedPath = await helpers.reducePathDescriptorToPath(optionsArg);
-      const exists = await this.fastExists({ path: optionsArg.path });
+      const exists = await this.fastExists({ path: reducedPath });
-  
+
       if (exists && !optionsArg.overwrite) {
-        console.error(`Object already exists at path '${optionsArg.path}' in bucket '${this.name}'.`);
+        console.error(`Object already exists at path '${reducedPath}' in bucket '${this.name}'.`);
         return;
       } else if (exists && optionsArg.overwrite) {
-        console.log(`Overwriting existing object at path '${optionsArg.path}' in bucket '${this.name}'.`);
+        console.log(
+          `Overwriting existing object at path '${reducedPath}' in bucket '${this.name}'.`
+        );
       } else {
-        console.log(`Creating new object at path '${optionsArg.path}' in bucket '${this.name}'.`);
+        console.log(`Creating new object at path '${reducedPath}' in bucket '${this.name}'.`);
       }
-  
+
-      // Proceed with putting the object
+      const command = new plugins.s3.PutObjectCommand({
-      const streamIntake = new plugins.smartstream.StreamIntake();
+        Bucket: this.name,
-      const putPromise = this.smartbucketRef.minioClient.putObject(this.name, optionsArg.path, streamIntake);
+        Key: reducedPath,
-      streamIntake.pushData(optionsArg.contents);
+        Body: optionsArg.contents,
-      streamIntake.signalEnd();
+      });
-      await putPromise;
+      await this.smartbucketRef.s3Client.send(command);
-  
+
-      console.log(`Object '${optionsArg.path}' has been successfully stored in bucket '${this.name}'.`);
+      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);
+      console.error(
+        `Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`,
+        error
+      );
       throw error;
     }
   }
-  
 
   /**
    * get file
    */
-  public async fastGet(optionsArg: Parameters<typeof this.fastGetStream>[0]): Promise<Buffer> {
+  public async fastGet(optionsArg: { path: string }): Promise<Buffer> {
     const done = plugins.smartpromise.defer();
     let completeFile: Buffer;
-    const replaySubject = await this.fastGetStream(optionsArg);
+    const replaySubject = await this.fastGetReplaySubject(optionsArg);
     const subscription = replaySubject.subscribe({
       next: (chunk) => {
         if (completeFile) {
@@ -109,93 +152,136 @@ export class Bucket {
     return completeFile;
   }
 
-  public async fastGetStream(optionsArg: {
+  /**
+   * good when time to first byte is important
+   * and multiple subscribers are expected
+   * @param optionsArg
+   * @returns
+   */
+  public async fastGetReplaySubject(optionsArg: {
     path: string;
   }): Promise<plugins.smartrx.rxjs.ReplaySubject<Buffer>> {
-    const fileStream = await this.smartbucketRef.minioClient
+    const command = new plugins.s3.GetObjectCommand({
-      .getObject(this.name, optionsArg.path)
+      Bucket: this.name,
-      .catch((e) => console.log(e));
+      Key: optionsArg.path,
-    const replaySubject = new plugins.smartrx.rxjs.ReplaySubject<Buffer>();
-    const duplexStream = new plugins.smartstream.SmartDuplex<Buffer, void>({
-      writeFunction: async (chunk) => {
-        replaySubject.next(chunk);
-        return;
-      },
-      finalFunction: async (cb) => {
-        replaySubject.complete();
-        return;
-      }
     });
+    const response = await this.smartbucketRef.s3Client.send(command);
+    const replaySubject = new plugins.smartrx.rxjs.ReplaySubject<Buffer>();
 
-    if (!fileStream) {
+    // Convert the stream to a format that supports piping
-      return null;
+    const stream = response.Body as any; // SdkStreamMixin includes readable stream
+    if (typeof stream.pipe === 'function') {
+      const duplexStream = new plugins.smartstream.SmartDuplex<Buffer, void>({
+        writeFunction: async (chunk) => {
+          replaySubject.next(chunk);
+          return;
+        },
+        finalFunction: async (cb) => {
+          replaySubject.complete();
+          return;
+        },
+      });
+
+      stream.pipe(duplexStream);
     }
 
-    const smartstream = new plugins.smartstream.StreamWrapper([
-      fileStream,
-      duplexStream,
-    ]);
-    smartstream.run();
     return replaySubject;
   }
 
+  public fastGetStream(
+    optionsArg: {
+      path: string;
+    },
+    typeArg: 'webstream'
+  ): Promise<ReadableStream>;
+  public async fastGetStream(
+    optionsArg: {
+      path: string;
+    },
+    typeArg: 'nodestream'
+  ): Promise<plugins.stream.Readable>;
+
+  public async fastGetStream(
+    optionsArg: { path: string },
+    typeArg: 'webstream' | 'nodestream' = 'nodestream'
+  ): Promise<ReadableStream | plugins.stream.Readable> {
+    const command = new plugins.s3.GetObjectCommand({
+      Bucket: this.name,
+      Key: optionsArg.path,
+    });
+    const response = await this.smartbucketRef.s3Client.send(command);
+    const stream = response.Body as any; // SdkStreamMixin includes readable stream
+
+    const duplexStream = new plugins.smartstream.SmartDuplex<Buffer, Buffer>({
+      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;
+    }
+  }
+
   /**
    * store file as stream
    */
   public async fastPutStream(optionsArg: {
     path: string;
-    dataStream: plugins.stream.Readable;
+    readableStream: plugins.stream.Readable | ReadableStream;
     nativeMetadata?: { [key: string]: string };
     overwrite?: boolean;
   }): Promise<void> {
     try {
-      // Check if the object already exists
       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}'.`);
+        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}'.`);
+        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}'.`);
       }
-  
+
-      // Proceed with putting the object
+      const command = new plugins.s3.PutObjectCommand({
-      await this.smartbucketRef.minioClient.putObject(
+        Bucket: this.name,
-        this.name,
+        Key: optionsArg.path,
-        optionsArg.path,
+        Body: optionsArg.readableStream,
-        optionsArg.dataStream,
+        Metadata: optionsArg.nativeMetadata,
-        null,
+      });
-        ...(optionsArg.nativeMetadata
+      await this.smartbucketRef.s3Client.send(command);
-          ? (() => {
+
-              const returnObject: any = {};
+      console.log(
-              return returnObject;
+        `Object '${optionsArg.path}' has been successfully stored in bucket '${this.name}'.`
-            })()
-          : {})
       );
-  
-      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);
+      console.error(
+        `Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`,
+        error
+      );
       throw error;
     }
   }
-  
 
-  public async copyObject(optionsArg: {
+  public async fastCopy(optionsArg: {
-    /**
+    sourcePath: string;
-     * the
+    destinationPath?: string;
-     */
-    objectKey: string;
-    /**
-     * in case you want to copy to another bucket specify it here
-     */
     targetBucket?: Bucket;
-    targetBucketKey?: string;
-    /**
-     * metadata will be merged with existing metadata
-     */
     nativeMetadata?: { [key: string]: string };
     deleteExistingNativeMetadata?: boolean;
   }): Promise<void> {
@@ -203,28 +289,29 @@ export class Bucket {
       const targetBucketName = optionsArg.targetBucket ? optionsArg.targetBucket.name : this.name;
 
       // Retrieve current object information to use in copy conditions
-      const currentObjInfo = await this.smartbucketRef.minioClient.statObject(
+      const currentObjInfo = await this.smartbucketRef.s3Client.send(
-        targetBucketName,
+        new plugins.s3.HeadObjectCommand({
-        optionsArg.objectKey
+          Bucket: this.name,
+          Key: optionsArg.sourcePath,
+        })
       );
 
-      // Setting up copy conditions
-      const copyConditions = new plugins.minio.CopyConditions();
-
       // Prepare new metadata
       const newNativeMetadata = {
-        ...(optionsArg.deleteExistingNativeMetadata ? {} : currentObjInfo.metaData),
+        ...(optionsArg.deleteExistingNativeMetadata ? {} : currentObjInfo.Metadata),
         ...optionsArg.nativeMetadata,
       };
 
-      // Define the copy operation as a Promise
+      // Define the copy operation
-      // TODO: check on issue here: https://github.com/minio/minio-js/issues/1286
+      const copySource = `${this.name}/${optionsArg.sourcePath}`;
-      await this.smartbucketRef.minioClient.copyObject(
+      const command = new plugins.s3.CopyObjectCommand({
-        this.name,
+        Bucket: targetBucketName,
-        optionsArg.objectKey,
+        CopySource: copySource,
-        `/${targetBucketName}/${optionsArg.objectKey}`,
+        Key: optionsArg.destinationPath || optionsArg.sourcePath,
-        copyConditions
+        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
@@ -232,28 +319,75 @@ export class Bucket {
   }
 
   /**
-   * removeObject
+   * Move object from one path to another within the same bucket or to another bucket
    */
-  public async fastRemove(optionsArg: {
+  public async fastMove(optionsArg: {
-    path: string;
+    sourcePath: string;
-  }) {
+    destinationPath: string;
-    await this.smartbucketRef.minioClient.removeObject(this.name, optionsArg.path);
+    targetBucket?: Bucket;
+    overwrite?: boolean;
+  }): Promise<void> {
+    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;
+    }
   }
 
   /**
-   * check wether file exists
+   * removeObject
-   * @param optionsArg
-   * @returns 
    */
-  public async fastExists(optionsArg: {
+  public async fastRemove(optionsArg: { path: string }) {
-    path: string;
+    const command = new plugins.s3.DeleteObjectCommand({
-  }): Promise<boolean> {
+      Bucket: this.name,
+      Key: optionsArg.path,
+    });
+    await this.smartbucketRef.s3Client.send(command);
+  }
+
+  /**
+   * check whether file exists
+   * @param optionsArg
+   * @returns
+   */
+  public async fastExists(optionsArg: { path: string }): Promise<boolean> {
     try {
-      await this.smartbucketRef.minioClient.statObject(this.name, optionsArg.path);
+      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.code === 'NotFound') {
+      if (error.name === 'NotFound') {
         console.log(`Object '${optionsArg.path}' does not exist in bucket '${this.name}'.`);
         return false;
       } else {
@@ -263,9 +397,43 @@ export class Bucket {
     }
   }
 
-  public async fastStat(optionsArg: {
+  /**
-    path: string;
+   * deletes this bucket
-  }) {
+   */
-    return this.smartbucketRef.minioClient.statObject(this.name, optionsArg.path);
+  public async delete() {
+    await this.smartbucketRef.s3Client.send(
+      new plugins.s3.DeleteBucketCommand({ Bucket: this.name })
+    );
+  }
+
+  public async fastStat(pathDescriptor: interfaces.IPathDecriptor) {
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+    const command = new plugins.s3.HeadObjectCommand({
+      Bucket: this.name,
+      Key: checkPath,
+    });
+    return this.smartbucketRef.s3Client.send(command);
+  }
+
+  public async isDirectory(pathDescriptor: interfaces.IPathDecriptor): Promise<boolean> {
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+    const command = new plugins.s3.ListObjectsV2Command({
+      Bucket: this.name,
+      Prefix: checkPath,
+      Delimiter: '/',
+    });
+    const response = await this.smartbucketRef.s3Client.send(command);
+    return response.CommonPrefixes.length > 0;
+  }
+
+  public async isFile(pathDescriptor: interfaces.IPathDecriptor): Promise<boolean> {
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+    const command = new plugins.s3.ListObjectsV2Command({
+      Bucket: this.name,
+      Prefix: checkPath,
+      Delimiter: '/',
+    });
+    const response = await this.smartbucketRef.s3Client.send(command);
+    return response.Contents.length > 0;
   }
 }

ts/classes.directory.ts

@@ -1,6 +1,9 @@
+// classes.directory.ts
+
 import * as plugins from './plugins.js';
 import { Bucket } from './classes.bucket.js';
 import { File } from './classes.file.js';
+import * as helpers from './helpers.js';
 
 export class Directory {
   public bucketRef: Bucket;
@@ -11,9 +14,9 @@ export class Directory {
   public files: string[];
   public folders: string[];
 
-  constructor(bucketRefArg: Bucket, parentDiretory: Directory, name: string) {
+  constructor(bucketRefArg: Bucket, parentDirectory: Directory, name: string) {
     this.bucketRef = bucketRefArg;
-    this.parentDirectoryRef = parentDiretory;
+    this.parentDirectoryRef = parentDirectory;
     this.name = name;
   }
 
@@ -63,52 +66,53 @@ export class Directory {
    * gets a file by name
    */
   public async getFile(optionsArg: {
-    name: string;
+    path: string;
     createWithContents?: string | Buffer;
+    getFromTrash?: boolean;
   }): Promise<File> {
-    // check wether the file exists
+    const pathDescriptor = {
+      directory: this,
+      path: optionsArg.path,
+    };
     const exists = await this.bucketRef.fastExists({
-      path: this.getBasePath() + optionsArg.name,
+      path: await helpers.reducePathDescriptorToPath(pathDescriptor),
     });
+    if (!exists && optionsArg.getFromTrash) {
+      const trash = await this.bucketRef.getTrash();
+      const trashedFile = await trash.getTrashedFileByOriginalName(pathDescriptor);
+      return trashedFile;
+    }
     if (!exists && !optionsArg.createWithContents) {
       return null;
     }
     if (!exists && optionsArg.createWithContents) {
-      await this.fastPut({
+      await File.create({
-        path: optionsArg.name,
+        directory: this,
+        name: optionsArg.path,
         contents: optionsArg.createWithContents,
       });
     }
     return new File({
       directoryRefArg: this,
-      fileName: optionsArg.name,
+      fileName: optionsArg.path,
-    })
+    });
   }
 
   /**
    * lists all files
    */
   public async listFiles(): Promise<File[]> {
-    const done = plugins.smartpromise.defer();
+    const command = new plugins.s3.ListObjectsV2Command({
-    const fileNameStream = await this.bucketRef.smartbucketRef.minioClient.listObjectsV2(
+      Bucket: this.bucketRef.name,
-      this.bucketRef.name,
+      Prefix: this.getBasePath(),
-      this.getBasePath(),
+      Delimiter: '/',
-      false
+    });
-    );
+    const response = await this.bucketRef.smartbucketRef.s3Client.send(command);
     const fileArray: File[] = [];
-    const duplexStream = new plugins.smartstream.SmartDuplex<plugins.minio.BucketItem, void>({
+
-      objectMode: true,
+    response.Contents.forEach((item) => {
-      writeFunction: async (bucketItem) => {
+      if (item.Key && !item.Key.endsWith('/')) {
-        if (bucketItem.prefix) {
+        const subtractedPath = item.Key.replace(this.getBasePath(), '');
-          return;
-        }
-        if (!bucketItem.name) {
-          return;
-        }
-        let subtractedPath = bucketItem.name.replace(this.getBasePath(), '');
-        if (subtractedPath.startsWith('/')) {
-          subtractedPath = subtractedPath.substr(1);
-        }
         if (!subtractedPath.includes('/')) {
           fileArray.push(
             new File({
@@ -117,13 +121,9 @@ export class Directory {
             })
           );
         }
-      },
-      finalFunction: async (tools) => {
-        done.resolve();
       }
     });
-    fileNameStream.pipe(duplexStream);
+
-    await done.promise;
     return fileArray;
   }
 
@@ -131,54 +131,52 @@ export class Directory {
    * lists all folders
    */
   public async listDirectories(): Promise<Directory[]> {
-    const done = plugins.smartpromise.defer();
+    try {
-    const basePath = this.getBasePath();
+      const command = new plugins.s3.ListObjectsV2Command({
-    const completeDirStream = await this.bucketRef.smartbucketRef.minioClient.listObjectsV2(
+        Bucket: this.bucketRef.name,
-      this.bucketRef.name,
+        Prefix: this.getBasePath(),
-      this.getBasePath(),
+        Delimiter: '/',
-      false
+      });
-    );
+      const response = await this.bucketRef.smartbucketRef.s3Client.send(command);
-    const directoryArray: Directory[] = [];
+      const directoryArray: Directory[] = [];
-    const duplexStream = new plugins.smartstream.SmartDuplex<plugins.minio.BucketItem, void>({
+  
-      objectMode: true,
+      if (response.CommonPrefixes) {
-      writeFunction: async (bucketItem) => {
+        response.CommonPrefixes.forEach((item) => {
-        if (bucketItem.name) {
+          if (item.Prefix) {
-          return;
+            const subtractedPath = item.Prefix.replace(this.getBasePath(), '');
-        }
+            if (subtractedPath.endsWith('/')) {
-        let subtractedPath = bucketItem.prefix.replace(this.getBasePath(), '');
+              const dirName = subtractedPath.slice(0, -1);
-        if (subtractedPath.startsWith('/')) {
+              // Ensure the directory name is not empty (which would indicate the base directory itself)
-          subtractedPath = subtractedPath.substr(1);
+              if (dirName) {
-        }
+                directoryArray.push(new Directory(this.bucketRef, this, dirName));
-        if (subtractedPath.includes('/')) {
+              }
-          const dirName = subtractedPath.split('/')[0];
+            }
-          if (directoryArray.find((directory) => directory.name === dirName)) {
-            return;
           }
-          directoryArray.push(new Directory(this.bucketRef, this, dirName));
+        });
-        }
-      },
-      finalFunction: async (tools) => {
-        done.resolve();
       }
-    });
+  
-    completeDirStream.pipe(duplexStream);
+      return directoryArray;
-    await done.promise;
+    } catch (error) {
-    return directoryArray;
+      console.error('Error listing directories:', error);
+      throw error;
+    }
   }
 
   /**
-   * gets an array that has all objects with a certain prefix;
+   * gets an array that has all objects with a certain prefix
    */
   public async getTreeArray() {
-    const treeArray = await this.bucketRef.smartbucketRef.minioClient.listObjectsV2(
+    const command = new plugins.s3.ListObjectsV2Command({
-      this.bucketRef.name,
+      Bucket: this.bucketRef.name,
-      this.getBasePath(),
+      Prefix: this.getBasePath(),
-      true
+      Delimiter: '/',
-    );
+    });
+    const response = await this.bucketRef.smartbucketRef.s3Client.send(command);
+    return response.Contents;
   }
 
   /**
-   * gets a sub directory
+   * gets a sub directory by name
    */
   public async getSubDirectoryByName(dirNameArg: string): Promise<Directory> {
     const dirNameArray = dirNameArg.split('/');
@@ -189,11 +187,13 @@ export class Directory {
         return directory.name === dirNameToSearch;
       });
     };
+
     let wantedDirectory: Directory;
     for (const dirNameToSearch of dirNameArray) {
       const directoryToSearchIn = wantedDirectory ? wantedDirectory : this;
       wantedDirectory = await getDirectory(directoryToSearchIn, dirNameToSearch);
     }
+
     return wantedDirectory;
   }
 
@@ -202,19 +202,20 @@ export class Directory {
    */
   public async move() {
     // TODO
-    throw new Error('moving a directory is not yet implemented');
+    throw new Error('Moving a directory is not yet implemented');
   }
 
   /**
-   * creates a file within this directory
+   * creates an empty file within this directory
    * @param relativePathArg
    */
   public async createEmptyFile(relativePathArg: string) {
-    const emtpyFile = await File.create({
+    const emptyFile = await File.create({
       directory: this,
       name: relativePathArg,
       contents: '',
     });
+    return emptyFile;
   }
 
   // file operations
@@ -234,29 +235,82 @@ export class Directory {
     return result;
   }
 
-  public async fastGetStream(pathArg: string): Promise<plugins.smartrx.rxjs.ReplaySubject<Buffer>> {
+  public fastGetStream(
-    const path = plugins.path.join(this.getBasePath(), pathArg);
+    optionsArg: {
-    const result = await this.bucketRef.fastGetStream({
+      path: string;
-      path,
+    },
-    });
+    typeArg: 'webstream'
+  ): Promise<ReadableStream>;
+  public async fastGetStream(
+    optionsArg: {
+      path: string;
+    },
+    typeArg: 'nodestream'
+  ): Promise<plugins.stream.Readable>;
+
+  /**
+   * fastGetStream
+   * @param optionsArg
+   * @returns
+   */
+  public async fastGetStream(
+    optionsArg: { path: string },
+    typeArg: 'webstream' | 'nodestream'
+  ): Promise<ReadableStream | plugins.stream.Readable> {
+    const path = plugins.path.join(this.getBasePath(), optionsArg.path);
+    const result = await this.bucketRef.fastGetStream(
+      {
+        path,
+      },
+      typeArg as any
+    );
     return result;
   }
 
-  public async fastRemove(optionsArg: { path: string }) {
+  /**
+   * fast put stream
+   */
+  public async fastPutStream(optionsArg: {
+    path: string;
+    stream: plugins.stream.Readable;
+  }): Promise<void> {
     const path = plugins.path.join(this.getBasePath(), optionsArg.path);
-    await this.bucketRef.fastRemove({
+    await this.bucketRef.fastPutStream({
       path,
+      readableStream: optionsArg.stream,
+    });
+  }
+
+  /**
+   * removes a file within the directory
+   * uses file class to make sure effects for metadata etc. are handled correctly
+   * @param optionsArg
+   */
+  public async fastRemove(optionsArg: {
+    path: string
+    /**
+     * wether the file should be placed into trash. Default is false.
+     */
+    mode?: 'permanent' | 'trash';
+  }) {
+    const file = await this.getFile({
+      path: optionsArg.path,
+    });
+    await file.delete({
+      mode: optionsArg.mode ? optionsArg.mode : 'permanent',
     });
   }
 
   /**
    * deletes the directory with all its contents
    */
-  public async delete() {
+  public async delete(optionsArg: {
+    mode?: 'permanent' | 'trash';
+  }) {
     const deleteDirectory = async (directoryArg: Directory) => {
       const childDirectories = await directoryArg.listDirectories();
       if (childDirectories.length === 0) {
-        console.log('directory empty! Path complete!');
+        console.log('Directory empty! Path complete!');
       } else {
         for (const childDir of childDirectories) {
           await deleteDirectory(childDir);
@@ -264,9 +318,9 @@ export class Directory {
       }
       const files = await directoryArg.listFiles();
       for (const file of files) {
-        await directoryArg.fastRemove({
+        await file.delete({
-          path: file.name,
+          mode: optionsArg.mode ? optionsArg.mode : 'permanent',
-        });
+        })
       }
     };
     await deleteDirectory(this);

ts/classes.file.ts

@@ -1,8 +1,9 @@
 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
  */
@@ -31,7 +32,12 @@ export class File {
       directoryRefArg: optionsArg.directory,
       fileName: optionsArg.name,
     });
-    if (contents instanceof plugins.stream.Readable) {} else {
+    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,
@@ -46,7 +52,7 @@ export class File {
 
   public getBasePath(): string {
     return plugins.path.join(this.parentDirectoryRef.getBasePath(), this.name);
-  };
+  }
 
   constructor(optionsArg: { directoryRefArg: Directory; fileName: string }) {
     this.parentDirectoryRef = optionsArg.directoryRefArg;
@@ -65,35 +71,61 @@ export class File {
     return resultBuffer;
   }
 
-  public async getReadStream() {
+  public async getReadStream(typeArg: 'webstream'): Promise<ReadableStream>;
-    const readStream = this.parentDirectoryRef.bucketRef.fastGetStream({
+  public async getReadStream(typeArg: 'nodestream'): Promise<plugins.stream.Readable>;
-      path: this.getBasePath(),
+  public async getReadStream(
-    });
+    typeArg: 'nodestream' | 'webstream'
+  ): Promise<ReadableStream | plugins.stream.Readable> {
+    const readStream = this.parentDirectoryRef.bucketRef.fastGetStream(
+      {
+        path: this.getBasePath(),
+      },
+      typeArg as any
+    );
+    return readStream;
   }
 
   /**
-   * removes this file
+   * deletes this file
-   * for using recycling mechanics use .delete()
    */
-  public async remove() {
+  public async delete(optionsArg?: {
-    await this.parentDirectoryRef.bucketRef.fastRemove({
+    mode: 'trash' | 'permanent';
-      path: this.getBasePath(),
+  }) {
-    });
+
-    if (!this.name.endsWith('.metadata')) {
+    optionsArg = {
+      ... {
+        mode: 'permanent',
+      },
+      ...optionsArg,
+    }
+
+    if (optionsArg.mode === 'permanent') {
       await this.parentDirectoryRef.bucketRef.fastRemove({
-        path: this.getBasePath() + '.metadata',
+        path: this.getBasePath(),
+      });
+      if (!this.name.endsWith('.metadata')) {
+        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();
+      await this.move({
+        directory: await trash.getTrashDir(),
+        path: await trash.getTrashKeyByOriginalBasePath(this.getBasePath()),
       });
     }
+    
     await this.parentDirectoryRef.listFiles();
   }
 
-  /**
-   * deletes the file with recycling mechanics
-   */
-  public async delete() {
-    await this.remove();
-  }
-
   /**
    * allows locking the file
    * @param optionsArg
@@ -102,7 +134,7 @@ export class File {
     const metadata = await this.getMetaData();
     await metadata.setLock({
       lock: 'locked',
-      expires: new Date(Date.now() + (optionsArg?.timeoutMillis || 1000)),
+      expires: Date.now() + (optionsArg?.timeoutMillis || 1000),
     });
   }
 
@@ -116,17 +148,23 @@ export class File {
      */
     force?: boolean;
   }) {
-
+    const metadata = await this.getMetaData();
+    await metadata.removeLock({
+      force: optionsArg?.force,
+    });
   }
 
   public async updateWithContents(optionsArg: {
-    contents: Buffer | string | plugins.stream.Readable;
+    contents: Buffer | string | plugins.stream.Readable | ReadableStream;
     encoding?: 'utf8' | 'binary';
   }) {
-    if (optionsArg.contents instanceof plugins.stream.Readable) {
+    if (
+      optionsArg.contents instanceof plugins.stream.Readable ||
+      optionsArg.contents instanceof ReadableStream
+    ) {
       await this.parentDirectoryRef.bucketRef.fastPutStream({
         path: this.getBasePath(),
-        dataStream: optionsArg.contents,
+        readableStream: optionsArg.contents,
       });
     } else if (Buffer.isBuffer(optionsArg.contents)) {
       await this.parentDirectoryRef.bucketRef.fastPut({
@@ -141,14 +179,55 @@ export class File {
     }
   }
 
+  /**
+   * moves the file to another directory
+   */
+  public async move(pathDescriptorArg: interfaces.IPathDecriptor) {
+    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),
+      });
+    }
+    // lets move the file
+    await this.parentDirectoryRef.bucketRef.fastMove({
+      sourcePath: this.getBasePath(),
+      destinationPath: moveToPath,
+    });
+
+    // lets move the metadatafile
+    const metadata = await this.getMetaData();
+    await metadata.metadataFile.move(pathDescriptorArg);
+  }
+
   /**
    * allows updating the metadata of a file
    * @param updatedMetadata
    */
   public 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
+   */
+  public async getJsonData() {
+    const json = await this.getContentsAsString();
+    const parsed = await JSON.parse(json);
+    return parsed;
+  }
+
+  public async writeJsonData(dataArg: any) {
+    await this.updateWithContents({
+      contents: JSON.stringify(dataArg),
+    });
+  }
 }

ts/classes.metadata.ts

@@ -4,15 +4,13 @@ import { File } from './classes.file.js';
 
 export class MetaData {
   // static
-  public static async createForFile(optionsArg: {
+  public static async createForFile(optionsArg: { file: File }) {
-    file: File;
-  }) {
     const metaData = new MetaData();
     metaData.fileRef = optionsArg.file;
 
     // lets find the existing metadata file
     metaData.metadataFile = await metaData.fileRef.parentDirectoryRef.getFile({
-      name: metaData.fileRef.name + '.metadata',
+      path: metaData.fileRef.name + '.metadata',
       createWithContents: '{}',
     });
 
@@ -29,16 +27,16 @@ export class MetaData {
    * the file that the metadata is for
    */
   fileRef: File;
-  
+
   public async getFileType(optionsArg?: {
     useFileExtension?: boolean;
     useMagicBytes?: boolean;
   }): Promise<string> {
-    if (optionsArg && optionsArg.useFileExtension || optionsArg.useFileExtension === undefined) {
+    if ((optionsArg && optionsArg.useFileExtension) || optionsArg.useFileExtension === undefined) {
       return plugins.path.extname(this.fileRef.name);
     }
-  };
+  }
-  
+
   /**
    * gets the size of the fileRef
    */
@@ -46,60 +44,57 @@ export class MetaData {
     const stat = await this.fileRef.parentDirectoryRef.bucketRef.fastStat({
       path: this.fileRef.getBasePath(),
     });
-    return stat.size;
+    return stat.ContentLength;
-  };
+  }
 
   private prefixCustomMetaData = 'custom_';
 
-  public async storeCustomMetaData<T = any>(optionsArg: {
+  public async storeCustomMetaData<T = any>(optionsArg: { key: string; value: T }) {
-    key: string;
+    const data = await this.metadataFile.getContentsAsString();
-    value: T;
+    data[this.prefixCustomMetaData + optionsArg.key] = optionsArg.value;
-  }) {
+    await this.metadataFile.writeJsonData(data);
-    const json = await this.metadataFile.getContentsAsString();
-    const parsed = await JSON.parse(json);
-    parsed[this.prefixCustomMetaData + optionsArg.key] = optionsArg.value;
-    await this.metadataFile.updateWithContents({
-      contents: JSON.stringify(parsed),
-    });
   }
 
-  public async getCustomMetaData<T = any>(optionsArg: {
+  public async getCustomMetaData<T = any>(optionsArg: { key: string }): Promise<T> {
-    key: string;
+    const data = await this.metadataFile.getJsonData();
-  }): Promise<T> {
+    return data[this.prefixCustomMetaData + optionsArg.key];
-    const json = await this.metadataFile.getContentsAsString();
-    const parsed = await JSON.parse(json);
-    return parsed[this.prefixCustomMetaData + optionsArg.key];
   }
 
-  public async deleteCustomMetaData(optionsArg: {
+  public async deleteCustomMetaData(optionsArg: { key: string }) {
-    key: string;
+    const data = await this.metadataFile.getJsonData();
-  }) {
+    delete data[this.prefixCustomMetaData + optionsArg.key];
-    const json = await this.metadataFile.getContentsAsString();
+    await this.metadataFile.writeJsonData(data);
-    const parsed = await JSON.parse(json);
-    delete parsed[this.prefixCustomMetaData + optionsArg.key];
-    await this.metadataFile.updateWithContents({
-      contents: JSON.stringify(parsed),
-    });
   }
 
   /**
    * set a lock on the ref file
    * @param optionsArg
    */
-  public async setLock(optionsArg: {
+  public async setLock(optionsArg: { lock: string; expires: number }) {
-    lock: string;
+    const data = await this.metadataFile.getJsonData();
-    expires: Date;
+    data.lock = optionsArg.lock;
-  }) {
+    data.lockExpires = optionsArg.expires;
-    
+    await this.metadataFile.writeJsonData(data);
   }
 
   /**
    * remove the lock on the ref file
-   * @param optionsArg 
+   * @param optionsArg
    */
-  public async removeLock(optionsArg: {
+  public async removeLock(optionsArg: { force: boolean }) {
-    force: boolean;
+    const data = await this.metadataFile.getJsonData();
-  }) {
+    delete data.lock;
-
+    delete data.lockExpires;
+    await this.metadataFile.writeJsonData(data);
   }
-}
+
+  public async checkLocked(): Promise<boolean> {
+    const data = await this.metadataFile.getJsonData();
+    return data.lock && data.lockExpires > Date.now();
+  }
+
+  public async getLockInfo(): Promise<{ lock: string; expires: number }> {
+    const data = await this.metadataFile.getJsonData();
+    return { lock: data.lock, expires: data.lockExpires };
+  }
+}

ts/classes.smartbucket.ts

@@ -1,22 +1,34 @@
+// classes.smartbucket.ts
+
 import * as plugins from './plugins.js';
 import { Bucket } from './classes.bucket.js';
 
 export class SmartBucket {
   public config: plugins.tsclass.storage.IS3Descriptor;
 
-  public minioClient: plugins.minio.Client;
+  public s3Client: plugins.s3.S3Client;
 
+  /**
+   * the constructor of SmartBucket
+   */
   /**
    * the constructor of SmartBucket
    */
   constructor(configArg: plugins.tsclass.storage.IS3Descriptor) {
     this.config = configArg;
-    this.minioClient = new plugins.minio.Client({
+
-      endPoint: this.config.endpoint,
+    const protocol = configArg.useSsl === false ? 'http' : 'https';
-      port: configArg.port || 443,
+    const port = configArg.port ? `:${configArg.port}` : '';
-      useSSL: configArg.useSsl !== undefined ? configArg.useSsl : true,
+    const endpoint = `${protocol}://${configArg.endpoint}${port}`;
-      accessKey: this.config.accessKey,
+
-      secretKey: this.config.accessSecret,
+    this.s3Client = new plugins.s3.S3Client({
+      endpoint,
+      region: configArg.region || 'us-east-1',
+      credentials: {
+        accessKeyId: configArg.accessKey,
+        secretAccessKey: configArg.accessSecret,
+      },
+      forcePathStyle: true, // Necessary for S3-compatible storage like MinIO or Wasabi
     });
   }
 

ts/classes.trash.ts

@@ -0,0 +1,30 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces.js';
+import * as helpers from './helpers.js';
+import type { Bucket } from './classes.bucket.js';
+import type { Directory } from './classes.directory.js';
+import type { File } from './classes.file.js';
+
+
+export class Trash {
+  public bucketRef: Bucket;
+
+  constructor(bucketRefArg: Bucket) {
+    this.bucketRef = bucketRefArg;
+  }
+
+  public async getTrashDir() {
+    return this.bucketRef.getDirectoryFromPath({ path: '.trash' });
+  }
+
+  public async getTrashedFileByOriginalName(pathDescriptor: interfaces.IPathDecriptor): Promise<File> {
+    const trashDir = await this.getTrashDir();
+    const originalPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+    const trashKey = await this.getTrashKeyByOriginalBasePath(originalPath);
+    return trashDir.getFile({ path: trashKey });
+  }
+
+  public async getTrashKeyByOriginalBasePath (originalPath: string): Promise<string> {
+    return plugins.smartstring.base64.encode(originalPath);
+  }
+}

ts/helpers.ts

@@ -0,0 +1,22 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces.js';
+
+export const reducePathDescriptorToPath = async (pathDescriptorArg: interfaces.IPathDecriptor): Promise<string> => {
+  let returnPath = ``
+  if (pathDescriptorArg.directory) {
+    if (pathDescriptorArg.path && plugins.path.isAbsolute(pathDescriptorArg.path)) {
+      console.warn('Directory is being ignored when path is absolute.');
+      returnPath = pathDescriptorArg.path;
+    } else if (pathDescriptorArg.path) {
+      returnPath = plugins.path.join(pathDescriptorArg.directory.getBasePath(), pathDescriptorArg.path);
+    }
+  } else if (pathDescriptorArg.path) {
+    returnPath = pathDescriptorArg.path;
+  } else {
+    throw new Error('You must specify either a path or a directory.');
+  }
+  if (returnPath.startsWith('/')) {
+    returnPath = returnPath.substring(1);
+  }
+  return returnPath;
+}

ts/interfaces.ts

@@ -0,0 +1,6 @@
+import type { Directory } from "./classes.directory.js";
+
+export interface IPathDecriptor {
+  path?: string;
+  directory?: Directory;
+}

ts/plugins.ts

@@ -1,3 +1,5 @@
+// plugins.ts
+
 // node native
 import * as path from 'path';
 import * as stream from 'stream';
@@ -10,8 +12,10 @@ import * as smartpath from '@push.rocks/smartpath';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';
 import * as smartstream from '@push.rocks/smartstream';
+import * as smartstring from '@push.rocks/smartstring';
+import * as smartunique from '@push.rocks/smartunique';
 
-export { smartmime, smartpath, smartpromise, smartrx, smartstream };
+export { smartmime, smartpath, smartpromise, smartrx, smartstream, smartstring, smartunique };
 
 // @tsclass
 import * as tsclass from '@tsclass/tsclass';
@@ -21,6 +25,8 @@ export {
 }
 
 // third party scope
-import * as minio from 'minio';
+import * as s3 from '@aws-sdk/client-s3';
 
-export { minio };
+export {
+  s3,
+}