@acodeninja/persist 3.0.0-next.22 → 3.0.0-next.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acodeninja/persist",
-  "version": "3.0.0-next.22",
+  "version": "3.0.0-next.24",
   "description": "A JSON based data modelling and persistence module with alternate storage mechanisms.",
   "type": "module",
   "scripts": {

package/src/Connection.js

@@ -7,24 +7,6 @@ import Model from './data/Model.js';
 import SearchIndex from './data/SearchIndex.js';
 import _ from 'lodash';
 
-/**
- * Represents a transactional operation to be executed, typically queued and later committed.
- *
- * Stores the method to invoke, the arguments to apply, and tracks the result or error state
- * of the transaction once it's processed.
- *
- * @class Transaction
- */
-export class Transaction {
-    constructor(method, ...args) {
-        this.method = method;
-        this.args = args;
-        this.original = undefined;
-        this.error = undefined;
-        this.committed = false;
-    }
-}
-
 /**
  * @class Connection
  */
@@ -35,12 +17,6 @@ export default class Connection {
      */
     #storage;
 
-    /**
-     * @private
-     * @property {CacheEngine|undefined}
-     */
-    #cache;
-
     /**
      * @private
      * @property {Record<String, Model.constructor>}
@@ -50,12 +26,10 @@ export default class Connection {
     /**
      * Create a new connection
      * @param {StorageEngine} storage
-     * @param {CacheEngine|undefined} cache
      * @param {Array<Model.constructor>} models
      */
-    constructor(storage, cache, models) {
+    constructor(storage, models) {
         this.#storage = storage;
-        this.#cache = cache;
         this.#models = Object.fromEntries((models ?? []).map(model => [model.name, model]));
 
         if (!this.#storage) throw new MissingArgumentsConnectionError('No storage engine provided');
@@ -434,51 +408,51 @@ export default class Connection {
      * @return {Connection}
      */
     transaction() {
-        const transactions = [];
+        const operations = [];
 
-        const engine = CreateTransactionalStorageEngine(transactions, this.#storage);
+        const engine = CreateTransactionalStorageEngine(operations, this.#storage);
 
-        const transaction = new this.constructor(engine, this.#cache, Object.values(this.#models));
+        const transaction = new this.constructor(engine, Object.values(this.#models));
 
         transaction.commit = async () => {
             try {
-                for (const [index, transaction] of transactions.entries()) {
+                for (const [index, operation] of operations.entries()) {
                     try {
-                        if (transaction.method === 'putModel')
-                            transactions[index].original = await this.#storage.getModel(transaction.args[0].id).catch(() => undefined);
+                        if (operation.method === 'putModel')
+                            operations[index].original = await this.#storage.getModel(operation.args[0].id).catch(() => undefined);
 
-                        if (transaction.method === 'deleteModel')
-                            transactions[index].original = await this.#storage.getModel(transaction.args[0]);
+                        if (operation.method === 'deleteModel')
+                            operations[index].original = await this.#storage.getModel(operation.args[0]);
 
-                        if (transaction.method === 'putIndex')
-                            transactions[index].original = await this.#storage.getIndex(transaction.args[0]);
+                        if (operation.method === 'putIndex')
+                            operations[index].original = await this.#storage.getIndex(operation.args[0]);
 
-                        if (transaction.method === 'putSearchIndex')
-                            transactions[index].original = await this.#storage.getSearchIndex(transaction.args[0]);
+                        if (operation.method === 'putSearchIndex')
+                            operations[index].original = await this.#storage.getSearchIndex(operation.args[0]);
 
-                        await this.#storage[transaction.method](...transaction.args);
+                        await this.#storage[operation.method](...operation.args);
 
-                        transactions[index].committed = true;
+                        operations[index].committed = true;
                     } catch (error) {
-                        transactions[index].error = error;
+                        operations[index].error = error;
                         throw error;
                     }
                 }
             } catch (error) {
-                for (const transaction of transactions) {
-                    if (transaction.committed && transaction.original) {
-                        if (['putModel', 'deleteModel'].includes(transaction.method))
-                            await this.#storage.putModel(transaction.original);
+                for (const operation of operations) {
+                    if (operation.committed && operation.original) {
+                        if (['putModel', 'deleteModel'].includes(operation.method))
+                            await this.#storage.putModel(operation.original);
 
-                        if ('putIndex' === transaction.method)
-                            await this.#storage.putIndex(transaction.args[0], transaction.original);
+                        if (operation.method === 'putIndex')
+                            await this.#storage.putIndex(operation.args[0], operation.original);
 
-                        if ('putSearchIndex' === transaction.method)
-                            await this.#storage.putSearchIndex(transaction.args[0], transaction.original);
+                        if (operation.method === 'putSearchIndex')
+                            await this.#storage.putSearchIndex(operation.args[0], operation.original);
                     }
                 }
 
-                throw new CommitFailedTransactionError(transactions, error);
+                throw new CommitFailedTransactionError(operations, error);
             }
         };
 
@@ -632,11 +606,11 @@ class TransactionError extends Error {
 export class CommitFailedTransactionError extends TransactionError {
     /**
      *
-     * @param {Array<Transaction>} transactions
+     * @param {Array<Operation>} transactions
      * @param {Error} error
      */
     constructor(transactions, error) {
-        super('Transaction failed to commit.');
+        super('Operation failed to commit.');
         this.transactions = transactions;
         this.error = error;
     }

package/src/engine/storage/StorageEngine.js

@@ -1,5 +1,3 @@
-import {Transaction} from '../../Connection.js';
-
 export default class StorageEngine {
     /**
      * @param {Object} configuration
@@ -142,32 +140,50 @@ export class DeleteHasUnintendedConsequencesStorageEngineError extends StorageEn
     }
 }
 
+/**
+ * Represents a transactional operation to be executed, typically queued and later committed.
+ *
+ * Stores the method to invoke, the arguments to apply, and tracks the result or error state
+ * of the transaction once it's processed.
+ *
+ * @class Operation
+ */
+export class Operation {
+    constructor(method, ...args) {
+        this.method = method;
+        this.args = args;
+        this.original = undefined;
+        this.error = undefined;
+        this.committed = false;
+    }
+}
+
 /**
  *
- * @param {Array<Transaction>} transactions
+ * @param {Array<Operation>} transactions
  * @param {StorageEngine} engine
  * @return {StorageEngine}
  */
-export function CreateTransactionalStorageEngine(transactions, engine) {
+export function CreateTransactionalStorageEngine(operations, engine) {
     const transactionalEngine = Object.create(engine);
 
     transactionalEngine.putModel = (...args) => {
-        transactions.push(new Transaction('putModel', ...args));
+        operations.push(new Operation('putModel', ...args));
         return Promise.resolve();
     };
 
     transactionalEngine.deleteModel = (...args) => {
-        transactions.push(new Transaction('deleteModel', ...args));
+        operations.push(new Operation('deleteModel', ...args));
         return Promise.resolve();
     };
 
     transactionalEngine.putIndex = (...args) => {
-        transactions.push(new Transaction('putIndex', ...args));
+        operations.push(new Operation('putIndex', ...args));
         return Promise.resolve();
     };
 
     transactionalEngine.putSearchIndex = (...args) => {
-        transactions.push(new Transaction('putSearchIndex', ...args));
+        operations.push(new Operation('putSearchIndex', ...args));
         return Promise.resolve();
     };