apeframework 0.0.0-dev.26 → 0.0.0-dev.28

package/dist/pwd/Algorithm.d.ts

@@ -0,0 +1,6 @@
+declare enum Algorithm {
+    ARGON2D = 0,
+    ARGON2I = 1,
+    ARGON2ID = 2
+}
+export { Algorithm, };

package/dist/pwd/Algorithm.js

@@ -0,0 +1,7 @@
+var Algorithm;
+(function (Algorithm) {
+    Algorithm[Algorithm["ARGON2D"] = 0] = "ARGON2D";
+    Algorithm[Algorithm["ARGON2I"] = 1] = "ARGON2I";
+    Algorithm[Algorithm["ARGON2ID"] = 2] = "ARGON2ID";
+})(Algorithm || (Algorithm = {}));
+export { Algorithm, };

package/dist/pwd/Pwd.d.ts

@@ -1,7 +1,16 @@
+import type { Algorithm } from './Algorithm.js';
 declare class Pwd {
-    private readonly hashRounds;
+    private readonly algorithm;
+    private readonly hashLength;
+    private readonly timeCost;
+    private readonly memoryCost;
+    private readonly parallelism;
     constructor(params: {
-        hashRounds: number;
+        algorithm?: Algorithm;
+        hashLength?: number;
+        timeCost?: number;
+        memoryCost?: number;
+        parallelism?: number;
     });
     hashPassword(password: string): Promise<string>;
     verifyPassword(password: string, hash: string): Promise<boolean>;

package/dist/pwd/Pwd.js

@@ -1,16 +1,36 @@
-import bcrypt from 'bcryptjs';
-import { validateHashRounds } from './validateHashRounds.js';
+import argon2 from 'argon2';
+import { validateHashLength } from './validateHashLength.js';
+import { validateMemoryCost } from './validateMemoryCost.js';
+import { validateParallelism } from './validateParallelism.js';
+import { validateTimeCost } from './validateTimeCost.js';
 class Pwd {
-    hashRounds;
+    algorithm;
+    hashLength;
+    timeCost;
+    memoryCost;
+    parallelism;
     constructor(params) {
-        validateHashRounds(params.hashRounds);
-        this.hashRounds = params.hashRounds;
+        this.algorithm = params.algorithm;
+        validateHashLength(params.hashLength);
+        this.hashLength = params.hashLength;
+        validateTimeCost(params.timeCost);
+        this.timeCost = params.timeCost;
+        validateMemoryCost(params.memoryCost);
+        this.memoryCost = params.memoryCost;
+        validateParallelism(params.parallelism);
+        this.parallelism = params.parallelism;
     }
     async hashPassword(password) {
-        return bcrypt.hashSync(password, this.hashRounds);
+        return argon2.hash(password, {
+            ...this.algorithm ? { type: this.algorithm } : {},
+            hashLength: this.hashLength,
+            timeCost: this.timeCost,
+            memoryCost: this.memoryCost,
+            parallelism: this.parallelism,
+        });
     }
     async verifyPassword(password, hash) {
-        return bcrypt.compareSync(password, hash);
+        return argon2.verify(hash, password);
     }
 }
 export { Pwd, };

package/dist/pwd/errors/HashLengthError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError.js';
+declare class HashLengthError extends BaseError {
+    constructor(hashLength: number);
+}
+export { HashLengthError, };

package/dist/pwd/errors/HashLengthError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class HashLengthError extends BaseError {
+    constructor(hashLength) {
+        super(`invalid hash length "${hashLength}"`);
+    }
+}
+export { HashLengthError, };

package/dist/pwd/errors/MemoryCostError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError.js';
+declare class MemoryCostError extends BaseError {
+    constructor(memoryCost: number);
+}
+export { MemoryCostError, };

package/dist/pwd/errors/MemoryCostError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class MemoryCostError extends BaseError {
+    constructor(memoryCost) {
+        super(`invalid memory cost "${memoryCost}"`);
+    }
+}
+export { MemoryCostError, };

package/dist/pwd/errors/ParallelismError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError.js';
+declare class ParallelismError extends BaseError {
+    constructor(parallelism: number);
+}
+export { ParallelismError, };

package/dist/pwd/errors/ParallelismError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class ParallelismError extends BaseError {
+    constructor(parallelism) {
+        super(`invalid parallelism "${parallelism}"`);
+    }
+}
+export { ParallelismError, };

package/dist/pwd/errors/TimeCostError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError.js';
+declare class TimeCostError extends BaseError {
+    constructor(timeCost: number);
+}
+export { TimeCostError, };

package/dist/pwd/errors/TimeCostError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class TimeCostError extends BaseError {
+    constructor(timeCost) {
+        super(`invalid time cost "${timeCost}"`);
+    }
+}
+export { TimeCostError, };

package/dist/pwd/validateHashLength.d.ts

@@ -0,0 +1,2 @@
+declare const validateHashLength: (hashLength?: number) => void;
+export { validateHashLength, };

package/dist/pwd/validateHashLength.js

@@ -0,0 +1,7 @@
+import { HashLengthError } from './errors/HashLengthError.js';
+const validateHashLength = (hashLength) => {
+    if (hashLength && hashLength < 4) {
+        throw new HashLengthError(hashLength);
+    }
+};
+export { validateHashLength, };

package/dist/pwd/validateMemoryCost.d.ts

@@ -0,0 +1,2 @@
+declare const validateMemoryCost: (memoryCost?: number) => void;
+export { validateMemoryCost, };

package/dist/pwd/validateMemoryCost.js

@@ -0,0 +1,7 @@
+import { MemoryCostError } from './errors/MemoryCostError.js';
+const validateMemoryCost = (memoryCost) => {
+    if (memoryCost && memoryCost < 1024) {
+        throw new MemoryCostError(memoryCost);
+    }
+};
+export { validateMemoryCost, };

package/dist/pwd/validateParallelism.d.ts

@@ -0,0 +1,2 @@
+declare const validateParallelism: (parallelism?: number) => void;
+export { validateParallelism, };

package/dist/pwd/validateParallelism.js

@@ -0,0 +1,7 @@
+import { ParallelismError } from './errors/ParallelismError.js';
+const validateParallelism = (parallelism) => {
+    if (parallelism && parallelism < 1) {
+        throw new ParallelismError(parallelism);
+    }
+};
+export { validateParallelism, };

package/dist/pwd/validateTimeCost.d.ts

@@ -0,0 +1,2 @@
+declare const validateTimeCost: (timeCost?: number) => void;
+export { validateTimeCost, };

package/dist/pwd/validateTimeCost.js

@@ -0,0 +1,7 @@
+import { TimeCostError } from './errors/TimeCostError.js';
+const validateTimeCost = (timeCost) => {
+    if (timeCost && timeCost < 2) {
+        throw new TimeCostError(timeCost);
+    }
+};
+export { validateTimeCost, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apeframework",
-  "version": "0.0.0-dev.26",
+  "version": "0.0.0-dev.28",
   "publishConfig": {
     "access": "public"
   },
@@ -30,7 +30,7 @@
     "@types/nodemailer": "^6.4",
     "@types/yargs-parser": "^21.0",
     "ajv": "^8.17",
-    "bcryptjs": "^3.0",
+    "argon2": "^0.41",
     "bullmq": "^5.49",
     "dotenv": "^16.5",
     "fast-uri": "^3.0",
@@ -518,22 +518,64 @@
         "default": "./dist/parser/parseString.js"
       }
     },
+    "./pwd/Algorithm": {
+      "import": {
+        "types": "./dist/pwd/Algorithm.d.ts",
+        "default": "./dist/pwd/Algorithm.js"
+      }
+    },
     "./pwd/Pwd": {
       "import": {
         "types": "./dist/pwd/Pwd.d.ts",
         "default": "./dist/pwd/Pwd.js"
       }
     },
-    "./pwd/errors/HashRoundsError": {
+    "./pwd/errors/HashLengthError": {
+      "import": {
+        "types": "./dist/pwd/errors/HashLengthError.d.ts",
+        "default": "./dist/pwd/errors/HashLengthError.js"
+      }
+    },
+    "./pwd/errors/MemoryCostError": {
+      "import": {
+        "types": "./dist/pwd/errors/MemoryCostError.d.ts",
+        "default": "./dist/pwd/errors/MemoryCostError.js"
+      }
+    },
+    "./pwd/errors/ParallelismError": {
+      "import": {
+        "types": "./dist/pwd/errors/ParallelismError.d.ts",
+        "default": "./dist/pwd/errors/ParallelismError.js"
+      }
+    },
+    "./pwd/errors/TimeCostError": {
+      "import": {
+        "types": "./dist/pwd/errors/TimeCostError.d.ts",
+        "default": "./dist/pwd/errors/TimeCostError.js"
+      }
+    },
+    "./pwd/validateHashLength": {
+      "import": {
+        "types": "./dist/pwd/validateHashLength.d.ts",
+        "default": "./dist/pwd/validateHashLength.js"
+      }
+    },
+    "./pwd/validateMemoryCost": {
+      "import": {
+        "types": "./dist/pwd/validateMemoryCost.d.ts",
+        "default": "./dist/pwd/validateMemoryCost.js"
+      }
+    },
+    "./pwd/validateParallelism": {
       "import": {
-        "types": "./dist/pwd/errors/HashRoundsError.d.ts",
-        "default": "./dist/pwd/errors/HashRoundsError.js"
+        "types": "./dist/pwd/validateParallelism.d.ts",
+        "default": "./dist/pwd/validateParallelism.js"
       }
     },
-    "./pwd/validateHashRounds": {
+    "./pwd/validateTimeCost": {
       "import": {
-        "types": "./dist/pwd/validateHashRounds.d.ts",
-        "default": "./dist/pwd/validateHashRounds.js"
+        "types": "./dist/pwd/validateTimeCost.d.ts",
+        "default": "./dist/pwd/validateTimeCost.js"
       }
     },
     "./server/ErrorHandler": {

package/dist/pwd/errors/HashRoundsError.d.ts

@@ -1,5 +0,0 @@
-import { BaseError } from '../../error/BaseError.js';
-declare class HashRoundsError extends BaseError {
-    constructor(hashRounds: number);
-}
-export { HashRoundsError, };

package/dist/pwd/errors/HashRoundsError.js

@@ -1,7 +0,0 @@
-import { BaseError } from '../../error/BaseError.js';
-class HashRoundsError extends BaseError {
-    constructor(hashRounds) {
-        super(`invalid hash rounds "${hashRounds}"`);
-    }
-}
-export { HashRoundsError, };

package/dist/pwd/validateHashRounds.d.ts

@@ -1,2 +0,0 @@
-declare const validateHashRounds: (hashRounds: number) => void;
-export { validateHashRounds, };

package/dist/pwd/validateHashRounds.js

@@ -1,7 +0,0 @@
-import { HashRoundsError } from './errors/HashRoundsError.js';
-const validateHashRounds = (hashRounds) => {
-    if (hashRounds < 1) {
-        throw new HashRoundsError(hashRounds);
-    }
-};
-export { validateHashRounds, };