feat: added vault efs resource aquisition

Author: aryanjassal

src/vaults/Vault.ts

@@ -8,6 +8,8 @@ interface Vault {
   writeG: VaultInternal['writeG'];
   readF: VaultInternal['readF'];
   readG: VaultInternal['readG'];
+  acquireRead: VaultInternal['acquireRead'];
+  acquireWrite: VaultInternal['acquireWrite'];
   log: VaultInternal['log'];
   version: VaultInternal['version'];
 }

src/vaults/VaultInternal.ts

@@ -25,7 +25,12 @@ import {
   CreateDestroyStartStop,
   ready,
 } from '@matrixai/async-init/dist/CreateDestroyStartStop';
-import { withF, withG } from '@matrixai/resources';
+import {
+  ResourceAcquire,
+  ResourceRelease,
+  withF,
+  withG,
+} from '@matrixai/resources';
 import { RWLockWriter } from '@matrixai/async-locks';
 import * as vaultsUtils from './utils';
 import * as vaultsErrors from './errors';
@@ -536,6 +541,86 @@ class VaultInternal {
     });
   }
 
+  /**
+   * Acquire a read-only lock on this vault
+   */
+  @ready(new vaultsErrors.ErrorVaultNotRunning())
+  public acquireRead(): ResourceAcquire<FileSystemReadable> {
+    return async () => {
+      const acquire = this.lock.read();
+      const [release] = await acquire();
+      return [
+        async (e?: Error) => {
+          release(e);
+        },
+        this.efsVault,
+      ];
+    };
+  }
+
+  /**
+   * Acquire a read-write lock on this vault
+   */
+  @ready(new vaultsErrors.ErrorVaultNotRunning())
+  public acquireWrite(
+    tran?: DBTransaction,
+  ): ResourceAcquire<FileSystemWritable> {
+    return async () => {
+      let releaseTran: ResourceRelease | undefined = undefined;
+      const acquire = this.lock.write();
+      const [release] = await acquire([tran]);
+      if (tran == null) {
+        const acquireTran = this.db.transaction();
+        [releaseTran, tran] = await acquireTran();
+      }
+      // The returned transaction can be undefined, too. We won't handle those
+      // cases.
+      if (tran == null) utils.never();
+      await tran.lock(
+        [...this.vaultMetadataDbPath, VaultInternal.dirtyKey].join(''),
+      );
+      if (
+        (await tran.get([
+          ...this.vaultMetadataDbPath,
+          VaultInternal.remoteKey,
+        ])) != null
+      ) {
+        // Mirrored vaults are immutable
+        throw new vaultsErrors.ErrorVaultRemoteDefined();
+      }
+      await tran.put(
+        [...this.vaultMetadataDbPath, VaultInternal.dirtyKey],
+        true,
+      );
+      return [
+        async (e?: Error) => {
+          if (e != null) {
+            try {
+              // After doing mutation we need to commit the new history
+              await this.createCommit();
+            } catch (e_) {
+              e = e_;
+            }
+            // This would happen if an error was caught inside the catch block
+            if (e != null) {
+              // Error implies dirty state
+              await this.cleanWorkingDirectory();
+            }
+          }
+          // For some reason, the transaction type doesn't properly waterfall
+          // down to here.
+          await tran!.put(
+            [...this.vaultMetadataDbPath, VaultInternal.dirtyKey],
+            false,
+          );
+          if (releaseTran != null) releaseTran(e);
+          release(e);
+        },
+        this.efsVault,
+      ];
+    };
+  }
+
   /**
    * Pulls changes to a vault from the vault's default remote.
    * If `pullNodeId` and `pullVaultNameOrId` it uses that for the remote instead.