chore: cleaning up promise variable names

Author: tegefaulkes

src/PolykeyAgent.ts

@@ -806,7 +806,7 @@ class PolykeyAgent {
         if (nodeId == null) {
           utils.never(`failed to decode NodeId "${nodeIdEncoded}"`);
         }
-        const setNodeProm = this.nodeManager.setNode(
+        const setNodeP = this.nodeManager.setNode(
           nodeId,
           optionsDefaulted.seedNodes[nodeIdEncoded],
           {
@@ -816,7 +816,7 @@ class PolykeyAgent {
           },
           true,
         );
-        setNodeProms.push(setNodeProm);
+        setNodeProms.push(setNodeP);
       }
       await Promise.all(setNodeProms);
       await this.nodeGraph.start({ fresh });

src/audit/Audit.ts

@@ -177,7 +177,7 @@ class Audit {
         promise.cancel(new auditErrors.ErrorAuditNotRunning());
       }
     }
-    await Promise.all([...this.taskPromises]).catch(() => {});
+    await Promise.allSettled([...this.taskPromises]);
     this.logger.info(`Stopped ${this.constructor.name}`);
   }
 
@@ -333,6 +333,7 @@ class Audit {
           resolveBlockP = resolveP;
           blockPSignal = signal;
         });
+        void blockP.catch(() => {});
         this.taskPromises.add(blockP);
 
         const iterator = this.getAuditEvents(topicPath, {

src/identities/IdentitiesManager.ts

@@ -265,7 +265,8 @@ class IdentitiesManager {
       );
     }
     // Create identity claim on our node
-    const publishedClaimProm = promise<IdentitySignedClaim>();
+    const { p: publishedClaimP, resolveP: publishedClaimResolveP } =
+      promise<IdentitySignedClaim>();
     await this.db.withTransactionF((tran) =>
       this.sigchain.addClaim(
         {
@@ -281,7 +282,7 @@ class IdentitiesManager {
             identityId,
             claim,
           );
-          publishedClaimProm.resolveP(identitySignedClaim);
+          publishedClaimResolveP(identitySignedClaim);
           // Append the ProviderIdentityClaimId to the token
           const payload: ClaimLinkIdentity = {
             ...claim.payload,
@@ -294,7 +295,7 @@ class IdentitiesManager {
         tran,
       ),
     );
-    const publishedClaim = await publishedClaimProm.p;
+    const publishedClaim = await publishedClaimP;
     // Publish claim on identity
     const issNodeInfo = {
       nodeId: this.keyRing.getNodeId(),

src/nodes/NodeConnectionManager.ts

@@ -571,25 +571,25 @@ class NodeConnectionManager {
     );
     this.quicSocket.removeEventListener(EventAll.name, this.handleEventAll);
 
-    const destroyProms: Array<Promise<void>> = [];
+    const destroyPs: Array<Promise<void>> = [];
     for (const [nodeId] of this.connections) {
       // It exists so we want to destroy it
-      const destroyProm = this.destroyConnection(
+      const destroyP = this.destroyConnection(
         IdInternal.fromString<NodeId>(nodeId),
         force,
       );
-      destroyProms.push(destroyProm);
+      destroyPs.push(destroyP);
     }
-    await Promise.all(destroyProms);
-    const signallingProms: Array<PromiseCancellable<void> | Promise<void>> = [];
+    await Promise.all(destroyPs);
+    const signallingPs: Array<PromiseCancellable<void> | Promise<void>> = [];
     for (const [, activePunch] of this.activeHolePunchPs) {
-      signallingProms.push(activePunch);
+      signallingPs.push(activePunch);
       activePunch.cancel();
     }
     for (const activeSignal of this.activeSignalFinalPs) {
-      signallingProms.push(activeSignal);
+      signallingPs.push(activeSignal);
     }
-    await Promise.allSettled(signallingProms);
+    await Promise.allSettled(signallingPs);
     await this.quicServer.stop({ force: true });
     await this.quicSocket.stop({ force: true });
     await this.rpcServer.stop({ force: true });
@@ -1113,13 +1113,13 @@ class NodeConnectionManager {
   ): Promise<void> {
     // We need to send a random data packet to the target until the process times out or a connection is established
     let ended = false;
-    const endedProm = utils.promise();
+    const { p: endedP, resolveP: endedResolveP } = utils.promise();
     if (ctx.signal.aborted) {
-      endedProm.resolveP();
+      endedResolveP();
     }
     const onAbort = () => {
       ended = true;
-      endedProm.resolveP();
+      endedResolveP();
       ctx.signal.removeEventListener('abort', onAbort);
     };
     ctx.signal.addEventListener('abort', onAbort);
@@ -1134,7 +1134,7 @@ class NodeConnectionManager {
         await this.quicSocket
           .send(Buffer.from(message), port, host)
           .catch(() => {});
-        await Promise.race([utils.sleep(delay), endedProm.p]);
+        await Promise.race([utils.sleep(delay), endedP]);
         if (ended) break;
         delay *= 2;
       }

src/nodes/NodeConnectionQueue.ts

@@ -189,6 +189,7 @@ export class NodeConnectionQueue {
     ctx: ContextCancellable,
   ): Promise<void> {
     const abortP = utils.signalPromise(ctx.signal);
+    void abortP.catch(() => {});
     try {
       while (
         !this.connectionMade &&

src/nodes/NodeManager.ts

@@ -290,12 +290,12 @@ class NodeManager {
       const task = await this.updateRefreshBucketDelay(i, 0, false);
       refreshBuckets.push(task.promise());
     }
-    const signalProm = utils.signalPromise(ctx.signal);
-    await Promise.race([Promise.all(refreshBuckets), signalProm]).finally(
+    const signalP = utils.signalPromise(ctx.signal);
+    await Promise.race([Promise.all(refreshBuckets), signalP]).finally(
       async () => {
         // Clean up signal promise when done
-        signalProm.cancel();
-        await signalProm;
+        signalP.cancel();
+        await signalP;
       },
     );
   };
@@ -1424,8 +1424,9 @@ class NodeManager {
     };
 
     // Now we want to send our own claim signed
-    const halfSignedClaimProm = utils.promise<SignedTokenEncoded>();
-    const claimProm = this.sigchain.addClaim(
+    const { p: halfSignedClaimP, resolveP: halfSignedClaimResolveP } =
+      utils.promise<SignedTokenEncoded>();
+    const claimP = this.sigchain.addClaim(
       {
         typ: 'ClaimLinkNode',
         iss: nodesUtils.encodeNodeId(requestingNodeId),
@@ -1436,7 +1437,7 @@ class NodeManager {
         const halfSignedClaim = token.toSigned();
         const halfSignedClaimEncoded =
           claimsUtils.generateSignedClaim(halfSignedClaim);
-        halfSignedClaimProm.resolveP(halfSignedClaimEncoded);
+        halfSignedClaimResolveP(halfSignedClaimEncoded);
         const readStatus = await input.next();
         if (readStatus.done) {
           throw new claimsErrors.ErrorEmptyStream();
@@ -1462,10 +1463,11 @@ class NodeManager {
         return fullySignedToken;
       },
     );
+    void claimP.catch(() => {});
     yield {
-      signedTokenEncoded: await halfSignedClaimProm.p,
+      signedTokenEncoded: await halfSignedClaimP,
     };
-    const [, claim] = await claimProm;
+    const [, claim] = await claimP;
     // With the claim created we want to add it to the gestalt graph
     const issNodeInfo = {
       nodeId: requestingNodeId,

src/nodes/utils.ts

@@ -314,6 +314,7 @@ function generateRandomNodeIdForBucket(
  * This is generally used to check the connection has failed
  * before cleaning it up.
  */
+// FIXME: need to include ErrorQUICConnectionIdleTimeout error in this list.
 function isConnectionError(e): boolean {
   return (
     e instanceof nodesErrors.ErrorNodeConnectionDestroyed ||