In the article on [CakePHP 4: How to Create a Login Function]. I have guided on how to create a login function using a web interface by combining Session and Cookie. In this article, I will guide you on how to create a token-based login and authentication function.

The steps to install the Authentication 2.0 plugin, create a controller, model, etc., have been guided in the article [CakePHP 4: How to Create a Login Function]. If you haven't read it, you can refer to the article at https://isb-vietnam.net/cakephp-4-how-to-create-a-login-function/.

1, Understand Token-Based Authentication.

To understand how the login function works, you can see the diagram below:

In a token-based application, The server will create a JWT and send the JWT back to the client when the user logs in. In subsequent requests, the client will send requests to the server with the JWT included in the header. The server will check if the JWT is valid to respond.

2, Implement JWT in CakePHP 4.

By default the JwtAuthenticator uses HS256 symmetric key algorithm and uses the value of Cake\Utility\Security::salt() as encryption key. For enhanced security one can instead use the RS256 asymmetric key algorithm.

Create encryption key.

# generate private key

openssl genrsa -out config/jwt.key 1024

# generate public key

openssl rsa -in config/jwt.key -outform PEM -pubout -out config/jwt.pem

The jwt.key file is the private key and should be kept safe. The jwt.pem file is the public key. This file should be used when you need to verify tokens created by external applications, eg: mobile apps.

Implement.

In src/Application.php, change the source code to identify the user based on the subject of the token by using JwtSubject identifier, and configures the Authenticator to use public key for token verification.

public function getAuthenticationService(ServerRequestInterface $request): AuthenticationServiceInterface

{

$service = new AuthenticationService([

           'unauthenticatedRedirect' => Router::url('/login'),

           'queryParam' => 'redirect',

       ]);

//…

$service->loadIdentifier('Authentication.JwtSubject');

$service->loadAuthenticator('Authentication.Jwt', [

           'header' => 'Authorization',

           'secretKey' => file_get_contents(CONFIG . 'jwt.pem'),

           'algorithm' => 'RS256',

           'returnPayload' => false

       ]);

  return $service;

   }

In UsersController.php, create a login function as below.

public function login()

   {

       if ($this->request->is('post')) {

           $result = $this->Authentication->getResult();

           if ($result->isValid()) {

               $privateKey = file_get_contents(CONFIG . 'jwt.key');

               $user = $result->getData();

               $payload = [

                   'iss' => 'myapp',

                   'sub' => $user->id,

                   'exp' => time() + 3600, // 1 hour

               ];

               $json = [

                   'token' => JWT::encode($payload, $privateKey, 'RS256'),

               ];

           } else {

               $this->response = $this->response->withStatus(401);

               $json = [

                   "message" => __('The Username or Password is Incorrect')

               ];

           }

           $this->RequestHandler->renderAs($this, 'json');

           $this->response->withType('application/json');

           $this->set(['json' => $json]);

           $this->viewBuilder()->setOption('serialize', 'json');

       } else {

           throw new NotFoundException();

       }

   }

Testing.

We create APIs to verify the token-based login function with the rules as shown in the table below:

Perform login testing using Postman. In case of a successful login, a token will be returned.

Call API Retrieve All Articles (GET), Can only be used by all users.

Call API Create an Article (POST), can only be used by authenticated users.

The result is returned successfully with the token attached in the header.

The result is returned unsuccessfully because the token is not attached in the header.

You can find the complete source code at: https://github.com/ivc-phampbt/cakephp-authentication

Conclusion

In this article, I introduced a new login method called Token-Based Authentication and how web applications authenticate using tokens. I hope this article provides knowledge to help you build token-based login features more easily.

References

• https://book.cakephp.org/authentication/2/en/index.html
• https://sherryhsu.medium.com/session-vs-token-based-authentication-11a6c5ac45e4 [Image]
• https://www.rockersinfo.com/php-frameworks/cakephp-development-company/ [Image]

In the dynamic world of web development, JavaScript has long been the go-to language for building interactive and dynamic web applications. However, as applications grow in complexity, managing large codebases and ensuring code quality with plain JavaScript can become challenging. Enter TypeScript, a powerful superset of JavaScript that addresses these challenges by adding static type-checking and other robust features.

What is TypeScript?

TypeScript is an open-source programming language developed by Microsoft. It builds on JavaScript by introducing static typing, classes, and interfaces, among other features, making it easier to write and maintain large-scale applications. Essentially, TypeScript is JavaScript with additional tools to catch errors early and enhance the development process.

Why Use TypeScript?

• Early Error Detection: TypeScript's static type system allows developers to catch errors at compile time rather than at runtime. This means you can identify and fix issues before your code even runs, significantly reducing the number of bugs.
• Enhanced Maintainability: As projects grow, maintaining code can become cumbersome. TypeScript's type annotations and interfaces make the code more readable and self-documenting, which simplifies maintenance and collaboration.
• Improved Tooling: TypeScript provides powerful tools such as IntelliSense, which offers intelligent code completion, parameter info, and documentation on the fly. This improves developer productivity and reduces the likelihood of errors.
• Interoperability with JavaScript: TypeScript is designed to be fully compatible with existing JavaScript codebases. You can gradually introduce TypeScript into your project, converting files one at a time without disrupting the entire codebase.

Basic Structure of TypeScript

TypeScript syntax is very similar to JavaScript, with additional features for static typing and more. Here are some key elements:

• Type Annotations: Define variable types to catch errors early.

• Interfaces: Define complex types and enforce structure.

• Classes: Support object-oriented programming with features like inheritance and encapsulation.

• Generics: Write reusable and flexible components.

Getting Started with TypeScript

To start using TypeScript, you need to install the TypeScript compiler (tsc) via npm (Node Package Manager). Open your terminal and run the following command:

Once installed, you can compile TypeScript files into JavaScript using the tsc command:

This will generate a corresponding file.js that you can run in any browser or Node.js environment.

Key Features of TypeScript

• Static Typing: TypeScript allows you to define types for variables, function parameters, and return values. This helps prevent type-related errors and improves code clarity.
• Type Inference: Even without explicit type annotations, TypeScript can often infer the type of a variable based on its value or how it is used.
• Type Declarations: TypeScript allows you to create type definitions for libraries or frameworks that are not written in TypeScript, enabling better integration and development experience.
• ES6 and Beyond: TypeScript supports many modern JavaScript features, such as async/await, destructuring, and template literals, even if they are not yet available in the target JavaScript environment.

Conclusion

TypeScript not only improves code quality and maintainability but also enhances developer productivity through better tooling and early error detection. Its compatibility with JavaScript allows for a smooth transition and incremental adoption. As web applications continue to grow in complexity, TypeScript emerges as a powerful ally for developers aiming to write clean, reliable, and scalable code.

References:
https://www.typescriptlang.org/docs
https://smachstack.com/how-to-work-ts ( Image source )

Improving performance with LINQ in C# is essential, especially when working with large datasets. LINQ provides a powerful and expressive way to query data, but it can introduce performance overhead if not used efficiently. Below are some tips and tricks to improve LINQ performance, along with sample code:

1. Avoid repeated Enumeration

When you execute a LINQ query, it can be enumerated multiple times, leading to unnecessary performance hits.

You can improve performance by materializing the result of a query (e.g., using ToList(), ToArray(), or ToDictionary()).

var data = GetData(); // Some large collection

// Not good: Repeatedly enumerating the sequence
var count = data.Where(x => x.IsActive).Count();
var sum = data.Where(x => x.IsActive).Sum(x => x.Value);

// Good: Materializing the result to avoid repeated enumeration
var activeData = data.Where(x => x.IsActive).ToList();
var count = activeData.Count;
var sum = activeData.Sum(x => x.Value);

2. Use Any()  instead of Count() > 0

If you're only checking whether a collection contains any elements, using Any() is faster than Count() > 0.

Any() stops as soon as it finds the first matching element, whereas Count() counts all elements before returning a result.

// Not good: Counting all elements
if (data.Where(x => x.IsActive).Count() > 0) { ... }

// Good: Checking for any element
if (data.Where(x => x.IsActive).Any()) { ... }

3. Use FirstOrDefault() and SingleOrDefault()

When you expect only one element or none, use FirstOrDefault() or SingleOrDefault() instead of Where() combined with First() or Single().

These methods are optimized for single element retrieval.

// Not good: Using Where with First
var item = data.Where(x => x.Id == 1).FirstOrDefault();

// Good: Using FirstOrDefault directly
var item = data.FirstOrDefault(x => x.Id == 1);

4. Use OrderBy and ThenBy efficiently

If you need to sort data, make sure that you're sorting only what is necessary, as sorting can be an expensive operation. Additionally, try to minimize the number of sorting operations.

// Not good: Multiple OrderBy statements
var sortedData = data.OrderBy(x => x.Age).OrderBy(x => x.Name);

// Good: Using OrderBy and ThenBy together
var sortedData = data.OrderBy(x => x.Age).ThenBy(x => x.Name);

5. Optimize GroupBy

The GroupBy operator can be expensive, especially if you're grouping large collections. If you need to perform a GroupBy but only need to count or get the First/Last element in each group, avoid creating the entire group and just perform a more efficient aggregation.

// Not good: GroupBy followed by a complex operation
var grouped = data.GroupBy(x => x.Category)
                  .Select(g => new { Category = g.Key, Count = g.Count() })
                  .ToList();

// Good: Perform aggregation more directly
var counts = data.GroupBy(x => x.Category)
                 .Select(g => new { Category = g.Key, Count = g.Count() })
                 .ToDictionary(g => g.Category, g => g.Count);

6. Prefer IEnumerable<T> over List<T> when possible

LINQ queries work best with IEnumerable<T> because it represents a lazy sequence.

Converting it to a List<T> immediately could result in unnecessary memory usage if not required.

// Not good: Convert to List too early
var result = data.Where(x => x.IsActive).ToList();

// Good: Keep it as IEnumerable until it's really needed
IEnumerable<int> result = data.Where(x => x.IsActive);

Hoping with these tips, you can significantly improve the performance of your LINQ queries in C#.

References:

https://www.bytehide.com/blog/linq-performance-optimization-csharp

Image source: https://www.freepik.com/free-photo/top-view-laptop-table-glowing-screen-dark_160644251.htm