ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ದೃಢೀಕರಣ: ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಜೆಡಬ್ಲ್ಯೂಟಿ ಟೈಪ್ ಸೇಫ್ಟಿ ಮಾದರಿಗಳು

ಇಂದಿನ ಪರಸ್ಪರ ಸಂಪರ್ಕಿತ ಜಗತ್ತಿನಲ್ಲಿ, ಸುರಕ್ಷಿತ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು ಅತಿಮುಖ್ಯವಾಗಿದೆ. ದೃಢೀಕರಣ, ಅಂದರೆ ಬಳಕೆದಾರರ ಗುರುತನ್ನು ಪರಿಶೀಲಿಸುವ ಪ್ರಕ್ರಿಯೆಯು ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ರಕ್ಷಿಸುವಲ್ಲಿ ಮತ್ತು ಅಧಿಕೃತ ಪ್ರವೇಶವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವಲ್ಲಿ ನಿರ್ಣಾಯಕ ಪಾತ್ರ ವಹಿಸುತ್ತದೆ. JSON ವೆಬ್ ಟೋಕನ್‌ಗಳು (JWTs) ಅವುಗಳ ಸರಳತೆ ಮತ್ತು ಪೋರ್ಟಬಿಲಿಟಿಯಿಂದಾಗಿ ದೃಢೀಕರಣವನ್ನು ಅಳವಡಿಸಲು ಜನಪ್ರಿಯ ಆಯ್ಕೆಯಾಗಿವೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಬಲ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ, ಜೆಡಬ್ಲ್ಯೂಟಿ ದೃಢೀಕರಣವನ್ನು ಇನ್ನಷ್ಟು ದೃಢವಾಗಿ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದಂತೆ ಮಾಡಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ-ಪ್ರಮಾಣದ, ಅಂತರರಾಷ್ಟ್ರೀಯ ಯೋಜನೆಗಳಿಗೆ ಇದು ಹೆಚ್ಚು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಜೆಡಬ್ಲ್ಯೂಟಿ ದೃಢೀಕರಣಕ್ಕಾಗಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

ದೃಢೀಕರಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಹಲವಾರು ಅನುಕೂಲಗಳನ್ನು ತರುತ್ತದೆ:

• ಟೈಪ್ ಸುರಕ್ಷತೆ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸ್ಟಾಟಿಕ್ ಟೈಪಿಂಗ್ ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯ ಆರಂಭಿಕ ಹಂತಗಳಲ್ಲಿ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ರನ್‌ಟೈಮ್ ಆಶ್ಚರ್ಯಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ದೃಢೀಕರಣದಂತಹ ಭದ್ರತಾ-ಸೂಕ್ಷ್ಮ ಘಟಕಗಳಿಗೆ ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
• ಉತ್ತಮ ಕೋಡ್ ನಿರ್ವಹಣೆ: ಟೈಪ್‌ಗಳು ಸ್ಪಷ್ಟ ಒಪ್ಪಂದಗಳು ಮತ್ತು ದಾಖಲಾತಿಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ತೊಡಗಿರುವ ಸಂಕೀರ್ಣ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ.
• ವರ್ಧಿತ ಕೋಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಮತ್ತು ಟೂಲಿಂಗ್: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್-ಅರಿವಿರುವ ಐಡಿಇಗಳು ಉತ್ತಮ ಕೋಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ, ನ್ಯಾವಿಗೇಷನ್ ಮತ್ತು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪರಿಕರಗಳನ್ನು ನೀಡುತ್ತವೆ, ಇದು ಡೆವಲಪರ್ ಉತ್ಪಾದಕತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.
• ಕಡಿಮೆ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್: ಇಂಟರ್‌ಫೇಸ್‌ಗಳು ಮತ್ತು ಜೆನೆರಿಕ್‌ಗಳಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳು ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಕೋಡ್ ಮರುಬಳಕೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಜೆಡಬ್ಲ್ಯೂಟಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಜೆಡಬ್ಲ್ಯೂಟಿ ಎನ್ನುವುದು ಎರಡು ಪಕ್ಷಗಳ ನಡುವೆ ವರ್ಗಾಯಿಸಬೇಕಾದ ಕ್ಲೈಮ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕಾಂಪ್ಯಾಕ್ಟ್, URL-ಸುರಕ್ಷಿತ ವಿಧಾನವಾಗಿದೆ. ಇದು ಮೂರು ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

1. ಹೆಡರ್: ಅಲ್ಗಾರಿದಮ್ ಮತ್ತು ಟೋಕನ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
2. ಪೇಲೋಡ್: ಬಳಕೆದಾರರ ಐಡಿ, ಪಾತ್ರಗಳು ಮತ್ತು ಮುಕ್ತಾಯ ಸಮಯದಂತಹ ಕ್ಲೈಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
3. ಸಹಿ: ರಹಸ್ಯ ಕೀಯನ್ನು ಬಳಸಿಕೊಂಡು ಟೋಕನ್‌ನ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಜೆಡಬ್ಲ್ಯೂಟಿಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ದೃಢೀಕರಣಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಪ್ರತಿ ವಿನಂತಿಗೂ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪ್ರಶ್ನಿಸುವ ಅಗತ್ಯವಿಲ್ಲದೆ ಅವುಗಳನ್ನು ಸರ್ವರ್-ಸೈಡ್‌ನಲ್ಲಿ ಸುಲಭವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ನೇರವಾಗಿ ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಿರುತ್ಸಾಹಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಟೈಪ್-ಸುರಕ್ಷಿತ ಜೆಡಬ್ಲ್ಯೂಟಿ ದೃಢೀಕರಣವನ್ನು ಅಳವಡಿಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಟೈಪ್-ಸುರಕ್ಷಿತ ಜೆಡಬ್ಲ್ಯೂಟಿ ದೃಢೀಕರಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಕೆಲವು ಮಾದರಿಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.

1. ಇಂಟರ್‌ಫೇಸ್‌ಗಳೊಂದಿಗೆ ಪೇಲೋಡ್ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ನಿಮ್ಮ ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್‌ನ ರಚನೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ. ಇದು ಟೋಕನ್‌ನಲ್ಲಿನ ಕ್ಲೈಮ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸುವಾಗ ನಿಮಗೆ ಟೈಪ್ ಸುರಕ್ಷತೆ ಇರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  iat: number; // Issued At (timestamp)
  exp: number; // Expiration Time (timestamp)
}

ಈ ಇಂಟರ್‌ಫೇಸ್ ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್‌ನ ನಿರೀಕ್ಷಿತ ಆಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ನಾವು ಟೋಕನ್‌ನ ಸಿಂಧುತ್ವವನ್ನು ನಿರ್ವಹಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿರುವ `iat` (ನಡೆಸಿದ ಸಮಯ) ಮತ್ತು `exp` (ಮುಕ್ತಾಯ ಸಮಯ) ನಂತಹ ಪ್ರಮಾಣಿತ ಜೆಡಬ್ಲ್ಯೂಟಿ ಕ್ಲೈಮ್‌ಗಳನ್ನು ಸೇರಿಸಿದ್ದೇವೆ. ಬಳಕೆದಾರರ ಪಾತ್ರಗಳು ಅಥವಾ ಅನುಮತಿಗಳಂತಹ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಯಾವುದೇ ಇತರ ಕ್ಲೈಮ್‌ಗಳನ್ನು ನೀವು ಸೇರಿಸಬಹುದು. ಟೋಕನ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಭದ್ರತೆಯನ್ನು ಸುಧಾರಿಸಲು ಅಗತ್ಯವಿರುವ ಮಾಹಿತಿಗೆ ಮಾತ್ರ ಕ್ಲೈಮ್‌ಗಳನ್ನು ಸೀಮಿತಗೊಳಿಸುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ.

ಉದಾಹರಣೆ: ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಬಳಕೆದಾರರ ಪಾತ್ರಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಪ್ರಪಂಚದಾದ್ಯಂತದ ಗ್ರಾಹಕರಿಗೆ ಸೇವೆ ಸಲ್ಲಿಸುವ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ವಿವಿಧ ಬಳಕೆದಾರರು ವಿಭಿನ್ನ ಪಾತ್ರಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ:

• ನಿರ್ವಾಹಕ: ಉತ್ಪನ್ನಗಳು, ಬಳಕೆದಾರರು ಮತ್ತು ಆದೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಂಪೂರ್ಣ ಪ್ರವೇಶ.
• ಮಾರಾಟಗಾರ: ತಮ್ಮದೇ ಆದ ಉತ್ಪನ್ನಗಳನ್ನು ಸೇರಿಸಬಹುದು ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದು.
• ಗ್ರಾಹಕ: ಉತ್ಪನ್ನಗಳನ್ನು ಬ್ರೌಸ್ ಮಾಡಬಹುದು ಮತ್ತು ಖರೀದಿಸಬಹುದು.

The `roles` array in the `JwtPayload` can be used to represent these roles. You could expand the `roles` property to a more complex structure, representing the user's access rights in a granular way. For example, you could have a list of countries that user is allowed to operate in as the seller, or an array of stores the user has admin access to.

2. ಟೈಪ್ ಮಾಡಿದ ಜೆಡಬ್ಲ್ಯೂಟಿ ಸೇವೆಯನ್ನು ರಚಿಸುವುದು

ಜೆಡಬ್ಲ್ಯೂಟಿ ರಚನೆ ಮತ್ತು ಪರಿಶೀಲನೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಸೇವೆಯನ್ನು ರಚಿಸಿ. ಈ ಸೇವೆಯು ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು `JwtPayload` ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಬಳಸಬೇಕು.

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key'; // Store securely!

class JwtService {
  static sign(payload: Omit<JwtPayload, 'iat' | 'exp'>, expiresIn: string = '1h'): string {
    const now = Math.floor(Date.now() / 1000);
    const payloadWithTimestamps: JwtPayload = {
        ...payload,
        iat: now,
        exp: now + parseInt(expiresIn) * 60 * 60,
    };
    return jwt.sign(payloadWithTimestamps, JWT_SECRET);
  }

  static verify(token: string): JwtPayload | null {
    try {
      const decoded = jwt.verify(token, JWT_SECRET) as JwtPayload;
      return decoded;
    } catch (error) {
      console.error('JWT verification error:', error);
      return null;
    }
  }
}

ಈ ಸೇವೆಯು ಎರಡು ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

• `sign()`: ಪೇಲೋಡ್‌ನಿಂದ ಜೆಡಬ್ಲ್ಯೂಟಿ ರಚಿಸುತ್ತದೆ. `iat` ಮತ್ತು `exp` ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉತ್ಪತ್ತಿಯಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು `Omit<JwtPayload, 'iat' | 'exp'>` ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. `JWT_SECRET` ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸುವುದು ಮುಖ್ಯ, ಆದರ್ಶಪ್ರಾಯವಾಗಿ ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ರಹಸ್ಯ ನಿರ್ವಹಣಾ ಪರಿಹಾರವನ್ನು ಬಳಸುವುದು.
• `verify()`: ಜೆಡಬ್ಲ್ಯೂಟಿ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಮಾನ್ಯವಾಗಿದ್ದರೆ ಡಿಕೋಡ್ ಮಾಡಿದ ಪೇಲೋಡ್ ಅನ್ನು ಅಥವಾ ಅಮಾನ್ಯವಾಗಿದ್ದರೆ `null` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಪರಿಶೀಲನೆಯ ನಂತರ ನಾವು `as JwtPayload` ಟೈಪ್ ಅಸರ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಸುರಕ್ಷಿತವಾಗಿದೆ ಏಕೆಂದರೆ `jwt.verify` ವಿಧಾನವು ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ (ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಸಿಕ್ಕಿಬಿದ್ದಿದೆ) ಅಥವಾ ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಪೇಲೋಡ್ ರಚನೆಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಭದ್ರತಾ ಪರಿಗಣನೆಗಳು:

• ರಹಸ್ಯ ಕೀ ನಿರ್ವಹಣೆ: ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಜೆಡಬ್ಲ್ಯೂಟಿ ರಹಸ್ಯ ಕೀಯನ್ನು ಎಂದಿಗೂ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬೇಡಿ. ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳು ಅಥವಾ ಮೀಸಲಾದ ರಹಸ್ಯ ನಿರ್ವಹಣಾ ಸೇವೆಯನ್ನು ಬಳಸಿ. ಕೀಗಳನ್ನು ನಿಯಮಿತವಾಗಿ ತಿರುಗಿಸಿ.
• ಅಲ್ಗಾರಿದಮ್ ಆಯ್ಕೆ: HS256 ಅಥವಾ RS256 ನಂತಹ ಪ್ರಬಲ ಸಹಿ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ. `none` ನಂತಹ ದುರ್ಬಲ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ತಪ್ಪಿಸಿ.
• ಟೋಕನ್ ಮುಕ್ತಾಯ: ರಾಜಿ ಮಾಡಿಕೊಂಡ ಟೋಕನ್‌ಗಳ ಪ್ರಭಾವವನ್ನು ಮಿತಿಗೊಳಿಸಲು ನಿಮ್ಮ ಜೆಡಬ್ಲ್ಯೂಟಿಗಳಿಗೆ ಸೂಕ್ತ ಮುಕ್ತಾಯ ಸಮಯವನ್ನು ಹೊಂದಿಸಿ.
• ಟೋಕನ್ ಸಂಗ್ರಹಣೆ: ಕ್ಲೈಂಟ್-ಸೈಡ್‌ನಲ್ಲಿ ಜೆಡಬ್ಲ್ಯೂಟಿಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸಿ. XSS ದಾಳಿಗಳ ವಿರುದ್ಧ ಸೂಕ್ತ ಮುನ್ನೆಚ್ಚರಿಕೆಗಳೊಂದಿಗೆ HTTP-ಮಾತ್ರ ಕುಕೀಗಳು ಅಥವಾ ಸ್ಥಳೀಯ ಸಂಗ್ರಹಣೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

3. ಮಿಡಲ್‌ವೇರ್‌ನೊಂದಿಗೆ API ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ರಕ್ಷಿಸುವುದು

`Authorization` ಹೆಡರ್‌ನಲ್ಲಿರುವ ಜೆಡಬ್ಲ್ಯೂಟಿ ಅನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ನಿಮ್ಮ API ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ರಕ್ಷಿಸಲು ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ರಚಿಸಿ.

import { Request, Response, NextFunction } from 'express';

interface RequestWithUser extends Request {
  user?: JwtPayload;
}

function authenticate(req: RequestWithUser, res: Response, next: NextFunction) {
  const authHeader = req.headers.authorization;

  if (!authHeader) {
    return res.status(401).json({ message: 'Unauthorized' });
  }

  const token = authHeader.split(' ')[1]; // Assuming Bearer token
  const decoded = JwtService.verify(token);

  if (!decoded) {
    return res.status(401).json({ message: 'Invalid token' });
  }

  req.user = decoded;
  next();
}

export default authenticate;

ಈ ಮಿಡಲ್‌ವೇರ್ `Authorization` ಹೆಡರ್‌ನಿಂದ ಜೆಡಬ್ಲ್ಯೂಟಿ ಅನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ, `JwtService` ಬಳಸಿ ಅದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಡಿಕೋಡ್ ಮಾಡಿದ ಪೇಲೋಡ್ ಅನ್ನು `req.user` ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಲಗತ್ತಿಸುತ್ತದೆ. ಎಕ್ಸ್‌ಪ್ರೆಸ್.ಜೆಎಸ್‌ನಿಂದ ಪ್ರಮಾಣಿತ `Request` ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸಲು ನಾವು `RequestWithUser` ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಸಹ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, `JwtPayload | undefined` ಪ್ರಕಾರದ `user` ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ಇದು ರಕ್ಷಿತ ಮಾರ್ಗಗಳಲ್ಲಿ ಬಳಕೆದಾರರ ಮಾಹಿತಿಯನ್ನು ಪ್ರವೇಶಿಸುವಾಗ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಸಮಯ ವಲಯಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವಿಭಿನ್ನ ಸಮಯ ವಲಯಗಳಿಂದ ಬಳಕೆದಾರರಿಗೆ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿಗದಿಪಡಿಸಲು ಅನುಮತಿಸುತ್ತದೆ ಎಂದು ಊಹಿಸಿ. ಈವೆಂಟ್ ಸಮಯಗಳನ್ನು ಸರಿಯಾಗಿ ಪ್ರದರ್ಶಿಸಲು ನೀವು ಬಳಕೆದಾರರ ಆದ್ಯತೆಯ ಸಮಯ ವಲಯವನ್ನು ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಬಯಸಬಹುದು. ನೀವು `JwtPayload` ಇಂಟರ್‌ಫೇಸ್‌ಗೆ `timeZone` ಕ್ಲೈಮ್ ಅನ್ನು ಸೇರಿಸಬಹುದು:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  timeZone: string; // e.g., 'America/Los_Angeles', 'Asia/Tokyo'
  iat: number;
  exp: number;
}

ನಂತರ, ನಿಮ್ಮ ಮಿಡಲ್‌ವೇರ್ ಅಥವಾ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ, ಬಳಕೆದಾರರ ಆದ್ಯತೆಗೆ ಅನುಗುಣವಾಗಿ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ನೀವು `req.user.timeZone` ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

4. ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ ದೃಢೀಕರಿಸಿದ ಬಳಕೆದಾರರನ್ನು ಬಳಸುವುದು

ನಿಮ್ಮ ರಕ್ಷಿತ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ, ನೀವು ಈಗ `req.user` ಆಬ್ಜೆಕ್ಟ್ ಮೂಲಕ ದೃಢೀಕರಿಸಿದ ಬಳಕೆದಾರರ ಮಾಹಿತಿಯನ್ನು ಸಂಪೂರ್ಣ ಟೈಪ್ ಸುರಕ್ಷತೆಯೊಂದಿಗೆ ಪ್ರವೇಶಿಸಬಹುದು.

import express, { Request, Response } from 'express';
import authenticate from './middleware/authenticate';

const app = express();

app.get('/profile', authenticate, (req: Request, res: Response) => {
  const user = (req as any).user; // or use RequestWithUser
  res.json({ message: `Hello, ${user.email}!`, userId: user.userId });
});

ಈ ಉದಾಹರಣೆಯು `req.user` ಆಬ್ಜೆಕ್ಟ್‌ನಿಂದ ದೃಢೀಕರಿಸಿದ ಬಳಕೆದಾರರ ಇಮೇಲ್ ಮತ್ತು ಐಡಿ ಅನ್ನು ಹೇಗೆ ಪ್ರವೇಶಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ನಾವು `JwtPayload` ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿರುವುದರಿಂದ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ `user` ಆಬ್ಜೆಕ್ಟ್‌ನ ನಿರೀಕ್ಷಿತ ರಚನೆಯನ್ನು ತಿಳಿದಿದೆ ಮತ್ತು ಟೈಪ್ ಚೆಕಿಂಗ್ ಹಾಗೂ ಕೋಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಒದಗಿಸಬಹುದು.

5. ಪಾತ್ರ-ಆಧಾರಿತ ಪ್ರವೇಶ ನಿಯಂತ್ರಣ (RBAC) ಅಳವಡಿಸುವುದು

ಹೆಚ್ಚು ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಪ್ರವೇಶ ನಿಯಂತ್ರಣಕ್ಕಾಗಿ, ನೀವು ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಪಾತ್ರಗಳ ಆಧಾರದ ಮೇಲೆ RBAC ಅನ್ನು ಅಳವಡಿಸಬಹುದು.

function authorize(roles: string[]) {
  return (req: RequestWithUser, res: Response, next: NextFunction) => {
    const user = req.user;

    if (!user || !user.roles.some(role => roles.includes(role))) {
      return res.status(403).json({ message: 'Forbidden' });
    }

    next();
  };
}

ಈ `authorize` ಮಿಡಲ್‌ವೇರ್ ಬಳಕೆದಾರರ ಪಾತ್ರಗಳು ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಪಾತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು 403 ನಿಷಿದ್ಧ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

app.get('/admin', authenticate, authorize(['admin']), (req: Request, res: Response) => {
  res.json({ message: 'Welcome, Admin!' });
});

ಈ ಉದಾಹರಣೆಯು `/admin` ಮಾರ್ಗವನ್ನು ರಕ್ಷಿಸುತ್ತದೆ, ಬಳಕೆದಾರರು `admin` ಪಾತ್ರವನ್ನು ಹೊಂದಿರಬೇಕು ಎಂದು ಕಡ್ಡಾಯಗೊಳಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ವಿಭಿನ್ನ ಕರೆನ್ಸಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಹಣಕಾಸಿನ ವಹಿವಾಟುಗಳನ್ನು ನಿರ್ವಹಿಸಿದರೆ, ನೀವು ಅನೇಕ ಕರೆನ್ಸಿಗಳನ್ನು ಬೆಂಬಲಿಸಬೇಕಾಗಬಹುದು. ನೀವು ಬಳಕೆದಾರರ ಆದ್ಯತೆಯ ಕರೆನ್ಸಿಯನ್ನು ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  currency: string; // e.g., 'USD', 'EUR', 'JPY'
  iat: number;
  exp: number;
}

ನಂತರ, ನಿಮ್ಮ ಬ್ಯಾಕೆಂಡ್ ತರ್ಕದಲ್ಲಿ, ಅಗತ್ಯವಿರುವಂತೆ ಬೆಲೆಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಮತ್ತು ಕರೆನ್ಸಿ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನೀವು `req.user.currency` ಅನ್ನು ಬಳಸಬಹುದು.

6. ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳು

ಜೆಡಬ್ಲ್ಯೂಟಿಗಳು ವಿನ್ಯಾಸದ ಪ್ರಕಾರ ಅಲ್ಪಾವಧಿಯವು. ಬಳಕೆದಾರರು ಆಗಾಗ್ಗೆ ಲಾಗಿನ್ ಆಗುವುದನ್ನು ತಪ್ಪಿಸಲು, ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ಅಳವಡಿಸಿ. ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಎನ್ನುವುದು ದೀರ್ಘಾವಧಿಯ ಟೋಕನ್ ಆಗಿದ್ದು, ಬಳಕೆದಾರರು ತಮ್ಮ ರುಜುವಾತುಗಳನ್ನು ಮತ್ತೆ ನಮೂದಿಸುವ ಅಗತ್ಯವಿಲ್ಲದೆ ಹೊಸ ಪ್ರವೇಶ ಟೋಕನ್ (ಜೆಡಬ್ಲ್ಯೂಟಿ) ಪಡೆಯಲು ಬಳಸಬಹುದು. ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸಿ ಮತ್ತು ಅವುಗಳನ್ನು ಬಳಕೆದಾರರೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ. ಬಳಕೆದಾರರ ಪ್ರವೇಶ ಟೋಕನ್ ಅವಧಿ ಮುಗಿದಾಗ, ಅವರು ಹೊಸದನ್ನು ವಿನಂತಿಸಲು ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಅನ್ನು ಬಳಸಬಹುದು. ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ತಪ್ಪಿಸಲು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಅಳವಡಿಸಬೇಕು.

ಸುಧಾರಿತ ಟೈಪ್ ಸುರಕ್ಷತೆ ತಂತ್ರಗಳು

1. ಸೂಕ್ಷ್ಮ-ನಿಯಂತ್ರಣಕ್ಕಾಗಿ ವಿಭಜಿತ ಯೂನಿಯನ್‌ಗಳು (Discriminated Unions)

ಕೆಲವೊಮ್ಮೆ, ಬಳಕೆದಾರರ ಪಾತ್ರ ಅಥವಾ ವಿನಂತಿಯ ಪ್ರಕಾರದ ಆಧಾರದ ಮೇಲೆ ನಿಮಗೆ ವಿಭಿನ್ನ ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್‌ಗಳು ಬೇಕಾಗಬಹುದು. ವಿಭಜಿತ ಯೂನಿಯನ್‌ಗಳು (Discriminated Unions) ಟೈಪ್ ಸುರಕ್ಷತೆಯೊಂದಿಗೆ ಇದನ್ನು ಸಾಧಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಬಹುದು.

interface AdminJwtPayload {
  type: 'admin';
  userId: string;
  email: string;
  roles: string[];
  iat: number;
  exp: number;
}

interface UserJwtPayload {
  type: 'user';
  userId: string;
  email: string;
  iat: number;
  exp: number;
}

type JwtPayload = AdminJwtPayload | UserJwtPayload;

function processToken(payload: JwtPayload) {
  if (payload.type === 'admin') {
    console.log('Admin email:', payload.email); // Safe to access email
  } else {
    // payload.email is not accessible here because type is 'user'
    console.log('User ID:', payload.userId);
  }
}

ಈ ಉದಾಹರಣೆಯು ಎರಡು ವಿಭಿನ್ನ ಜೆಡಬ್ಲ್ಯೂಟಿ ಪೇಲೋಡ್ ಪ್ರಕಾರಗಳನ್ನು, `AdminJwtPayload` ಮತ್ತು `UserJwtPayload` ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ವಿಭಜಿತ ಯೂನಿಯನ್ `JwtPayload` ಆಗಿ ಸಂಯೋಜಿಸುತ್ತದೆ. `type` ಪ್ರಾಪರ್ಟಿಯು ಭೇದಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಪೇಲೋಡ್ ಪ್ರಕಾರದ ಆಧಾರದ ಮೇಲೆ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಪ್ರವೇಶಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

2. ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ದೃಢೀಕರಣ ತರ್ಕಕ್ಕಾಗಿ ಜೆನೆರಿಕ್ಸ್

ನೀವು ವಿಭಿನ್ನ ಪೇಲೋಡ್ ರಚನೆಗಳೊಂದಿಗೆ ಅನೇಕ ದೃಢೀಕರಣ ಯೋಜನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ದೃಢೀಕರಣ ತರ್ಕವನ್ನು ರಚಿಸಲು ನೀವು ಜೆನೆರಿಕ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

interface BaseJwtPayload {
  userId: string;
  iat: number;
  exp: number;
}

function verifyToken<T extends BaseJwtPayload>(token: string): T | null {
  try {
    const decoded = jwt.verify(token, JWT_SECRET) as T;
    return decoded;
  } catch (error) {
    console.error('JWT verification error:', error);
    return null;
  }
}

const adminToken = verifyToken<AdminJwtPayload>('admin-token');
if (adminToken) {
  console.log('Admin email:', adminToken.email);
}

ಈ ಉದಾಹರಣೆಯು `BaseJwtPayload` ಅನ್ನು ವಿಸ್ತರಿಸುವ ಸಾಮಾನ್ಯ ಪ್ರಕಾರ `T` ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ `verifyToken` ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಇದು ವಿಭಿನ್ನ ಪೇಲೋಡ್ ರಚನೆಗಳೊಂದಿಗೆ ಟೋಕನ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಅವುಗಳು ಕನಿಷ್ಠ `userId`, `iat` ಮತ್ತು `exp` ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್ ಪರಿಗಣನೆಗಳು

ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ದೃಢೀಕರಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ, ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಸ್ಥಳೀಕರಣ: ದೋಷ ಸಂದೇಶಗಳು ಮತ್ತು ಬಳಕೆದಾರ ಇಂಟರ್‌ಫೇಸ್ ಅಂಶಗಳು ವಿಭಿನ್ನ ಭಾಷೆಗಳು ಮತ್ತು ಪ್ರದೇಶಗಳಿಗೆ ಸ್ಥಳೀಕರಿಸಲ್ಪಟ್ಟಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಸಮಯ ವಲಯಗಳು: ಟೋಕನ್ ಮುಕ್ತಾಯ ಸಮಯವನ್ನು ಹೊಂದಿಸುವಾಗ ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವಾಗ ಸಮಯ ವಲಯಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಿ.
• ಡೇಟಾ ಗೌಪ್ಯತೆ: GDPR ಮತ್ತು CCPA ನಂತಹ ಡೇಟಾ ಗೌಪ್ಯತೆ ನಿಯಮಗಳನ್ನು ಅನುಸರಿಸಿ. ಜೆಡಬ್ಲ್ಯೂಟಿಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ವೈಯಕ್ತಿಕ ಡೇಟಾದ ಪ್ರಮಾಣವನ್ನು ಕಡಿಮೆ ಮಾಡಿ.
• ಪ್ರವೇಶಸಾಧ್ಯತೆ: ಅಂಗವೈಕಲ್ಯ ಹೊಂದಿರುವ ಬಳಕೆದಾರರಿಗೆ ಪ್ರವೇಶಿಸಬಹುದಾದಂತೆ ನಿಮ್ಮ ದೃಢೀಕರಣ ಹರಿವುಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿ.
• ಸಾಂಸ್ಕೃತಿಕ ಸೂಕ್ಷ್ಮತೆ: ಬಳಕೆದಾರ ಇಂಟರ್‌ಫೇಸ್‌ಗಳು ಮತ್ತು ದೃಢೀಕರಣ ಹರಿವುಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ ಸಾಂಸ್ಕೃತಿಕ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಜೆಡಬ್ಲ್ಯೂಟಿ ದೃಢೀಕರಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಇಂಟರ್‌ಫೇಸ್‌ಗಳೊಂದಿಗೆ ಪೇಲೋಡ್ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು, ಟೈಪ್ ಮಾಡಿದ ಜೆಡಬ್ಲ್ಯೂಟಿ ಸೇವೆಗಳನ್ನು ರಚಿಸುವುದು, ಮಿಡಲ್‌ವೇರ್‌ನೊಂದಿಗೆ API ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ರಕ್ಷಿಸುವುದು ಮತ್ತು RBAC ಅನ್ನು ಅಳವಡಿಸುವುದು ಭದ್ರತೆ ಮತ್ತು ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವಲ್ಲಿ ಅಗತ್ಯ ಹಂತಗಳಾಗಿವೆ. ಸ್ಥಳೀಕರಣ, ಸಮಯ ವಲಯಗಳು, ಡೇಟಾ ಗೌಪ್ಯತೆ, ಪ್ರವೇಶಸಾಧ್ಯತೆ ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸೂಕ್ಷ್ಮತೆಯಂತಹ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್ ಪರಿಗಣನೆಗಳನ್ನು ಪರಿಗಣಿಸುವ ಮೂಲಕ, ವೈವಿಧ್ಯಮಯ ಅಂತರರಾಷ್ಟ್ರೀಯ ಪ್ರೇಕ್ಷಕರಿಗೆ ಅಂತರ್ಗತ ಮತ್ತು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ದೃಢೀಕರಣ ಅನುಭವಗಳನ್ನು ನೀವು ರಚಿಸಬಹುದು. ಜೆಡಬ್ಲ್ಯೂಟಿಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಯಾವಾಗಲೂ ಭದ್ರತಾ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡುವುದನ್ನು ನೆನಪಿಡಿ, ಇದರಲ್ಲಿ ಸುರಕ್ಷಿತ ಕೀ ನಿರ್ವಹಣೆ, ಅಲ್ಗಾರಿದಮ್ ಆಯ್ಕೆ, ಟೋಕನ್ ಮುಕ್ತಾಯ ಮತ್ತು ಟೋಕನ್ ಸಂಗ್ರಹಣೆ ಸೇರಿವೆ. ನಿಮ್ಮ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಸುರಕ್ಷಿತ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ದೃಢೀಕರಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಶಕ್ತಿಯನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ.