3.0.23

fix(dependencies): Update package dependencies for improved functionality and security.
3.0.22
2024-10-16 10:27:27 +02:00 · 2024-10-16 10:27:27 +02:00 · 2024-07-28 12:46:39 +02:00 · 2024-07-28 12:46:39 +02:00 · 2024-07-04 18:39:28 +02:00 · 2024-07-04 18:39:27 +02:00
24 changed files with 3475 additions and 1253 deletions
--- a/changelog.md
+++ b/changelog.md
@ -0,0 +1,73 @@
+# Changelog
+
+## 2024-10-16 - 3.0.23 - fix(dependencies)
+Update package dependencies for improved functionality and security.
+
+- Updated @aws-sdk/client-s3 to version ^3.670.0 for enhanced S3 client capabilities.
+- Updated @push.rocks/smartstream to version ^3.2.4.
+- Updated the dev dependency @push.rocks/tapbundle to version ^5.3.0.
+
+## 2024-07-28 - 3.0.22 - fix(dependencies)
+Update dependencies and improve bucket retrieval logging
+
+- Updated @aws-sdk/client-s3 to ^3.620.0
+- Updated @git.zone/tsbuild to ^2.1.84
+- Updated @git.zone/tsrun to ^1.2.49
+- Updated @push.rocks/smartpromise to ^4.0.4
+- Updated @tsclass/tsclass to ^4.1.2
+- Added a log for when a bucket is not found by name in getBucketByName method
+
+## 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.
--- a/npmextra.json
+++ b/npmextra.json
@ -8,22 +8,28 @@
      "githost": "code.foss.global",
      "gitscope": "push.rocks",
      "gitrepo": "smartbucket",
-      "description": "A TypeScript library for simple cloud independent object storage with support for buckets, directories, and files.",
+      "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",
-        "minio",
+        "bucket creation",
+        "file management",
+        "directory management",
+        "data streaming",
+        "multi-cloud",
+        "API",
+        "unified storage",
        "S3",
-        "TypeScript",
-        "smartstream",
-        "smartpromise",
-        "smartpath",
-        "smartrx",
-        "buckets",
-        "files management",
-        "directories management"
+        "minio",
+        "file locking",
+        "metadata",
+        "buffer handling",
+        "access key",
+        "secret key",
+        "cloud agnostic"
      ]
    }
  },
--- a/package-lock.json
+++ b/package-lock.json
@ -1,12 +1,12 @@
 {
  "name": "@push.rocks/smartbucket",
-  "version": "3.0.2",
+  "version": "3.0.23",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@push.rocks/smartbucket",
-      "version": "3.0.2",
+      "version": "3.0.23",
      "license": "UNLICENSED",
      "dependencies": {
        "@push.rocks/smartpath": "^5.0.18",
--- a/package.json
+++ b/package.json
@ -1,7 +1,7 @@
 {
  "name": "@push.rocks/smartbucket",
-  "version": "3.0.2",
-  "description": "A TypeScript library for simple cloud independent object storage with support for buckets, directories, and files.",
+  "version": "3.0.23",
+  "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",
@ -12,19 +12,22 @@
    "build": "(tsbuild --web --allowimplicitany)"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.80",
-    "@git.zone/tsrun": "^1.2.46",
+    "@git.zone/tsbuild": "^2.1.84",
+    "@git.zone/tsrun": "^1.2.49",
    "@git.zone/tstest": "^1.0.90",
    "@push.rocks/qenv": "^6.0.5",
-    "@push.rocks/tapbundle": "^5.0.23"
+    "@push.rocks/tapbundle": "^5.3.0"
  },
  "dependencies": {
+    "@aws-sdk/client-s3": "^3.670.0",
+    "@push.rocks/smartmime": "^2.0.2",
    "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/smartpromise": "^4.0.4",
    "@push.rocks/smartrx": "^3.0.7",
-    "@push.rocks/smartstream": "^3.0.38",
-    "@tsclass/tsclass": "^4.0.54",
-    "minio": "^8.0.0"
+    "@push.rocks/smartstream": "^3.2.4",
+    "@push.rocks/smartstring": "^4.0.15",
+    "@push.rocks/smartunique": "^3.0.9",
+    "@tsclass/tsclass": "^4.1.2"
  },
  "private": false,
  "files": [
@ -43,17 +46,28 @@
    "last 1 chrome versions"
  ],
  "keywords": [
+    "TypeScript",
    "cloud storage",
    "object storage",
-    "minio",
+    "bucket creation",
+    "file management",
+    "directory management",
+    "data streaming",
+    "multi-cloud",
+    "API",
+    "unified storage",
    "S3",
-    "TypeScript",
-    "smartstream",
-    "smartpromise",
-    "smartpath",
-    "smartrx",
-    "buckets",
-    "files management",
-    "directories management"
-  ]
+    "minio",
+    "file locking",
+    "metadata",
+    "buffer handling",
+    "access 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"
+  }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/qenv.yml
+++ b/qenv.yml
@ -1,3 +1,4 @@
 required:
  - S3_KEY
-  - S3_SECRET
+  - S3_SECRET
+  - S3_ENDPOINT
--- a/readme.md
+++ b/readme.md
@ -1,9 +1,10 @@
 # @push.rocks/smartbucket
-simple cloud independent object storage
+
+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,15 +14,28 @@ This command will download and install `@push.rocks/smartbucket` along with its

 ## Usage

-`@push.rocks/smartbucket` is a 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.

-To use `@push.rocks/smartbucket` in your project, you'll need to follow these general steps:
+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.
+
+### Table of Contents
+1. [Setting Up](#setting-up)
+2. [Creating a New Bucket](#creating-a-new-bucket)
+3. [Listing Buckets](#listing-buckets)
+4. [Working with Files](#working-with-files)
+    - [Uploading Files](#uploading-files)
+    - [Downloading Files](#downloading-files)
+    - [Deleting Files](#deleting-files)
+    - [Streaming Files](#streaming-files)
+5. [Working with Directories](#working-with-directories)
+6. [Advanced Features](#advanced-features)
+    - [Bucket Policies](#bucket-policies)
+    - [Object Metadata](#object-metadata)
+    - [Cloud Agnostic](#cloud-agnostic)

 ### Setting Up

-First, ensure you are using ECMAScript modules (ESM) and TypeScript in your project for best compatibility. 
-
-Here's how to import and initialize smartbucket in a TypeScript file:
+First, ensure you are using ECMAScript modules (ESM) and TypeScript in your project for best compatibility. Here's how to import and initialize SmartBucket in a TypeScript file:

 ```typescript
 import {
@ -35,10 +49,12 @@ const mySmartBucket = new SmartBucket({
  accessKey: "yourAccessKey",
  accessSecret: "yourSecretKey",
  endpoint: "yourEndpointURL",
+  port: 443,            // Default is 443, can be customized for specific endpoint
+  useSsl: true          // Defaults to true
 });
 ```

-Make sure to replace `"yourAccessKey"`, `"yourSecretKey"`, and `"yourEndpointURL"` with your actual credentials and endpoint URL.
+Make sure to replace `"yourAccessKey"`, `"yourSecretKey"`, and `"yourEndpointURL"` with your actual credentials and endpoint URL. The `port` and `useSsl` options are optional and can be omitted if the defaults are acceptable.

 ### Creating a New Bucket

@ -58,19 +74,15 @@ async function createBucket(bucketName: string) {
 createBucket("exampleBucket");
 ```

-**Important:** Bucket names must be unique across the storage service.
+Bucket names must be unique across the storage service.

 ### Listing Buckets

-To list all buckets:
+Currently, SmartBucket does not include a direct method to list all buckets, but you can access the underlying client provided by the cloud storage SDK to perform such operations, depending on the SDK's capabilities.

-```typescript
-// Currently, SmartBucket does not include a direct method to list all buckets,
-// but you can access the underlying client provided by the cloud storage SDK
-// to perform such operations, depending on the SDK's capabilities.
-```
+### Working with Files

-### Uploading Objects to a Bucket
+#### Uploading Files

 To upload an object to a bucket:

@ -78,8 +90,10 @@ To upload an object to a bucket:
 async function uploadFile(bucketName: string, filePath: string, fileContent: Buffer | string) {
  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
  if (myBucket) {
-    await myBucket.fastStore(filePath, fileContent);
+    await myBucket.fastPut({ path: filePath, contents: fileContent });
    console.log(`File uploaded to ${bucketName} at ${filePath}`);
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
  }
 }

@ -87,7 +101,7 @@ async function uploadFile(bucketName: string, filePath: string, fileContent: Buf
 uploadFile("exampleBucket", "path/to/object.txt", "Hello, world!");
 ```

-### Downloading Objects from a Bucket
+#### Downloading Files

 To download an object:

@ -95,8 +109,10 @@ To download an object:
 async function downloadFile(bucketName: string, filePath: string) {
  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
  if (myBucket) {
-    const fileContent: Buffer = await myBucket.fastGet(filePath);
+    const fileContent: Buffer = await myBucket.fastGet({ path: filePath });
    console.log("Downloaded file content:", fileContent.toString());
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
  }
 }

@ -104,7 +120,7 @@ async function downloadFile(bucketName: string, filePath: string) {
 downloadFile("exampleBucket", "path/to/object.txt");
 ```

-### Deleting Objects
+#### Deleting Files

 To delete an object from a bucket:

@ -112,8 +128,10 @@ To delete an object from a bucket:
 async function deleteFile(bucketName: string, filePath: string) {
  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
  if (myBucket) {
-    await myBucket.fastRemove(filePath);
+    await myBucket.fastRemove({ path: filePath });
    console.log(`File at ${filePath} deleted from ${bucketName}.`);
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
  }
 }

@ -121,19 +139,174 @@ async function deleteFile(bucketName: string, filePath: string) {
 deleteFile("exampleBucket", "path/to/object.txt");
 ```

+#### Streaming Files
+
+SmartBucket allows you to work with file streams, which can be useful for handling large files. 
+
+To read a file as a stream:
+
+```typescript
+import { ReplaySubject } from '@push.rocks/smartrx';
+
+async function readFileStream(bucketName: string, filePath: string) {
+  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
+  if (myBucket) {
+    const fileStream: ReplaySubject<Buffer> = await myBucket.fastGetStream({ path: filePath });
+    fileStream.subscribe({
+      next(chunk: Buffer) {
+        console.log("Chunk received:", chunk.toString());
+      },
+      complete() {
+        console.log("File read completed.");
+      },
+      error(err) {
+        console.error("Error reading file stream:", err);
+      }
+    });
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
+  }
+}
+
+// Use the function
+readFileStream("exampleBucket", "path/to/object.txt");
+```
+
+To write a file as a stream:
+
+```typescript
+import { Readable } from 'stream';
+
+async function writeFileStream(bucketName: string, filePath: string, readableStream: Readable) {
+  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
+  if (myBucket) {
+    await myBucket.fastPutStream({ path: filePath, dataStream: readableStream });
+    console.log(`File streamed to ${bucketName} at ${filePath}`);
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
+  }
+}
+
+// Create a readable stream from a string
+const readable = new Readable();
+readable.push('Hello world streamed as a file!');
+readable.push(null); // End of stream
+
+// Use the function
+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.

-### Additional Features
+To list the contents of a directory:

- **Bucket Policies:** Manage bucket policies to control access permissions.
- **Object Metadata:** Retrieve and modify object metadata.
- **Cloud-Agnostic:** Designed to work with multiple cloud providers, allowing for easier migration or multi-cloud strategies.
+```typescript
+async function listDirectoryContents(bucketName: string, directoryPath: string) {
+  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
+  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 => {
+      console.log(`- ${dir.name}`);
+    });
+
+    console.log('Listing files:');
+    const files = await targetDirectory.listFiles();
+    files.forEach(file => {
+      console.log(`- ${file.name}`);
+    });
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
+  }
+}
+
+// Use the function
+listDirectoryContents("exampleBucket", "some/directory/path");
+```
+
+To create a file within a directory:
+
+```typescript
+async function createFileInDirectory(bucketName: string, directoryPath: string, fileName: string, fileContent: string) {
+  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
+  if (myBucket) {
+    const baseDirectory: Directory = await myBucket.getBaseDirectory();
+    const targetDirectory: Directory = await baseDirectory.getSubDirectoryByName(directoryPath);
+    await targetDirectory.createEmptyFile(fileName); // Create an empty file
+    const file = new File({ directoryRefArg: targetDirectory, fileName });
+    await file.updateWithContents({ contents: fileContent });
+    console.log(`File created: ${fileName}`);
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
+  }
+}
+
+// Use the function
+createFileInDirectory("exampleBucket", "some/directory", "newfile.txt", "Hello, world!");
+```
+
+### Advanced Features
+
+#### Bucket Policies
+
+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
+
+Retrieve and modify object metadata. Metadata can be useful for storing additional information about an object.
+
+To retrieve metadata:
+
+```typescript
+async function getObjectMetadata(bucketName: string, filePath: string) {
+  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
+  if (myBucket) {
+    const metadata = await mySmartBucket.minioClient.statObject(bucketName, filePath);
+    console.log("Object metadata:", metadata);
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
+  }
+}
+
+// Use the function
+getObjectMetadata("exampleBucket", "path/to/object.txt");
+```
+
+To update metadata:
+
+```typescript
+async function updateObjectMetadata(bucketName: string, filePath: string, newMetadata: { [key: string]: string }) {
+  const myBucket: Bucket = await mySmartBucket.getBucketByName(bucketName);
+  if (myBucket) {
+    await myBucket.copyObject({
+      objectKey: filePath,
+      nativeMetadata: newMetadata,
+      deleteExistingNativeMetadata: false,
+    });
+    console.log(`Metadata updated for ${filePath}`);
+  } else {
+    console.error(`Bucket ${bucketName} does not exist.`);
+  }
+}
+
+// Use the function
+updateObjectMetadata("exampleBucket", "path/to/object.txt", {
+  customKey: "customValue"
+});
+```
+
+#### Cloud Agnostic
+
+`@push.rocks/smartbucket` is designed to work with multiple cloud providers, allowing for easier migration or multi-cloud strategies. This means you can switch from one provider to another with minimal changes to your codebase.

 Remember, each cloud provider has specific features and limitations. `@push.rocks/smartbucket` aims to abstract common functionalities, but always refer to the specific cloud provider's documentation for advanced features or limitations.

-> **Note:** This document focuses on basic operations to get you started with `@push.rocks/smartbucket`. For advanced usage, including streaming data, managing bucket policies, and handling large file uploads, refer to the detailed API documentation and examples.
+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

--- a/test/test.trash.ts
+++ b/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();
--- a/test/test.ts
+++ b/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'),
  });
-});
-
-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 () => {
+  expect(testSmartbucket).toBeInstanceOf(smartbucket.SmartBucket);
  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',
  });
 });
--- a/ts/00_commitinfo_data.ts
+++ b/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.2',
-  description: 'A TypeScript library for simple cloud independent object storage with support for buckets, directories, and files.'
+  version: '3.0.23',
+  description: 'A TypeScript library offering simple and cloud-agnostic object storage with advanced features like bucket creation, file and directory management, and data streaming.'
 }
--- a/ts/classes.bucket.ts
+++ b/ts/classes.bucket.ts
@ -0,0 +1,440 @@
+// 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 command = new plugins.s3.ListBucketsCommand({});
+    const buckets = await smartbucketRef.s3Client.send(command);
+    const foundBucket = buckets.Buckets.find((bucket) => bucket.Name === bucketNameArg);
+
+    if (foundBucket) {
+      console.log(`bucket with name ${bucketNameArg} exists.`);
+      console.log(`Taking this as base for new Bucket instance`);
+      return new this(smartbucketRef, bucketNameArg);
+    } else {
+      console.log(`did not find bucket by name: ${bucketNameArg}`);
+      return null;
+    }
+  }
+
+  public static async createBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
+    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) {
+    const command = new plugins.s3.DeleteBucketCommand({ Bucket: bucketName });
+    await smartbucketRef.s3Client.send(command).catch((e) => console.log(e));
+  }
+
+  public smartbucketRef: SmartBucket;
+  public name: string;
+
+  constructor(smartbucketRef: SmartBucket, bucketName: string) {
+    this.smartbucketRef = smartbucketRef;
+    this.name = bucketName;
+  }
+
+  /**
+   * gets the base directory of the bucket
+   */
+  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
+  // ===============
+
+  /**
+   * store file
+   */
+  public async fastPut(
+    optionsArg: interfaces.IPathDecriptor & {
+      contents: string | Buffer;
+      overwrite?: boolean;
+    }
+  ): Promise<File> {
+    try {
+      const reducedPath = await helpers.reducePathDescriptorToPath(optionsArg);
+      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}'.`
+        );
+      } else {
+        console.log(`Creating new object at path '${reducedPath}' in bucket '${this.name}'.`);
+      }
+
+      const command = new plugins.s3.PutObjectCommand({
+        Bucket: this.name,
+        Key: reducedPath,
+        Body: optionsArg.contents,
+      });
+      await this.smartbucketRef.s3Client.send(command);
+
+      console.log(`Object '${reducedPath}' has been successfully stored in bucket '${this.name}'.`);
+      const parsedPath = plugins.path.parse(reducedPath);
+      return new File({
+        directoryRefArg: await this.getDirectoryFromPath({
+          path: parsedPath.dir,
+        }),
+        fileName: parsedPath.base,
+      });
+    } catch (error) {
+      console.error(
+        `Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * get file
+   */
+  public async fastGet(optionsArg: { path: string }): Promise<Buffer> {
+    const done = plugins.smartpromise.defer();
+    let completeFile: Buffer;
+    const replaySubject = await this.fastGetReplaySubject(optionsArg);
+    const subscription = replaySubject.subscribe({
+      next: (chunk) => {
+        if (completeFile) {
+          completeFile = Buffer.concat([completeFile, chunk]);
+        } else {
+          completeFile = chunk;
+        }
+      },
+      complete: () => {
+        done.resolve();
+        subscription.unsubscribe();
+      },
+      error: (err) => {
+        console.log(err);
+      },
+    });
+    await done.promise;
+    return completeFile;
+  }
+
+  /**
+   * good when time to first byte is important
+   * and multiple subscribers are expected
+   * @param optionsArg
+   * @returns
+   */
+  public async fastGetReplaySubject(optionsArg: {
+    path: string;
+  }): Promise<plugins.smartrx.rxjs.ReplaySubject<Buffer>> {
+    const command = new plugins.s3.GetObjectCommand({
+      Bucket: this.name,
+      Key: optionsArg.path,
+    });
+    const response = await this.smartbucketRef.s3Client.send(command);
+    const replaySubject = new plugins.smartrx.rxjs.ReplaySubject<Buffer>();
+
+    // Convert the stream to a format that supports piping
+    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);
+    }
+
+    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;
+    readableStream: plugins.stream.Readable | ReadableStream;
+    nativeMetadata?: { [key: string]: string };
+    overwrite?: boolean;
+  }): Promise<void> {
+    try {
+      const exists = await this.fastExists({ path: optionsArg.path });
+
+      if (exists && !optionsArg.overwrite) {
+        console.error(
+          `Object already exists at path '${optionsArg.path}' in bucket '${this.name}'.`
+        );
+        return;
+      } else if (exists && optionsArg.overwrite) {
+        console.log(
+          `Overwriting existing object at path '${optionsArg.path}' in bucket '${this.name}'.`
+        );
+      } else {
+        console.log(`Creating new object at path '${optionsArg.path}' in bucket '${this.name}'.`);
+      }
+
+      const command = new plugins.s3.PutObjectCommand({
+        Bucket: this.name,
+        Key: optionsArg.path,
+        Body: optionsArg.readableStream,
+        Metadata: optionsArg.nativeMetadata,
+      });
+      await this.smartbucketRef.s3Client.send(command);
+
+      console.log(
+        `Object '${optionsArg.path}' has been successfully stored in bucket '${this.name}'.`
+      );
+    } catch (error) {
+      console.error(
+        `Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  public async fastCopy(optionsArg: {
+    sourcePath: string;
+    destinationPath?: string;
+    targetBucket?: Bucket;
+    nativeMetadata?: { [key: string]: string };
+    deleteExistingNativeMetadata?: boolean;
+  }): Promise<void> {
+    try {
+      const targetBucketName = optionsArg.targetBucket ? optionsArg.targetBucket.name : this.name;
+
+      // Retrieve current object information to use in copy conditions
+      const currentObjInfo = await this.smartbucketRef.s3Client.send(
+        new plugins.s3.HeadObjectCommand({
+          Bucket: this.name,
+          Key: optionsArg.sourcePath,
+        })
+      );
+
+      // Prepare new metadata
+      const newNativeMetadata = {
+        ...(optionsArg.deleteExistingNativeMetadata ? {} : currentObjInfo.Metadata),
+        ...optionsArg.nativeMetadata,
+      };
+
+      // Define the copy operation
+      const copySource = `${this.name}/${optionsArg.sourcePath}`;
+      const command = new plugins.s3.CopyObjectCommand({
+        Bucket: targetBucketName,
+        CopySource: copySource,
+        Key: optionsArg.destinationPath || optionsArg.sourcePath,
+        Metadata: newNativeMetadata,
+        MetadataDirective: optionsArg.deleteExistingNativeMetadata ? 'REPLACE' : 'COPY',
+      });
+      await this.smartbucketRef.s3Client.send(command);
+    } catch (err) {
+      console.error('Error updating metadata:', err);
+      throw err; // rethrow to allow caller to handle
+    }
+  }
+
+  /**
+   * Move object from one path to another within the same bucket or to another bucket
+   */
+  public async fastMove(optionsArg: {
+    sourcePath: string;
+    destinationPath: string;
+    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;
+    }
+  }
+
+  /**
+   * removeObject
+   */
+  public async fastRemove(optionsArg: { path: string }) {
+    const command = new plugins.s3.DeleteObjectCommand({
+      Bucket: this.name,
+      Key: optionsArg.path,
+    });
+    await this.smartbucketRef.s3Client.send(command);
+  }
+
+  /**
+   * check whether file exists
+   * @param optionsArg
+   * @returns
+   */
+  public async fastExists(optionsArg: { path: string }): Promise<boolean> {
+    try {
+      const command = new plugins.s3.HeadObjectCommand({
+        Bucket: this.name,
+        Key: optionsArg.path,
+      });
+      await this.smartbucketRef.s3Client.send(command);
+      console.log(`Object '${optionsArg.path}' exists in bucket '${this.name}'.`);
+      return true;
+    } catch (error) {
+      if (error.name === 'NotFound') {
+        console.log(`Object '${optionsArg.path}' does not exist in bucket '${this.name}'.`);
+        return false;
+      } else {
+        console.error('Error checking object existence:', error);
+        throw error; // Rethrow if it's not a NotFound error to handle unexpected issues
+      }
+    }
+  }
+
+  /**
+   * deletes this bucket
+   */
+  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;
+  }
+}
--- a/ts/classes.directory.ts
+++ b/ts/classes.directory.ts
@ -0,0 +1,328 @@
+// 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;
+  public parentDirectoryRef: Directory;
+  public name: string;
+
+  public tree: string[];
+  public files: string[];
+  public folders: string[];
+
+  constructor(bucketRefArg: Bucket, parentDirectory: Directory, name: string) {
+    this.bucketRef = bucketRefArg;
+    this.parentDirectoryRef = parentDirectory;
+    this.name = name;
+  }
+
+  /**
+   * returns an array of parent directories
+   */
+  public getParentDirectories(): Directory[] {
+    let parentDirectories: Directory[] = [];
+    if (this.parentDirectoryRef) {
+      parentDirectories.push(this.parentDirectoryRef);
+      parentDirectories = parentDirectories.concat(this.parentDirectoryRef.getParentDirectories());
+    }
+    return parentDirectories;
+  }
+
+  /**
+   * returns the directory level
+   */
+  public getDirectoryLevel(): number {
+    return this.getParentDirectories().length;
+  }
+
+  /**
+   * updates the base path
+   */
+  public getBasePath(): string {
+    const parentDirectories = this.getParentDirectories();
+    let basePath = '';
+    for (const parentDir of parentDirectories) {
+      if (!parentDir.name && !basePath) {
+        basePath = this.name + '/';
+        continue;
+      }
+      if (parentDir.name && !basePath) {
+        basePath = parentDir.name + '/' + this.name + '/';
+        continue;
+      }
+      if (parentDir.name && basePath) {
+        basePath = parentDir.name + '/' + basePath;
+        continue;
+      }
+    }
+    return basePath;
+  }
+
+  /**
+   * gets a file by name
+   */
+  public async getFile(optionsArg: {
+    path: string;
+    createWithContents?: string | Buffer;
+    getFromTrash?: boolean;
+  }): Promise<File> {
+    const pathDescriptor = {
+      directory: this,
+      path: optionsArg.path,
+    };
+    const exists = await this.bucketRef.fastExists({
+      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 File.create({
+        directory: this,
+        name: optionsArg.path,
+        contents: optionsArg.createWithContents,
+      });
+    }
+    return new File({
+      directoryRefArg: this,
+      fileName: optionsArg.path,
+    });
+  }
+
+  /**
+   * lists all files
+   */
+  public async listFiles(): Promise<File[]> {
+    const command = new plugins.s3.ListObjectsV2Command({
+      Bucket: this.bucketRef.name,
+      Prefix: this.getBasePath(),
+      Delimiter: '/',
+    });
+    const response = await this.bucketRef.smartbucketRef.s3Client.send(command);
+    const fileArray: File[] = [];
+
+    response.Contents.forEach((item) => {
+      if (item.Key && !item.Key.endsWith('/')) {
+        const subtractedPath = item.Key.replace(this.getBasePath(), '');
+        if (!subtractedPath.includes('/')) {
+          fileArray.push(
+            new File({
+              directoryRefArg: this,
+              fileName: subtractedPath,
+            })
+          );
+        }
+      }
+    });
+
+    return fileArray;
+  }
+
+  /**
+   * lists all folders
+   */
+  public async listDirectories(): Promise<Directory[]> {
+    try {
+      const command = new plugins.s3.ListObjectsV2Command({
+        Bucket: this.bucketRef.name,
+        Prefix: this.getBasePath(),
+        Delimiter: '/',
+      });
+      const response = await this.bucketRef.smartbucketRef.s3Client.send(command);
+      const directoryArray: Directory[] = [];
+  
+      if (response.CommonPrefixes) {
+        response.CommonPrefixes.forEach((item) => {
+          if (item.Prefix) {
+            const subtractedPath = item.Prefix.replace(this.getBasePath(), '');
+            if (subtractedPath.endsWith('/')) {
+              const dirName = subtractedPath.slice(0, -1);
+              // Ensure the directory name is not empty (which would indicate the base directory itself)
+              if (dirName) {
+                directoryArray.push(new Directory(this.bucketRef, this, dirName));
+              }
+            }
+          }
+        });
+      }
+  
+      return directoryArray;
+    } catch (error) {
+      console.error('Error listing directories:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * gets an array that has all objects with a certain prefix
+   */
+  public async getTreeArray() {
+    const command = new plugins.s3.ListObjectsV2Command({
+      Bucket: this.bucketRef.name,
+      Prefix: this.getBasePath(),
+      Delimiter: '/',
+    });
+    const response = await this.bucketRef.smartbucketRef.s3Client.send(command);
+    return response.Contents;
+  }
+
+  /**
+   * gets a sub directory by name
+   */
+  public async getSubDirectoryByName(dirNameArg: string): Promise<Directory> {
+    const dirNameArray = dirNameArg.split('/');
+
+    const getDirectory = async (directoryArg: Directory, dirNameToSearch: string) => {
+      const directories = await directoryArg.listDirectories();
+      return directories.find((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;
+  }
+
+  /**
+   * moves the directory
+   */
+  public async move() {
+    // TODO
+    throw new Error('Moving a directory is not yet implemented');
+  }
+
+  /**
+   * creates an empty file within this directory
+   * @param relativePathArg
+   */
+  public async createEmptyFile(relativePathArg: string) {
+    const emptyFile = await File.create({
+      directory: this,
+      name: relativePathArg,
+      contents: '',
+    });
+    return emptyFile;
+  }
+
+  // file operations
+  public async fastPut(optionsArg: { path: string; contents: string | Buffer }) {
+    const path = plugins.path.join(this.getBasePath(), optionsArg.path);
+    await this.bucketRef.fastPut({
+      path,
+      contents: optionsArg.contents,
+    });
+  }
+
+  public async fastGet(optionsArg: { path: string }) {
+    const path = plugins.path.join(this.getBasePath(), optionsArg.path);
+    const result = await this.bucketRef.fastGet({
+      path,
+    });
+    return result;
+  }
+
+  public fastGetStream(
+    optionsArg: {
+      path: string;
+    },
+    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;
+  }
+
+  /**
+   * 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.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(optionsArg: {
+    mode?: 'permanent' | 'trash';
+  }) {
+    const deleteDirectory = async (directoryArg: Directory) => {
+      const childDirectories = await directoryArg.listDirectories();
+      if (childDirectories.length === 0) {
+        console.log('Directory empty! Path complete!');
+      } else {
+        for (const childDir of childDirectories) {
+          await deleteDirectory(childDir);
+        }
+      }
+      const files = await directoryArg.listFiles();
+      for (const file of files) {
+        await file.delete({
+          mode: optionsArg.mode ? optionsArg.mode : 'permanent',
+        })
+      }
+    };
+    await deleteDirectory(this);
+  }
+}
--- a/ts/classes.file.ts
+++ b/ts/classes.file.ts
@ -0,0 +1,233 @@
+import * as plugins from './plugins.js';
+import * as helpers from './helpers.js';
+import * as interfaces from './interfaces.js';
+import { Directory } from './classes.directory.js';
+import { MetaData } from './classes.metadata.js';
+
+/**
+ * represents a file in a directory
+ */
+export class File {
+  // STATIC
+
+  /**
+   * creates a file in draft mode
+   * you need to call .save() to store it in s3
+   * @param optionsArg
+   */
+  public static async create(optionsArg: {
+    directory: Directory;
+    name: string;
+    contents: Buffer | string | plugins.stream.Readable;
+    /**
+     * if contents are of type string, you can specify the encoding here
+     */
+    encoding?: 'utf8' | 'binary';
+  }): Promise<File> {
+    const contents =
+      typeof optionsArg.contents === 'string'
+        ? Buffer.from(optionsArg.contents, optionsArg.encoding)
+        : optionsArg.contents;
+    const file = new File({
+      directoryRefArg: optionsArg.directory,
+      fileName: optionsArg.name,
+    });
+    if (contents instanceof plugins.stream.Readable) {
+      await optionsArg.directory.fastPutStream({
+        path: optionsArg.name,
+        stream: contents,
+      });
+    } else {
+      await optionsArg.directory.fastPut({
+        path: optionsArg.name,
+        contents: contents,
+      });
+    }
+    return file;
+  }
+
+  // INSTANCE
+  public parentDirectoryRef: Directory;
+  public name: string;
+
+  public getBasePath(): string {
+    return plugins.path.join(this.parentDirectoryRef.getBasePath(), this.name);
+  }
+
+  constructor(optionsArg: { directoryRefArg: Directory; fileName: string }) {
+    this.parentDirectoryRef = optionsArg.directoryRefArg;
+    this.name = optionsArg.fileName;
+  }
+
+  public async getContentsAsString(): Promise<string> {
+    const fileBuffer = await this.getContents();
+    return fileBuffer.toString();
+  }
+
+  public async getContents(): Promise<Buffer> {
+    const resultBuffer = await this.parentDirectoryRef.bucketRef.fastGet({
+      path: this.getBasePath(),
+    });
+    return resultBuffer;
+  }
+
+  public async getReadStream(typeArg: 'webstream'): Promise<ReadableStream>;
+  public async getReadStream(typeArg: 'nodestream'): Promise<plugins.stream.Readable>;
+  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;
+  }
+
+  /**
+   * deletes this file
+   */
+  public async delete(optionsArg?: {
+    mode: 'trash' | 'permanent';
+  }) {
+
+    optionsArg = {
+      ... {
+        mode: 'permanent',
+      },
+      ...optionsArg,
+    }
+
+    if (optionsArg.mode === 'permanent') {
+      await this.parentDirectoryRef.bucketRef.fastRemove({
+        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();
+  }
+
+  /**
+   * allows locking the file
+   * @param optionsArg
+   */
+  public async lock(optionsArg?: { timeoutMillis?: number }) {
+    const metadata = await this.getMetaData();
+    await metadata.setLock({
+      lock: 'locked',
+      expires: Date.now() + (optionsArg?.timeoutMillis || 1000),
+    });
+  }
+
+  /**
+   * actively unlocks a file
+   *
+   */
+  public async unlock(optionsArg?: {
+    /**
+     * unlock the file even if not locked from this instance
+     */
+    force?: boolean;
+  }) {
+    const metadata = await this.getMetaData();
+    await metadata.removeLock({
+      force: optionsArg?.force,
+    });
+  }
+
+  public async updateWithContents(optionsArg: {
+    contents: Buffer | string | plugins.stream.Readable | ReadableStream;
+    encoding?: 'utf8' | 'binary';
+  }) {
+    if (
+      optionsArg.contents instanceof plugins.stream.Readable ||
+      optionsArg.contents instanceof ReadableStream
+    ) {
+      await this.parentDirectoryRef.bucketRef.fastPutStream({
+        path: this.getBasePath(),
+        readableStream: optionsArg.contents,
+      });
+    } else if (Buffer.isBuffer(optionsArg.contents)) {
+      await this.parentDirectoryRef.bucketRef.fastPut({
+        path: this.getBasePath(),
+        contents: optionsArg.contents,
+      });
+    } else if (typeof optionsArg.contents === 'string') {
+      await this.parentDirectoryRef.bucketRef.fastPut({
+        path: this.getBasePath(),
+        contents: Buffer.from(optionsArg.contents, optionsArg.encoding),
+      });
+    }
+  }
+
+  /**
+   * 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),
+    });
+  }
+}
--- a/ts/classes.metadata.ts
+++ b/ts/classes.metadata.ts
@ -0,0 +1,100 @@
+import * as plugins from './plugins.js';
+
+import { File } from './classes.file.js';
+
+export class MetaData {
+  // static
+  public static async createForFile(optionsArg: { file: File }) {
+    const metaData = new MetaData();
+    metaData.fileRef = optionsArg.file;
+
+    // lets find the existing metadata file
+    metaData.metadataFile = await metaData.fileRef.parentDirectoryRef.getFile({
+      path: metaData.fileRef.name + '.metadata',
+      createWithContents: '{}',
+    });
+
+    return metaData;
+  }
+
+  // instance
+  /**
+   * the file that contains the metadata
+   */
+  metadataFile: File;
+
+  /**
+   * 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) {
+      return plugins.path.extname(this.fileRef.name);
+    }
+  }
+
+  /**
+   * gets the size of the fileRef
+   */
+  public async getSizeInBytes(): Promise<number> {
+    const stat = await this.fileRef.parentDirectoryRef.bucketRef.fastStat({
+      path: this.fileRef.getBasePath(),
+    });
+    return stat.ContentLength;
+  }
+
+  private prefixCustomMetaData = 'custom_';
+
+  public async storeCustomMetaData<T = any>(optionsArg: { key: string; value: T }) {
+    const data = await this.metadataFile.getContentsAsString();
+    data[this.prefixCustomMetaData + optionsArg.key] = optionsArg.value;
+    await this.metadataFile.writeJsonData(data);
+  }
+
+  public async getCustomMetaData<T = any>(optionsArg: { key: string }): Promise<T> {
+    const data = await this.metadataFile.getJsonData();
+    return data[this.prefixCustomMetaData + optionsArg.key];
+  }
+
+  public async deleteCustomMetaData(optionsArg: { key: string }) {
+    const data = await this.metadataFile.getJsonData();
+    delete data[this.prefixCustomMetaData + optionsArg.key];
+    await this.metadataFile.writeJsonData(data);
+  }
+
+  /**
+   * set a lock on the ref file
+   * @param optionsArg
+   */
+  public async setLock(optionsArg: { lock: string; expires: number }) {
+    const data = await this.metadataFile.getJsonData();
+    data.lock = optionsArg.lock;
+    data.lockExpires = optionsArg.expires;
+    await this.metadataFile.writeJsonData(data);
+  }
+
+  /**
+   * remove the lock on the ref file
+   * @param optionsArg
+   */
+  public async removeLock(optionsArg: { 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 };
+  }
+}
--- a/ts/classes.smartbucket.ts
+++ b/ts/classes.smartbucket.ts
@ -0,0 +1,47 @@
+// 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 s3Client: plugins.s3.S3Client;
+
+  /**
+   * the constructor of SmartBucket
+   */
+  /**
+   * the constructor of SmartBucket
+   */
+  constructor(configArg: plugins.tsclass.storage.IS3Descriptor) {
+    this.config = configArg;
+
+    const protocol = configArg.useSsl === false ? 'http' : 'https';
+    const port = configArg.port ? `:${configArg.port}` : '';
+    const endpoint = `${protocol}://${configArg.endpoint}${port}`;
+
+    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
+    });
+  }
+
+  public async createBucket(bucketNameArg: string) {
+    const bucket = await Bucket.createBucketByName(this, bucketNameArg);
+    return bucket;
+  }
+
+  public async removeBucket(bucketName: string) {
+    await Bucket.removeBucketByName(this, bucketName);
+  }
+
+  public async getBucketByName(bucketName: string) {
+    return Bucket.getBucketByName(this, bucketName);
+  }
+}
--- a/ts/classes.trash.ts
+++ b/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);
+  }
+}
--- a/ts/helpers.ts
+++ b/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;
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,4 +1,4 @@
-export * from './smartbucket.classes.smartbucket.js';
-export * from './smartbucket.classes.bucket.js';
-export * from './smartbucket.classes.directory.js';
-export * from './smartbucket.classes.file.js';
+export * from './classes.smartbucket.js';
+export * from './classes.bucket.js';
+export * from './classes.directory.js';
+export * from './classes.file.js';
--- a/ts/interfaces.ts
+++ b/ts/interfaces.ts
@ -0,0 +1,6 @@
+import type { Directory } from "./classes.directory.js";
+
+export interface IPathDecriptor {
+  path?: string;
+  directory?: Directory;
+}
--- a/ts/smartbucket.plugins.ts
+++ b/ts/smartbucket.plugins.ts
@ -1,3 +1,5 @@
+// plugins.ts
+
 // node native
 import * as path from 'path';
 import * as stream from 'stream';
@ -5,12 +7,15 @@ import * as stream from 'stream';
 export { path, stream };

 // @push.rocks scope
+import * as smartmime from '@push.rocks/smartmime';
 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 { smartpath, smartpromise, smartrx, smartstream };
+export { smartmime, smartpath, smartpromise, smartrx, smartstream, smartstring, smartunique };

 // @tsclass
 import * as tsclass from '@tsclass/tsclass';
@ -20,6 +25,8 @@ export {
 }

 // third party scope
-import * as minio from 'minio';
+import * as s3 from '@aws-sdk/client-s3';

-export { minio };
+export {
+  s3,
+}
--- a/ts/smartbucket.classes.bucket.ts
+++ b/ts/smartbucket.classes.bucket.ts
@ -1,218 +0,0 @@
-import * as plugins from './smartbucket.plugins.js';
-import { SmartBucket } from './smartbucket.classes.smartbucket.js';
-import { Directory } from './smartbucket.classes.directory.js';
-
-export class Bucket {
-  public static async getBucketByName(smartbucketRef: SmartBucket, bucketNameArg: string) {
-    const buckets = await smartbucketRef.minioClient.listBuckets();
-    const foundBucket = buckets.find((bucket) => {
-      return bucket.name === bucketNameArg;
-    });
-
-    if (foundBucket) {
-      console.log(`bucket with name ${bucketNameArg} exists.`);
-      console.log(`Taking this as base for new Bucket instance`);
-      return new this(smartbucketRef, bucketNameArg);
-    } else {
-      return null;
-    }
-  }
-
-  public static async createBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
-    await smartbucketRef.minioClient.makeBucket(bucketName, 'ams3').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));
-  }
-
-  public smartbucketRef: SmartBucket;
-  public name: string;
-
-  constructor(smartbucketRef: SmartBucket, bucketName: string) {
-    this.smartbucketRef = smartbucketRef;
-    this.name = bucketName;
-  }
-
-  /**
-   * gets the base directory of the bucket
-   */
-  public async getBaseDirectory() {
-    return new Directory(this, null, '');
-  }
-
-  // ===============
-  // Fast Operations
-  // ===============
-
-  /**
-   * store file
-   */
-  public async fastPut(optionsArg: {
-    path: string;
-    contents: string | Buffer;
-  }): Promise<void> {
-    const streamIntake = new plugins.smartstream.StreamIntake();
-    const putPromise = this.smartbucketRef.minioClient
-      .putObject(this.name, optionsArg.path, streamIntake)
-      .catch((e) => console.log(e));
-    streamIntake.pushData(optionsArg.contents);
-    streamIntake.signalEnd();
-    const response = await putPromise;
-  }
-
-  /**
-   * get file
-   */
-  public async fastGet(optionsArg: Parameters<typeof this.fastGetStream>[0]): Promise<Buffer> {
-    const done = plugins.smartpromise.defer();
-    let completeFile: Buffer;
-    const replaySubject = await this.fastGetStream(optionsArg);
-    const subscription = replaySubject.subscribe({
-      next: (chunk) => {
-        if (completeFile) {
-          completeFile = Buffer.concat([completeFile, chunk]);
-        } else {
-          completeFile = chunk;
-        }
-      },
-      complete: () => {
-        done.resolve();
-        subscription.unsubscribe();
-      },
-      error: (err) => {
-        console.log(err);
-      },
-    });
-    await done.promise;
-    return completeFile;
-  }
-
-  public async fastGetStream(optionsArg: {
-    path: string;
-  }): Promise<plugins.smartrx.rxjs.ReplaySubject<Buffer>> {
-    const fileStream = await this.smartbucketRef.minioClient
-      .getObject(this.name, optionsArg.path)
-      .catch((e) => console.log(e));
-    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;
-      }
-    });
-
-    if (!fileStream) {
-      return null;
-    }
-
-    const smartstream = new plugins.smartstream.StreamWrapper([
-      fileStream,
-      duplexStream,
-    ]);
-    smartstream.run();
-    return replaySubject;
-  }
-
-  /**
-   * store file as stream
-   */
-  public async fastPutStream(optionsArg: {
-    path: string;
-    dataStream: plugins.stream.Readable;
-    nativeMetadata?: { [key: string]: string };
-  }): Promise<void> {
-    await this.smartbucketRef.minioClient.putObject(
-      this.name,
-      optionsArg.path,
-      optionsArg.dataStream,
-      null,
-      ...(optionsArg.nativeMetadata
-        ? (() => {
-            const returnObject: any = {};
-            return returnObject;
-          })()
-        : {})
-    );
-  }
-
-  public async copyObject(optionsArg: {
-    /**
-     * the
-     */
-    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> {
-    try {
-      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(
-        targetBucketName,
-        optionsArg.objectKey
-      );
-
-      // Setting up copy conditions
-      const copyConditions = new plugins.minio.CopyConditions();
-
-      // Prepare new metadata
-      const newNativeMetadata = {
-        ...(optionsArg.deleteExistingNativeMetadata ? {} : currentObjInfo.metaData),
-        ...optionsArg.nativeMetadata,
-      };
-
-      // Define the copy operation as a Promise
-      // TODO: check on issue here: https://github.com/minio/minio-js/issues/1286
-      await this.smartbucketRef.minioClient.copyObject(
-        this.name,
-        optionsArg.objectKey,
-        `/${targetBucketName}/${optionsArg.objectKey}`,
-        copyConditions
-      );
-    } catch (err) {
-      console.error('Error updating metadata:', err);
-      throw err; // rethrow to allow caller to handle
-    }
-  }
-
-  /**
-   * removeObject
-   */
-  public async fastRemove(optionsArg: {
-    path: string;
-  }) {
-    await this.smartbucketRef.minioClient.removeObject(this.name, optionsArg.path);
-  }
-
-  public async doesObjectExist(optionsArg: {
-    path: string;
-  }): Promise<boolean> {
-    try {
-      await this.smartbucketRef.minioClient.statObject(this.name, optionsArg.path);
-      console.log(`Object '${optionsArg.path}' exists in bucket '${this.name}'.`);
-      return true;
-    } catch (error) {
-      if (error.code === 'NotFound') {
-        console.log(`Object '${optionsArg.path}' does not exist in bucket '${this.name}'.`);
-        return false;
-      } else {
-        console.error('Error checking object existence:', error);
-        throw error; // Rethrow if it's not a NotFound error to handle unexpected issues
-      }
-    }
-  }
-}
--- a/ts/smartbucket.classes.directory.ts
+++ b/ts/smartbucket.classes.directory.ts
@ -1,248 +0,0 @@
-import * as plugins from './smartbucket.plugins.js';
-import { Bucket } from './smartbucket.classes.bucket.js';
-import { File } from './smartbucket.classes.file.js';
-
-export class Directory {
-  public bucketRef: Bucket;
-  public parentDirectoryRef: Directory;
-  public name: string;
-
-  public tree: string[];
-  public files: string[];
-  public folders: string[];
-
-  constructor(bucketRefArg: Bucket, parentDiretory: Directory, name: string) {
-    this.bucketRef = bucketRefArg;
-    this.parentDirectoryRef = parentDiretory;
-    this.name = name;
-  }
-
-  /**
-   * returns an array of parent directories
-   */
-  public getParentDirectories(): Directory[] {
-    let parentDirectories: Directory[] = [];
-    if (this.parentDirectoryRef) {
-      parentDirectories.push(this.parentDirectoryRef);
-      parentDirectories = parentDirectories.concat(this.parentDirectoryRef.getParentDirectories());
-    }
-    return parentDirectories;
-  }
-
-  /**
-   * returns the directory level
-   */
-  public getDirectoryLevel(): number {
-    return this.getParentDirectories().length;
-  }
-
-  /**
-   * updates the base path
-   */
-  public getBasePath(): string {
-    const parentDirectories = this.getParentDirectories();
-    let basePath = '';
-    for (const parentDir of parentDirectories) {
-      if (!parentDir.name && !basePath) {
-        basePath = this.name + '/';
-        continue;
-      }
-      if (parentDir.name && !basePath) {
-        basePath = parentDir.name + '/' + this.name + '/';
-        continue;
-      }
-      if (parentDir.name && basePath) {
-        basePath = parentDir.name + '/' + basePath;
-        continue;
-      }
-    }
-    return basePath;
-  }
-
-  /**
-   * lists all files
-   */
-  public async listFiles(): Promise<File[]> {
-    const done = plugins.smartpromise.defer();
-    const fileNameStream = await this.bucketRef.smartbucketRef.minioClient.listObjectsV2(
-      this.bucketRef.name,
-      this.getBasePath(),
-      false
-    );
-    const fileArray: File[] = [];
-    const duplexStream = new plugins.smartstream.SmartDuplex<plugins.minio.BucketItem, void>({
-      objectMode: true,
-      writeFunction: async (bucketItem) => {
-        if (bucketItem.prefix) {
-          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({
-              directoryRefArg: this,
-              fileName: subtractedPath,
-            })
-          );
-        }
-      },
-      finalFunction: async (tools) => {
-        done.resolve();
-      }
-    });
-    fileNameStream.pipe(duplexStream);
-    await done.promise;
-    return fileArray;
-  }
-
-  /**
-   * lists all folders
-   */
-  public async listDirectories(): Promise<Directory[]> {
-    const done = plugins.smartpromise.defer();
-    const basePath = this.getBasePath();
-    const completeDirStream = await this.bucketRef.smartbucketRef.minioClient.listObjectsV2(
-      this.bucketRef.name,
-      this.getBasePath(),
-      false
-    );
-    const directoryArray: Directory[] = [];
-    const duplexStream = new plugins.smartstream.SmartDuplex<plugins.minio.BucketItem, void>({
-      objectMode: true,
-      writeFunction: async (bucketItem) => {
-        if (bucketItem.name) {
-          return;
-        }
-        let subtractedPath = bucketItem.prefix.replace(this.getBasePath(), '');
-        if (subtractedPath.startsWith('/')) {
-          subtractedPath = subtractedPath.substr(1);
-        }
-        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);
-    await done.promise;
-    return directoryArray;
-  }
-
-  /**
-   * gets an array that has all objects with a certain prefix;
-   */
-  public async getTreeArray() {
-    const treeArray = await this.bucketRef.smartbucketRef.minioClient.listObjectsV2(
-      this.bucketRef.name,
-      this.getBasePath(),
-      true
-    );
-  }
-
-  /**
-   * gets a sub directory
-   */
-  public async getSubDirectoryByName(dirNameArg: string): Promise<Directory> {
-    const dirNameArray = dirNameArg.split('/');
-
-    const getDirectory = async (directoryArg: Directory, dirNameToSearch: string) => {
-      const directories = await directoryArg.listDirectories();
-      return directories.find((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;
-  }
-
-  /**
-   * moves the directory
-   */
-  public async move() {
-    // TODO
-    throw new Error('moving a directory is not yet implemented');
-  }
-
-  /**
-   * creates a file within this directory
-   * @param relativePathArg
-   */
-  public async createEmptyFile(relativePathArg: string) {
-    const emtpyFile = await File.create({
-      directory: this,
-      name: relativePathArg,
-      contents: '',
-    });
-  }
-
-  // file operations
-  public async fastPut(optionsArg: { path: string; contents: string | Buffer }) {
-    const path = plugins.path.join(this.getBasePath(), optionsArg.path);
-    await this.bucketRef.fastPut({
-      path,
-      contents: optionsArg.contents,
-    });
-  }
-
-  public async fastGet(optionsArg: { path: string }) {
-    const path = plugins.path.join(this.getBasePath(), optionsArg.path);
-    const result = await this.bucketRef.fastGet({
-      path,
-    });
-    return result;
-  }
-
-  public async fastGetStream(pathArg: string): Promise<plugins.smartrx.rxjs.ReplaySubject<Buffer>> {
-    const path = plugins.path.join(this.getBasePath(), pathArg);
-    const result = await this.bucketRef.fastGetStream({
-      path,
-    });
-    return result;
-  }
-
-  public async fastRemove(optionsArg: { path: string }) {
-    const path = plugins.path.join(this.getBasePath(), optionsArg.path);
-    await this.bucketRef.fastRemove({
-      path,
-    });
-  }
-
-  /**
-   * deletes the directory with all its contents
-   */
-  public async delete() {
-    const deleteDirectory = async (directoryArg: Directory) => {
-      const childDirectories = await directoryArg.listDirectories();
-      if (childDirectories.length === 0) {
-        console.log('directory empty! Path complete!');
-      } else {
-        for (const childDir of childDirectories) {
-          await deleteDirectory(childDir);
-        }
-      }
-      const files = await directoryArg.listFiles();
-      for (const file of files) {
-        await directoryArg.fastRemove({
-          path: file.name,
-        });
-      }
-    };
-    await deleteDirectory(this);
-  }
-}
--- a/ts/smartbucket.classes.file.ts
+++ b/ts/smartbucket.classes.file.ts
@ -1,140 +0,0 @@
-import * as plugins from './smartbucket.plugins.js';
-import { Directory } from './smartbucket.classes.directory.js';
-
-export interface IFileMetaData {
-  name: string;
-  fileType: string;
-  size: string;
-}
-
-/**
- * represents a file in a directory
- */
-export class File {
-  // STATIC
-
-  /**
-   * creates a file in draft mode
-   * you need to call .save() to store it in s3
-   * @param optionsArg
-   */
-  public static async create(optionsArg: {
-    directory: Directory;
-    name: string;
-    contents: Buffer | string | plugins.stream.Readable;
-    /**
-     * if contents are of type string, you can specify the encoding here
-     */
-    encoding?: 'utf8' | 'binary';
-  }): Promise<File> {
-    const contents =
-      typeof optionsArg.contents === 'string'
-        ? Buffer.from(optionsArg.contents, optionsArg.encoding)
-        : optionsArg.contents;
-    const file = new File({
-      directoryRefArg: optionsArg.directory,
-      fileName: optionsArg.name,
-    });
-    if (contents instanceof plugins.stream.Readable) {} else {
-      await optionsArg.directory.fastPut({
-        path: optionsArg.name,
-        contents: contents,
-      });
-    }
-    return file;
-  }
-
-  // INSTANCE
-  public parentDirectoryRef: Directory;
-  public name: string;
-
-  public path: string;
-  public metaData: IFileMetaData;
-
-  constructor(optionsArg: { directoryRefArg: Directory; fileName: string }) {
-    this.parentDirectoryRef = optionsArg.directoryRefArg;
-    this.name = optionsArg.fileName;
-  }
-
-  public async getContentAsString() {
-    const fileBuffer = await this.getContentAsBuffer();
-    return fileBuffer.toString();
-  }
-
-  public async getContentAsBuffer() {
-    const done = plugins.smartpromise.defer();
-    const fileStream = await this.parentDirectoryRef.bucketRef.smartbucketRef.minioClient
-      .getObject(this.parentDirectoryRef.bucketRef.name, this.path)
-      .catch((e) => console.log(e));
-    let completeFile = Buffer.from('');
-    const duplexStream = new plugins.smartstream.SmartDuplex<Buffer, Buffer>(
-      {
-        writeFunction: async (chunk) => {
-          completeFile = Buffer.concat([chunk]);
-          return chunk;
-        },
-        finalFunction: async (cb) => {
-          done.resolve();
-          return Buffer.from('');
-        },
-      }
-    );
-
-    if (!fileStream) {
-      return null;
-    }
-
-    fileStream.pipe(duplexStream);
-    await done.promise;
-    return completeFile;
-  }
-
-  public async readStreaming() {
-    // TODO
-    throw new Error('not yet implemented');
-  }
-
-  /**
-   * removes this file
-   */
-  public async remove() {
-    await this.parentDirectoryRef.bucketRef.smartbucketRef.minioClient.removeObject(
-      this.parentDirectoryRef.bucketRef.name,
-      this.path
-    );
-    await this.parentDirectoryRef.listFiles();
-  }
-
-  /**
-   * deletes the file
-   */
-  public async delete() {}
-
-  /**
-   * allows locking the file
-   * @param optionsArg
-   */
-  public async lock(optionsArg?: { timeoutMillis?: number }) {}
-
-  /**
-   * actively unlocks a file
-   *
-   */
-  public async unlock(optionsArg?: {
-    /**
-     * unlock the file even if not locked from this instance
-     */
-    force?: boolean;
-  }) {}
-
-  public async updateWithContents(optionsArg: {
-    contents: Buffer | string | plugins.stream.Readable;
-    encoding?: 'utf8' | 'binary';
-  }) {}
-
-  /**
-   * allows updating the metadata of a file
-   * @param updatedMetadata
-   */
-  public async updateMetaData(updatedMetadata: any) {}
-}
--- a/ts/smartbucket.classes.smartbucket.ts
+++ b/ts/smartbucket.classes.smartbucket.ts
@ -1,35 +0,0 @@
-import * as plugins from './smartbucket.plugins.js';
-import { Bucket } from './smartbucket.classes.bucket.js';
-
-export class SmartBucket {
-  public config: plugins.tsclass.storage.IS3Descriptor;
-
-  public minioClient: plugins.minio.Client;
-
-  /**
-   * the constructor of SmartBucket
-   */
-  constructor(configArg: plugins.tsclass.storage.IS3Descriptor) {
-    this.config = configArg;
-    this.minioClient = new plugins.minio.Client({
-      endPoint: this.config.endpoint,
-      port: configArg.port || 443,
-      useSSL: configArg.useSsl !== undefined ? configArg.useSsl : true,
-      accessKey: this.config.accessKey,
-      secretKey: this.config.accessSecret,
-    });
-  }
-
-  public async createBucket(bucketNameArg: string) {
-    const bucket = await Bucket.createBucketByName(this, bucketNameArg);
-    return bucket;
-  }
-
-  public async removeBucket(bucketName: string) {
-    await Bucket.removeBucketByName(this, bucketName);
-  }
-
-  public async getBucketByName(bucketName: string) {
-    return Bucket.getBucketByName(this, bucketName);
-  }
-}
Author	SHA1	Message	Date
Philipp Kunz	7db4d24817	3.0.23	2024-10-16 10:27:27 +02:00
Philipp Kunz	dc599585b8	fix(dependencies): Update package dependencies for improved functionality and security.	2024-10-16 10:27:27 +02:00
Philipp Kunz	a22e32cd32	3.0.22	2024-07-28 12:46:39 +02:00
Philipp Kunz	4647181807	fix(dependencies): Update dependencies and improve bucket retrieval logging	2024-07-28 12:46:39 +02:00
Philipp Kunz	99c3935d0c	3.0.21	2024-07-04 18:39:28 +02:00
Philipp Kunz	05523dc7a1	fix(test): Update endpoint configuration in tests to use environment variable	2024-07-04 18:39:27 +02:00
Philipp Kunz	dc99cfa229	3.0.20	2024-06-19 18:28:53 +02:00
Philipp Kunz	23f8dc55d0	fix(core): update	2024-06-19 18:28:52 +02:00
Philipp Kunz	ffaf0fc97a	3.0.19	2024-06-18 18:44:59 +02:00
Philipp Kunz	2a0425ff54	fix(delete functions): ensure more consistency between methods and trash behaviour	2024-06-18 18:44:58 +02:00
Philipp Kunz	9adcdee0a0	3.0.18	2024-06-17 20:00:58 +02:00
Philipp Kunz	786f8d4365	fix(core): update	2024-06-17 20:00:57 +02:00
Philipp Kunz	67244ba5cf	3.0.17	2024-06-17 19:57:56 +02:00
Philipp Kunz	a9bb31c2a2	fix(core): update	2024-06-17 19:57:56 +02:00
Philipp Kunz	bd8b05920f	3.0.16	2024-06-17 16:01:36 +02:00
Philipp Kunz	535d9f8520	fix(core): update	2024-06-17 16:01:35 +02:00
Philipp Kunz	8401fe1c0c	3.0.15	2024-06-11 17:21:22 +02:00
Philipp Kunz	08c3f674bf	fix(core): update	2024-06-11 17:21:22 +02:00
Philipp Kunz	df0a439def	3.0.14	2024-06-11 17:20:49 +02:00
Philipp Kunz	7245b49c31	fix(core): update	2024-06-11 17:20:48 +02:00
Philipp Kunz	4b70edb947	finish trash	2024-06-10 16:47:20 +02:00
Philipp Kunz	9629a04da6	3.0.13	2024-06-09 16:32:33 +02:00
Philipp Kunz	963463d40d	fix(core): update	2024-06-09 16:32:32 +02:00
Philipp Kunz	ce58b99fc7	3.0.12	2024-06-09 16:02:34 +02:00
Philipp Kunz	591c99736d	fix(core): update	2024-06-09 16:02:33 +02:00
Philipp Kunz	559e3da47b	3.0.11	2024-06-08 19:13:25 +02:00
Philipp Kunz	a7ac870e05	fix(core): update	2024-06-08 19:13:24 +02:00
Philipp Kunz	d48c5e229a	3.0.10	2024-06-03 21:35:08 +02:00
Philipp Kunz	b9c384dd08	fix(core): update	2024-06-03 21:35:08 +02:00
Philipp Kunz	91c04b2364	update description	2024-05-29 14:11:54 +02:00
Philipp Kunz	b5dcc131e2	3.0.9	2024-05-27 17:34:27 +02:00
Philipp Kunz	cb0ab2c9db	fix(core): update	2024-05-27 17:34:26 +02:00
Philipp Kunz	2a17ee542e	3.0.8	2024-05-27 14:34:13 +02:00
Philipp Kunz	95e9d2f0ff	fix(core): update	2024-05-27 14:34:12 +02:00
Philipp Kunz	1a71c76da3	3.0.7	2024-05-27 12:56:26 +02:00
Philipp Kunz	e924511147	fix(s3 paths): pathing differences now correctly handled in a reducePath method.	2024-05-27 12:56:25 +02:00
Philipp Kunz	645ebbdd4d	3.0.6	2024-05-21 18:47:00 +02:00
Philipp Kunz	168148b2c9	fix(core): update	2024-05-21 18:46:59 +02:00
Philipp Kunz	1293fc4ca6	3.0.5	2024-05-21 18:42:55 +02:00
Philipp Kunz	b040120813	fix(core): update	2024-05-21 18:42:55 +02:00
Philipp Kunz	5c2d92c041	3.0.4	2024-05-21 01:22:22 +02:00
Philipp Kunz	eaf2e7e6bb	fix(core): update	2024-05-21 01:22:21 +02:00
Philipp Kunz	1e1f65119c	3.0.3	2024-05-17 19:24:53 +02:00
Philipp Kunz	c70ee820d7	fix(core): update	2024-05-17 19:24:52 +02:00