Rewrite encode/decode logic to use BigInt and bitwise operators.

.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [10.x, 12.x, 14.x, 15.x]
+        node-version: [22.x, 23.x, 24.x]
 
     steps:
       - uses: actions/checkout@v2
@@ -28,7 +28,9 @@ jobs:
         run: npm test
 
       - name: Code Coverage on Node LTS version
-        if: ${{ matrix.node-version == '14.x' }}
-        uses: codecov/codecov-action@v1
+        if: ${{ matrix.node-version == '22.x' }}
+        uses: codecov/codecov-action@v5
         with:
           fail_ci_if_error: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

jest.config.ts

@@ -7,6 +7,7 @@ export default async (): Promise<Config.InitialOptions> => {
     testEnvironment: 'node',
     coverageDirectory: './coverage/',
     collectCoverage: true,
+    testPathIgnorePatterns: ['<rootDir>/src/Aclatraz.performance.test.ts'],
     coverageThreshold: {
       global: {
         branches: 100,

package.json

@@ -3,6 +3,9 @@
   "version": "0.1.4",
   "description": "Simple dependency-free package for ACL. It can handle hundreds of roles easily.",
   "main": "lib/index.js",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "scripts": {
     "build": "rimraf ./lib && tsc",
     "test": "jest",
@@ -35,18 +38,18 @@
   },
   "homepage": "https://github.com/PoOwAa/aclatraz#readme",
   "devDependencies": {
-    "@types/jest": "^26.0.20",
-    "@types/node": "^14.14.29",
-    "@typescript-eslint/eslint-plugin": "^4.15.1",
-    "@typescript-eslint/parser": "^4.15.1",
-    "eslint": "^7.20.0",
-    "eslint-config-prettier": "^7.2.0",
-    "eslint-plugin-jest": "^24.1.5",
-    "jest": "^26.6.3",
-    "np": "^7.4.0",
-    "rimraf": "^3.0.2",
-    "ts-jest": "^26.5.1",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.1.5"
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.11.30",
+    "@typescript-eslint/eslint-plugin": "^7.7.0",
+    "@typescript-eslint/parser": "^7.7.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-jest": "^27.9.0",
+    "jest": "^29.7.0",
+    "np": "^8.0.4",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
   }
-}
+}

src/Aclatraz.performance.test.ts

@@ -0,0 +1,144 @@
+import { performance } from 'perf_hooks';
+import { Aclatraz } from './Aclatraz';
+
+describe('Aclatraz performance test', () => {
+  test('generate permission code for 10,000 rules', () => {
+    const rules = [];
+    for (let i = 1; i <= 10000; i++) {
+      rules.push({ id: i, slug: `rule${i}` });
+    }
+    const acl = new Aclatraz(rules);
+
+    const ruleIds = Array.from({ length: 10000 }, (_, i) => i + 1);
+
+    const start = performance.now();
+    const code = acl.generateAclCode(ruleIds);
+    const end = performance.now();
+
+    console.log(`Generated code length: ${code.length}`);
+    console.log(`Time taken: ${(end - start).toFixed(2)} ms`);
+
+    expect(typeof code).toBe('string');
+  });
+
+  test('grantPermission 100,000 times', () => {
+    const rules = [];
+    for (let i = 1; i <= 100; i++) {
+      rules.push({ id: i, slug: `rule${i}` });
+    }
+    const acl = new Aclatraz(rules);
+    const ruleIds = Array.from({ length: 100 }, (_, i) => i + 1);
+
+    const start = performance.now();
+    for (let i = 0; i < 100000; i++) {
+      acl.grantPermission('', ruleIds);
+    }
+    const end = performance.now();
+    console.log(
+      `grantPermission 100,000 times took: ${(end - start).toFixed(2)} ms`
+    );
+    expect(true).toBe(true);
+  });
+
+  test('verify (decode) 100,000 times', () => {
+    const rules = [];
+    for (let i = 1; i <= 100; i++) {
+      rules.push({ id: i, slug: `rule${i}` });
+    }
+    const acl = new Aclatraz(rules);
+    const ruleIds = Array.from({ length: 100 }, (_, i) => i + 1);
+    const permission = acl.grantPermission('', ruleIds);
+
+    const start = performance.now();
+    for (let i = 0; i < 100000; i++) {
+      acl.verify(permission, 50); // Arbitrary ruleId in the middle
+    }
+    const end = performance.now();
+    console.log(
+      `verify (decode) 100,000 times took: ${(end - start).toFixed(2)} ms`
+    );
+    expect(true).toBe(true);
+  });
+
+  test('revokePermission 100,000 times', () => {
+    const rules = [];
+    for (let i = 1; i <= 100; i++) {
+      rules.push({ id: i, slug: `rule${i}` });
+    }
+    const acl = new Aclatraz(rules);
+    const ruleIds = Array.from({ length: 100 }, (_, i) => i + 1);
+    const permission = acl.grantPermission('', ruleIds);
+
+    const start = performance.now();
+    for (let i = 0; i < 100000; i++) {
+      acl.revokePermission(permission, [50]); // Arbitrary ruleId
+    }
+    const end = performance.now();
+    console.log(
+      `revokePermission 100,000 times took: ${(end - start).toFixed(2)} ms`
+    );
+    expect(true).toBe(true);
+  });
+
+  test('grantPermission with 100,000 rules', () => {
+    const rules = [];
+    for (let i = 1; i <= 100000; i++) {
+      rules.push({ id: i, slug: `rule${i}` });
+    }
+    const acl = new Aclatraz(rules);
+    const ruleIds = Array.from({ length: 100000 }, (_, i) => i + 1);
+
+    const start = performance.now();
+    const permission = acl.grantPermission('', ruleIds);
+    const end = performance.now();
+    console.log(
+      `grantPermission with 100,000 rules took: ${(end - start).toFixed(
+        2
+      )} ms, token length: ${permission.length}`
+    );
+    expect(typeof permission).toBe('string');
+  });
+
+  test('verify (decode) with 100,000 rules', () => {
+    const rules = [];
+    for (let i = 1; i <= 100000; i++) {
+      rules.push({ id: i, slug: `rule${i}` });
+    }
+    const acl = new Aclatraz(rules);
+    const ruleIds = Array.from({ length: 100000 }, (_, i) => i + 1);
+    const permission = acl.grantPermission('', ruleIds);
+
+    const start = performance.now();
+    let count = 0;
+    for (let i = 1; i <= 100000; i += 10000) {
+      if (acl.verify(permission, i)) count++;
+    }
+    const end = performance.now();
+    console.log(
+      `verify (decode) with 100,000 rules (checked every 10,000th): ${(
+        end - start
+      ).toFixed(2)} ms, found: ${count}`
+    );
+    expect(count).toBe(10);
+  });
+
+  test('revokePermission with 100,000 rules', () => {
+    const rules = [];
+    for (let i = 1; i <= 100000; i++) {
+      rules.push({ id: i, slug: `rule${i}` });
+    }
+    const acl = new Aclatraz(rules);
+    const ruleIds = Array.from({ length: 100000 }, (_, i) => i + 1);
+    const permission = acl.grantPermission('', ruleIds);
+
+    const start = performance.now();
+    const revoked = acl.revokePermission(permission, [50000, 99999, 100000]);
+    const end = performance.now();
+    console.log(
+      `revokePermission with 100,000 rules took: ${(end - start).toFixed(
+        2
+      )} ms, token length: ${revoked.length}`
+    );
+    expect(typeof revoked).toBe('string');
+  });
+});