@theshelf/database 0.0.4 → 0.2.0

package/README.md

@@ -11,42 +11,45 @@ This integration is based on simple CRUD operations and purposely does NOT suppo
 npm install @theshelf/database
 ```
 
-## Implementations
+## Drivers
 
-Currently, there are two implementations:
+Currently, there are two drivers available:
 
-* **Memory** - non-persistent in memory storage  (suited for testing).
+* **Memory** - non-persistent in memory storage (suited for testing).
 * **MongoDB** - persistent document storage.
 
-## Configuration
+## How to use
 
-The used implementation needs to be configured in the `.env` file.
+The basic set up looks like this.
 
-```env
-DATABASE_IMPLEMENTATION="mongodb" # (memory | mongodb)
-```
+```ts
+import Database, { MemoryDriver | MongoDBDriver as SelectedDriver } from '@theshelf/database';
 
-In case of MongoDB, additional configuration is required.
+const driver = new SelectedDriver(/* configuration */);
+const database = new Database(driver);
 
-```env
-MONGODB_CONNECTION_STRING="mongodb://username:password@address:27017"
-MONGODB_DATABASE_NAME="mydb"
+// Perform operations with the database instance
 ```
 
-## How to use
+### Configuration
 
-An instance of the configured implementation can be imported for performing database operations.
+#### Memory driver
 
-```ts
-import database from '@theshelf/database';
+No configuration options.
 
-// Perform operations with the database instance
+#### MongoDB driver
+
+```ts
+type MongoDBConfiguration = {
+    connectionString: string; // e.g. "mongodb://development:development@localhost:27017"
+    databaseName: string; // e.g. "mydb"
+};
 ```
 
 ### Operations
 
 ```ts
-import database, { RecordData, RecordQuery, RecordSort, SortDirections } from '@theshelf/database';
+import { RecordData, RecordQuery, RecordSort, SortDirections } from '@theshelf/database';
 
 // Open connection
 await database.connect();

package/dist/ConnectionManager.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,53 @@
+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/Database.d.ts

@@ -1,8 +1,10 @@
+import type { ConnectionState } from './definitions/constants.js';
 import type { Driver } from './definitions/interfaces.js';
 import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from './definitions/types.js';
 export default class Database implements Driver {
     #private;
     constructor(driver: Driver);
+    get connectionState(): ConnectionState;
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
@@ -13,5 +15,4 @@ export default class Database implements Driver {
     updateRecords(type: RecordType, query: RecordQuery, data: RecordData): Promise<number>;
     deleteRecord(type: RecordType, query: RecordQuery): Promise<number>;
     deleteRecords(type: RecordType, query: RecordQuery): Promise<number>;
-    clear(): Promise<void>;
 }

package/dist/Database.js

@@ -1,15 +1,24 @@
 import sanitize from './utilities/sanitize.js';
+import { ConnectionStates } from './definitions/constants.js';
+import ConnectionManager from './ConnectionManager.js';
 export default class Database {
     #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;
     }
-    get connected() { return this.#driver.connected; }
     connect() {
-        return this.#driver.connect();
+        return this.#connectionManager.connect();
     }
     disconnect() {
-        return this.#driver.disconnect();
+        return this.#connectionManager.disconnect();
     }
     createRecord(type, data) {
         const cleanData = sanitize(data);
@@ -35,7 +44,4 @@ export default class Database {
     deleteRecords(type, query) {
         return this.#driver.deleteRecords(type, query);
     }
-    clear() {
-        return this.#driver.clear();
-    }
 }

package/dist/definitions/constants.d.ts

@@ -1,22 +1,29 @@
 export declare const ID = "id";
 export declare const LogicalOperators: {
-    AND: string;
-    OR: string;
+    readonly AND: "AND";
+    readonly OR: "OR";
 };
 export declare const SortDirections: {
-    ASCENDING: string;
-    DESCENDING: string;
+    readonly ASCENDING: "ASCENDING";
+    readonly DESCENDING: "DESCENDING";
 };
 export declare const QueryOperators: {
-    EQUALS: string;
-    NOT_EQUALS: string;
-    LESS_THAN: string;
-    LESS_THAN_OR_EQUALS: string;
-    GREATER_THAN: string;
-    GREATER_THAN_OR_EQUALS: string;
-    IN: string;
-    NOT_IN: string;
-    CONTAINS: string;
-    STARTS_WITH: string;
-    ENDS_WITH: string;
+    readonly EQUALS: "EQUALS";
+    readonly NOT_EQUALS: "NOT_EQUALS";
+    readonly LESS_THAN: "LESS_THAN";
+    readonly LESS_THAN_OR_EQUALS: "LESS_THAN_OR_EQUALS";
+    readonly GREATER_THAN: "GREATER_THAN";
+    readonly GREATER_THAN_OR_EQUALS: "GREATER_THAN_OR_EQUALS";
+    readonly IN: "IN";
+    readonly NOT_IN: "NOT_IN";
+    readonly CONTAINS: "CONTAINS";
+    readonly STARTS_WITH: "STARTS_WITH";
+    readonly ENDS_WITH: "ENDS_WITH";
 };
+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

@@ -20,6 +20,9 @@ export const QueryOperators = {
     STARTS_WITH: 'STARTS_WITH', // "LIKE%"
     ENDS_WITH: 'ENDS_WITH' // "%LIKE"
 };
-Object.freeze(LogicalOperators);
-Object.freeze(SortDirections);
-Object.freeze(QueryOperators);
+export const ConnectionStates = {
+    DISCONNECTED: 'DISCONNECTED',
+    DISCONNECTING: 'DISCONNECTING',
+    CONNECTING: 'CONNECTING',
+    CONNECTED: 'CONNECTED'
+};

package/dist/definitions/interfaces.d.ts

@@ -10,5 +10,4 @@ export interface Driver {
     updateRecords(type: RecordType, query: RecordQuery, data: RecordData): Promise<number>;
     deleteRecord(type: RecordType, query: RecordQuery): Promise<number>;
     deleteRecords(type: RecordType, query: RecordQuery): Promise<number>;
-    clear(): Promise<void>;
 }

package/dist/{implementations/memory → drivers}/Memory.d.ts

@@ -1,9 +1,9 @@
-import type { Driver } from '../../definitions/interfaces.js';
-import type { RecordData, RecordQuery, RecordSort } from '../../definitions/types.js';
+import type { Driver } from '../definitions/interfaces.js';
+import type { RecordData, RecordQuery, RecordSort } from '../definitions/types.js';
 export default class Memory implements Driver {
     #private;
-    recordId: number;
     get connected(): boolean;
+    get memory(): Map<string, RecordData[]>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     createRecord(type: string, data: RecordData): Promise<string>;
@@ -13,5 +13,5 @@ export default class Memory implements Driver {
     updateRecords(type: string, query: RecordQuery, data: RecordData): Promise<number>;
     deleteRecord(type: string, query: RecordQuery): Promise<number>;
     deleteRecords(type: string, query: RecordQuery): Promise<number>;
-    clear(): Promise<void>;
+    clear(): void;
 }

package/dist/{implementations/memory → drivers}/Memory.js

@@ -1,5 +1,5 @@
-import { LogicalOperators, QueryOperators, SortDirections } from '../../definitions/constants.js';
-import NotConnected from '../../errors/NotConnected.js';
+import { LogicalOperators, QueryOperators, SortDirections } from '../definitions/constants.js';
+import NotConnected from '../errors/NotConnected.js';
 const OPERATORS = {
     [QueryOperators.EQUALS]: '==',
     [QueryOperators.GREATER_THAN]: '>',
@@ -15,13 +15,20 @@ const LOGICAL_OPERATORS = {
 export default class Memory {
     #memory = new Map();
     #connected = false;
-    recordId = 0;
+    #recordId = 0;
     get connected() { return this.#connected; }
+    get memory() {
+        if (this.#connected === false) {
+            throw new NotConnected();
+        }
+        return this.#memory;
+    }
     async connect() {
         this.#connected = true;
     }
     async disconnect() {
         this.#connected = false;
+        this.#memory.clear();
     }
     async createRecord(type, data) {
         const collection = this.#getCollection(type);
@@ -73,8 +80,8 @@ export default class Memory {
         indexes.forEach(index => collection.splice(index, 1));
         return indexes.length;
     }
-    async clear() {
-        this.#memory.clear();
+    clear() {
+        this.memory.clear();
     }
     #fetchRecord(type, query) {
         const collection = this.#getCollection(type);
@@ -168,16 +175,14 @@ export default class Memory {
         return `record.${key} ${codeOperator} ${codeValue}`;
     }
     #createId() {
-        return (++this.recordId).toString().padStart(8, '0');
+        return (++this.#recordId).toString().padStart(8, '0');
     }
     #getCollection(type) {
-        if (this.#memory === undefined) {
-            throw new NotConnected();
-        }
-        let collection = this.#memory.get(type);
+        const memory = this.memory;
+        let collection = memory.get(type);
         if (collection === undefined) {
             collection = [];
-            this.#memory.set(type, collection);
+            memory.set(type, collection);
         }
         return collection;
     }

package/dist/{implementations/mongodb/MongoDb.d.ts → drivers/MongoDB.d.ts}

@@ -1,8 +1,12 @@
-import type { Driver } from '../../definitions/interfaces.js';
-import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from '../../definitions/types.js';
+import type { Driver } from '../definitions/interfaces.js';
+import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from '../definitions/types.js';
+type MongoDBConfiguration = {
+    connectionString: string;
+    databaseName: string;
+};
 export default class MongoDB implements Driver {
     #private;
-    constructor(connectionString: string, databaseName: string);
+    constructor(configuration: MongoDBConfiguration);
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
@@ -13,5 +17,5 @@ export default class MongoDB implements Driver {
     updateRecords(type: RecordType, query: RecordQuery, data: RecordData): Promise<number>;
     deleteRecord(type: RecordType, query: RecordQuery): Promise<number>;
     deleteRecords(type: RecordType, query: RecordQuery): Promise<number>;
-    clear(): Promise<void>;
 }
+export {};

package/dist/{implementations/mongodb/MongoDb.js → drivers/MongoDB.js}

@@ -1,8 +1,8 @@
 /* eslint @typescript-eslint/no-explicit-any: "off" */
 import { MongoClient } from 'mongodb';
-import { ID, LogicalOperators, QueryOperators, SortDirections } from '../../definitions/constants.js';
-import DatabaseError from '../../errors/DatabaseError.js';
-import NotConnected from '../../errors/NotConnected.js';
+import { ID, LogicalOperators, QueryOperators, SortDirections } from '../definitions/constants.js';
+import DatabaseError from '../errors/DatabaseError.js';
+import NotConnected from '../errors/NotConnected.js';
 const UNKNOWN_ERROR = 'Unknown error';
 const OPERATORS = {
     [QueryOperators.EQUALS]: '$eq',
@@ -28,9 +28,9 @@ export default class MongoDB {
     #client;
     #database;
     #connected = false;
-    constructor(connectionString, databaseName) {
-        this.#connectionString = connectionString;
-        this.#databaseName = databaseName;
+    constructor(configuration) {
+        this.#connectionString = configuration.connectionString;
+        this.#databaseName = configuration.databaseName;
     }
     get connected() { return this.#connected; }
     async connect() {
@@ -106,9 +106,6 @@ export default class MongoDB {
         const result = await collection.deleteMany(mongoQuery);
         return result.deletedCount;
     }
-    async clear() {
-        return; // Deliberately not implemented
-    }
     #buildMongoQuery(query) {
         const mongoQuery = {};
         const multiStatements = query;

package/dist/errors/DatabaseError.d.ts

@@ -1,2 +1,3 @@
 export default class DatabaseError extends Error {
+    constructor(message?: string);
 }

package/dist/errors/DatabaseError.js

@@ -1,2 +1,9 @@
 export default class DatabaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
 }

package/dist/errors/NotConnected.d.ts

@@ -1,4 +1,4 @@
 import DatabaseError from './DatabaseError.js';
 export default class NotConnected extends DatabaseError {
-    constructor(message?: string);
+    constructor();
 }

package/dist/errors/NotConnected.js

@@ -1,6 +1,6 @@
 import DatabaseError from './DatabaseError.js';
 export default class NotConnected extends DatabaseError {
-    constructor(message) {
-        super(message ?? 'Database not connected');
+    constructor() {
+        super('Database not connected');
     }
 }

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import Database from './Database.js';
-declare const database: Database;
 export * from './definitions/constants.js';
-export * from './definitions/types.js';
+export type * from './definitions/interfaces.js';
+export type * from './definitions/types.js';
 export { default as DatabaseError } from './errors/DatabaseError.js';
 export { default as NotConnected } from './errors/NotConnected.js';
-export type { Database };
-export default database;
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default as MongoDBDriver } from './drivers/MongoDB.js';
+export { default } from './Database.js';

package/dist/index.js

@@ -1,8 +1,6 @@
-import Database from './Database.js';
-import implementation from './implementation.js';
-const database = new Database(implementation);
 export * from './definitions/constants.js';
-export * from './definitions/types.js';
 export { default as DatabaseError } from './errors/DatabaseError.js';
 export { default as NotConnected } from './errors/NotConnected.js';
-export default database;
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default as MongoDBDriver } from './drivers/MongoDB.js';
+export { default } from './Database.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@theshelf/database",
   "private": false,
-  "version": "0.0.4",
+  "version": "0.2.0",
   "type": "module",
   "repository": {
     "url": "https://github.com/MaskingTechnology/theshelf"

package/dist/errors/UnknownImplementation.d.ts

@@ -1,4 +0,0 @@
-import DatabaseError from './DatabaseError.js';
-export default class UnknownImplementation extends DatabaseError {
-    constructor(name: string);
-}

package/dist/errors/UnknownImplementation.js

@@ -1,6 +0,0 @@
-import DatabaseError from './DatabaseError.js';
-export default class UnknownImplementation extends DatabaseError {
-    constructor(name) {
-        super(`Unknown database implementation: ${name}`);
-    }
-}

package/dist/implementation.d.ts

@@ -1,3 +0,0 @@
-import type { Driver } from './definitions/interfaces.js';
-declare const _default: Driver;
-export default _default;

package/dist/implementation.js

@@ -1,14 +0,0 @@
-import UnknownImplementation from './errors/UnknownImplementation.js';
-import createMemoryDb from './implementations/memory/create.js';
-import createMongoDb from './implementations/mongodb/create.js';
-const implementations = new Map([
-    ['memory', createMemoryDb],
-    ['mongodb', createMongoDb],
-]);
-const DEFAULT_DATABASE_IMPLEMENTATION = 'memory';
-const implementationName = process.env.DATABASE_IMPLEMENTATION ?? DEFAULT_DATABASE_IMPLEMENTATION;
-const creator = implementations.get(implementationName.toLowerCase());
-if (creator === undefined) {
-    throw new UnknownImplementation(implementationName);
-}
-export default creator();

package/dist/implementations/memory/create.d.ts

@@ -1,2 +0,0 @@
-import Memory from './Memory.js';
-export default function create(): Memory;

package/dist/implementations/memory/create.js

@@ -1,4 +0,0 @@
-import Memory from './Memory.js';
-export default function create() {
-    return new Memory();
-}

package/dist/implementations/mongodb/create.d.ts

@@ -1,2 +0,0 @@
-import MongoDb from './MongoDb.js';
-export default function create(): MongoDb;

package/dist/implementations/mongodb/create.js

@@ -1,6 +0,0 @@
-import MongoDb from './MongoDb.js';
-export default function create() {
-    const connectionString = process.env.MONGODB_CONNECTION_STRING ?? 'undefined';
-    const databaseName = process.env.MONGODB_DATABASE_NAME ?? 'undefined';
-    return new MongoDb(connectionString, databaseName);
-}