auth0-password-policies 2.2.0 → 3.1.0

package/.github/workflows/publish.yml

@@ -68,9 +68,9 @@ jobs:
           fi
 
       - name: Setup Node
-        uses: actions/setup-node@5e2628c959b9ade56971c0afcebbe5332d44b398 # Aug 2025
+        uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238  # v6.2.0
         with:
-          node-version: 20
+          node-version: 24
           cache: 'yarn'
           registry-url: 'https://registry.npmjs.org'
 
@@ -95,6 +95,4 @@ jobs:
         shell: bash
         run: |
           echo "About to run: npm publish --provenance --tag ${{ steps.npm-tag.outputs.tag }}"
-          npm publish --provenance --tag ${{ steps.npm-tag.outputs.tag }}
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN="" npm publish --provenance --tag ${{ steps.npm-tag.outputs.tag }}

package/index.js

@@ -43,64 +43,56 @@ const CHARACTER_TYPES = {
 };
 
 /**
- * @typedef {Object} PasswordOptions
- * @property {number} [min_length=15] - Minimum password length (1-72)
- * @property {Array<'uppercase'|'lowercase'|'number'|'special'>} [character_types=[]] - Required character types
- * @property {'all'|'three_of_four'} [character_type_rule='all'] - How many character types are required
- * @property {'allow'|'block'} [identical_characters='allow'] - Whether to allow >2 identical consecutive characters
- * @property {'allow'|'block'} [sequential_characters='allow'] - Whether to allow sequential_characters (increasing or decreasing) alphanumeric characters.
- * @property {'error'|'truncate'} [max_length_exceeded='error'] - Behavior when password exceeds max length of 72 bytes
+ * @typedef {Object} PasswordComplexityOptions
+ * @property {number} min_length - Minimum password length (1-72)
+ * @property {Array<'uppercase'|'lowercase'|'number'|'special'>} character_types - Required character types
+ * @property {'all'|'three_of_four'} character_type_rule - How many character types are required
+ * @property {'allow'|'block'} identical_characters - Whether to allow >2 identical consecutive characters
+ * @property {'allow'|'block'} sequential_characters - Whether to allow sequential alphanumeric characters
+ * @property {'error'|'truncate'} max_length_exceeded - Behavior when password exceeds max length of 72 bytes
  */
 
-/**
- * Default values for password options
- * @constant
- * @type {PasswordOptions}
- */
-const DEFAULT_PASSWORD_OPTIONS = {
-  min_length: 15,
-  character_types: [],
-  character_type_rule: "all",
-  identical_characters: "allow",
-  sequential_characters: "allow",
-  max_length_exceeded: "error"
-};
-
 /**
  * Creates a PasswordPolicy rules configuration from an Auth0
  * `connection.options.password_options.complexity` object.
  *
- * @param {PasswordOptions} options - Auth0 password_options.complexity object
+ * @param {PasswordComplexityOptions} options - Auth0 password complexity configuration
  * @returns {Object} password-sheriff rules configuration object that can be passed to PasswordPolicy constructor
  */
-function createRulesFromOptions(options = {}) {
+function createRulesFromOptions(options) {
+  if (!options || typeof options !== 'object') {
+    throw new Error("options must be a PasswordComplexity object");
+  }
+
   const rules = {};
 
-  // Apply defaults
   const {
     min_length: minLength,
     character_types: requiredTypes,
     character_type_rule: characterTypeRule,
     identical_characters: identicalChars,
     sequential_characters: sequentialChars,
-    max_length_exceeded: maxLength
-  } = { ...DEFAULT_PASSWORD_OPTIONS, ...options };
+    max_length_exceeded: maxLengthExceeded
+  } = options;
 
-  // Validate min_length is within acceptable range
-  if (minLength < 1 || minLength > 72) {
-    throw new Error("min_length must be between 1 and 72");
-  }
+  const require3of4 = characterTypeRule === "three_of_four";
+
+  if (minLength !== undefined && minLength !== null) {
+    // Validate min_length is within acceptable range (if provided)
+    if (typeof minLength !== 'number' || minLength < 1 || minLength > 72) {
+      throw new Error("min_length must be between 1 and 72");
+    }
 
-  // Handle min_length
-  rules.length = { minLength: minLength };
+    // Handle min_length (if provided)
+    rules.length = { minLength: minLength };
+  }
 
   // Validate '3 of 4' prerequisite
-  const require3of4 = characterTypeRule === "three_of_four";
   if (require3of4) {
     const hasAllFourTypes = Object.values(CHARACTER_TYPES).every(function (
       type
     ) {
-      return requiredTypes.includes(type);
+      return requiredTypes?.includes(type);
     });
 
     if (!hasAllFourTypes) {
@@ -112,7 +104,7 @@ function createRulesFromOptions(options = {}) {
     }
   }
 
-  if (requiredTypes.length > 0 || require3of4) {
+  if (requiredTypes?.length > 0 || require3of4) {
     const expressions = [];
 
     if (require3of4) {
@@ -123,16 +115,16 @@ function createRulesFromOptions(options = {}) {
       };
     } else {
       // Map character types to expressions
-      if (requiredTypes.includes(CHARACTER_TYPES.LOWERCASE)) {
+      if (requiredTypes?.includes(CHARACTER_TYPES.LOWERCASE)) {
         expressions.push(lowerCase);
       }
-      if (requiredTypes.includes(CHARACTER_TYPES.UPPERCASE)) {
+      if (requiredTypes?.includes(CHARACTER_TYPES.UPPERCASE)) {
         expressions.push(upperCase);
       }
-      if (requiredTypes.includes(CHARACTER_TYPES.NUMBER)) {
+      if (requiredTypes?.includes(CHARACTER_TYPES.NUMBER)) {
         expressions.push(numbers);
       }
-      if (requiredTypes.includes(CHARACTER_TYPES.SPECIAL)) {
+      if (requiredTypes?.includes(CHARACTER_TYPES.SPECIAL)) {
         expressions.push(specialCharacters);
       }
 
@@ -150,7 +142,7 @@ function createRulesFromOptions(options = {}) {
     rules.sequentialChars = { max: 2 }
   }
   
-  if (maxLength === "error") {
+  if (maxLengthExceeded === "error") {
     rules.maxLength = { maxBytes: 72 };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auth0-password-policies",
-  "version": "2.2.0",
+  "version": "3.1.0",
   "main": "index.js",
   "repository": "git@github.com:auth0/auth0-password-policies.git",
   "author": "Shaun Starsprung <shaun.starsprung@auth0.com>",

package/test/test.js

@@ -23,7 +23,9 @@ describe("password policies", function () {
       it("should test min_length from 1 to 72", function () {
         const auth0Config1 = {
           min_length: 1,
+          character_types: [],
           identical_characters: "allow",
+          sequential_characters: "allow",
           max_length_exceeded: "truncate",
         };
         const rules = createRulesFromOptions(auth0Config1);
@@ -35,7 +37,9 @@ describe("password policies", function () {
 
         const auth0Config72 = {
           min_length: 72,
+          character_types: [],
           identical_characters: "allow",
+          sequential_characters: "allow",
           max_length_exceeded: "truncate",
         };
         const rules72 = createRulesFromOptions(auth0Config72);
@@ -54,14 +58,38 @@ describe("password policies", function () {
           createRulesFromOptions(auth0Config);
         }).toThrow("min_length must be between 1 and 72");
       });
+
+      it("should not set length rule when min_length is undefined", function () {
+        const auth0Config = {
+          character_types: [],
+          identical_characters: "allow",
+          sequential_characters: "allow",
+          max_length_exceeded: "truncate",
+        };
+        const rules = createRulesFromOptions(auth0Config);
+        expect(rules.length).toBeUndefined();
+      });
+
+      it("should not set length rule when min_length is null", function () {
+        const auth0Config = {
+          min_length: null,
+          character_types: [],
+          identical_characters: "allow",
+          sequential_characters: "allow",
+          max_length_exceeded: "truncate",
+        };
+        const rules = createRulesFromOptions(auth0Config);
+        expect(rules.length).toBeUndefined();
+      });
     });
 
     describe("character_types", function () {
       it("should enforce required character types", function () {
         const auth0Config = {
+          min_length: 4,
           character_types: ["lowercase", "uppercase", "number", "special"],
           identical_characters: "allow",
-          min_length: 4,
+          sequential_characters: "allow",
           max_length_exceeded: "truncate",
         };
         const rules = createRulesFromOptions(auth0Config);
@@ -78,15 +106,33 @@ describe("password policies", function () {
           expect(typeof expr.explain).toBe("function");
         });
       });
+
+      it("should handle undefined character_types", function () {
+        const auth0Config = {
+          min_length: 8,
+          identical_characters: "allow",
+          sequential_characters: "allow",
+          max_length_exceeded: "truncate",
+        };
+        const rules = createRulesFromOptions(auth0Config);
+        expect(rules).toEqual({
+          length: {
+            minLength: 8,
+          },
+        });
+        expect(rules).not.toHaveProperty("contains");
+        expect(rules).not.toHaveProperty("containsAtLeast");
+      });
     });
 
     describe("character_type_rule", function () {
       it("when set to 'three_of_four', should enforce 3 out of 4 character types when all 4 types are specified", function () {
         const auth0Config = {
+          min_length: 3,
           character_types: ["lowercase", "uppercase", "number", "special"],
           character_type_rule: "three_of_four",
           identical_characters: "allow",
-          min_length: 3,
+          sequential_characters: "allow",
           max_length_exceeded: "truncate",
         };
         const rules = createRulesFromOptions(auth0Config);
@@ -108,8 +154,11 @@ describe("password policies", function () {
       it("when set to 'three_of_four', should throw an error when all 4 character types are NOT specified", function () {
         expect(function () {
           const auth0Config = {
+            min_length: 8,
             character_types: ["lowercase", "uppercase"],
             character_type_rule: "three_of_four",
+            identical_characters: "allow",
+            sequential_characters: "allow",
             max_length_exceeded: "error",
           };
           createRulesFromOptions(auth0Config);
@@ -122,13 +171,16 @@ describe("password policies", function () {
     describe("identical_characters", function () {
       it("should disallow more than 2 identical characters when specified", function () {
         const auth0Config = {
+          min_length: 8,
+          character_types: [],
           identical_characters: "block",
+          sequential_characters: "allow",
           max_length_exceeded: "error",
         };
         const rules = createRulesFromOptions(auth0Config);
         expect(rules).toEqual({
           length: {
-            minLength: 15,
+            minLength: 8,
           },
           identicalChars: {
             max: 2,
@@ -141,13 +193,16 @@ describe("password policies", function () {
 
       it("should allow more than 2 identical characters when specified", function () {
         const auth0Config = {
+          min_length: 8,
+          character_types: [],
           identical_characters: "allow",
+          sequential_characters: "allow",
           max_length_exceeded: "error",
         };
         const rules = createRulesFromOptions(auth0Config);
         expect(rules).toEqual({
           length: {
-            minLength: 15,
+            minLength: 8,
           },
           maxLength: {
             maxBytes: 72,
@@ -159,12 +214,16 @@ describe("password policies", function () {
     describe("sequential_characters", function () {
       it("should disallow more than 2 sequential characters when specified (set to block)", function () {
         const auth0Config = {
+          min_length: 8,
+          character_types: [],
+          identical_characters: "allow",
           sequential_characters: "block",
+          max_length_exceeded: "error",
         };
         const rules = createRulesFromOptions(auth0Config);
         expect(rules).toEqual({
           length: {
-            minLength: 15,
+            minLength: 8,
           },
           sequentialChars: {
             max: 2,
@@ -177,12 +236,16 @@ describe("password policies", function () {
 
       it("should allow more than 2 sequential characters when specified (set to allow)", function () {
         const auth0Config = {
+          min_length: 8,
+          character_types: [],
+          identical_characters: "allow",
           sequential_characters: "allow",
+          max_length_exceeded: "error",
         };
         const rules = createRulesFromOptions(auth0Config);
         expect(rules).toEqual({
           length: {
-            minLength: 15,
+            minLength: 8,
           },
           maxLength: {
             maxBytes: 72,
@@ -193,7 +256,10 @@ describe("password policies", function () {
       it("should correctly validate a password when sequential_characters is set to allow", function () {
         const auth0Config = {
           min_length: 2,
+          character_types: [],
+          identical_characters: "allow",
           sequential_characters: "allow",
+          max_length_exceeded: "truncate",
         };
         const rules = createRulesFromOptions(auth0Config);
         const policy = new PasswordPolicy(rules);
@@ -204,7 +270,10 @@ describe("password policies", function () {
       it("should correctly validate a password when sequential_characters is set to block", function () {
         const auth0Config = {
           min_length: 2,
+          character_types: [],
+          identical_characters: "allow",
           sequential_characters: "block",
+          max_length_exceeded: "truncate",
         };
         const rules = createRulesFromOptions(auth0Config);
         const policy = new PasswordPolicy(rules);
@@ -217,12 +286,16 @@ describe("password policies", function () {
     describe("max_length_exceeded", function () {
       it("should disallow more than 72 bytes when creating password if max_length_exceeded is set to error", function () {
         const auth0Config = {
+          min_length: 8,
+          character_types: [],
+          identical_characters: "allow",
+          sequential_characters: "allow",
           max_length_exceeded: "error",
         };
         const rules = createRulesFromOptions(auth0Config);
         expect(rules).toEqual({
           length: {
-            minLength: 15,
+            minLength: 8,
           },
           maxLength: {
             maxBytes: 72,
@@ -232,12 +305,16 @@ describe("password policies", function () {
 
       it("should not set a maxLength on rules when max_length_exceeded is set to truncate", function () {
         const auth0Config = {
+          min_length: 8,
+          character_types: [],
+          identical_characters: "allow",
+          sequential_characters: "allow",
           max_length_exceeded: "truncate",
         };
         const rules = createRulesFromOptions(auth0Config);
         expect(rules).toEqual({
           length: {
-            minLength: 15,
+            minLength: 8,
           },
         });
       });
@@ -245,6 +322,9 @@ describe("password policies", function () {
       it("should correctly validate a password when max_length_exceeded is set to error", function () {
         const auth0Config = {
           min_length: 2,
+          character_types: [],
+          identical_characters: "allow",
+          sequential_characters: "allow",
           max_length_exceeded: "error",
         };
         const rules = createRulesFromOptions(auth0Config);
@@ -257,6 +337,9 @@ describe("password policies", function () {
       it("should correctly validate a password when max_length_exceeded is set to truncate", function () {
         const auth0Config = {
           min_length: 2,
+          character_types: [],
+          identical_characters: "allow",
+          sequential_characters: "allow",
           max_length_exceeded: "truncate",
         };
         const rules = createRulesFromOptions(auth0Config);
@@ -267,23 +350,24 @@ describe("password policies", function () {
       });
     });
 
-    describe("default values", function () {
-      it("should apply default values when not specified", function () {
+    describe("validation", function () {
+      it("should throw an error when options parameter is undefined", function () {
+        expect(function () {
+          const auth0Config = undefined;
+          createRulesFromOptions(auth0Config);
+        }).toThrow();
+      });
+
+      it("should accept valid configuration with empty options", function () {
         const auth0Config = {};
         const rules = createRulesFromOptions(auth0Config);
-        expect(rules).toEqual({
-          length: {
-            minLength: 15,
-          },
-          maxLength: {
-            maxBytes: 72,
-          },
-        });
+        expect(rules).toEqual({});
       });
 
-      it("should allow overriding default values", function () {
+      it("should accept valid configuration with all properties", function () {
         const auth0Config = {
           min_length: 5,
+          character_types: [],
           identical_characters: "allow",
           sequential_characters: "allow",
           max_length_exceeded: "truncate",