@theshelf/filestore 0.3.2 → 0.4.1

package/README.md

@@ -1,7 +1,7 @@
 
-# File Store | The Shelf
+# File Store core | The Shelf
 
-The file store package provides a universal interaction layer with an actual file storage solution.
+This package contains the definition of the file operations. It uses a interchangeable driver system for performing the actual operations. An in-memory driver is included.
 
 ## Installation
 
@@ -9,44 +9,20 @@ The file store package provides a universal interaction layer with an actual fil
 npm install @theshelf/filestore
 ```
 
-## Drivers
-
-Currently, there are two drivers available:
-
-* **Memory** - non-persistent in memory storage (suited for testing).
-* **S3** - persistent S3 (compatible) object storage.
-
 ## How to use
 
 The basic set up looks like this.
 
 ```ts
-import FileStore, { MemoryDriver | S3Driver as SelectedDriver } from '@theshelf/fileStore';
+import FileStore, { MemoryDriver } from '@theshelf/fileStore';
 
-const driver = new SelectedDriver(/* configuration */);
+const driver = new MemoryDriver();
 const fileStore = new FileStore(driver);
 
 // Perform operations with the fileStore instance
 ```
 
-### Configuration
-
-#### Memory driver
-
-No configuration options.
-
-#### S3 driver
-
-```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
+## Operations
 
 ```ts
 // Open connection
@@ -70,3 +46,16 @@ const data: Buffer = await fileStore.readFile('path/to/file.txt');
 // Throws FileNotFound if not found
 await fileStore.deleteFile('path/to/file.txt');
 ```
+
+## Drivers
+
+There is one driver included in this package. Other drivers are available in separate packages.
+
+### Memory
+
+In memory file store (suited for testing). It doesn't have any configuration options, but has an additional operation.
+
+```ts
+// Clear the memory
+driver.clear();
+```

package/dist/FileStore.d.ts

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

package/dist/FileStore.js

@@ -1,27 +1,89 @@
+import NotConnected from './errors/NotConnected.js';
 export default class FileStore {
     #driver;
-    constructor(driver) {
+    #logger;
+    #logPrefix;
+    constructor(driver, logger) {
         this.#driver = driver;
+        this.#logger = logger?.for(FileStore.name);
+        this.#logPrefix = `${this.#driver.name} ->`;
     }
     get connected() {
         return this.#driver.connected;
     }
-    connect() {
-        return this.#driver.connect();
+    async connect() {
+        if (this.connected === true) {
+            return;
+        }
+        this.#logger?.debug(this.#logPrefix, 'Connecting');
+        try {
+            await this.#driver.connect();
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Connect failed with error', error);
+            throw error;
+        }
     }
-    disconnect() {
-        return this.#driver.disconnect();
+    async disconnect() {
+        if (this.connected === false) {
+            return;
+        }
+        this.#logger?.debug(this.#logPrefix, 'Disconnecting');
+        try {
+            return await this.#driver.disconnect();
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Disconnect failed with error', error);
+            throw error;
+        }
     }
-    hasFile(path) {
-        return this.#driver.hasFile(path);
+    async hasFile(path) {
+        this.#logger?.debug(this.#logPrefix, 'Checking has file', path);
+        try {
+            this.#validateConnection();
+            return await this.#driver.hasFile(path);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Check has file', path, 'failed with error', error);
+            throw error;
+        }
     }
-    writeFile(path, data) {
-        return this.#driver.writeFile(path, data);
+    async writeFile(path, data) {
+        this.#logger?.debug(this.#logPrefix, 'Writing file', path);
+        try {
+            this.#validateConnection();
+            return await this.#driver.writeFile(path, data);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Write file', path, 'failed with error', error);
+            throw error;
+        }
     }
-    readFile(path) {
-        return this.#driver.readFile(path);
+    async readFile(path) {
+        this.#logger?.debug(this.#logPrefix, 'Reading file', path);
+        try {
+            this.#validateConnection();
+            return await this.#driver.readFile(path);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Read file', path, 'failed with error', error);
+            throw error;
+        }
     }
-    deleteFile(path) {
-        return this.#driver.deleteFile(path);
+    async deleteFile(path) {
+        this.#logger?.debug(this.#logPrefix, 'Deleting file', path);
+        try {
+            this.#validateConnection();
+            return await this.#driver.deleteFile(path);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Delete file', path, 'failed with error', error);
+            throw error;
+        }
+    }
+    #validateConnection() {
+        if (this.connected === false) {
+            throw new NotConnected();
+        }
     }
 }

package/dist/definitions/interfaces.d.ts

@@ -1,4 +1,5 @@
 export interface Driver {
+    get name(): string;
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;

package/dist/drivers/Memory.d.ts

@@ -1,6 +1,7 @@
 import type { Driver } from '../definitions/interfaces.js';
 export default class Memory implements Driver {
     #private;
+    get name(): string;
     get connected(): boolean;
     get files(): Map<string, Buffer>;
     connect(): Promise<void>;

package/dist/drivers/Memory.js

@@ -3,6 +3,7 @@ import NotConnected from '../errors/NotConnected.js';
 export default class Memory {
     #files = new Map();
     #connected = false;
+    get name() { return Memory.name; }
     get connected() { return this.#connected; }
     get files() {
         if (this.#connected === false) {

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-export type * from './definitions/interfaces.js';
+export type { Driver } from './definitions/interfaces.js';
 export { default as FileNotFound } from './errors/FileNotFound.js';
-export { default as FileSystemError } from './errors/FileStoreError.js';
+export { default as FileStoreError } from './errors/FileStoreError.js';
 export { default as NotConnected } from './errors/NotConnected.js';
 export { default as MemoryDriver } from './drivers/Memory.js';
-export { default as S3Driver } from './drivers/S3.js';
 export { default } from './FileStore.js';

package/dist/index.js

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

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@theshelf/filestore",
   "private": false,
-  "version": "0.3.2",
+  "version": "0.4.1",
   "type": "module",
   "repository": {
     "url": "git+https://github.com/MaskingTechnology/theshelf.git"
   },
+  "license": "MIT",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
@@ -19,9 +20,9 @@
     "README.md",
     "dist"
   ],
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": "./dist/index.js",
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.968.0"
+  "peerDependencies": {
+    "@theshelf/logging": "^0.4.0"
   }
 }

package/dist/drivers/S3.d.ts

@@ -1,18 +0,0 @@
-import type { S3ClientConfig } from '@aws-sdk/client-s3';
-import type { Driver } from '../definitions/interfaces.js';
-type S3Configuration = {
-    clientConfig: S3ClientConfig;
-    bucketName: string;
-};
-export default class S3 implements Driver {
-    #private;
-    constructor(configuration: S3Configuration);
-    get connected(): boolean;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    hasFile(path: string): Promise<boolean>;
-    writeFile(path: string, data: Buffer): Promise<void>;
-    readFile(path: string): Promise<Buffer>;
-    deleteFile(path: string): Promise<void>;
-}
-export {};

package/dist/drivers/S3.js

@@ -1,105 +0,0 @@
-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) {
-                const createBucket = new CreateBucketCommand({ Bucket: this.#bucketName });
-                await this.#client.send(createBucket);
-            }
-            this.#connected = true;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : UNKNOWN_ERROR;
-            throw new FileStoreError('File store connection failed: ' + message);
-        }
-    }
-    async disconnect() {
-        if (this.#client === undefined) {
-            throw new NotConnected();
-        }
-        try {
-            this.#client.destroy();
-            this.#client = undefined;
-            this.#connected = false;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : UNKNOWN_ERROR;
-            throw new FileStoreError('File store disconnection failed: ' + message);
-        }
-    }
-    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;
-    }
-}