@theshelf/database 0.3.2 → 0.4.0

package/README.md

@@ -1,9 +1,7 @@
 
-# Database | The Shelf
+# Database core | The Shelf
 
-The database integration provides a universal interaction layer with an actual data storage solution.
-
-This integration is based on simple CRUD operations and purposely does NOT support relational querying.
+This package contains the definition of the CRUD operations. It uses a interchangeable driver system for performing the actual operations. An in-memory driver is included.
 
 ## Installation
 
@@ -11,42 +9,20 @@ This integration is based on simple CRUD operations and purposely does NOT suppo
 npm install @theshelf/database
 ```
 
-## Drivers
-
-Currently, there are two drivers available:
-
-* **Memory** - non-persistent in memory storage (suited for testing).
-* **MongoDB** - persistent document storage.
-
 ## How to use
 
 The basic set up looks like this.
 
 ```ts
-import Database, { MemoryDriver | MongoDBDriver as SelectedDriver } from '@theshelf/database';
+import Database, { MemoryDriver } from '@theshelf/database';
 
-const driver = new SelectedDriver(/* configuration */);
+const driver = new MemoryDriver();
 const database = new Database(driver);
 
 // Perform operations with the database instance
 ```
 
-### Configuration
-
-#### Memory driver
-
-No configuration options.
-
-#### MongoDB driver
-
-```ts
-type MongoDBConfiguration = {
-    connectionString: string; // e.g. "mongodb://development:development@localhost:27017"
-    databaseName: string; // e.g. "mydb"
-};
-```
-
-### Operations
+## Operations
 
 ```ts
 import { RecordData, RecordQuery, RecordSort, SortDirections } from '@theshelf/database';
@@ -95,7 +71,7 @@ await database.updateRecord('items', item.id, { 'name': item.name });
 await database.deleteRecord('items', item.id);
 ```
 
-### Query options
+## Query options
 
 A basic query has the following structure.
 
@@ -112,7 +88,7 @@ const andQuery: RecordQuery = { AND: [ query1, query2, ...]  }
 const orQuery: RecordQuery = { OR: [ query1, query2, ...]  }
 ```
 
-### Sort options
+## Sort options
 
 A basic query has the following structure.
 
@@ -127,3 +103,16 @@ const sort: RecordSort = { fieldName1: SortDirections.ASCENDING, fieldName2: Sor
 ```
 
 The sort will be performed in the configured order.
+
+## Drivers
+
+There is one driver included in this package. Other drivers are available in separate packages.
+
+### Memory
+
+In memory database (suited for testing). It doesn't have any configuration options, but has an additional operation.
+
+```ts
+// Clear the memory
+driver.clear();
+```

package/dist/Database.d.ts

@@ -1,8 +1,9 @@
+import type Logger from '@theshelf/logging';
 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 {
+export default class Database {
     #private;
-    constructor(driver: Driver);
+    constructor(driver: Driver, logger?: Logger);
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;

package/dist/Database.js

@@ -1,40 +1,126 @@
 import sanitize from './utilities/sanitize.js';
+import NotConnected from './errors/NotConnected.js';
 export default class Database {
     #driver;
-    constructor(driver) {
+    #logger;
+    #logPrefix;
+    constructor(driver, logger) {
         this.#driver = driver;
+        this.#logger = logger?.for(Database.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;
+        }
     }
-    createRecord(type, data) {
-        const cleanData = sanitize(data);
-        return this.#driver.createRecord(type, cleanData);
+    async createRecord(type, data) {
+        this.#logger?.debug(this.#logPrefix, 'Creating record for type', type);
+        try {
+            this.#validateConnection();
+            const cleanData = sanitize(data);
+            return await this.#driver.createRecord(type, cleanData);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Create record for type', type, 'failed with error', error);
+            throw error;
+        }
     }
-    readRecord(type, query, fields, sort) {
-        return this.#driver.readRecord(type, query, fields, sort);
+    async readRecord(type, query, fields, sort) {
+        this.#logger?.debug(this.#logPrefix, 'Reading record for type', type);
+        try {
+            this.#validateConnection();
+            return await this.#driver.readRecord(type, query, fields, sort);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Read record for type', type, 'failed with error', error);
+            throw error;
+        }
     }
-    searchRecords(type, query, fields, sort, limit, offset) {
-        return this.#driver.searchRecords(type, query, fields, sort, limit, offset);
+    async searchRecords(type, query, fields, sort, limit, offset) {
+        this.#logger?.debug(this.#logPrefix, 'Searching record for type', type);
+        try {
+            this.#validateConnection();
+            return await this.#driver.searchRecords(type, query, fields, sort, limit, offset);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Search record for type', type, 'failed with error', error);
+            throw error;
+        }
     }
-    updateRecord(type, query, data) {
-        const cleanData = sanitize(data);
-        return this.#driver.updateRecord(type, query, cleanData);
+    async updateRecord(type, query, data) {
+        this.#logger?.debug(this.#logPrefix, 'Updating record for type', type);
+        try {
+            this.#validateConnection();
+            const cleanData = sanitize(data);
+            return await this.#driver.updateRecord(type, query, cleanData);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Update record for type', type, 'failed with error', error);
+            throw error;
+        }
     }
-    updateRecords(type, query, data) {
-        const cleanData = sanitize(data);
-        return this.#driver.updateRecords(type, query, cleanData);
+    async updateRecords(type, query, data) {
+        this.#logger?.debug(this.#logPrefix, 'Updating records for type', type);
+        try {
+            this.#validateConnection();
+            const cleanData = sanitize(data);
+            return await this.#driver.updateRecords(type, query, cleanData);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Update records for type', type, 'failed with error', error);
+            throw error;
+        }
     }
-    deleteRecord(type, query) {
-        return this.#driver.deleteRecord(type, query);
+    async deleteRecord(type, query) {
+        this.#logger?.debug(this.#logPrefix, 'Deleting record for type', type);
+        try {
+            this.#validateConnection();
+            return await this.#driver.deleteRecord(type, query);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Delete record for type', type, 'failed with error', error);
+            throw error;
+        }
     }
-    deleteRecords(type, query) {
-        return this.#driver.deleteRecords(type, query);
+    async deleteRecords(type, query) {
+        this.#logger?.debug(this.#logPrefix, 'Deleting records for type', type);
+        try {
+            this.#validateConnection();
+            return await this.#driver.deleteRecords(type, query);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Delete records for type', type, 'failed with error', error);
+            throw error;
+        }
+    }
+    #validateConnection() {
+        if (this.connected === false) {
+            throw new NotConnected();
+        }
     }
 }

package/dist/definitions/interfaces.d.ts

@@ -1,5 +1,6 @@
 import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from './types.js';
 export interface Driver {
+    get name(): string;
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;

package/dist/drivers/Memory.d.ts

@@ -2,6 +2,7 @@ import type { Driver } from '../definitions/interfaces.js';
 import type { RecordData, RecordQuery, RecordSort } from '../definitions/types.js';
 export default class Memory implements Driver {
     #private;
+    get name(): string;
     get connected(): boolean;
     get memory(): Map<string, RecordData[]>;
     connect(): Promise<void>;

package/dist/drivers/Memory.js

@@ -16,6 +16,7 @@ export default class Memory {
     #memory = new Map();
     #connected = false;
     #recordId = 0;
+    get name() { return Memory.name; }
     get connected() { return this.#connected; }
     get memory() {
         if (this.#connected === false) {

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-export * from './definitions/constants.js';
-export type * from './definitions/interfaces.js';
-export type * from './definitions/types.js';
+export { ID, LogicalOperators, SortDirections, QueryOperators } from './definitions/constants.js';
+export type { Driver } from './definitions/interfaces.js';
+export type { RecordType, RecordId, RecordField, RecordValue, RecordData, QueryOperator, QueryExpression, QuerySingleExpressionStatement, QueryMultiExpressionStatement, QuerySingleStatement, QueryMultiStatement, QueryStatement, RecordQuery, RecordDirection, RecordSort } from './definitions/types.js';
 export { default as DatabaseError } from './errors/DatabaseError.js';
 export { default as NotConnected } from './errors/NotConnected.js';
 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,6 +1,5 @@
-export * from './definitions/constants.js';
+export { ID, LogicalOperators, SortDirections, QueryOperators } from './definitions/constants.js';
 export { default as DatabaseError } from './errors/DatabaseError.js';
 export { default as NotConnected } from './errors/NotConnected.js';
 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,11 +1,12 @@
 {
   "name": "@theshelf/database",
   "private": false,
-  "version": "0.3.2",
+  "version": "0.4.0",
   "type": "module",
   "repository": {
     "url": "git+https://github.com/MaskingTechnology/theshelf.git"
   },
+  "license": "MIT",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
@@ -19,10 +20,15 @@
     "README.md",
     "dist"
   ],
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": "./dist/index.js",
   "dependencies": {
-    "mongodb": "7.0.0",
     "sanitize-html": "2.17.0"
+  },
+  "devDependencies": {
+    "@types/sanitize-html": "2.16.0"
+  },
+  "peerDependencies": {
+    "@theshelf/logging": "^0.4.0"
   }
 }

package/dist/drivers/MongoDB.d.ts

@@ -1,21 +0,0 @@
-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(configuration: MongoDBConfiguration);
-    get connected(): boolean;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    createRecord(type: RecordType, data: RecordData): Promise<RecordId>;
-    readRecord(type: RecordType, query: RecordQuery, fields?: RecordField[], sort?: RecordSort): Promise<RecordData | undefined>;
-    searchRecords(type: RecordType, query: RecordQuery, fields?: RecordField[], sort?: RecordSort, limit?: number, offset?: number): Promise<RecordData[]>;
-    updateRecord(type: RecordType, query: RecordQuery, data: RecordData): Promise<number>;
-    updateRecords(type: RecordType, query: RecordQuery, data: RecordData): Promise<number>;
-    deleteRecord(type: RecordType, query: RecordQuery): Promise<number>;
-    deleteRecords(type: RecordType, query: RecordQuery): Promise<number>;
-}
-export {};

package/dist/drivers/MongoDB.js

@@ -1,187 +0,0 @@
-/* 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';
-const UNKNOWN_ERROR = 'Unknown error';
-const OPERATORS = {
-    [QueryOperators.EQUALS]: '$eq',
-    [QueryOperators.GREATER_THAN]: '$gt',
-    [QueryOperators.GREATER_THAN_OR_EQUALS]: '$gte',
-    [QueryOperators.IN]: '$in',
-    [QueryOperators.LESS_THAN]: '$lt',
-    [QueryOperators.LESS_THAN_OR_EQUALS]: '$lte',
-    [QueryOperators.NOT_EQUALS]: '$ne',
-    [QueryOperators.NOT_IN]: '$nin',
-    [QueryOperators.CONTAINS]: '$regex',
-    [QueryOperators.STARTS_WITH]: '$regex',
-    [QueryOperators.ENDS_WITH]: '$regex'
-};
-const LOGICAL_OPERATORS = {
-    [LogicalOperators.AND]: '$and',
-    [LogicalOperators.OR]: '$or'
-};
-const MONGO_ID = '_id';
-export default class MongoDB {
-    #connectionString;
-    #databaseName;
-    #client;
-    #database;
-    #connected = false;
-    constructor(configuration) {
-        this.#connectionString = configuration.connectionString;
-        this.#databaseName = configuration.databaseName;
-    }
-    get connected() { return this.#connected; }
-    async connect() {
-        try {
-            this.#client = await this.#createClient(this.#connectionString);
-            this.#client.on('close', () => { this.#connected = false; });
-            this.#client.on('serverHeartbeatSucceeded', () => { this.#connected = true; });
-            this.#client.on('serverHeartbeatFailed', () => { this.#connected = false; });
-            this.#database = this.#getDatabase(this.#databaseName);
-            this.#connected = true;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : UNKNOWN_ERROR;
-            throw new DatabaseError('Database connection failed: ' + message);
-        }
-    }
-    async disconnect() {
-        if (this.#client === undefined) {
-            throw new NotConnected();
-        }
-        try {
-            await this.#client.close();
-            this.#connected = false;
-            this.#client = undefined;
-            this.#database = undefined;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : UNKNOWN_ERROR;
-            throw new DatabaseError('Database disconnection failed: ' + message);
-        }
-    }
-    async createRecord(type, data) {
-        const collection = await this.#getCollection(type);
-        const dataCopy = { ...data };
-        const id = dataCopy.id;
-        delete dataCopy.id;
-        await collection.insertOne({ _id: id, ...dataCopy });
-        return id;
-    }
-    async readRecord(type, query, fields, sort) {
-        const result = await this.searchRecords(type, query, fields, sort, 1, 0);
-        return result[0];
-    }
-    async searchRecords(type, query, fields, sort, limit, offset) {
-        const mongoQuery = this.#buildMongoQuery(query);
-        const mongoSort = this.#buildMongoSort(sort);
-        const collection = await this.#getCollection(type);
-        const cursor = collection.find(mongoQuery, { sort: mongoSort, limit: limit, skip: offset });
-        const result = await cursor.toArray();
-        return result.map(data => this.#buildRecordData(data, fields));
-    }
-    async updateRecord(type, query, data) {
-        const mongoQuery = this.#buildMongoQuery(query);
-        const collection = await this.#getCollection(type);
-        const result = await collection.updateOne(mongoQuery, { $set: data });
-        return result.modifiedCount;
-    }
-    async updateRecords(type, query, data) {
-        const mongoQuery = this.#buildMongoQuery(query);
-        const collection = await this.#getCollection(type);
-        const result = await collection.updateMany(mongoQuery, { $set: data });
-        return result.modifiedCount;
-    }
-    async deleteRecord(type, query) {
-        const mongoQuery = this.#buildMongoQuery(query);
-        const collection = await this.#getCollection(type);
-        const result = await collection.deleteOne(mongoQuery);
-        return result.deletedCount;
-    }
-    async deleteRecords(type, query) {
-        const mongoQuery = this.#buildMongoQuery(query);
-        const collection = await this.#getCollection(type);
-        const result = await collection.deleteMany(mongoQuery);
-        return result.deletedCount;
-    }
-    #buildMongoQuery(query) {
-        const mongoQuery = {};
-        const multiStatements = query;
-        const singleStatements = query;
-        for (const key in multiStatements) {
-            if (key === 'AND' || key === 'OR') {
-                const singleMultiStatements = multiStatements[key] ?? [];
-                const multiMongoQuery = [];
-                for (const statement of singleMultiStatements) {
-                    const mongoQuery = this.#buildMongoQuery(statement);
-                    multiMongoQuery.push(mongoQuery);
-                }
-                const mongoKey = LOGICAL_OPERATORS[key];
-                mongoQuery[mongoKey] = multiMongoQuery;
-                continue;
-            }
-            const expression = singleStatements[key];
-            const mongoKey = key === ID ? MONGO_ID : key;
-            const mongoExpression = {};
-            for (const operator in expression) {
-                const value = this.#extractValue(expression, operator);
-                const mongoOperator = OPERATORS[operator];
-                mongoExpression[mongoOperator] = value;
-            }
-            mongoQuery[mongoKey] = mongoExpression;
-        }
-        return mongoQuery;
-    }
-    #buildMongoSort(sort) {
-        const mongoSort = {};
-        if (sort === undefined) {
-            return mongoSort;
-        }
-        for (const element in sort) {
-            const direction = sort[element];
-            mongoSort[element] = direction === SortDirections.DESCENDING ? -1 : 1;
-        }
-        return mongoSort;
-    }
-    async #getCollection(name) {
-        if (this.#database === undefined) {
-            throw new NotConnected();
-        }
-        return this.#database.collection(name);
-    }
-    #getDatabase(databaseName) {
-        if (this.#client === undefined) {
-            throw new NotConnected();
-        }
-        return this.#client.db(databaseName);
-    }
-    async #createClient(connectionString) {
-        return MongoClient.connect(connectionString);
-    }
-    #buildRecordData(data, fields) {
-        const result = {};
-        if (fields === undefined) {
-            const recordData = { ...data };
-            fields = Object.keys(recordData);
-            const idIndex = fields.indexOf(MONGO_ID);
-            fields[idIndex] = ID;
-        }
-        for (const field of fields) {
-            const value = field === ID
-                ? data[MONGO_ID]
-                : data[field];
-            result[field] = value ?? undefined;
-        }
-        return result;
-    }
-    #extractValue(expression, operator) {
-        const value = expression[operator];
-        switch (operator) {
-            case QueryOperators.STARTS_WITH: return '^' + value;
-            case QueryOperators.ENDS_WITH: return value + '$';
-        }
-        return value;
-    }
-}