@theshelf/filestore 0.2.1 → 0.3.1

package/README.md

@@ -14,14 +14,14 @@ npm install @theshelf/filestore
 Currently, there are two drivers available:
 
 * **Memory** - non-persistent in memory storage (suited for testing).
-* **Minio** - persistent S3 compatible object storage.
+* **S3** - persistent S3 (compatible) object storage.
 
 ## How to use
 
 The basic set up looks like this.
 
 ```ts
-import FileStore, { MemoryDriver | MinioDriver as SelectedDriver } from '@theshelf/fileStore';
+import FileStore, { MemoryDriver | S3Driver as SelectedDriver } from '@theshelf/fileStore';
 
 const driver = new SelectedDriver(/* configuration */);
 const fileStore = new FileStore(driver);
@@ -35,9 +35,16 @@ const fileStore = new FileStore(driver);
 
 No configuration options.
 
-#### Minio driver
+#### S3 driver
 
-The `ClientOptions` from the 'minio' package.
+```ts
+type S3Configuration = {
+    clientConfig: S3ClientConfig;
+    bucketName: string;
+};
+```
+
+The exact configuration of the `clientConfig` depends on your S3-compatible storage provider. See the AWS SDK documentation for details.
 
 ### Operations
 

package/dist/FileStore.d.ts

@@ -1,9 +1,7 @@
-import type { ConnectionState } from './definitions/constants.js';
 import type { Driver } from './definitions/interfaces.js';
 export default class FileStore implements Driver {
     #private;
     constructor(driver: Driver);
-    get connectionState(): ConnectionState;
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;

package/dist/FileStore.js

@@ -1,23 +1,16 @@
-import { ConnectionStates } from './definitions/constants.js';
-import ConnectionManager from './ConnectionManager.js';
 export default class FileStore {
     #driver;
-    #connectionManager;
     constructor(driver) {
         this.#driver = driver;
-        this.#connectionManager = new ConnectionManager(driver);
-    }
-    get connectionState() {
-        return this.#connectionManager.state;
     }
     get connected() {
-        return this.connectionState === ConnectionStates.CONNECTED;
+        return this.#driver.connected;
     }
     connect() {
-        return this.#connectionManager.connect();
+        return this.#driver.connect();
     }
     disconnect() {
-        return this.#connectionManager.disconnect();
+        return this.#driver.disconnect();
     }
     hasFile(path) {
         return this.#driver.hasFile(path);

package/dist/drivers/Memory.js

@@ -1,5 +1,5 @@
-import NotConnected from '../errors/NotConnected.js';
 import FileNotFound from '../errors/FileNotFound.js';
+import NotConnected from '../errors/NotConnected.js';
 export default class Memory {
     #files = new Map();
     #connected = false;

package/dist/drivers/{Minio.d.ts → S3.d.ts}

@@ -1,8 +1,12 @@
-import type { ClientOptions } from 'minio';
+import type { S3ClientConfig } from '@aws-sdk/client-s3';
 import type { Driver } from '../definitions/interfaces.js';
-export default class Minio implements Driver {
+type S3Configuration = {
+    clientConfig: S3ClientConfig;
+    bucketName: string;
+};
+export default class S3 implements Driver {
     #private;
-    constructor(configuration: ClientOptions);
+    constructor(configuration: S3Configuration);
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
@@ -11,3 +15,4 @@ export default class Minio implements Driver {
     readFile(path: string): Promise<Buffer>;
     deleteFile(path: string): Promise<void>;
 }
+export {};

package/dist/drivers/S3.js

@@ -0,0 +1,98 @@
+import { CreateBucketCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListBucketsCommand, NotFound, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import FileNotFound from '../errors/FileNotFound.js';
+import FileStoreError from '../errors/FileStoreError.js';
+import NotConnected from '../errors/NotConnected.js';
+const UNKNOWN_ERROR = 'Unknown error';
+export default class S3 {
+    #configuration;
+    #bucketName;
+    #client;
+    #connected = false;
+    constructor(configuration) {
+        this.#configuration = configuration.clientConfig;
+        this.#bucketName = configuration.bucketName;
+    }
+    get connected() { return this.#connected; }
+    async connect() {
+        try {
+            this.#client = new S3Client(this.#configuration);
+            const buckets = await this.#client.send(new ListBucketsCommand({}));
+            const bucketExists = buckets.Buckets?.some(bucket => bucket.Name === this.#bucketName);
+            if (bucketExists === true)
+                return;
+            await this.#client.send(new CreateBucketCommand({ Bucket: this.#bucketName }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : UNKNOWN_ERROR;
+            throw new FileStoreError('File store connection failed: ' + message);
+        }
+        this.#connected = true;
+    }
+    async disconnect() {
+        if (this.#client === undefined) {
+            throw new NotConnected();
+        }
+        this.#client.destroy();
+        this.#client = undefined;
+        this.#connected = false;
+    }
+    async hasFile(path) {
+        const client = this.#getClient();
+        try {
+            await client.send(new HeadObjectCommand({ Bucket: this.#bucketName, Key: path }));
+            return true;
+        }
+        catch (error) {
+            const customError = this.#handleError(error, path);
+            if (customError instanceof FileNotFound) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async writeFile(path, data) {
+        const client = this.#getClient();
+        try {
+            await client.send(new PutObjectCommand({ Bucket: this.#bucketName, Key: path, Body: data }));
+        }
+        catch (error) {
+            throw this.#handleError(error, path);
+        }
+    }
+    async readFile(path) {
+        const client = this.#getClient();
+        try {
+            const response = await client.send(new GetObjectCommand({ Bucket: this.#bucketName, Key: path }));
+            const body = response.Body;
+            if (body === undefined) {
+                throw new FileNotFound(path);
+            }
+            const byteArray = await body.transformToByteArray();
+            return Buffer.from(byteArray);
+        }
+        catch (error) {
+            throw this.#handleError(error, path);
+        }
+    }
+    async deleteFile(path) {
+        const client = this.#getClient();
+        try {
+            await client.send(new DeleteObjectCommand({ Bucket: this.#bucketName, Key: path }));
+        }
+        catch (error) {
+            throw this.#handleError(error, path);
+        }
+    }
+    #getClient() {
+        if (this.#client === undefined) {
+            throw new NotConnected();
+        }
+        return this.#client;
+    }
+    #handleError(error, path) {
+        if (error instanceof NotFound) {
+            return new FileNotFound(path);
+        }
+        return error;
+    }
+}

package/dist/index.d.ts

@@ -3,5 +3,5 @@ export { default as FileNotFound } from './errors/FileNotFound.js';
 export { default as FileSystemError } from './errors/FileStoreError.js';
 export { default as NotConnected } from './errors/NotConnected.js';
 export { default as MemoryDriver } from './drivers/Memory.js';
-export { default as MinioDriver } from './drivers/Minio.js';
+export { default as S3Driver } from './drivers/S3.js';
 export { default } from './FileStore.js';

package/dist/index.js

@@ -2,5 +2,5 @@ export { default as FileNotFound } from './errors/FileNotFound.js';
 export { default as FileSystemError } from './errors/FileStoreError.js';
 export { default as NotConnected } from './errors/NotConnected.js';
 export { default as MemoryDriver } from './drivers/Memory.js';
-export { default as MinioDriver } from './drivers/Minio.js';
+export { default as S3Driver } from './drivers/S3.js';
 export { default } from './FileStore.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@theshelf/filestore",
   "private": false,
-  "version": "0.2.1",
+  "version": "0.3.1",
   "type": "module",
   "repository": {
     "url": "git+https://github.com/MaskingTechnology/theshelf.git"
@@ -22,6 +22,6 @@
   "types": "dist/index.d.ts",
   "exports": "./dist/index.js",
   "dependencies": {
-    "minio": "8.0.6"
+    "@aws-sdk/client-s3": "^3.968.0"
   }
 }

package/dist/ConnectionManager.d.ts

@@ -1,9 +0,0 @@
-import type { ConnectionState } from './definitions/constants.js';
-import type { Driver } from './definitions/interfaces.js';
-export default class ConnectionManager {
-    #private;
-    constructor(driver: Driver);
-    get state(): ConnectionState;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-}

package/dist/ConnectionManager.js

@@ -1,53 +0,0 @@
-import { ConnectionStates } from './definitions/constants.js';
-export default class ConnectionManager {
-    #driver;
-    #state = ConnectionStates.DISCONNECTED;
-    #connectPromise;
-    #disconnectPromise;
-    constructor(driver) {
-        this.#driver = driver;
-    }
-    get state() { return this.#state; }
-    async connect() {
-        if (this.#connectPromise !== undefined) {
-            return this.#connectPromise;
-        }
-        if (this.#state !== ConnectionStates.DISCONNECTED) {
-            return;
-        }
-        this.#state = ConnectionStates.CONNECTING;
-        try {
-            this.#connectPromise = this.#driver.connect();
-            await this.#connectPromise;
-            this.#state = ConnectionStates.CONNECTED;
-        }
-        catch (error) {
-            this.#state = ConnectionStates.DISCONNECTED;
-            throw error;
-        }
-        finally {
-            this.#connectPromise = undefined;
-        }
-    }
-    async disconnect() {
-        if (this.#disconnectPromise !== undefined) {
-            return this.#disconnectPromise;
-        }
-        if (this.#state !== ConnectionStates.CONNECTED) {
-            return;
-        }
-        this.#state = ConnectionStates.DISCONNECTING;
-        try {
-            this.#disconnectPromise = this.#driver.disconnect();
-            await this.#disconnectPromise;
-            this.#state = ConnectionStates.DISCONNECTED;
-        }
-        catch (error) {
-            this.#state = ConnectionStates.CONNECTED;
-            throw error;
-        }
-        finally {
-            this.#disconnectPromise = undefined;
-        }
-    }
-}

package/dist/definitions/constants.d.ts

@@ -1,7 +0,0 @@
-export declare const ConnectionStates: {
-    readonly DISCONNECTED: "DISCONNECTED";
-    readonly DISCONNECTING: "DISCONNECTING";
-    readonly CONNECTING: "CONNECTING";
-    readonly CONNECTED: "CONNECTED";
-};
-export type ConnectionState = typeof ConnectionStates[keyof typeof ConnectionStates];

package/dist/definitions/constants.js

@@ -1,6 +0,0 @@
-export const ConnectionStates = {
-    DISCONNECTED: 'DISCONNECTED',
-    DISCONNECTING: 'DISCONNECTING',
-    CONNECTING: 'CONNECTING',
-    CONNECTED: 'CONNECTED'
-};

package/dist/drivers/Minio.js

@@ -1,85 +0,0 @@
-import { Client } from 'minio';
-import FileNotFound from '../errors/FileNotFound.js';
-import NotConnected from '../errors/NotConnected.js';
-const BUCKET_NAME = 'comify';
-export default class Minio {
-    #configuration;
-    #client;
-    constructor(configuration) {
-        this.#configuration = configuration;
-    }
-    get connected() {
-        return this.#client !== undefined;
-    }
-    async connect() {
-        this.#client = new Client(this.#configuration);
-        if (await this.#client.bucketExists(BUCKET_NAME) === false) {
-            await this.#client.makeBucket(BUCKET_NAME);
-        }
-    }
-    async disconnect() {
-        if (this.#client === undefined) {
-            throw new NotConnected();
-        }
-        this.#client = undefined;
-    }
-    async hasFile(path) {
-        const client = this.#getClient();
-        try {
-            await client.statObject(BUCKET_NAME, path);
-            return true;
-        }
-        catch (error) {
-            const customError = this.#handleError(error, path);
-            if (customError instanceof FileNotFound) {
-                return false;
-            }
-            throw error;
-        }
-    }
-    async writeFile(path, data) {
-        const client = this.#getClient();
-        try {
-            await client.putObject(BUCKET_NAME, path, data);
-        }
-        catch (error) {
-            throw this.#handleError(error, path);
-        }
-    }
-    async readFile(path) {
-        const client = this.#getClient();
-        try {
-            const stream = await client.getObject(BUCKET_NAME, path);
-            const chunks = await stream.toArray();
-            return Buffer.concat(chunks);
-        }
-        catch (error) {
-            throw this.#handleError(error, path);
-        }
-    }
-    async deleteFile(path) {
-        const client = this.#getClient();
-        try {
-            await client.removeObject(BUCKET_NAME, path);
-        }
-        catch (error) {
-            throw this.#handleError(error, path);
-        }
-    }
-    #getClient() {
-        if (this.#client === undefined) {
-            throw new NotConnected();
-        }
-        return this.#client;
-    }
-    #handleError(error, path) {
-        if (error instanceof Error && this.#isNotFoundError(error)) {
-            return new FileNotFound(path);
-        }
-        return error;
-    }
-    #isNotFoundError(error) {
-        return error.message.startsWith('The specified key does not exist')
-            || error.message.startsWith('Not Found');
-    }
-}