3.0.19

npmextra.json

@@ -8,29 +8,27 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartbucket",
-      "description": "A TypeScript library for cloud-independent object storage, providing features like bucket creation, file and directory management, and data streaming.",
+      "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",
-        "metadata",
-        "file locking",
-        "file streaming",
-        "directory listing",
         "cloud agnostic"
       ]
     }

package-lock.json

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

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@push.rocks/smartbucket",
-  "version": "3.0.7",
+  "version": "3.0.19",
-  "description": "A TypeScript library for cloud-independent object storage, providing features like bucket creation, file and directory management, and data streaming.",
+  "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.598.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.59"
   },
   "private": false,
   "files": [
@@ -44,25 +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",
-    "metadata",
-    "file locking",
-    "file streaming",
-    "directory listing",
     "cloud agnostic"
-  ]
+  ],
+  "homepage": "https://code.foss.global/push.rocks/smartbucket",
+  "repository": {
+    "type": "git",
+    "url": "https://code.foss.global/push.rocks/smartbucket.git"
+  }
 }

readme.md

@@ -1,10 +1,10 @@
 # @push.rocks/smartbucket
 
-A TypeScript library that offers simple, cloud-independent object storage with features like bucket creation, file management, and directory management.
+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
@@ -49,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
 });
 ```
@@ -190,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);
@@ -198,9 +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.
 
-Here's how to list the contents of a directory:
+To list the contents of a directory:
 
 ```typescript
 async function listDirectoryContents(bucketName: string, directoryPath: string) {
@@ -254,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:
 
@@ -308,8 +308,6 @@ Remember, each cloud provider has specific features and limitations. `@push.rock
 
 This guide covers the basic to advanced scenarios of using `@push.rocks/smartbucket`. For further details, refer to the API documentation and examples.
 
-
-
 ## License and Legal Information
 
 This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 

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: 's3.eu-central-1.wasabisys.com',
+  });
+  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

@@ -15,22 +15,20 @@ tap.test('should create a valid smartbucket', async () => {
     accessSecret: await testQenv.getEnvVarOnDemand('S3_SECRET'),
     endpoint: 's3.eu-central-1.wasabisys.com',
   });
-});
+  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);
 });
 

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartbucket',
-  version: '3.0.7',
+  version: '3.0.19',
-  description: 'A TypeScript library for cloud-independent object storage, providing features like bucket creation, file and directory management, and data streaming.'
+  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,16 +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.`);
@@ -22,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;
@@ -45,11 +54,21 @@ export class Bucket {
     return new Directory(this, null, '');
   }
 
-  public async getDirectoryFromPath(pathDescriptorArg: interfaces.IPathDecriptor): Promise<Directory> {
+  /**
+   * 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();
     }
-    let checkPath = await helpers.reducePathDescriptorToPath(pathDescriptorArg);
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptorArg);
     const baseDirectory = await this.getBaseDirectory();
     return await baseDirectory.getSubDirectoryByName(checkPath);
   }
@@ -61,33 +80,33 @@ 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<File> {
+    }
+  ): Promise<File> {
     try {
-      const reducedPath = await helpers.reducePathDescriptorToPath({
+      const reducedPath = await helpers.reducePathDescriptorToPath(optionsArg);
-        path: optionsArg.path,
-      })
-      // Check if the object already exists
       const exists = await this.fastExists({ path: reducedPath });
 
       if (exists && !optionsArg.overwrite) {
         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 '${reducedPath}' in bucket '${this.name}'.`);
+        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}'.`);
       }
 
-      // 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, reducedPath, streamIntake);
+        Key: reducedPath,
-      streamIntake.pushData(optionsArg.contents);
+        Body: optionsArg.contents,
-      streamIntake.signalEnd();
+      });
-      await putPromise;
+      await this.smartbucketRef.s3Client.send(command);
 
       console.log(`Object '${reducedPath}' has been successfully stored in bucket '${this.name}'.`);
       const parsedPath = plugins.path.parse(reducedPath);
@@ -98,19 +117,21 @@ export class Bucket {
         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) {
@@ -131,80 +152,132 @@ 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 = {};
-              return returnObject;
-            })()
-          : {})
-      );
 
-      console.log(`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 fastCopy(optionsArg: {
     sourcePath: string;
     destinationPath?: string;
@@ -216,94 +289,105 @@ 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.sourcePath
+          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.sourcePath,
+        CopySource: copySource,
-        `/${targetBucketName}/${optionsArg.destinationPath || optionsArg.sourcePath}`,
+        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
     }
   }
 
-    /**
+  /**
    * Move object from one path to another within the same bucket or to another bucket
    */
-    public async fastMove(optionsArg: {
+  public async fastMove(optionsArg: {
-      sourcePath: string;
+    sourcePath: string;
-      destinationPath: string;
+    destinationPath: string;
-      targetBucket?: Bucket;
+    targetBucket?: Bucket;
-      overwrite?: boolean;
+    overwrite?: boolean;
-    }): Promise<void> {
+  }): Promise<void> {
-      try {
+    try {
-        // Check if the destination object already exists
+      const destinationBucket = optionsArg.targetBucket || this;
-        const destinationBucket = optionsArg.targetBucket || this;
+      const exists = await destinationBucket.fastExists({ path: optionsArg.destinationPath });
-        const exists = await destinationBucket.fastExists({ path: optionsArg.destinationPath });
 
-        if (exists && !optionsArg.overwrite) {
+      if (exists && !optionsArg.overwrite) {
-          console.error(`Object already exists at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
+        console.error(
-          return;
+          `Object already exists at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
-        } else if (exists && optionsArg.overwrite) {
+        );
-          console.log(`Overwriting existing object at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
+        return;
-        } else {
+      } else if (exists && optionsArg.overwrite) {
-          console.log(`Moving object to path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
+        console.log(
-        }
+          `Overwriting existing object at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
-  
+        );
-        // Proceed with copying the object to the new path
+      } else {
-        await this.fastCopy(optionsArg);
+        console.log(
-  
+          `Moving object to path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
-        // Remove the original object after successful copy
+        );
-        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;
       }
-    }
 
+      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
    */
-  public async fastRemove(optionsArg: {
+  public async fastRemove(optionsArg: { path: string }) {
-    path: string;
+    const command = new plugins.s3.DeleteObjectCommand({
-  }) {
+      Bucket: this.name,
-    await this.smartbucketRef.minioClient.removeObject(this.name, optionsArg.path);
+      Key: optionsArg.path,
+    });
+    await this.smartbucketRef.s3Client.send(command);
   }
 
   /**
-   * check wether file exists
+   * check whether file exists
    * @param optionsArg
    * @returns
    */
-  public async fastExists(optionsArg: {
+  public async fastExists(optionsArg: { path: string }): Promise<boolean> {
-    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 {
@@ -313,56 +397,43 @@ export class Bucket {
     }
   }
 
+  /**
+   * deletes this bucket
+   */
+  public async delete() {
+    await this.smartbucketRef.s3Client.send(
+      new plugins.s3.DeleteBucketCommand({ Bucket: this.name })
+    );
+  }
+
   public async fastStat(pathDescriptor: interfaces.IPathDecriptor) {
-    let checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
-    return this.smartbucketRef.minioClient.statObject(this.name, checkPath);
+    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> {
-    let checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
-    
+    const command = new plugins.s3.ListObjectsV2Command({
-    // lets check if the checkPath is a directory
+      Bucket: this.name,
-    const stream = this.smartbucketRef.minioClient.listObjectsV2(this.name, checkPath, true);
+      Prefix: checkPath,
-    const done = plugins.smartpromise.defer<boolean>();
+      Delimiter: '/',
-    stream.on('data', (dataArg) => {
-      stream.destroy(); // Stop the stream early if we find at least one object
-      if (dataArg.prefix.startsWith(checkPath + '/')) {
-        done.resolve(true);
-      }
     });
-    
+    const response = await this.smartbucketRef.s3Client.send(command);
-    stream.on('end', () => {
+    return response.CommonPrefixes.length > 0;
-      done.resolve(false);
+  }
-    });
-    
-    stream.on('error', (err) => {
-      done.reject(err);
-    });
-
-    return done.promise;
-  };
 
   public async isFile(pathDescriptor: interfaces.IPathDecriptor): Promise<boolean> {
-    let checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+    const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
-    
+    const command = new plugins.s3.ListObjectsV2Command({
-    // lets check if the checkPath is a directory
+      Bucket: this.name,
-    const stream = this.smartbucketRef.minioClient.listObjectsV2(this.name, checkPath, true);
+      Prefix: checkPath,
-    const done = plugins.smartpromise.defer<boolean>();
+      Delimiter: '/',
-    stream.on('data', (dataArg) => {
-      stream.destroy(); // Stop the stream early if we find at least one object
-      if (dataArg.prefix === checkPath) {
-        done.resolve(true);
-      }
     });
-    
+    const response = await this.smartbucketRef.s3Client.send(command);
-    stream.on('end', () => {
+    return response.Contents.length > 0;
-      done.resolve(false);
-    });
-    
-    stream.on('error', (err) => {
-      done.reject(err);
-    });
-
-    return done.promise;
   }
 }

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

@@ -4,7 +4,6 @@ import * as interfaces from './interfaces.js';
 import { Directory } from './classes.directory.js';
 import { MetaData } from './classes.metadata.js';
 
-
 /**
  * represents a file in a directory
  */
@@ -33,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,
@@ -48,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;
@@ -67,33 +71,59 @@ 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();
-  }
     
-  /**
+    await this.parentDirectoryRef.listFiles();
-   * deletes the file with recycling mechanics
-   */
-  public async delete() {
-    await this.remove();
   }
 
   /**
@@ -125,13 +155,16 @@ export class File {
   }
 
   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({

ts/classes.metadata.ts

@@ -10,7 +10,7 @@ export class MetaData {
 
     // lets find the existing metadata file
     metaData.metadataFile = await metaData.fileRef.parentDirectoryRef.getFile({
-      name: metaData.fileRef.name + '.metadata',
+      path: metaData.fileRef.name + '.metadata',
       createWithContents: '{}',
     });
 
@@ -44,7 +44,7 @@ export class MetaData {
     const stat = await this.fileRef.parentDirectoryRef.bucketRef.fastStat({
       path: this.fileRef.getBasePath(),
     });
-    return stat.size;
+    return stat.ContentLength;
   }
 
   private prefixCustomMetaData = 'custom_';

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/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,
+}