@theshelf/database 0.0.2 → 0.0.4

package/dist/Database.d.ts

@@ -1,5 +1,5 @@
-import type { Driver } from './definitions/interfaces';
-import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from './definitions/types';
+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);
@@ -7,12 +7,11 @@ export default class Database implements Driver {
     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>;
+    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, 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>;
+    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>;
     clear(): Promise<void>;
 }

package/dist/Database.js

@@ -1,4 +1,4 @@
-import sanitize from './utilities/sanitize';
+import sanitize from './utilities/sanitize.js';
 export default class Database {
     #driver;
     constructor(driver) {
@@ -15,25 +15,22 @@ export default class Database {
         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);
+    readRecord(type, query, fields, sort) {
+        return this.#driver.readRecord(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) {
+    updateRecord(type, query, data) {
         const cleanData = sanitize(data);
-        return this.#driver.updateRecord(type, id, cleanData);
+        return this.#driver.updateRecord(type, query, 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);
+    deleteRecord(type, query) {
+        return this.#driver.deleteRecord(type, query);
     }
     deleteRecords(type, query) {
         return this.#driver.deleteRecords(type, query);

package/dist/definitions/interfaces.d.ts

@@ -1,15 +1,14 @@
-import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from './types';
+import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from './types.js';
 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>;
+    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, 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>;
+    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>;
     clear(): Promise<void>;
 }

package/dist/definitions/types.d.ts

@@ -1,4 +1,4 @@
-import type { QueryOperators, SortDirections } from './constants';
+import type { QueryOperators, SortDirections } from './constants.js';
 export type RecordType = string;
 export type RecordId = string;
 export type RecordField = string;

package/dist/errors/NotConnected.d.ts

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

package/dist/errors/NotConnected.js

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

package/dist/errors/UnknownImplementation.d.ts

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

package/dist/errors/UnknownImplementation.js

@@ -1,4 +1,4 @@
-import DatabaseError from './DatabaseError';
+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 +1,3 @@
-import type { Driver } from './definitions/interfaces';
+import type { Driver } from './definitions/interfaces.js';
 declare const _default: Driver;
 export default _default;

package/dist/implementation.js

@@ -1,6 +1,6 @@
-import UnknownImplementation from './errors/UnknownImplementation';
-import createMemoryDb from './implementations/memory/create';
-import createMongoDb from './implementations/mongodb/create';
+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],

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

@@ -1,5 +1,5 @@
-import type { Driver } from '../../definitions/interfaces';
-import type { QueryStatement, RecordData, RecordSort } from '../../definitions/types';
+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;
@@ -7,12 +7,11 @@ export default class Memory implements Driver {
     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>;
+    readRecord(type: string, query: RecordQuery, fields?: string[], sort?: RecordSort): Promise<RecordData | undefined>;
+    searchRecords(type: string, query: RecordQuery, fields?: string[], sort?: RecordSort, limit?: number, offset?: number): Promise<RecordData[]>;
+    updateRecord(type: string, query: RecordQuery, data: RecordData): Promise<number>;
+    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>;
 }

package/dist/implementations/memory/Memory.js

@@ -1,7 +1,5 @@
-import { LogicalOperators, QueryOperators, SortDirections } from '../../definitions/constants';
-import NotConnected from '../../errors/NotConnected';
-import RecordNotFound from '../../errors/RecordNotFound';
-import RecordNotUpdated from '../../errors/RecordNotUpdated';
+import { LogicalOperators, QueryOperators, SortDirections } from '../../definitions/constants.js';
+import NotConnected from '../../errors/NotConnected.js';
 const OPERATORS = {
     [QueryOperators.EQUALS]: '==',
     [QueryOperators.GREATER_THAN]: '>',
@@ -33,14 +31,7 @@ export default class Memory {
         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) {
+    async readRecord(type, query, fields, sort) {
         const result = await this.searchRecords(type, query, fields, sort, 1, 0);
         return result[0];
     }
@@ -50,24 +41,28 @@ export default class Memory {
         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);
+    async updateRecord(type, query, data) {
+        const record = this.#fetchRecord(type, query);
         if (record === undefined) {
-            throw new RecordNotUpdated();
+            return 0;
         }
         this.#updateRecordData(record, data);
+        return 1;
     }
     async updateRecords(type, query, data) {
         const records = this.#fetchRecords(type, query);
         records.forEach(record => this.#updateRecordData(record, data));
+        return records.length;
     }
-    async deleteRecord(type, id) {
+    async deleteRecord(type, query) {
+        const filterFunction = this.#buildFilterFunction(query);
         const collection = this.#getCollection(type);
-        const index = collection.findIndex(record => record.id === id);
+        const index = collection.findIndex(filterFunction);
         if (index === -1) {
-            throw new RecordNotFound();
+            return 0;
         }
         collection.splice(index, 1);
+        return 1;
     }
     async deleteRecords(type, query) {
         const collection = this.#getCollection(type);
@@ -76,13 +71,15 @@ export default class Memory {
             .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));
+        return indexes.length;
     }
     async clear() {
         this.#memory.clear();
     }
-    #fetchRecord(type, id) {
+    #fetchRecord(type, query) {
         const collection = this.#getCollection(type);
-        return collection.find(object => object.id === id);
+        const filterFunction = this.#buildFilterFunction(query);
+        return collection.find(filterFunction);
     }
     #fetchRecords(type, query) {
         const collection = this.#getCollection(type);

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

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

package/dist/implementations/memory/create.js

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

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

@@ -1,5 +1,5 @@
-import type { Driver } from '../../definitions/interfaces';
-import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from '../../definitions/types';
+import type { Driver } from '../../definitions/interfaces.js';
+import type { RecordData, RecordField, RecordId, RecordQuery, RecordSort, RecordType } from '../../definitions/types.js';
 export default class MongoDB implements Driver {
     #private;
     constructor(connectionString: string, databaseName: string);
@@ -7,12 +7,11 @@ export default class MongoDB implements Driver {
     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>;
+    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, 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>;
+    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>;
     clear(): Promise<void>;
 }

package/dist/implementations/mongodb/MongoDb.js

@@ -1,14 +1,8 @@
 /* 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';
+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',
@@ -73,24 +67,10 @@ export default class MongoDB {
         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);
-        }
+        await collection.insertOne({ _id: id, ...dataCopy });
         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) {
+    async readRecord(type, query, fields, sort) {
         const result = await this.searchRecords(type, query, fields, sort, 1, 0);
         return result[0];
     }
@@ -102,35 +82,29 @@ export default class MongoDB {
         const result = await cursor.toArray();
         return result.map(data => this.#buildRecordData(data, fields));
     }
-    async updateRecord(type, id, data) {
+    async updateRecord(type, query, data) {
+        const mongoQuery = this.#buildMongoQuery(query);
         const collection = await this.#getCollection(type);
-        const entry = await collection.updateOne({ _id: id }, { $set: data });
-        if (entry.modifiedCount === 0) {
-            throw new RecordNotUpdated();
-        }
+        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 });
-        if (result.acknowledged === false) {
-            throw new RecordsNotUpdated();
-        }
+        return result.modifiedCount;
     }
-    async deleteRecord(type, id) {
+    async deleteRecord(type, query) {
+        const mongoQuery = this.#buildMongoQuery(query);
         const collection = await this.#getCollection(type);
-        const result = await collection.deleteOne({ _id: id });
-        if (result.deletedCount !== 1) {
-            throw new RecordNotDeleted();
-        }
+        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);
-        if (result.acknowledged === false) {
-            throw new RecordsNotDeleted();
-        }
+        return result.deletedCount;
     }
     async clear() {
         return; // Deliberately not implemented

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

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

package/dist/implementations/mongodb/create.js

@@ -1,4 +1,4 @@
-import MongoDb from './MongoDb';
+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';

package/dist/index.d.ts

@@ -1,12 +1,8 @@
-import Database from './Database';
+import Database from './Database.js';
 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 * 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 type { Database };
 export default database;

package/dist/index.js

@@ -1,12 +1,8 @@
-import Database from './Database';
-import implementation from './implementation';
+import Database from './Database.js';
+import implementation from './implementation.js';
 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 * 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;

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@theshelf/database",
   "private": false,
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
+  "repository": {
+    "url": "https://github.com/MaskingTechnology/theshelf"
+  },
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",

package/dist/errors/RecordNotCreated.d.ts

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

package/dist/errors/RecordNotCreated.js

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

package/dist/errors/RecordNotDeleted.d.ts

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

package/dist/errors/RecordNotDeleted.js

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

package/dist/errors/RecordNotFound.d.ts

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

package/dist/errors/RecordNotFound.js

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

package/dist/errors/RecordNotUpdated.d.ts

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

package/dist/errors/RecordNotUpdated.js

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

package/dist/errors/RecordsNotDeleted.d.ts

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

package/dist/errors/RecordsNotDeleted.js

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

package/dist/errors/RecordsNotUpdated.d.ts

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

package/dist/errors/RecordsNotUpdated.js

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