@nivinjoseph/n-sec 5.0.1 → 5.0.2

package/test/hash.test.ts

@@ -9,26 +9,27 @@ suite("Hash", () =>
     {
         test("must return a string value that is not null, empty, whitespace or same as input when called with a valid input", () =>
         {
-            let input = "hello world";
-            let hash = Hash.create(input);
+            const input = "hello world";
+            const hash = Hash.create(input);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hash, input);
         });
         
         test("multiple invocations with the same input must return the same output", () =>
         {
-            let input = "hello world";
-            let hash1 = Hash.create(input);
-            let hash2 = Hash.create(input);
+            const input = "hello world";
+            const hash1 = Hash.create(input);
+            const hash2 = Hash.create(input);
             Assert.strictEqual(hash1, hash2);
         });
         
         test("multiple invocations with the different inputs must return different outputs", () =>
         {
-            let input1 = "hello world";
-            let hash1 = Hash.create(input1);
-            let input2 = "goodbye world";
-            let hash2 = Hash.create(input2);
+            const input1 = "hello world";
+            const hash1 = Hash.create(input1);
+            const input2 = "goodbye world";
+            const hash2 = Hash.create(input2);
             Assert.notStrictEqual(hash1, hash2);
         });
         
@@ -93,9 +94,10 @@ suite("Hash", () =>
     {
         test("must return a string value that is not null, empty, whitespace or same as input or salt when called with a valid input and salt", () =>
         {
-            let input = "hello world";
-            let salt = "salt";
-            let hash = Hash.createUsingSalt(input, salt);
+            const input = "hello world";
+            const salt = "salt";
+            const hash = Hash.createUsingSalt(input, salt);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hash, input);
             Assert.notStrictEqual(hash, salt);
@@ -103,46 +105,46 @@ suite("Hash", () =>
 
         test("multiple invocations with the same input and salt must return the same output", () =>
         {
-            let input = "hello world";
-            let salt = "salt";
-            let hash1 = Hash.createUsingSalt(input, salt);
-            let hash2 = Hash.createUsingSalt(input, salt);
+            const input = "hello world";
+            const salt = "salt";
+            const hash1 = Hash.createUsingSalt(input, salt);
+            const hash2 = Hash.createUsingSalt(input, salt);
             Assert.strictEqual(hash1, hash2);
         });
 
         test("multiple invocations with different inputs and different salts must return different outputs", () =>
         {
-            let input1 = "hello world";
-            let salt1 = "salt-1";
-            let hash1 = Hash.createUsingSalt(input1, salt1);
+            const input1 = "hello world";
+            const salt1 = "salt-1";
+            const hash1 = Hash.createUsingSalt(input1, salt1);
             
-            let input2 = "goodbye world";
-            let salt2 = "salt-2";
-            let hash2 = Hash.createUsingSalt(input2, salt2);
+            const input2 = "goodbye world";
+            const salt2 = "salt-2";
+            const hash2 = Hash.createUsingSalt(input2, salt2);
             
             Assert.notStrictEqual(hash1, hash2);
         });
         
         test("multiple invocations with different inputs and the same salt must return different outputs", () =>
         {
-            let input1 = "hello world";
-            let salt1 = "salt-1";
-            let hash1 = Hash.createUsingSalt(input1, salt1);
+            const input1 = "hello world";
+            const salt1 = "salt-1";
+            const hash1 = Hash.createUsingSalt(input1, salt1);
 
-            let input2 = "goodbye world";
-            let hash2 = Hash.createUsingSalt(input2, salt1);
+            const input2 = "goodbye world";
+            const hash2 = Hash.createUsingSalt(input2, salt1);
 
             Assert.notStrictEqual(hash1, hash2);
         });
         
         test("multiple invocations with the same input and different salts must return different outputs", () =>
         {
-            let input = "hello world";
-            let salt1 = "salt-1";
-            let hash1 = Hash.createUsingSalt(input, salt1);
+            const input = "hello world";
+            const salt1 = "salt-1";
+            const hash1 = Hash.createUsingSalt(input, salt1);
 
-            let salt2 = "salt-2";
-            let hash2 = Hash.createUsingSalt(input, salt2);
+            const salt2 = "salt-2";
+            const hash2 = Hash.createUsingSalt(input, salt2);
 
             Assert.notStrictEqual(hash1, hash2);
         });

package/test/hmac.test.ts

@@ -9,9 +9,10 @@ suite("Hmac", () =>
     {
         test("should return string value that is not null, empty, whitespace or same as the key or input", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value = "hello world";
-            let hmac = Hmac.create(key, value);
+            const key = await SymmetricEncryption.generateKey();
+            const value = "hello world";
+            const hmac = Hmac.create(key, value);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(hmac !== null && !hmac.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hmac, key);
             Assert.notStrictEqual(hmac, value);
@@ -19,42 +20,42 @@ suite("Hmac", () =>
         
         test("multiple invocations with the same key and value must return the same output", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value = "hello world";
-            let hmac1 = Hmac.create(key, value);
-            let hmac2 = Hmac.create(key, value);
+            const key = await SymmetricEncryption.generateKey();
+            const value = "hello world";
+            const hmac1 = Hmac.create(key, value);
+            const hmac2 = Hmac.create(key, value);
             Assert.strictEqual(hmac1, hmac2);
         });
         
         test("multiple invocations with different keys and different values must return different outputs", async () =>
         {
-            let key1 = await SymmetricEncryption.generateKey();
-            let value1 = "hello world";
-            let hmac1 = Hmac.create(key1, value1);
+            const key1 = await SymmetricEncryption.generateKey();
+            const value1 = "hello world";
+            const hmac1 = Hmac.create(key1, value1);
             
-            let key2 = await SymmetricEncryption.generateKey();
-            let value2 = "goodbye world";
-            let hmac2 = Hmac.create(key2, value2);
+            const key2 = await SymmetricEncryption.generateKey();
+            const value2 = "goodbye world";
+            const hmac2 = Hmac.create(key2, value2);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         
         test("multiple invocations with the same key and different values must return different outputs", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value1 = "hello world";
-            let value2 = "goodbye world";
-            let hmac1 = Hmac.create(key, value1);
-            let hmac2 = Hmac.create(key, value2);
+            const key = await SymmetricEncryption.generateKey();
+            const value1 = "hello world";
+            const value2 = "goodbye world";
+            const hmac1 = Hmac.create(key, value1);
+            const hmac2 = Hmac.create(key, value2);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         
         test("multiple invocations with different keys and the same value must return different outputs", async () =>
         {
-            let key1 = await SymmetricEncryption.generateKey();
-            let key2 = await SymmetricEncryption.generateKey();
-            let value = "hello world";
-            let hmac1 = Hmac.create(key1, value);
-            let hmac2 = Hmac.create(key2, value);
+            const key1 = await SymmetricEncryption.generateKey();
+            const key2 = await SymmetricEncryption.generateKey();
+            const value = "hello world";
+            const hmac1 = Hmac.create(key1, value);
+            const hmac2 = Hmac.create(key2, value);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         

package/test/json-web-token.test.ts

@@ -14,11 +14,12 @@ suite("Json Web Token ", () =>
     
         test("should successfully create a token using hmac with one claim", async () =>
         {
-            let claim = new Claim("this_claim", "ThisValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
-            let jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            const claim = new Claim("this_claim", "ThisValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
+            const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -28,12 +29,13 @@ suite("Json Web Token ", () =>
 
         test("should successfully create a token using hmac with 2 claims", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
-            let jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -43,12 +45,13 @@ suite("Json Web Token ", () =>
 
         test("should successfully create a token using hmac with 2 claims", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
-            let jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -58,11 +61,11 @@ suite("Json Web Token ", () =>
 
         test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
             try
             {
                 JsonWebToken.fromToken("notTheIssuer", 1, key, token);
@@ -78,11 +81,11 @@ suite("Json Web Token ", () =>
         
         test("should throw an exception when getting JWT when the token is expired", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = JsonWebToken.fromClaims("issuer1", 1, key, time, [claim1, claim2]).generateToken();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time, [claim1, claim2]).generateToken();
             try
             {
                 JsonWebToken.fromToken("issuer1", 1, key, token);
@@ -120,12 +123,12 @@ suite("Json Web Token ", () =>
         
         test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let key2 = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const key2 = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
             try
             {
                 JsonWebToken.fromToken("issuer1", 1, key2, token);
@@ -141,10 +144,10 @@ suite("Json Web Token ", () =>
         
         test("should throw an exception when getting JWT when the token is tampered with", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
             let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
             token = token + "someStuff";
             try

package/test/other.test.ts

@@ -4,11 +4,11 @@ suite("Other", () =>
 {
     test("encoding decoding", () =>
     {
-        let text = "moonlight43iuj90/;msdnnksdkdkdk[[[][][";
-        let encodedText = Buffer.from(text, "utf8").toString("base64");
+        const text = "moonlight43iuj90/;msdnnksdkdkdk[[[][][";
+        const encodedText = Buffer.from(text, "utf8").toString("base64");
         Assert.notStrictEqual(encodedText, text);
         
-        let decodedText = Buffer.from(encodedText, "base64").toString("utf8");
+        const decodedText = Buffer.from(encodedText, "base64").toString("utf8");
         Assert.notStrictEqual(decodedText, encodedText);
         Assert.strictEqual(decodedText, text);
     });

package/test/symmetric-encryption.test.ts

@@ -10,16 +10,17 @@ suite("SymmetricEncryption", () =>
     { 
         test("must return string value that is not null, empty or whitespace", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
+            const key = await SymmetricEncryption.generateKey();
             console.log("key", key);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(key !== null && !key.isEmptyOrWhiteSpace());
         });
         
         
         test("consecutive calls must yield unique values", async () =>
         {
-            let key1 = await SymmetricEncryption.generateKey();
-            let key2 = await SymmetricEncryption.generateKey();
+            const key1 = await SymmetricEncryption.generateKey();
+            const key2 = await SymmetricEncryption.generateKey();
             Assert.notStrictEqual(key1, key2);
         });
     });    
@@ -28,9 +29,10 @@ suite("SymmetricEncryption", () =>
     { 
         test("must return cipher text value when called with key and plain text value", async () =>
         {
-            let key = "E25B269440F88601C453CD171D76EDDC11D8CF33230742DF8CAD5873D28F78B2";
-            let value = "password";
-            let encrypted = await SymmetricEncryption.encrypt(key, value);
+            const key = "E25B269440F88601C453CD171D76EDDC11D8CF33230742DF8CAD5873D28F78B2";
+            const value = "password";
+            const encrypted = await SymmetricEncryption.encrypt(key, value);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(encrypted !== null);
             Assert.notStrictEqual(encrypted, value);
         });
@@ -171,10 +173,10 @@ suite("SymmetricEncryption", () =>
     {
         test("must return plain text value when called with key and cipher text value", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value = "password";
-            let encrypted = await SymmetricEncryption.encrypt(key, value);
-            let decrypted = SymmetricEncryption.decrypt(key, encrypted);
+            const key = await SymmetricEncryption.generateKey();
+            const value = "password";
+            const encrypted = await SymmetricEncryption.encrypt(key, value);
+            const decrypted = SymmetricEncryption.decrypt(key, encrypted);
             Assert.strictEqual(decrypted, value);
         });
           

package/tsconfig.json

@@ -3,9 +3,9 @@
         "module": "commonjs",
         "target": "es2015",
         "strict": true,
-        "strictNullChecks": false,
-        "strictFunctionTypes": false,
-        "noImplicitThis": false,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "noImplicitThis": true,
         "noImplicitReturns": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
@@ -14,16 +14,13 @@
         "sourceMap": true,
         "experimentalDecorators": true,
         "emitDecoratorMetadata": true,
-        "removeComments": true,
+        "removeComments": false,
         "forceConsistentCasingInFileNames": true,
         "incremental": false,
+        "skipLibCheck": true,
+        "importHelpers": true,
+        "noEmitHelpers": true,
         "noImplicitOverride": true,
-        "plugins": [
-            {
-                "name": "typescript-tslint-plugin",
-                "configFile": "./tslint.json",
-                "alwaysShowRuleFailuresAsWarnings": false
-            }
-        ]
+        "pretty": true
     }
 }

package/dist/crypto/uuid.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uuid.js","sourceRoot":"","sources":["../../src/crypto/uuid.ts"],"names":[],"mappings":";;AAAA,6BAA6B;AAI7B,MAAa,IAAI;IAEb,gBAAwB,CAAC;IAGlB,MAAM,CAAC,MAAM;QAEhB,OAAO,IAAI,CAAC,EAAE,EAAE,CAAC;IACrB,CAAC;CACJ;AATD,oBASC","sourcesContent":["import * as uuid from \"uuid\";\n\n\n// public\nexport class Uuid\n{\n    private constructor() { }\n    \n    \n    public static create(): string\n    {\n        return uuid.v4();\n    }\n}"]}

package/tslint.json

@@ -1,64 +0,0 @@
-{
-    "defaultSeverity": "error",
-    "rules": {
-        "class-name": true,
-        "comment-format": [
-            true,
-            "check-space"
-        ],
-        "indent": [
-            true,
-            "spaces"
-        ],
-        "no-duplicate-variable": true,
-        "no-eval": true,
-        "no-internal-module": true,
-        "no-trailing-whitespace": false,
-        "no-var-keyword": true,
-        "no-default-export": true,
-        "one-line": [
-            true,
-            "check-whitespace"
-        ],
-        "quotemark": [
-            true,
-            "double"
-        ],
-        "semicolon": [
-            true,
-            "always"
-        ],
-        "triple-equals": [
-            true,
-            "allow-null-check"
-        ],
-        "typedef-whitespace": [
-            true,
-            {
-                "call-signature": "nospace",
-                "index-signature": "nospace",
-                "parameter": "nospace",
-                "property-declaration": "nospace",
-                "variable-declaration": "nospace"
-            }
-        ],
-        "variable-name": [
-            true,
-            "ban-keywords"
-        ],
-        "whitespace": [
-            true,
-            "check-branch",
-            "check-decl",
-            "check-operator",
-            "check-separator",
-            "check-type"
-        ],
-        "interface-name": [
-            true,
-            "never-prefix"
-        ],
-        "await-promise": true,
-        "no-floating-promises": true
-    }
-}