@theshelf/database 0.0.1

package/README.md

@@ -0,0 +1,126 @@
+
+# Database | 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.
+
+## Installation
+
+```bash
+npm install @theshelf/database
+```
+
+## Implementations
+
+Currently, there are two implementations:
+
+* **Memory** - non-persistent in memory storage  (suited for testing).
+* **MongoDB** - persistent document storage.
+
+## Configuration
+
+The used implementation needs to be configured in the `.env` file.
+
+```env
+DATABASE_IMPLEMENTATION="mongodb" # (memory | mongodb)
+```
+
+In case of MongoDB, additional configuration is required.
+
+```env
+MONGODB_CONNECTION_STRING="mongodb://username:password@address:27017"
+MONGODB_DATABASE_NAME="mydb"
+```
+
+## How to use
+
+An instance of the configured implementation can be imported for performing database operations.
+
+```ts
+import database from '@theshelf/database';
+
+// Perform operations with the database instance
+```
+
+### Operations
+
+```ts
+import database, { RecordData, RecordQuery, RecordSort, SortDirections } from '@theshelf/database';
+
+// Open connection
+await database.connect();
+
+// Close connection
+await database.disconnect();
+
+// INSERT INTO items (name, quantity) VALUES (?, ?)
+const id: string = await database.createRecord('items', { name: 'Popcorn', quantity: 3 });
+
+// SELECT * FROM items WHERE id = ?
+// Throws `RecordNotFound` if not found
+const record: RecordData = await database.readRecord('items', id);
+
+// SELECT name FROM items WHERE id = ?
+const record: RecordData = await database.readRecord('items', id, ['name']);
+
+// SELECT * FROM items
+const records: RecordData[] = await database.searchRecords('items', {});
+
+// SELECT name FROM items
+const records: RecordData[] = await database.searchRecords('items', {}, ['name']);
+
+// SELECT * FROM items WHERE id = ? LIMIT 1 OFFSET 0
+const records: RecordData | undefined = await database.findRecord('items', { id }, undefined, undefined, 1, 0);
+
+// SELECT * FROM items WHERE name LIKE "%?%" ORDER BY name ASC LIMIT ? OFFSET ?
+const query: RecordQuery = { name: { CONTAINS: name }};
+const sort: RecordSort = { name: SortDirections.ASCENDING };
+const records: RecordData[] = await database.searchRecords('items', query, undefined, sort, limit, offset);
+
+// SELECT name FROM items WHERE name LIKE "?%" OR name LIKE "%?" ORDER BY name ASC, quantity DESC LIMIT ? OFFSET ?;
+const query: RecordQuery = { OR: [ { name: { STARTS_WITH: name } }, { name: { ENDS_WITH: name } } ] };
+const sort: RecordSort = { name: SortDirections.ASCENDING, quantity: SortDirections.DESCENDING };
+const records: RecordData[] = await database.searchRecords('items', query, ['name'], sort, limit, offset);
+
+// UPDATE items SET name = ? WHERE id = ?
+// Throws `RecordNotFound` if not found
+await database.updateRecord('items', item.id, { 'name': item.name });
+
+// DELETE FROM items WHERE id = ?
+// Throws `RecordNotFound` if not found
+await database.deleteRecord('items', item.id);
+```
+
+### Query options
+
+A basic query has the following structure.
+
+```ts
+const query: RecordQuery = { fieldName1: { OPERATOR: value }, fieldName2: { OPERATOR: value }, ...  }
+```
+
+The following operators are supported: `EQUALS`, `NOT_EQUALS`, `LESS_THAN`, `LESS_THAN_OR_EQUALS`, `GREATER_THAN`, `GREATER_THAN_OR_EQUALS`, `IN`, `NOT_IN`, `CONTAINS`, `STARTS_WITH`, `ENDS_WITH`
+
+Multiple queries can be grouped using the logical operators: `AND`, `OR`.
+
+```ts
+const andQuery: RecordQuery = { AND: [ query1, query2, ...]  }
+const orQuery: RecordQuery = { OR: [ query1, query2, ...]  }
+```
+
+### Sort options
+
+A basic query has the following structure.
+
+```ts
+const sort: RecordSort = { fieldName1: DIRECTION, fieldName2: DIRECTION, ... };
+```
+
+The following directions are supported: `ASCENDING`, `DESCENDING`. Both are defined in the `SortDirections` enum.
+
+```ts
+const sort: RecordSort = { fieldName1: SortDirections.ASCENDING, fieldName2: SortDirections.DESCENDING, ... };
+```
+
+The sort will be performed in the configured order.

package/dist/Database.d.ts

@@ -0,0 +1,18 @@
+import type { Driver } from './definitions/interfaces';
+import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from './definitions/types';
+export default class Database implements Driver {
+    #private;
+    constructor(driver: Driver);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createRecord(type: RecordType, data: RecordData): Promise<RecordId>;
+    readRecord(type: RecordType, id: RecordId, fields?: RecordField[]): Promise<RecordData>;
+    findRecord(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, id: RecordId, data: RecordData): Promise<void>;
+    updateRecords(type: RecordType, query: RecordQuery, data: RecordData): Promise<void>;
+    deleteRecord(type: RecordType, id: RecordId): Promise<void>;
+    deleteRecords(type: RecordType, query: RecordQuery): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/Database.js

@@ -0,0 +1,44 @@
+import sanitize from './utilities/sanitize';
+export default class Database {
+    #driver;
+    constructor(driver) {
+        this.#driver = driver;
+    }
+    get connected() { return this.#driver.connected; }
+    connect() {
+        return this.#driver.connect();
+    }
+    disconnect() {
+        return this.#driver.disconnect();
+    }
+    createRecord(type, data) {
+        const cleanData = sanitize(data);
+        return this.#driver.createRecord(type, cleanData);
+    }
+    readRecord(type, id, fields) {
+        return this.#driver.readRecord(type, id, fields);
+    }
+    findRecord(type, query, fields, sort) {
+        return this.#driver.findRecord(type, query, fields, sort);
+    }
+    searchRecords(type, query, fields, sort, limit, offset) {
+        return this.#driver.searchRecords(type, query, fields, sort, limit, offset);
+    }
+    updateRecord(type, id, data) {
+        const cleanData = sanitize(data);
+        return this.#driver.updateRecord(type, id, cleanData);
+    }
+    updateRecords(type, query, data) {
+        const cleanData = sanitize(data);
+        return this.#driver.updateRecords(type, query, cleanData);
+    }
+    deleteRecord(type, id) {
+        return this.#driver.deleteRecord(type, id);
+    }
+    deleteRecords(type, query) {
+        return this.#driver.deleteRecords(type, query);
+    }
+    clear() {
+        return this.#driver.clear();
+    }
+}

package/dist/definitions/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const ID = "id";
+export declare const LogicalOperators: {
+    AND: string;
+    OR: string;
+};
+export declare const SortDirections: {
+    ASCENDING: string;
+    DESCENDING: string;
+};
+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;
+};

package/dist/definitions/constants.js

@@ -0,0 +1,25 @@
+export const ID = 'id';
+export const LogicalOperators = {
+    AND: 'AND',
+    OR: 'OR'
+};
+export const SortDirections = {
+    ASCENDING: 'ASCENDING',
+    DESCENDING: 'DESCENDING'
+};
+export const QueryOperators = {
+    EQUALS: 'EQUALS',
+    NOT_EQUALS: 'NOT_EQUALS',
+    LESS_THAN: 'LESS_THAN',
+    LESS_THAN_OR_EQUALS: 'LESS_THAN_OR_EQUALS',
+    GREATER_THAN: 'GREATER_THAN',
+    GREATER_THAN_OR_EQUALS: 'GREATER_THAN_OR_EQUALS',
+    IN: 'IN',
+    NOT_IN: 'NOT_IN',
+    CONTAINS: 'CONTAINS', // "%LIKE%"
+    STARTS_WITH: 'STARTS_WITH', // "LIKE%"
+    ENDS_WITH: 'ENDS_WITH' // "%LIKE"
+};
+Object.freeze(LogicalOperators);
+Object.freeze(SortDirections);
+Object.freeze(QueryOperators);

package/dist/definitions/interfaces.d.ts

@@ -0,0 +1,15 @@
+import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from './types';
+export interface Driver {
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createRecord(type: RecordType, data: RecordData): Promise<RecordId>;
+    readRecord(type: RecordType, id: RecordId, fields?: RecordField[]): Promise<RecordData>;
+    findRecord(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, id: RecordId, data: RecordData): Promise<void>;
+    updateRecords(type: RecordType, query: RecordQuery, data: RecordData): Promise<void>;
+    deleteRecord(type: RecordType, id: RecordId): Promise<void>;
+    deleteRecords(type: RecordType, query: RecordQuery): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/definitions/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/definitions/types.d.ts

@@ -0,0 +1,16 @@
+import type { QueryOperators, SortDirections } from './constants';
+export type RecordType = string;
+export type RecordId = string;
+export type RecordField = string;
+export type RecordValue = unknown;
+export type RecordData = Record<RecordField, RecordValue>;
+export type QueryOperator = keyof typeof QueryOperators;
+export type QueryExpression = Partial<Record<QueryOperator, RecordValue>>;
+export type QuerySingleExpressionStatement = Record<RecordField, QueryExpression>;
+export type QueryMultiExpressionStatement = Partial<Record<'AND' | 'OR', QuerySingleExpressionStatement[]>>;
+export type QuerySingleStatement = QuerySingleExpressionStatement | QueryMultiExpressionStatement;
+export type QueryMultiStatement = Partial<Record<'AND' | 'OR', QuerySingleStatement[]>>;
+export type QueryStatement = QuerySingleStatement | QueryMultiStatement;
+export type RecordQuery = QueryStatement;
+export type RecordDirection = keyof typeof SortDirections;
+export type RecordSort = Record<RecordField, string>;

package/dist/definitions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/errors/DatabaseError.d.ts

@@ -0,0 +1,2 @@
+export default class DatabaseError extends Error {
+}

package/dist/errors/DatabaseError.js

@@ -0,0 +1,2 @@
+export default class DatabaseError extends Error {
+}

package/dist/errors/NotConnected.d.ts

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

package/dist/errors/NotConnected.js

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

package/dist/errors/RecordNotCreated.d.ts

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

package/dist/errors/RecordNotCreated.js

@@ -0,0 +1,6 @@
+import DatabaseError from './DatabaseError';
+export default class RecordNotCreated extends DatabaseError {
+    constructor(message) {
+        super(message ?? 'Record not created');
+    }
+}

package/dist/errors/RecordNotDeleted.d.ts

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

package/dist/errors/RecordNotDeleted.js

@@ -0,0 +1,6 @@
+import DatabaseError from './DatabaseError';
+export default class RecordNotDeleted extends DatabaseError {
+    constructor(message) {
+        super(message ?? 'Record not deleted');
+    }
+}

package/dist/errors/RecordNotFound.d.ts

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

package/dist/errors/RecordNotFound.js

@@ -0,0 +1,6 @@
+import DatabaseError from './DatabaseError';
+export default class RecordNotFound extends DatabaseError {
+    constructor(message) {
+        super(message ?? 'Record not found');
+    }
+}

package/dist/errors/RecordNotUpdated.d.ts

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

package/dist/errors/RecordNotUpdated.js

@@ -0,0 +1,6 @@
+import DatabaseError from './DatabaseError';
+export default class RecordNotUpdated extends DatabaseError {
+    constructor(message) {
+        super(message ?? 'Record not updated');
+    }
+}

package/dist/errors/RecordsNotDeleted.d.ts

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

package/dist/errors/RecordsNotDeleted.js

@@ -0,0 +1,6 @@
+import DatabaseError from './DatabaseError';
+export default class RecordsNotDeleted extends DatabaseError {
+    constructor(message) {
+        super(message ?? 'Records not deleted');
+    }
+}

package/dist/errors/RecordsNotUpdated.d.ts

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

package/dist/errors/RecordsNotUpdated.js

@@ -0,0 +1,6 @@
+import DatabaseError from './DatabaseError';
+export default class RecordsNotUpdated extends DatabaseError {
+    constructor(message) {
+        super(message ?? 'Records not updated');
+    }
+}

package/dist/errors/UnknownImplementation.d.ts

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

package/dist/errors/UnknownImplementation.js

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

package/dist/implementation.d.ts

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

package/dist/implementation.js

@@ -0,0 +1,14 @@
+import UnknownImplementation from './errors/UnknownImplementation';
+import createMemoryDb from './implementations/memory/create';
+import createMongoDb from './implementations/mongodb/create';
+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/Memory.d.ts

@@ -0,0 +1,18 @@
+import type { Driver } from '../../definitions/interfaces';
+import type { QueryStatement, RecordData, RecordSort } from '../../definitions/types';
+export default class Memory implements Driver {
+    #private;
+    recordId: number;
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createRecord(type: string, data: RecordData): Promise<string>;
+    readRecord(type: string, id: string, fields?: string[]): Promise<RecordData>;
+    findRecord(type: string, query: QueryStatement, fields?: string[], sort?: RecordSort): Promise<RecordData | undefined>;
+    searchRecords(type: string, query: QueryStatement, fields?: string[], sort?: RecordSort, limit?: number, offset?: number): Promise<RecordData[]>;
+    updateRecord(type: string, id: string, data: RecordData): Promise<void>;
+    updateRecords(type: string, query: QueryStatement, data: RecordData): Promise<void>;
+    deleteRecord(type: string, id: string): Promise<void>;
+    deleteRecords(type: string, query: QueryStatement): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/implementations/memory/Memory.js

@@ -0,0 +1,197 @@
+import { LogicalOperators, QueryOperators, SortDirections } from '../../definitions/constants';
+import NotConnected from '../../errors/NotConnected';
+import RecordNotFound from '../../errors/RecordNotFound';
+import RecordNotUpdated from '../../errors/RecordNotUpdated';
+const OPERATORS = {
+    [QueryOperators.EQUALS]: '==',
+    [QueryOperators.GREATER_THAN]: '>',
+    [QueryOperators.GREATER_THAN_OR_EQUALS]: '>=',
+    [QueryOperators.LESS_THAN]: '<',
+    [QueryOperators.LESS_THAN_OR_EQUALS]: '<=',
+    [QueryOperators.NOT_EQUALS]: '!=',
+};
+const LOGICAL_OPERATORS = {
+    [LogicalOperators.AND]: '&&',
+    [LogicalOperators.OR]: '||'
+};
+export default class Memory {
+    #memory = new Map();
+    #connected = false;
+    recordId = 0;
+    get connected() { return this.#connected; }
+    async connect() {
+        this.#connected = true;
+    }
+    async disconnect() {
+        this.#connected = false;
+    }
+    async createRecord(type, data) {
+        const collection = this.#getCollection(type);
+        const record = data.id === undefined
+            ? { id: this.#createId(), ...data }
+            : data;
+        collection.push(record);
+        return record.id;
+    }
+    async readRecord(type, id, fields) {
+        const record = this.#fetchRecord(type, id);
+        if (record === undefined) {
+            throw new RecordNotFound();
+        }
+        return this.#buildRecordData(record, fields);
+    }
+    async findRecord(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 records = this.#fetchRecords(type, query);
+        const sortedRecords = this.#sortRecords(records, sort);
+        const limitedRecords = this.#limitNumberOfRecords(sortedRecords, offset, limit);
+        return limitedRecords.map(record => this.#buildRecordData(record, fields));
+    }
+    async updateRecord(type, id, data) {
+        const record = this.#fetchRecord(type, id);
+        if (record === undefined) {
+            throw new RecordNotUpdated();
+        }
+        this.#updateRecordData(record, data);
+    }
+    async updateRecords(type, query, data) {
+        const records = this.#fetchRecords(type, query);
+        records.forEach(record => this.#updateRecordData(record, data));
+    }
+    async deleteRecord(type, id) {
+        const collection = this.#getCollection(type);
+        const index = collection.findIndex(record => record.id === id);
+        if (index === -1) {
+            throw new RecordNotFound();
+        }
+        collection.splice(index, 1);
+    }
+    async deleteRecords(type, query) {
+        const collection = this.#getCollection(type);
+        const records = this.#fetchRecords(type, query);
+        const indexes = records
+            .map(fetchedRecord => collection.findIndex(collectionRecord => collectionRecord.id === fetchedRecord.id))
+            .sort((a, b) => b - a); // Reverse the order of indexes to delete from the end to the beginning
+        indexes.forEach(index => collection.splice(index, 1));
+    }
+    async clear() {
+        this.#memory.clear();
+    }
+    #fetchRecord(type, id) {
+        const collection = this.#getCollection(type);
+        return collection.find(object => object.id === id);
+    }
+    #fetchRecords(type, query) {
+        const collection = this.#getCollection(type);
+        const filterFunction = this.#buildFilterFunction(query);
+        return collection.filter(filterFunction);
+    }
+    #updateRecordData(record, data) {
+        for (const key of Object.keys(data)) {
+            record[key] = data[key];
+        }
+    }
+    #limitNumberOfRecords(result, offset, limit) {
+        if (offset === undefined && limit === undefined) {
+            return result;
+        }
+        const first = offset ?? 0;
+        const last = limit === undefined ? undefined : first + limit;
+        return result.slice(first, last);
+    }
+    #sortRecords(result, sort) {
+        if (sort === undefined) {
+            return result;
+        }
+        return result.sort((a, b) => {
+            for (const key in sort) {
+                const order = sort[key];
+                const valueA = a[key];
+                const valueB = b[key];
+                if (valueA > valueB) {
+                    return order === SortDirections.ASCENDING ? 1 : -1;
+                }
+                else if (valueA < valueB) {
+                    return order === SortDirections.ASCENDING ? -1 : 1;
+                }
+            }
+            return 0;
+        });
+    }
+    #buildFilterFunction(query) {
+        const statementCode = this.#buildStatementCode(query);
+        const functionCode = statementCode === '' ? 'true' : statementCode;
+        // eslint-disable-next-line sonarjs/code-eval
+        return new Function('record', `return ${functionCode}`);
+    }
+    #buildStatementCode(query) {
+        const multiStatements = query;
+        const singleStatements = query;
+        const statementCodes = [];
+        for (const key in multiStatements) {
+            const code = key === 'AND' || key === 'OR'
+                ? this.#buildMultiStatementCode(key, multiStatements[key] ?? [])
+                : this.#buildExpressionCode(key, singleStatements[key]);
+            statementCodes.push(code);
+        }
+        return statementCodes.join(' && ');
+    }
+    #buildMultiStatementCode(operator, statements) {
+        const codeOperator = LOGICAL_OPERATORS[operator];
+        const statementCodes = [];
+        for (const statement of statements) {
+            const statementCode = this.#buildStatementCode(statement);
+            statementCodes.push(statementCode);
+        }
+        const code = statementCodes.join(` ${codeOperator} `);
+        return `(${code})`;
+    }
+    #buildExpressionCode(key, expression) {
+        const expressionCodes = [];
+        for (const operator in expression) {
+            const value = expression[operator];
+            const expressionCode = this.#buildOperatorCode(key, operator, value);
+            expressionCodes.push(expressionCode);
+        }
+        return `(${expressionCodes.join(' && ')})`;
+    }
+    #buildOperatorCode(key, operator, value) {
+        const codeValue = JSON.stringify(value);
+        switch (operator) {
+            case QueryOperators.STARTS_WITH: return `record.${key}.startsWith(${codeValue})`;
+            case QueryOperators.ENDS_WITH: return `record.${key}.endsWith(${codeValue})`;
+            case QueryOperators.CONTAINS: return `record.${key}.includes(${codeValue})`;
+            case QueryOperators.IN: return `${codeValue}.includes(record.${key})`;
+            case QueryOperators.NOT_IN: return `!${codeValue}.includes(record.${key})`;
+        }
+        const codeOperator = OPERATORS[operator];
+        return `record.${key} ${codeOperator} ${codeValue}`;
+    }
+    #createId() {
+        return (++this.recordId).toString().padStart(8, '0');
+    }
+    #getCollection(type) {
+        if (this.#memory === undefined) {
+            throw new NotConnected();
+        }
+        let collection = this.#memory.get(type);
+        if (collection === undefined) {
+            collection = [];
+            this.#memory.set(type, collection);
+        }
+        return collection;
+    }
+    #buildRecordData(data, fields) {
+        if (fields === undefined) {
+            return { ...data };
+        }
+        const result = {};
+        for (const field of fields) {
+            result[field] = data[field];
+        }
+        return result;
+    }
+}

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

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

package/dist/implementations/memory/create.js

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

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

@@ -0,0 +1,18 @@
+import type { Driver } from '../../definitions/interfaces';
+import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from '../../definitions/types';
+export default class MongoDB implements Driver {
+    #private;
+    constructor(connectionString: string, databaseName: string);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createRecord(type: RecordType, data: RecordData): Promise<RecordId>;
+    readRecord(type: RecordType, id: RecordId, fields?: RecordField[]): Promise<RecordData>;
+    findRecord(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, id: RecordId, data: RecordData): Promise<void>;
+    updateRecords(type: RecordType, query: RecordQuery, data: RecordData): Promise<void>;
+    deleteRecord(type: RecordType, id: RecordId): Promise<void>;
+    deleteRecords(type: RecordType, query: RecordQuery): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/implementations/mongodb/MongoDb.js

@@ -0,0 +1,216 @@
+/* eslint @typescript-eslint/no-explicit-any: "off" */
+import { MongoClient } from 'mongodb';
+import { ID, LogicalOperators, QueryOperators, SortDirections } from '../../definitions/constants';
+import DatabaseError from '../../errors/DatabaseError';
+import NotConnected from '../../errors/NotConnected';
+import RecordNotCreated from '../../errors/RecordNotCreated';
+import RecordNotDeleted from '../../errors/RecordNotDeleted';
+import RecordNotFound from '../../errors/RecordNotFound';
+import RecordNotUpdated from '../../errors/RecordNotUpdated';
+import RecordsNotDeleted from '../../errors/RecordsNotDeleted';
+import RecordsNotUpdated from '../../errors/RecordsNotUpdated';
+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(connectionString, databaseName) {
+        this.#connectionString = connectionString;
+        this.#databaseName = 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;
+        try {
+            await collection.insertOne({ _id: id, ...dataCopy });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : UNKNOWN_ERROR;
+            throw new RecordNotCreated(message);
+        }
+        return id;
+    }
+    async readRecord(type, id, fields) {
+        const collection = await this.#getCollection(type);
+        const entry = await collection.findOne({ _id: id });
+        if (entry === null) {
+            throw new RecordNotFound(`Record ${type} found: ${id}`);
+        }
+        return this.#buildRecordData(entry, fields);
+    }
+    async findRecord(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, id, data) {
+        const collection = await this.#getCollection(type);
+        const entry = await collection.updateOne({ _id: id }, { $set: data });
+        if (entry.modifiedCount === 0) {
+            throw new RecordNotUpdated();
+        }
+    }
+    async updateRecords(type, query, data) {
+        const mongoQuery = this.#buildMongoQuery(query);
+        const collection = await this.#getCollection(type);
+        const result = await collection.updateMany(mongoQuery, { $set: data });
+        if (result.acknowledged === false) {
+            throw new RecordsNotUpdated();
+        }
+    }
+    async deleteRecord(type, id) {
+        const collection = await this.#getCollection(type);
+        const result = await collection.deleteOne({ _id: id });
+        if (result.deletedCount !== 1) {
+            throw new RecordNotDeleted();
+        }
+    }
+    async deleteRecords(type, query) {
+        const mongoQuery = this.#buildMongoQuery(query);
+        const collection = await this.#getCollection(type);
+        const result = await collection.deleteMany(mongoQuery);
+        if (result.acknowledged === false) {
+            throw new RecordsNotDeleted();
+        }
+    }
+    async clear() {
+        return; // Deliberately not implemented
+    }
+    #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;
+    }
+}

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

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

package/dist/implementations/mongodb/create.js

@@ -0,0 +1,6 @@
+import MongoDb from './MongoDb';
+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);
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import Database from './Database';
+declare const database: Database;
+export * from './definitions/constants';
+export * from './definitions/types';
+export { default as DatabaseError } from './errors/DatabaseError';
+export { default as NotConnected } from './errors/NotConnected';
+export { default as RecordNotCreated } from './errors/RecordNotCreated';
+export { default as RecordNotDeleted } from './errors/RecordNotDeleted';
+export { default as RecordNotFound } from './errors/RecordNotFound';
+export { default as RecordNotUpdated } from './errors/RecordNotUpdated';
+export type { Database };
+export default database;

package/dist/index.js

@@ -0,0 +1,12 @@
+import Database from './Database';
+import implementation from './implementation';
+const database = new Database(implementation);
+export * from './definitions/constants';
+export * from './definitions/types';
+export { default as DatabaseError } from './errors/DatabaseError';
+export { default as NotConnected } from './errors/NotConnected';
+export { default as RecordNotCreated } from './errors/RecordNotCreated';
+export { default as RecordNotDeleted } from './errors/RecordNotDeleted';
+export { default as RecordNotFound } from './errors/RecordNotFound';
+export { default as RecordNotUpdated } from './errors/RecordNotUpdated';
+export default database;

package/dist/utilities/sanitize.d.ts

@@ -0,0 +1 @@
+export default function sanitize(input: Record<string, unknown>): Record<string, unknown>;

package/dist/utilities/sanitize.js

@@ -0,0 +1,17 @@
+import sanitizeHtml from 'sanitize-html';
+const options = {
+    allowedTags: [],
+    allowedAttributes: {}
+};
+function sanitizeValue(input) {
+    return typeof input === 'string'
+        ? sanitizeHtml(input, options)
+        : input;
+}
+export default function sanitize(input) {
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+        result[key] = sanitizeValue(value);
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@theshelf/database",
+  "private": false,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "test": "vitest run",
+    "test-coverage": "vitest run --coverage",
+    "lint": "eslint",
+    "review": "npm run build && npm run lint && npm run test",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "types": "dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "dependencies": {
+    "@theshelf/errors": "*",
+    "mongodb": "7.0.0",
+    "sanitize-html": "2.17.0"
+  }
+}