refactor: replace q.promise with native promise and remove q package

Author: rocwind

package.json

@@ -45,7 +45,6 @@
     "progress": "^1.1.8",
     "prompt": "^0.2.14",
     "properties": "^1.2.1",
-    "q": "~1.4.1",
     "recursive-fs": "0.1.4",
     "rimraf": "^3.0.2",
     "semver": "^7.3.2",

src/definitions/cli.ts

@@ -219,7 +219,7 @@ export type ReleaseHook = (
   currentCommand: IReleaseCommand,
   originalCommand: IReleaseCommand,
   sdk: AccountManager
-) => Q.Promise<IReleaseCommand | void>;
+) => Promise<IReleaseCommand | void>;
 
 export interface ReleaseFile {
   sourceLocation: string; // The current location of the file on disk

src/release-hooks/core-release.ts

@@ -2,8 +2,6 @@ import fs from "fs";
 import path from "path";
 import recursiveFs from "recursive-fs";
 import slash = require("slash");
-import Q from "q";
-import Promise = Q.Promise;
 import yazl from "yazl";
 var progress = require("progress");
 
@@ -19,7 +17,7 @@ var coreReleaseHook: cli.ReleaseHook = (
   originalCommand: cli.IReleaseCommand,
   sdk: AccountManager
 ): Promise<cli.IReleaseCommand> => {
-  return Q(<void>null)
+  return Promise.resolve(<void>null)
     .then(() => {
       var releaseFiles: ReleaseFile[] = [];
 
@@ -28,36 +26,35 @@ var coreReleaseHook: cli.ReleaseHook = (
           sourceLocation: currentCommand.package,
           targetLocation: path.basename(currentCommand.package), // Put the file in the root
         });
-        return Q(releaseFiles);
+        return Promise.resolve(releaseFiles);
       }
 
-      var deferred = Q.defer<ReleaseFile[]>();
-      var directoryPath: string = currentCommand.package;
-      var baseDirectoryPath = path.join(directoryPath, ".."); // For legacy reasons, put the root directory in the zip
+      return new Promise<ReleaseFile[]>((resolve, reject) => {
+        var directoryPath: string = currentCommand.package;
+        var baseDirectoryPath = path.join(directoryPath, ".."); // For legacy reasons, put the root directory in the zip
 
-      recursiveFs.readdirr(currentCommand.package, (error?: any, directories?: string[], files?: string[]): void => {
-        if (error) {
-          deferred.reject(error);
-          return;
-        }
+        recursiveFs.readdirr(currentCommand.package, (error?: any, directories?: string[], files?: string[]): void => {
+          if (error) {
+            reject(error);
+            return;
+          }
 
-        files.forEach((filePath: string) => {
-          var relativePath: string = path.relative(baseDirectoryPath, filePath);
-          // yazl does not like backslash (\) in the metadata path.
-          relativePath = slash(relativePath);
-          releaseFiles.push({
-            sourceLocation: filePath,
-            targetLocation: relativePath,
+          files.forEach((filePath: string) => {
+            var relativePath: string = path.relative(baseDirectoryPath, filePath);
+            // yazl does not like backslash (\) in the metadata path.
+            relativePath = slash(relativePath);
+            releaseFiles.push({
+              sourceLocation: filePath,
+              targetLocation: relativePath,
+            });
           });
-        });
 
-        deferred.resolve(releaseFiles);
+          resolve(releaseFiles);
+        });
       });
-
-      return deferred.promise;
     })
     .then((releaseFiles: ReleaseFile[]) => {
-      return Promise<string>((resolve: (file: string) => void, reject: (reason: Error) => void): void => {
+      return new Promise<string>((resolve, reject): void => {
         var packagePath: string = path.join(process.cwd(), generateRandomFilename(15) + ".zip");
         var zipFile = new yazl.ZipFile();
         var writeStream: fs.WriteStream = fs.createWriteStream(packagePath);

src/release-hooks/signing.ts

@@ -3,7 +3,6 @@ import fs from "fs";
 import jwt from "jsonwebtoken";
 import os from "os";
 import path from "path";
-import q from "q";
 import * as rimraf from "rimraf";
 import { generatePackageHashFromDirectory } from "../lib/hash-utils";
 
@@ -17,7 +16,7 @@ interface CodeSigningClaims {
   contentHash: string;
 }
 
-const deletePreviousSignatureIfExists = (targetPackage: string): q.Promise<any> => {
+const deletePreviousSignatureIfExists = (targetPackage: string): Promise<any> => {
   let signatureFilePath: string = path.join(targetPackage, METADATA_FILE_NAME);
   let prevSignatureExists: boolean = true;
   try {
@@ -26,7 +25,7 @@ const deletePreviousSignatureIfExists = (targetPackage: string): q.Promise<any>
     if (err.code === "ENOENT") {
       prevSignatureExists = false;
     } else {
-      return q.reject(
+      return Promise.reject(
         new Error(
           `Could not delete previous release signature at ${signatureFilePath}.
                 Please, check your access rights.`
@@ -40,35 +39,35 @@ const deletePreviousSignatureIfExists = (targetPackage: string): q.Promise<any>
     rimraf.sync(signatureFilePath);
   }
 
-  return q.resolve(<void>null);
+  return Promise.resolve(<void>null);
 };
 
 var sign: cli.ReleaseHook = (
   currentCommand: cli.IReleaseCommand,
   originalCommand: cli.IReleaseCommand,
   sdk: AccountManager
-): q.Promise<cli.IReleaseCommand> => {
+): Promise<cli.IReleaseCommand> => {
   if (!currentCommand.privateKeyPath) {
     if (fs.lstatSync(currentCommand.package).isDirectory()) {
       // If new update wasn't signed, but signature file for some reason still appears in the package directory - delete it
       return deletePreviousSignatureIfExists(currentCommand.package).then(() => {
-        return q.resolve<cli.IReleaseCommand>(currentCommand);
+        return Promise.resolve<cli.IReleaseCommand>(currentCommand);
       });
     } else {
-      return q.resolve<cli.IReleaseCommand>(currentCommand);
+      return Promise.resolve<cli.IReleaseCommand>(currentCommand);
     }
   }
 
   let privateKey: Buffer;
   let signatureFilePath: string;
 
-  return q(<void>null)
+  return Promise.resolve(<void>null)
     .then(() => {
       signatureFilePath = path.join(currentCommand.package, METADATA_FILE_NAME);
       try {
         privateKey = fs.readFileSync(currentCommand.privateKeyPath);
       } catch (err) {
-        return q.reject(new Error(`The path specified for the signing key ("${currentCommand.privateKeyPath}") was not valid`));
+        return Promise.reject(new Error(`The path specified for the signing key ("${currentCommand.privateKeyPath}") was not valid`));
       }
 
       if (!fs.lstatSync(currentCommand.package).isDirectory()) {
@@ -89,39 +88,45 @@ var sign: cli.ReleaseHook = (
       return generatePackageHashFromDirectory(currentCommand.package, path.join(currentCommand.package, ".."));
     })
     .then((hash: string) => {
-      var claims: CodeSigningClaims = {
-        claimVersion: CURRENT_CLAIM_VERSION,
-        contentHash: hash,
-      };
-
-      return q
-        .nfcall<string>(jwt.sign, claims, privateKey, {
-          algorithm: "RS256",
-        })
-        .catch((err: Error) => {
-          return q.reject<string>(new Error("The specified signing key file was not valid"));
-        });
+      return new Promise<string>((resolve, reject) => {
+        const claims: CodeSigningClaims = {
+          claimVersion: CURRENT_CLAIM_VERSION,
+          contentHash: hash,
+        };
+
+        jwt.sign(
+          claims,
+          privateKey,
+          {
+            algorithm: "RS256",
+          },
+          (err, token) => {
+            if (err) {
+              return reject(new Error("The specified signing key file was not valid"));
+            }
+            resolve(token);
+          }
+        );
+      });
     })
     .then((signedJwt: string) => {
-      var deferred = q.defer<void>();
-
-      fs.writeFile(signatureFilePath, signedJwt, (err: Error) => {
-        if (err) {
-          deferred.reject(err);
-        } else {
-          console.log(`Generated a release signature and wrote it to ${signatureFilePath}`);
-          deferred.resolve(<void>null);
-        }
+      return new Promise<void>((resolve, reject) => {
+        fs.writeFile(signatureFilePath, signedJwt, (err: Error) => {
+          if (err) {
+            reject(err);
+          } else {
+            console.log(`Generated a release signature and wrote it to ${signatureFilePath}`);
+            resolve(<void>null);
+          }
+        });
       });
-
-      return deferred.promise;
     })
     .then(() => {
       return currentCommand;
     })
     .catch((err: Error) => {
       err.message = `Could not sign package: ${err.message}`;
-      return q.reject<cli.IReleaseCommand>(err);
+      return Promise.reject<cli.IReleaseCommand>(err);
     });
 };