Forem: Ngo Dinh Cuong

OAuth Integration in NestJS: From Hours of Configuration to 2 Minutes

Ngo Dinh Cuong — Sun, 23 Nov 2025 10:17:40 +0000

Let's be honest: implementing OAuth in a NestJS application is more tedious than it should be. You need to:

Install multiple Passport strategies (passport-google-oauth20, passport-facebook, passport-linkedin-oauth2, etc.)
Create strategy files for each provider with boilerplate code
Configure environment variables correctly
Set up guards and controllers
Handle callback routes
Normalize different provider response formats
Write tests for each integration

By the time you've added Google, Facebook, LinkedIn, and Apple login, you've written hundreds of lines of repetitive code. And if you need to add another provider later? Start over.

There had to be a better way.

I built nestjs-social-auth to solve this problem once and for all. It's a NestJS library that provides pre-configured OAuth strategies for the most popular social providers with three flexible integration approaches.

Key Features:

🔐 4 OAuth providers out of the box (Google, Facebook, LinkedIn, Apple)
⚡ 2-minute setup for basic use cases
🎯 3 integration methods (from zero-config to full customization)
🤖 MCP (Model Context Protocol) support for AI-assisted configuration

The Architecture: Three Integration Paths
One size doesn't fit all. That's why the library offers three distinct integration approaches:

Option 1: OAuthModule (Zero Configuration)

Perfect for getting started quickly. Import the module, set environment variables, and you're done.

// app.module.ts
import { Module } from '@nestjs/common';
import { OAuthModule } from 'nestjs-social-auth';

@Module({
  imports: [OAuthModule],
})
export class AppModule {}

# .env
GOOGLE_CLIENT_ID=your-google-client-id
GOOGLE_CLIENT_SECRET=your-google-client-secret
GOOGLE_CALLBACK_URL=http://localhost:3000/oauth/google/callback

What you get automatically:

GET /oauth/:provider - Initiates OAuth flow
GET /oauth/:provider/callback - Handles OAuth callback
All strategies registered and configured
Normalized response format across providers

Under the hood, the library uses:

Dynamic Strategy Registration: Strategies are registered only for providers with valid environment variables
Strategy Registry Pattern: Maps provider names to their corresponding Passport strategies
Dynamic Route Guards: OAuthGuard dynamically selects the correct strategy based on the :provider parameter

Option 2: Integration Command (Full Control)

For teams that want full ownership of the OAuth code:

npx nestjs-social-auth-integrate

This copies the entire src/oauth directory into your project, giving you:

Complete source code ownership
Full customization capability
No dependency on the package for core functionality
Easy debugging and modification

Technical benefit: Your OAuth implementation becomes part of your codebase, avoiding potential version conflicts and allowing team-specific modifications.

Option 3: OAuthGuard (Custom Implementation)

For advanced use cases where you need custom endpoints and logic:

import { Controller, Get, Param, UseGuards, Req } from '@nestjs/common';
import { OAuthGuard } from 'nestjs-social-auth';

@Controller('auth')
export class CustomAuthController {
  @Get('login/:provider')
  @UseGuards(OAuthGuard)
  async login(@Param('provider') provider: string) {
    // Guard handles the redirect
  }

  @Get('callback/:provider')
  @UseGuards(OAuthGuard)
  async callback(@Param('provider') provider: string, @Req() req: Request) {
    const user = (req as any).user;

    // Your custom logic: save to DB, generate JWT, etc.
    const token = this.authService.generateToken(user);

    return {
      message: 'Login successful',
      user: user.profile,
      token,
    };
  }
}

Design pattern: The OAuthGuard implements a dynamic guard pattern that inspects the provider parameter at runtime and applies the corresponding Passport strategy.

Technical Deep Dive: How It Works

1. Strategy Registry Pattern

The library uses a centralized strategy registry to map provider names to their Passport strategies:

// Simplified version of the actual implementation
export class StrategyRegistry {
  private strategies = new Map();

  register(provider: string, strategy: any) {
    this.strategies.set(provider, strategy);
  }

  get(provider: string) {
    return this.strategies.get(provider);
  }
}

2. Conditional Strategy Initialization

Strategies are only initialized when their required environment variables are present:

// Only registers if all required env vars exist
if (config.google.clientID && config.google.clientSecret) {
  providers.push(GoogleStrategy);
}

This prevents runtime errors and allows selective provider enablement.

3. Response Normalization

Each provider returns OAuth data in a different format. The library normalizes these into a consistent interface:

interface OAuthProfile {
  id: string;
  email: string;
  firstName: string;
  lastName: string;
  picture: string;
  provider: 'google' | 'facebook' | 'linkedin' | 'apple';
}

interface OAuthResponse {
  profile: OAuthProfile;
  accessToken: string;
  refreshToken?: string;
}

Innovation: MCP Integration

One unique feature is MCP (Model Context Protocol) support, making this the first NestJS OAuth library that AI assistants can understand and help configure.

import { OAuthMcpModule } from 'nestjs-social-auth';

@Module({
  imports: [
    OAuthModule,
    OAuthMcpModule.forRoot({
      name: 'my-oauth-mcp-server',
      version: '1.0.0',
    }),
  ],
})
export class AppModule {}

What this enables:

AI assistants (like Claude) can query supported providers
Get configuration requirements for each provider
Receive example environment variable values
Understand provider-specific requirements (e.g., Apple's 5-variable setup vs. Google's 3-variable setup)

MCP Tools Available:

get_supported_providers - Lists all supported OAuth providers
check_provider_support - Validates if a provider is supported
get_provider_config_keys - Returns required env vars and examples

This is especially powerful for junior developers or when setting up OAuth in new projects.

Getting Started in 2 Minutes

Step 1: Install

npm install nestjs-social-auth

Step 2: Import Module

import { OAuthModule } from 'nestjs-social-auth';

@Module({
  imports: [OAuthModule],
})
export class AppModule {}

Step 3: Configure Environment

GOOGLE_CLIENT_ID=your-google-client-id
GOOGLE_CLIENT_SECRET=your-google-client-secret
GOOGLE_CALLBACK_URL=http://localhost:3000/oauth/google/callback

Step 4: Start & Test

npm run start:dev

Visit http://localhost:3000/oauth/google and you'll be redirected to Google's OAuth page. After authorization, you'll receive:

{
  "profile": {
    "id": "123456789",
    "email": "user@gmail.com",
    "firstName": "John",
    "lastName": "Doe",
    "picture": "https://...",
    "provider": "google"
  },
  "accessToken": "ya29.a0...",
  "refreshToken": "1//0e..."
}

OAuth integration doesn't have to be a multi-day task. With nestjs-social-auth, you can go from zero to working social login in 2 minutes, with the flexibility to customize everything when you need to. Whether you're building your first NestJS app or architecting an enterprise system, having reliable, well-tested OAuth infrastructure lets you focus on what matters: building your product.

Try it out and let me know what you think. And if you're interested in contributing, the community would love to have you! 🚀

The library is open source and welcomes contributors. Potential areas for contribution:

🔧 New Providers: Twitter/X, GitHub, Microsoft, Discord
📚 Documentation: More examples, use cases, migration guides
🧪 Testing: Additional edge cases, integration scenarios
🎨 Features: PKCE support, state validation, custom scopes

Get involved:

📦 NPM: https://www.npmjs.com/package/nestjs-social-auth
💻 GitHub: https://github.com/cuongdinhngo/nestjs-social-authl providers with three flexible integration approaches.

Deep dive into Laravel Pagination - PHP IteratorAggregate

Ngo Dinh Cuong — Mon, 07 Mar 2022 10:27:54 +0000

Regarding to Laravel pagination doc, when calling the paginate method, you will receive an instance of Illuminate\Pagination\LengthAwarePaginator. When calling the simplePaginate method, you will receive an instance of Illuminate\Pagination\Paginator. These objects provide several methods that describe the result set. In addition to these helpers methods, the paginator instances are iterators and may be looped as an array.

There is a basic example of Laravel pagination in your project

public function index(Request $request)
   {
       $users = User::paginate(15);
       return view('user.index', ['users' => $users]);
   }

<div class="container">
   @foreach ($users as $user)
       {{ $user->name }}
   @endforeach
</div>

Here is what you see in detail of $users variable

Now let look at inside LengthAwarePaginator class, we can see that it implements several interfaces such as ArrayAccess, Countable, IteratorAggregate, JsonSerializable which are known as predefined interfaces in PHP. This class also extends AbstractPaginator which has getIterator() to return ArrayIterator

In this case, we consider the IteratorAggregate is an interface to create an external Iterator which allows you to traverse your custom class objects using foreach. With the Interface synopsis, IteratorAggregate extends Traversable interface itself is an abstract base interface (with no methods as shown in the interface synopsis) that cannot be instantiated. However, it can be used to check whether a class is traversable using foreach or not.

class Food implements IteratorAggregate
{
   public array $arr;

   public function __construct() {
       $this->arr = ['Milk', 'Cake', 'Coke'];
   }

   public function getIterator() {
       return new ArrayIterator($this->arr);
   }
}

$obj = new Food();

foreach($obj as $key => $value) {
  echo $key ." =>" . $value . "\n";
}

======================================
OUTPUT

0 => 'Milk'
1 => 'Cake'
2 => 'Coke'

IteratorAggregate is an easy way to implement an Iterator. The advantage with IteratorAggregate is the speed, it is much faster than its alternatives. The problem with it it's that... despite the name it's not an iterator but a traversable (so again, no next, key, current, valid, rewind methods).

Laravel Simple Datatable

Ngo Dinh Cuong — Sun, 26 Dec 2021 13:56:25 +0000

Laravel Simple Datatable enhances the accessibility of data in HTML tables

https://github.com/cuongnd88/lara-simple-datatable

1-Install cuongnd88/lara-simple-datatable using Composer.

$ composer require cuongnd88/lara-simple-datatable

2-Add the following service provider in config/app.php

<?php
// config/app.php
return [
    // ...
    'aliases' => [
        . . . .
        'SimpleDatatable' => Cuongnd88\LaraSimpleDatatable\Facades\SimpleDatatableFacade::class,
    ],
    // ...
];

You can modify the Simple Datatable interface by copying its components to your local config directory:

php artisan vendor:publish --provider="Cuongnd88\LaraSimpleDatatable\LaraSimpleDatatableServiceProvider"

Sample Usage

Let start code less with Laravel Simple Datatable

....
use SimpleDatatable;

class UserController extends Controller
{
    public function index(Request $request)
    {
        $users = SimpleDatatable::buildQuery(User::query())
                    ->setPerPage(10)
                    ->addIncrement(function($value) {
                        return "#{$value["increment"]}";
                    })
                    ->editColumn('id', function($value) {
                        return "[{$value["id"]}]";
                    })
                    ->editColumn('name', 'user.partials.name')
                    ->addColumn('action', 'user.partials.action')
                    ->make();

        return view('user.index', ['users' => $users]);
    }
}

buildQuery(Builder $query): set Query build.

setPerPage(int $perPage) is to set quantity of items per page.

addIncrement($callback) is to add increment number.

editColumn(string $key, $callback|$view) is to edit existed column.

addColumn(string $key, $callback|$view) is to add mroe column.

make() is to make simple datatable.

Simple Datatable makes your job more easier to render view by using @simpleDatatable and @simplePaginator

index.blade.php

@extends('layouts.app')

@section('content')
<div class="container">
    <div class="row justify-content-center">
        <div class="col-md-8">
            <div class="card">
                <div class="card-header">Simple Datatable</div>

                <div class="card-body">
                    @simpleDatatable(['data' => $users, 'view' => simple_table_view('users')])
                    @endsimpleDatatable

                    @simplePaginator(['data' => $users, 'appends' => ['name' => 'cuong.ngo']])
                    @endsimplePaginator
                </div>


            </div>
        </div>
    </div>
</div>
@endsection

@simpleDatatable(array $result): $result must has key data for content and key view for setting views.

@simplePaginator(array $result): $result must has key data for content and key appends is optional for your extend data (ex: http://localhost:8080/users?name=cuong.ngo&page=10).

simple_table_view(string $view): is to set table headers which is loaded from simple-datatable.php in config folder .

<?php

return [
    /*
    |--------------------------------------------------------------------------
    | Default paginator view
    |--------------------------------------------------------------------------
    |
    */
    'paginator_view' => 'components.simple-datatable.default-bootstrap-4',

    /*
    |--------------------------------------------------------------------------
    | Default simple paginator view
    |--------------------------------------------------------------------------
    |
    */
    'simple_paginator_view' => 'components.simple-datatable.default-bootstrap-4',

    /*
    |--------------------------------------------------------------------------
    | Default makeup for simple table view
    |--------------------------------------------------------------------------
    |
    */
    'default_table_makeup' => 'table-striped table-hover',

    /*
    |--------------------------------------------------------------------------
    | Setting views for specified datatable
    |--------------------------------------------------------------------------
    |
    */
    'views' => [
        'users' => [
            'items' => [
                'increment' => '#',
                'id' => 'ID',
                'name' => 'Name',
                'email' => 'Email',
                'action' => '',
            ],
        ],
    ],
];

To modify the view of column, you can create blade file as addColumn('action', 'user.partials.action')

user.partials.action

<a href="user/{{$id}}">Edit</a> | <a href="user/{{$id}}/remove">Remove</a>

You also modify the view of whole table, you can see at simple-datatable.blade.php

@php
$makeup = $view['makeup'] ?? '';
$keys = array_keys($view['items']);
$headLabels = array_values($view['items']);
@endphp
<table class="table {{$makeup}}">
    <thead>
        <tr>
            @foreach ($headLabels as $label)
                <th scope="col">{{$label}}</th>
            @endforeach
        </tr>
    </thead>
    <tbody>
        @foreach ($data as $item)
            <tr>
                @foreach ($keys as $key)
                    <td>{{ $item[$key] ?? '' }}</td>
                @endforeach
            </tr>
        @endforeach
    </tbody>
</table>

Build your own PHP framework

Ngo Dinh Cuong — Mon, 04 Oct 2021 14:29:35 +0000

Atom Framework: https://github.com/cuongdinhngo/atom

Ezycrazy Project is powered by Atom framework: https://github.com/cuongdinhngo/ezycrazy

1.First things

Single Entry Point

The entry point for all requests to a Atom application is the public/index.php file. All requests are directed to this file by your web server (Apache / Nginx) configuration. The index.php file doesn’t contain much code. Rather, it is a starting point for loading the rest of the framework.

<?php

require __DIR__ . '/../vendor/autoload.php';
require __DIR__ . '/../app/autoload.php';

use Atom\Http\Server;

try {
    $server = new Server(['env']);
    $server->handle();
} catch (\Exception $e) {
    echo $e->getMessage();
}

The index.php file loads the Composer generated autoloader definition, and then initiates an Server instance (Atom/Http/Server.php) with specified configured files (config/env.ini)

2. Atom/Http/Server.php

The method signature for the Server’s handle method is simple: receive a Request, dispatch to Router and load Controller.

/**
* Handle progress
* @return void
*/
public function handle()
{
    try {
        $routeData = $this->router->dispatchRouter();
        $this->handleMiddlewares($routeData);
        $this->controllerMaster->loadController($routeData);
    } catch (\Exception $e) {
        echo $e->getMessage();
    }
}

3. Basic routing

The router will dispatch the request to a route or controller, as well as run any route specific middleware.
The routes are defined in your route files, which are located in the app/Routes directory. The web.php file defines routes that are for your web interface. The routes in routes/api.php are stateless.
You will begin by defining routes in your app/Routes/web.php file. The routes defined in routes/web.php may be accessed by entering the defined route’s URL in your browser. For example, you enter http://localhost/users in your browser:

return [
    '/users' => [
        'middleware' => ['first', 'auth', 'second'],
        ['get' => 'User/UserController@list'],
        ['post' => 'User/UserController@create'],
        ['put' => 'User/UserController@put']
    ],
];

Routes defined in the app/Routes/api.php that the /api URI prefix is automatically applied so you do not need to manually apply it to every route in the file.

return [
    '/users' => [
        'middleware' => ['first', 'second'],
        ['get' => 'User/UserController@list'],
        ['post' => 'User/UserController@create'],
        ['put' => 'User/UserController@put']
    ],
];

Sometimes you will need to capture segments of the URI within your route. For example, you may need to capture a user’s ID from the URL. You may do so by defining route parameters:

return [

    '/users/{uId}/skills/{sId}' => [

        ['get' => 'User/UserController@test'],

    ],

];

Memo

Route parameters are always encased within {} braces and only consist of alphabetic characters. URL must contains only number /users/1/skills/22

4. Middleware

Middleware provides a convenient mechanism for filtering the requests entering your application. For example, Atom includes a middleware that verifies the user of your application is authenticated. If the user is not authenticated, the middleware will redirect the user to the login screen or throw an error. If the user is authenticated, the middleware will allow the request to proceed further into the application.
To define a new middleware, you must create a class at app/Middlewares directory.

<?php

namespace App\Middlewares;

use Atom\Guard\Auth;
use Atom\File\Log;

class Authorization
{
    /**
    * Handle Authorize
    *
    * @return void
    */
    public function handle()
    {
        Log::info(__METHOD__);
        Auth::check();
    }
}

If you would like to assign middleware to specific routes, you should first assign the middleware a key in your config/middleware.php file.

return [
    /**
    * The application's route middlewares
    */
    'routeMiddlewares' => [
        'first' => 'FirstMiddleware',
        'second' => 'SecondMiddleware',
        'auth' => 'Authorization',
        'phpToJs' => 'PhpToJs',
        'signed.url' => 'IdentifySignedUrl',
    ],

    /**
    * List of priority middlewares
    */
    'priorityMiddlewares' => [
        'auth' => 'Authorization',
        'signed.url' => 'IdentifySignedUrl',
        'phpToJs' => 'PhpToJs',
    ],
];

Once the middleware has been defined, you may middleware to a route:

return [
    '/users' => [
        'middleware' => ['first', 'auth', 'second'],
        ['get' => 'User/UserController@list'],
        ['post' => 'User/UserController@create'],
        ['put' => 'User/UserController@put']
    ],
];

5. Basic Controller

Below is an example of a basic controller class. Note that the controller extends the Base controller class.

<?php

namespace App\Controllers\User;

use Atom\Controllers\Controller as BaseController;
use Atom\Http\Response;
use Atom\IMDB\Redis;
use Atom\Http\Request;
use Atom\Db\Database;
use Atom\Validation\Validator;
use Atom\Guard\Token;
use Atom\File\Log;
use Atom\File\Image;
use Atom\File\CSV;
use Atom\Guard\Auth;
use Atom\Template\Template;
use App\Models\User;
use Atom\Http\Url;

class UserController extends BaseController
{
    private $user;
    private $log;
    private $template;

    /**
    * User Controller construct
    *
    * @param User $user User
    */
    public function __construct(User $user)
    {
        parent::__construct();
        $this->user = $user;
        $this->log = new Log();
        $this->template = new Template();
    }

    /**
    * Created User Form
    *
    * @return void
    */
    public function createForm()
    {
        return template('admin', 'admin.users.create');
    }
}

You can define a route to this controller action like so:

'/users/add' => [

    'middleware' => ['signed.url'],

    ['get' => 'User/UserController@createForm'],

],

6. Dependency Injection & Controllers

Constructor Injection

You are able to type-hint any dependencies your controller may need in its constructor. The declared dependencies will automatically be resolved and injected into the controller instance:

<?php

namespace App\Controllers\User;

use Atom\Controllers\Controller as BaseController;
use Atom\Http\Response;
use Atom\Http\Request;
use Atom\File\Log;
use Atom\Template\Template;
use App\Models\User;

class UserController extends BaseController
{
    private $user;
    private $log;
    private $template;

    /**
    * User Controller construct
    *
    * @param User $user User
    */
    public function __construct(User $user)
    {
        parent::__construct();
        $this->user = $user;
        $this->log = new Log();
        $this->template = new Template();
    }
}

Method Injection

In addition to constructor injection, you may also type-hint dependencies on your controller’s methods. A common use-case for method injection is injecting the Atom\Http\Request instance into your controller methods:

<?php

namespace App\Controllers\User;

use Atom\Controllers\Controller as BaseController;
use Atom\Http\Response;
use Atom\Http\Request;
use Atom\File\Log;
use Atom\Template\Template;
use App\Models\User;

class UserController extends BaseController
{
    /**
     * Delete User
     *
     * @param mixed $request Request
     *
     * @return void
     */
    public function delete(Request $request)
    {
        $database = new Database();
        $database->enableQueryLog();
        $database->table('users')->where(['id', $request['id']])->delete();
        $this->log->info($database->getQueryLog());
        Response::redirect('/users');
    }
}

7. Model

Database: Query Builder

Atom query builder provides a convenient, fluent interface to creating and running database queries. The table method returns a fluent query builder instance for the given table, allowing you to chain more constraints onto the query and then finally get the results using the get method

$database = new Database();

$database->enableQueryLog();

$users = $database->table('users')->select(['id', 'fullname', 'email', 'thumb'])->where(['gender', '=', 'male'])->orWhere(['gender', '=', 'female'])->get();

Log::info($database->getQueryLog());

If you just need to retrieve a single row from the database table, you may use the first method. This method will return an array:

$database = new Database();

$database->enableQueryLog();

$user = $database->table('users')->select(['id', 'fullname', 'email', 'thumb'])

->where(['id', $request['id']])->first();

Log::info($database->getQueryLog());

Retrieving Models

The Atom provides a simple ORM that applies ActiveRecord implementation for working with your database. Each database table has a corresponding “Model” which is used to interact with that table. Models allow you to query for data in your tables, as well as insert new records into the table.
Remember to configure database connection. The database configuration for your application is located at config/env.ini. In this file you may define all of your database connections:

; Database config
DB_CONNECTION = 'mysql'
DB_HOST = '172.18.0.2'
DB_USER = 'root'
DB_PASSWORD = 'root@secret123'
DB_NAME = 'app'
DB_PORT = 3306

Let’s create a model. Models typically live in the app/Models directory and all models must extend App\Models\Model class.

<?php

namespace App\Models;

use Atom\Models\Model as BaseModel;
use Atom\Db\Database;
use Atom\Models\Filterable;

class User extends BaseModel
{
    use Filterable;
    protected $table = 'users';
    protected $fillable = [
        'fullname',
        'email',
        'password',
        'photo',
        'gender',
        'thumb',
    ];

    protected $filterable = [
        'gender',
        'fullname' => ['LIKE' => '%{fullname}%'],
    ];
}

You need specify the table name by defining a table property on your model:

protected $table = 'users';

Once you have created a model and its associated database table, you are ready to start retrieving data from your database. Since each Eloquent model serves as a query builder, you may also add constraints to queries, and then use the get method to retrieve the results:

/**
* Show user's detail
*
* @return [type] [description]
*/
public function show(Request $request)
{
    $this->user->enableQueryLog();
    $user = $this->user->select(['id', 'fullname', 'email', 'thumb'])where(['id', $request->id])->get();
    Log::info($this->user->getQueryLog());
    if (isApi()) {
        return Response::toJson($user);
    }

    return template('admin', 'admin.users.show', compact('user'));
}

8. View and Template

View

Views contain the HTML served by your application and separate your controller / application logic from your presentation logic. Views are stored in the resources/views directory. A simple view might look something like this:

<!DOCTYPE html>
<html lang="ja">
  <head>
    <?php view('admin.header') ?>
  </head>
  <body id="">
    <?php view('admin.nav') ?>
    <div id="content">
      <h1>Welcome to Atom Framework!!!</h1>
    </div>
  </body>
</html>

As you can see, the first argument passed to the view helper corresponds to the name of the view file in the resources/views directory. The second argument is an array of data that should be made available to the view.

return view('admin.users.list, $data);

Views may also be nested within subdirectories of the resources/views directory. “Dot” notation may be used to reference nested views. For example, if your view is stored at resources/views/admin/users.php

Template

Template assists to show the structure for the comprehensive layout. The process of template is same the view

public function list()
{
    $params = [
        'gender' => 'female',
        'fullname' => 'ngo',
    ];
    $this->user->enableQueryLog();
    $users = $this->user->select(['id', 'fullname', 'email', 'thumb'])->get();
    if (isApi()) {
        return Response::toJson($users);
    }
    return template('admin', 'admin.users.list', compact('users'));
}

The first argument corresponds to the name of the template file in the config/templates.php.

return [
    "admin" => [
        "template" => [
            "header" => "admin.header",
            "content" => null,
            "footer" => "admin.footer",
        ],
    ],
];

The second argument is used to reference nested views as template content, and the last argument is data

Understand more magic methods: __callStatic()

Ngo Dinh Cuong — Tue, 24 Aug 2021 09:50:40 +0000

As you know, magic methods are special methods which override PHP's default's action when certain actions are performed on an object. The following method names are considered magical: __construct(), __destruct(), __call(), __callStatic(), __get(), __set(), __isset(), __unset(), __sleep(), __wakeup(), __serialize(), __unserialize(), __toString(), __invoke(), __set_state(), __clone(), and __debugInfo(). All magic methods, with the exception of __construct(), __destruct(), and __clone(), must be declared as public, otherwise an E_WARNING is emitted.

__callStatic() is method overloading, triggered when invoking inaccessible methods in a static context.

public static __callStatic(string $name, array $arguments): mixed

The $name argument is the name of the method being called. The $arguments argument is an enumerated array containing the parameters passed to the $name'ed method.

With regard to __callStatic(), you can call a method via double colon, and rename functions to short/pretty name

class Str
{
    /**
     * Shortcut methods
     */
    private static $methods = [
        'chunk' => 'chunk_split',
        'split' => 'str_split',
        'length' => 'strlen',
        'reverse' => 'strrev',
        'countWord' => 'str_word_count',
    ];

    /**
     * Trigger when invoking inaccessible methods in a static context
     */
    public static function __callStatic(string $method, array $parameters)
    {
        if (!array_key_exists($method, self::$methods)) {
            throw new Exception('The ' . $method . ' is not supported.');
        }

        return call_user_func_array(self::$methods[$method], $parameters);
    }

    /**
     * Parse query string to varaibles
     */
    public static function parse(string $str)
    {
        parse_str($str, $output);
        return $output;
    }
}

$data = "Happy New Year!";
$countWord = Str::countWord($data, 1);
var_dump($countWord);

$queryStr = "first=value&arr[]=foo+bar&arr[]=baz";
$output = Str::parse($queryStr);
var_dump($output);

class Arr
{
    /**
     * Shortcut methods
     */
    private static $methods = [
        'search' => 'array_search',
        'chunk' => 'array_chunk',
        'combine' => 'array_combine',
        'count' => 'array_count_values'
    ];

    /**
     * Trigger when invoking inaccessible methods in a static context
     */
    public static function __callStatic(string $method, array $parameters)
    {
        if (!array_key_exists($method, self::$methods)) {
            throw new Exception('The ' . $method . ' is not supported.');
        }

        return call_user_func_array(self::$methods[$method], $parameters);
    }

    /**
     * Count all elements in an array
     */
    public static function length(array $arr)
    {
        return count($arr);
    }
}

$arr = [1,2,3,4,5];
$arr2 = [9,8,7,6,5];

$rs = Arr::combine($arr, $arr2);
var_dump($rs);

$length = Arr::length($arr);
var_dump($length);

Another way uses this overloading method that you can define your own function without static keyword, access using double colon. However, this way restricts you must define methods as protected

class Helper
{
    /**
     * __callStatic
     * @param  string $method
     * @param  mixed $args
     * @return void
     */
    public static function __callStatic($method, $args) {
        $called = get_called_class();
        $class = new $called();
        return $class->$method(...$args);
    }

    protected function generateToken($length)
    {
        $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $charactersLength = strlen($characters);
        $randomString = '';
        for ($i = 0; $i < $length; $i++) {
            $randomString .= $characters[rand(0, $charactersLength - 1)];
        }
        return $randomString;
    }
}

$result = Helper::generateToken(10);
var_dump($result);

Handle OTP Auth via your own source code

Ngo Dinh Cuong — Tue, 17 Aug 2021 01:38:44 +0000

Laravel OTP AUTH

This package allows you to authenticate with one time password access (OTP).

https://github.com/cuongnd88/otp-auth

Example Usage:

Route::get("/notify", function(){
    return App\Models\User::find(1)->notify(new App\Authentication\SendOtp('mail', 4, 10));
});

Route::get("/auth-otp/{otp}", function(){
    return App\Models\User::authByOtp(request()->otp, '84905279285');
});

Route::get("/check-otp/{otp}", function(){
    return App\Models\User::find(1)->checkOtp(request()->otp);
});

Installation
Usage
- Generate OTP
- Verify OTP
- Basic identification
- Demo
Credits

Installation

1- Add the package to your dependencies.

$ composer require cuongnd88/otp-auth

2- Run the command:

php artisan auth:otp {ClassName}

Example:

php artisan auth:otp Authentication/SendOtp

SendOtp class and HasOtpAuth trait are auto-generated at app/Authentication directory.

CreateNotificationsTable class is alseo auto-generated at app/database/migrations.

3- Apply the migrations:

It will create a table called notifications to store generated OTP information.

$ php artisan migrate

Usage

Generate OTP

You can generate OTP via email or SMS

Route::get("/notify", function(){
    return App\Models\User::find(1)->notify(new App\Authentication\SendOtp(['mail', 'nexmo']));
});

This package allows you to alter OTP length and lifetime

Route::get("/notify", function(){
    $length = 4;
    $liftime = 10; //minutes
    return App\Models\User::find(1)->notify(new App\Authentication\SendOtp(['mail', 'nexmo']), $length, $liftime);
});

OTP default length: The default length is 6.

OTP default lifetime: The default lifetime is 1 minute.

There is the detail of auto-generate SentOTP class:

<?php

namespace App\Authentication;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Notification;
use Cuongnd88\DeliveryChannel\Messages\TwilioMessage;

class SendOtp extends Notification
{
    use Queueable;

    protected $defaultChannels = ['database'];

    protected $otp;

    protected $lifeTime;

    const OPT_LIFETIME = 1;

    const OPT_LENGTH = 6;

    /**
     * Construct
     *
     * @param array|string $channels
     * @param integer|string $otpLength
     * @param integer|string $lifeTime
     */
    public function __construct($channels = null, $otpLength = null, $lifeTime = null)
    {
        $this->otp = $this->generateOtp($otpLength ?? self::OPT_LENGTH);
        $this->lifeTime = $lifeTime ?? self::OPT_LIFETIME;
        $this->defaultChannels = $this->verifyChannels($channels);
    }

    /**
     * Get the notification's delivery channels.
     *
     * @param  mixed  $notifiable
     * @return array
     */
    public function via($notifiable)
    {
        return $this->defaultChannels;
    }

    /**
     * Get the mail representation of the notification.
     *
     * @param  mixed  $notifiable
     * @return \Illuminate\Notifications\Messages\MailMessage
     */
    public function toMail($notifiable)
    {
        return (new MailMessage)
                    ->line('Your OTP is '.$this->otp)
                    ->line('Thank you for using our application!');
    }

    /**
     * Get the array representation of the notification.
     *
     * @param  mixed  $notifiable
     * @return array
     */
    public function toArray($notifiable)
    {
        return [
            'otp' => $this->otp,
            'expired_at' => now()->addMinutes($this->lifeTime)->toDateTimeString(),
        ];
    }

    /**
     * Get the Nexmo / SMS representation of the notification.
     *
     * @param  mixed  $notifiable
     *
     * @return mixed
     */
    public function toTwilio($notifiable)
    {
        return (new TwilioMessage)
                    ->to("+8439xxxxxxx")
                    ->from("+xxxxxxxxxx")
                    ->body('OTP AUTH is '.$this->otp);
    }

    /**
     * Generate OTP
     *
     * @param integer|string $n
     *
     * @return string
     */
    public function generateOtp($n)
    {
        $generator = "0987654321";
        $result = "";

        for ($i = 1; $i <= $n; $i++) {
            $result .= substr($generator, (rand()%(strlen($generator))), 1);
        }
        return $result;
    }

    /**
     * Verify channels
     *
     * @param string|array $channels
     *
     * @return array
     */
    public function verifyChannels($channels)
    {
        if ($channels && is_array($channels)) {
            return array_merge($this->defaultChannels, $channels);
        }
        if ($channels && is_string($channels)) {
            array_push($this->defaultChannels, $channels);
        }
        return $this->defaultChannels;
    }
}

toTwilio: This method is implemented by importing delivery-channels.

Verify OTP

After sent OTP via your configed methods, you call authByOtp to authenticate

Route::get("/auth-otp/{otp}", function(){
    return App\Models\User::authByOtp(request()->otp, '84905123456');
});

Based on your credentials, you might authenticate with email or phone number

Set up the credentials:

In this case, you can apply User model which must use HasOtpAuth trait

. . . .
use App\Authentication\HasOtpAuth;

class User extends Authenticatable
{
    use Notifiable;
    use HasOtpAuth;

    protected $credential = 'mobile';

. . . .

Let see more detail HasOtpAuth trait

<?php

namespace App\Authentication;

trait HasOtpAuth
{
    /**
     * Check OTP
     *
     * @return bool
     */
    public function checkOtp($otp)
    {
        $authenticator = $this->otp();
        return $this->validateOtp($authenticator, $otp);
    }

    /**
     * Get OTP data
     *
     * @return \Illuminate\Notifications\DatabaseNotification
     */
    public function otp()
    {
        return $this->notifications()
                ->where('type', 'LIKE', '%SendOtp%')
                ->whereNull('read_at')
                ->first();
    }

    /**
     * Validate OTP
     *
     * @param \Illuminate\Notifications\DatabaseNotification $authenticator
     * @param mixed $otp
     *
     * @return void
     */
    public function validateOtp($authenticator, $otp)
    {
        $result = false;
        if (is_null($authenticator)) {
            return response()->json($result,200);
        }
        if ($authenticator
            && now()->lte($authenticator->data['expired_at'])
            && $authenticator->data['otp'] == $otp
        ) {
            $result = true;
        }
        $authenticator->markAsRead();
        return response()->json($result,200);
    }

    /**
     * Authenticate by OTP
     *
     * @param string $otp
     * @param string $credentialValue
     * @return void
     */
    public static function authByOtp($otp, $credentialValue)
    {
        $model = new static;
        $credentialName = property_exists($model,'credential') ? $model->credential : 'email';

        $authenticator = $model->where($credentialName, '=', $credentialValue)->first();
        if (is_null($authenticator)) {
            return response()->json(false,200);
        }

        $authenticator = $authenticator->notifications()
                    ->where('type', 'LIKE', '%SendOtp%')
                    ->whereNull('read_at')
                    ->first();

        return $model->validateOtp($authenticator, $otp);
    }
}

Basic identification

In some cases, you just need to identify the right access, you might need to execute checkOtp method

Route::get("/check-otp/{otp}", function(){
    return auth()->user->checkOtp(request()->otp);
});

Demo

This is demo soure code.
Laravel Colab

Credits

Ngo Dinh Cuong

Make Laravel Permission by yourself

Ngo Dinh Cuong — Sun, 25 Jul 2021 10:32:39 +0000

Laravel Guardian

Laravel Guardian makes it easy to perform permission

https://github.com/cuongnd88/lara-guardian

1-Install cuongnd88/lara-repository using Composer.

$ composer require cuongnd88/lara-guardian

2-Add the following service provider in config/app.php

<?php
// config/app.php
return [
    // ...
    'providers' => [
        // ...
        Cuongnd88\LaraGuardian\LaraGuardianServiceProvider::class,
    ]
    // ...
];

3-Run make:guardian command


php artisan vendor:publish --provider="Cuongnd88\LaraQueryKit\LaraQueryKitServiceProvider"

php artisan make:guardian

App/Traits provides QueryKit trait to empower Laravel models.

App/Guardian/Traits has a trait to support Laravel Guardian.

App/Http/Middlewares/GuardianMiddleware.php is to check user's permissions.

App/Models provides 5 models such as Action, Role, Group, Permission, Role.

database/migrations has 5 tables: actions, roles, groups, permissions, roles.

Sample Usage

Based on route's name, Lara Guardian checks user's permission. You must follow the rule in naming a route: $page.$action

Route::group(['middleware' => ['guardian']], function(){
    Route::get('/user', function(){
        dump("Congratulation. You have the right permission");
    })->name('user.read');
});

You have to assign the guard middleware in your app/Http/Kernel.php file.

    protected $routeMiddleware = [
        . . . .
        'guardian' => \App\Http\Middleware\GuardianMiddleware::class,
    ];

There is the relationship of Guardian's models

MEMO: the alias of actions, pages tables is used to name a route, therefore you need to enter lower-case letters, dash symbol instead of space.

Please add App\Guardian\Traits\HasGuardian.php into the model

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use App\Guardian\Traits\HasGuardian;

class User extends Authenticatable
{
    use Notifiable;
    use HasGuardian;
}

The HasGuardian trait provides:

joinGroup($groupId) : user joins a group.

    public function joinGroup(Request $request)
    {
        $user = \App\Models\User::find(10);
        $user->joinGroup(2);
    }

joinMultiGroups($groups) : user joins multi groups.

    public function joinManyGroups(Request $request)
    {
        $user = \App\Models\User::find(10);
        $user->joinMultiGroups([
            ['group_id' => 1],
            ['group_id' => 3],
        ]);
    }

hasPermissions(array $where = [], string $action = null, array $select = []) : show user's permissions.

    public function getUserPermissions(Request $request)
    {
        $user = \App\Models\User::find(10);
        $user->hasPermissions()->toArray();
    }

rightAccess(string $page = null, string $action = null) : check user has the permission to access.

    public function checkUserAccess(Request $request)
    {
        $user = \App\Models\User::find(10);
        if ($user->rightAccess('product', 'create')) {
            dump('Right Access');
        } else {
            dump('Forbidden');
        }
    }

Import/Export data

Currently, Lara Guardian imports array data (read files in config\guardian) into database, and exports data in DB to file by using simple command

php artisan guardian --action[=ACTION] --model[=MODEL]

--action= is import or export value.

model= is one or three values actions|pages|groups.

For example:

php artisan guardian --action=import --model=actions

App\Traits\QueryKit.php support these useful methods in importing/exporting guardian data:

insertDuplicate(array $data, array $insertKeys, array $updateKeys) is insert new rows or update existed rows. The first argument consists of the values to insert or update, while second argument lists the column(s) that uniquely identify records within the associated table. The third argument is an array of the columns that should be updated if a matching record already exists in the database.

$data = [
    ['fullname' => 'AAAA', 'email' => 'aaaa@xxxx.com', 'age' => 20, 'address' => 'WWW'],
    ['fullname' => 'BBBBB', 'email' => 'bbbb@xxxx.com', 'age' => 25, 'address' => 'QQQQ'],
];
\App\Models\User::insertDuplicate(
        $data,
        ['fullname', 'email'],
        ['age', 'address']
    );

except(array $columns) is to retrieve a subset of the output data.

    $exceptable = ['created_at', 'updated_at', 'deleted_at'];
    $data = app(User::class)->except($exceptable)->get()->toArray()

Boost your Laravel models by Lara Query Kit

Ngo Dinh Cuong — Tue, 20 Jul 2021 04:03:45 +0000

Lara Query Kit utilizes the Eloquent model. PHP Trait and Laravel local scope are used to implement this utilitiy

PHP Traits

PHP only supports single inheritance: a child class can inherit only from one single parent.

So, what if a class needs to inherit multiple behaviors? OOP traits solve this problem.

Traits are used to declare methods that can be used in multiple classes. Traits can have methods and abstract methods that can be used in multiple classes, and the methods can have any access modifier (public, private, or protected).

Laravel local scope

Local scopes allow you to define common sets of constraints that you may easily re-use throughout your application. To define a scope, simply prefix an Eloquent model method with scope.

Installation & Configuration

1-Install cuongnd88/lara-query-kit using Composer.

composer require cuongnd88/lara-query-kit

2-Push lara-query-kit into your application.

php artisan vendor:publish --provider="Cuongnd88\LaraQueryKit\LaraQueryKitServiceProvider"

3-App\Traits\QueryKit.php is already to pump your performance. Please add QueryKit into the model

. . . .
use App\Traits\QueryKit;

class User extends Authenticatable
{
    use Notifiable;
    use HasOtpAuth;
    use HasGuardian;
    use QueryKit;

. . . .
}

Available methods

Let discuss each method available on the Query Kit.

insertDuplicate()
getTableColumns()
exclude()
filter()
searchFulltext()

insertDuplicate

insertDuplicate(array $data, array $insertKeys, array $updateKeys): Insert new rows or update existed rows.

    public function upsert()
    {
        $data = [
            ['name' => "Dean Ngo", 'email' => 'dinhcuongngo@gmail.com', 'mobile' => '84905005533', 'password' => Hash::make('123456')],
            ['name' => "Robert Neil", 'email' => '1111@gmail.com', 'mobile' => '84905001122', 'password' => Hash::make('123456')],
        ];
        User::insertDuplicate($data, ['name', 'email', 'mobile', 'password'], ['name', 'email', 'mobile']);
    }

getTableColumns

getTableColumns(): Get the array of columns.

    public function listTableColumns()
    {
        $columns = User::getTableColumns();
        dump($columns);
    }

exclude

exclude(array $columns): Retrieve a subset of the output data.

You should define which model attributes you want to exclude. You may do this using the $excludable property on the model.

. . . .
use App\Traits\QueryKit;

class User extends Authenticatable
{
    use Notifiable;
    use HasOtpAuth;
    use HasGuardian;
    use QueryKit;

    protected $excludable = ['deleted_at', 'created_at', 'updated_at'];

. . . .
}

    public function listUsers()
    {
        $data = User::exclude()->get()->toArray();
        dump($data);
    }

Or pass a array of excludable columns as argument

    public function listUsers()
    {
        $users = User::exclude(['deleted_at', 'created_at', 'updated_at'])
                        ->get()->toArray();
        dump($users);
    }

filter

filter(array $params): Get the result with filter conditions.

You may use the fitler method on a query builder instance to add where clauses to the query.
The $filterable property should contain an array of conditions that you want to execute searching. The key of filterable array corresponds to table columns, whereas the value is condition to call where clauses. The most basic condition requires two arguments:

The first argument is simple where clause such as: where, orWhere, whereBetween, whereNotBetween, whereIn, whereNotIn, whereNull, whereNotNull, orWhereNull , orWhereNotNull, whereDate, whereMonth, whereDay, whereYear, whereTime
The second argument is an operator, which can be any of the database's supported operators.

Exceptionally, the third argument is required with the operator is LIKE, it is for a specified pattern

For convenience, if you verify only column in fiterable property, the default clause is where with = operator

. . . .
use App\Traits\QueryKit;

class User extends Authenticatable
{
    use Notifiable;
    use HasOtpAuth;
    use HasGuardian;
    use QueryKit;

    protected $filterable = [
        'id' => ['whereBetween'],
        'email',
        'name' => ['orWhere', 'LIKE', '%{name}%'],
    ];

. . . .
}

    public function filter()
    {
        $where = [
            'id' => [1,5],
            'email' => 'dinhcuongngo@gmail.com',
            'name' => 'ngo',
        ];

        $data = User::->filter($where)->get()->toArray();
    }

Dynamically, you can call filterableCondition() and assign the filterable conditions

    public function filter()
    {
        $filterable = [
            'email',
            'name' => ['orWhere', 'LIKE', '%{name}%'],
            'deleted_at' => ['whereNull'],
        ];

        $where = [
            'email' => 'dinhcuongngo@gmail.com',
            'name' => 'ngo',
            'deleted_at' => '',
        ];

        $data = User::filterableCondition($filterable)
                        ->filter($where)
                        ->get()
                        ->toArray();
    }

searchFulltext

searchFulltext($value, $mode = NATURAL_LANGUAGE): Run full-text queries against character-based data in MySQL tables.

There are four modes of full-text searches:

NATURAL_LANGUAGE (is default): IN NATURAL LANGUAGE MODE
NATURAL_LANGUAGE_QUERY: IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION
BOOLEAN_MODE: IN BOOLEAN MODE
QUERY_EXPANSION: WITH QUERY EXPANSION

The $searchable property should contain an array of conditions that you search full-

. . . .
use App\Traits\QueryKit;

class User extends Authenticatable
{
    use Notifiable;
    use HasOtpAuth;
    use HasGuardian;
    use QueryKit;


    protected $excludable = ['deleted_at', 'created_at', 'updated_at'];

    protected $searchable = [
        'name', 'address'
    ];

. . . .
}

    public function search()
    {
        $data = User::searchFulltext('ngo')->exclude()->get()->toArray();
        dump($data);
    }

You flexibly add matched columns by searchableCols()

    public function search()
    {
        $data = User::searchableCols(['name', 'address'])
                        ->searchFulltext('ngo')
                        ->exclude()
                        ->get()
                        ->toArray();
        dump($data);
    }

You must create a full-text index on the table before you run full-text queries on a table. The full-text index can include one or more character-based columns in the table.

ALTER TABLE `users` ADD FULLTEXT(`name`, `address`);

Create your own `upsert` method

Ngo Dinh Cuong — Mon, 12 Jul 2021 01:42:23 +0000

Occasionally, you may need to update an existing record or create a new record if no matching record exists. You will wish to conduct it by one statement, thus UPSERT is your solution

UPSERT is one of the essential features of DBMS software for managing the database. This operation allows the DML users to insert a new record or update existing data into a table. An UPSERT is made up of a combination of two words named UPDATE and INSERT. The first two letters, i.e., UP stands for UPDATE while the SERT stands for INSERT.

The UPSERT is an atomic operation that means it is an operation that completes in a single-step. For example, if a record is new, it will trigger an INSERT command. But, if it already exists in the table, then this operation will perform an UPDATE statement. By default, MySQL provides the ON DUPLICATE KEY UPDATE option to INSERT, which accomplishes this task.

The INSERT ON DUPLICATE KEY UPDATE statement is a non-destructive method that means it does not remove the duplicate row. Instead, when we specify the ON DUPLICATE KEY UPDATE clause in a SQL statement and a row would cause duplicate error value in a UNIQUE or PRIMARY KEY index column, then updating the existing row occurs.

The syntax of Insert on Duplicate Key Update statement in MySQL is given below:

INSERT INTO table (column_names) 
VALUES (data) 
ON DUPLICATE KEY UPDATE 
column1 = expression, column2 = expression…;

Based on this idea, you can apply to create your own upsert() method in Laravel project. Let do it now!

In this example, if an user exists with fullname is Dean Ngo, and email is dean@ngo.com, his age and address columns will be updated. If no such user exists, a new user will be created. Especially, you wish to perform multiple records in one query

$data = [
    ['fullname' => 'Dean Ngo', 'email' => 'dean@ngo.com', 'age' => 20, 'address' => 'Danang'],
    ['fullname' => 'Bean Roman', 'email' => 'bean@roman.com', 'age' => 25, 'address' => 'Countryard'],
];

To implement a way in reusing code, you have to use Trait

// App\Traits\QueryKit.php
<?php

namespace App\Traits;

use Illuminate\Support\Facades\DB;

trait QueryKit
{
    /**
     * Insert new rows or update existed rows
     *
     * @param array $data
     * @param array $insertKeys
     * @param array $updateKeys
     *
     * @return void
     */
    public static function insertDuplicate(array $data, array $insertKeys, array $updateKeys)
    {
        $model = new static;
        $query = "INSERT INTO {$model->getTable()} __INSERTKEYS__ VALUES __INSERTVALUE__ ON DUPLICATE KEY UPDATE __UPDATEVALUES__";
        $tmpInKeys = array_fill_keys($insertKeys, null);
        $tmpUpKeys = array_fill_keys($updateKeys, null);

        try {
            DB::beginTransaction();
            foreach ($data as $item) {
                $insertValue = array_intersect_key($item, $tmpInKeys);

                $updateValue = implode(', ', array_map(
                    function ($v, $k) { return sprintf("`%s`='%s'", $k, $v); },
                    array_intersect_key($item, $tmpUpKeys),
                    $updateKeys
                ));

                $statement = str_replace(
                    ['__INSERTKEYS__', '__INSERTVALUE__', '__UPDATEVALUES__'],
                    ["(`" . implode("`,`", $insertKeys) . "`)", "('" . implode("','", $insertValue) . "')", $updateValue],
                    $query
                );
                DB::statement($statement);
            }
            DB::commit();
        } catch (\Exception $e) {
            DB::rollBack();
            report($e);
            throw new \Exception($e->getMessage());
        }
    }
}

insertDuplicate(array $data, array $insertKeys, array $updateKeys)

First argument consists of the values to insert or update
Second argument lists the column(s) that uniquely identify records within the associated table
Third argument is an array of the columns that should be updated if a matching record already exists in the database.

// App\Models\User.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
use App\Guardian\Traits\QueryKit;
class User extends Model
{
    use SoftDeletes;
    use QueryKit;
    protected $table = "users";
    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = ['fullname', 'email', 'age', 'address'];
}

OK, you can try it now!

$data = [
    ['fullname' => 'Dean Ngo', 'email' => 'dean@ngo.com', 'age' => 20, 'address' => 'Danang'],
    ['fullname' => 'Bean Roman', 'email' => 'bean@roman.com', 'age' => 25, 'address' => 'Countryard'],
];
\App\Models\User::insertDuplicate(
        $data,
        ['fullname', 'email'],
        ['age', 'address']
    );

The statement first attempts to insert a new row into the table. When a duplicate entry is their error occurs, MySQL will update the existing row with the value specified in the ON DUPLICATE KEY UPDATE clause.

INSERT ON DUPLICATE KEY UPDATE in MySQL

MySQL Upsert

Laravel Japanese Utility

Ngo Dinh Cuong — Wed, 07 Jul 2021 01:40:02 +0000

This package provides a convenient way to retrieve Japanese Utility such as Japanese Postal Code, Japanese Localization, CSV

Installation

1-Install cuongnd88/jutility using Composer.

$ composer require cuongnd88/jutility

2-You can modify the configuration by copying it to your local config directory:

php artisan vendor:publish --provider="Cuongnd88\Jutility\JutilityServiceProvider"

You select the utility by adding --tag option:

php artisan vendor:publish --provider="Cuongnd88\Jutility\JutilityServiceProvider" --tag=public

There are 3 options:

--tag=public is to publish the JPostal Utility via javascript.

--tag=config is to publish the JPostal Utility via php/laravel.

--tag=lang is to publish the Japanese Localization Utility.

Sample Usage

JPostal Utility via Javascript

With the JPostal utility, you can achieve Japanese postal data by postal code. You just need implementing like below

resources/views/user/jpostal.blade.php

. . . .

    <div class="form-group row">
        <label for="email" class="col-md-4 col-form-label text-md-right">{{ __('Post code') }}</label>

        <div class="col-md-6">
            <input id="zip" type="text" class="form-control" name="email" value="" onkeyup="JPostal.capture('#zip', ['#info'])">
        </div>
    </div>

    <div class="form-group row">
        <label for="password" class="col-md-4 col-form-label text-md-right">{{ __('Info') }}</label>

        <div class="col-md-6">
            <input id="info" type="text" class="form-control" name="info">
        </div>
    </div>

. . . .
<script type="text/javascript" src="{{ asset('js/jpostal/jpostal.js') }}"></script>
<script type="text/javascript">
    JPostal.init();
</script>

JPostal.capture(zip, response):

zip : is a string value that you can assign a value contains id or class sign in identifing zip code. For example: .zip or #zip.

response is a array or function that you get the data (prefecture, city, area and street). If the array only has one item, it resturns data with comma sign. The array has 4 elements, so it returns seperated data corresponding to prefecture, city, area and street. If the resposne is a function, it will callback .

MEMO you can use id and class signs for zip and response parameters. You can enter both postal code formats (NNN-NNNN or NNNNNNN).

    <div class="col-md-6">
        <input id="zip" type="text" class="form-control" name="email" value="" onkeyup="JPostal.capture('#zip', ['.prefecture', '.city', '.area', '.street'])">
    </div>

<script type="text/javascript">
    JPostal.init();

    $( "#zip" ).keyup(function() {
        JPostal.capture('#zip', function(data){
            console.log(data);
        });
    });
</script>

The JPostal provides functions to select a city correspond to a prefecture

JPostal.innerPrefecturesHtml(callback) .

JPostal.nnerCityHtmlByPref(prefTag, callback) .

. . . .
    <div class="form-group row">
        <label class="col-md-4 col-form-label text-md-right">{{ __('Prefecture') }}</label>

        <div class="col-md-6">
            <select class="form-control selectPrefecture" id="selectPrefecture">
            </select>
        </div>
    </div>

    <div class="form-group row">
        <label class="col-md-4 col-form-label text-md-right">{{ __('City') }}</label>

        <div class="col-md-6">
            <select class="form-control selectCity" id="selectCity">
            </select>
        </div>
    </div>
. . . .

<script type="text/javascript" src="{{ asset('js/jpostal/jpostal.js') }}"></script>
<script type="text/javascript">
    JPostal.init();

    JPostal.innerPrefecturesHtml(function(prefectures){
        let selectTag = '<option value="">Prefecture</option>';
        for (const [key, value] of Object.entries(prefectures)) {
            selectTag += `<option value="${key}">${value}</option>`;
        }
        $('#selectPrefecture').append(selectTag);
    });

    $("#selectPrefecture").change(function(){
        JPostal.innerCityHtmlByPref('#selectPrefecture', function(cities){
            let selectTag = '<option value="">City</option>';
            for (const item in cities) {
                const {id, name} = cities[item];
                selectTag += `<option value="${id}">${name}</option>`;
            }
            $('#selectCity').append(selectTag);
        });
    });
</script>

JPostal Utility via PHP/Laravel

There are several functions to assist you get Japanese postal code:

jpostal_pref($code = null): Get Japanese prefectures by code .

dump(jpostal_pref(47));

jpostal_pref_city($prefCode, $city = null): Get Japanese city by prefecture code .

dump(jpostal_pref_city(47));
dump(jpostal_pref_city(1, '01101));

jpostal_code($code): Get Japanese postal data by code .

    dump(jpostal_code('1200000'));
    dump(jpostal_code('120-0000'));

jlang($key): Use translation strings as keys are stored as JSON files in the resources/lang/{$currentLocale}/ directory .

    dump(jlang('Add Team Member'));

Japanese Localization Utility

The cuongnd88/jutility package provides a convenient way to retrieve strings in Japanese languages. The default language for your application is stored in the config/app.php configuration file. You may modify this value to suit the needs of your application.

. . . .
    'locale' => 'ja',
. . . .

Language strings are stored in files within the resources/lang directory.

/resources
    /lang
        /en
            messages.php
        /ja
            messages.php

CSV

The CSV utility support to read, validate and get the CSV file. You have to set the valitor in config/csv.php. Please refer to the defaut:

return [
    /*
    |--------------------------------------------------------------------------
    | UTF-8 Bom
    |--------------------------------------------------------------------------
    |
    | The UTF-8 BOM is a sequence of bytes at the start of a text stream (0xEF, 0xBB, 0xBF)
    | that allows the reader to more reliably guess a file as being encoded in UTF-8.
    | Suitable for exporting Japanese data
    |
    */
    'utf-8-bom' => false,

    /*
    |--------------------------------------------------------------------------
    | Validator Support
    |--------------------------------------------------------------------------
    |
    | This is a sample defines how to validate CSV data:
    | - `user.header` is to identify the format of CSV file, that compare the standard header to the CSV header.
    | The "Invalid Header" message of Exception is threw if there is an error
    |
    | - `user.validator` is based on Laravel Validator. If you have multiple user tables or models you may configure multiple
    |       + `user.validator.rules`: set the Laravel validation rules
    |       + `user.validator.messages`: customize the Laravel default error messages
    |       + `user.validator.attributes`: customize the validation attributes
    */
    'user' => [
        'header' => [
            'fname' => 'First Name',
            'lname' => 'Last Name',
            'email' => 'Email',
        ],
        'validator' => [
            'rules' => [
                'fname' => 'required',
                'lname' => 'required',
                'email' => 'required|email',
            ],
            'messages' => [],
            'attributes' => [],
        ],
    ],
];

The CSV is a facade that provides access to an object from the container. You just need to import the CSV facade near the top of the file.

. . . .
use Cuongnd88\Jutility\Facades\CSV;

class UserController extends Controller
{
    . . . .
    public function postCSV(Request $request)
    {
        $csv = CSV::read(
                    $request->csv,
                    config('csv.user.header'),
                    config('csv.user.validator')
                )->filter();
        dump($csv);
    }
}
. . . .

read($file, array $standardHeader = [], $validatorConfig = null): read CSV file, return CSV object .

filter(): filter CSV data, return an array ['validated' => [...], 'error' => [...]].

get(): get CSV data (including validated and error data) except CSV header line, return an array.

validatorErrors(): get validated errors, return an array .

    public function postCSV(Request $request)
    {
        $csv = CSV::read(
                    $request->csv,
                    config('csv.user.header'),
                    config('csv.user.validator')
                );
        $data = $csv->get();
        dump($data);
        $errorList = $csv->validatorErrors();
        dump($errorList);
    }

MEMO: the CSV returns an array data (or error list), the index array is line number of CSV file.

save(string $fileName, array $data, $header = null): export data to CSV file .

    public function downloadCSV()
    {
        $data = User::all()->toArray();
        $header = ['ID','Fullname','Email','Mobile number', 'Email verified data time', 'Created date time', 'Updated date time'];
        CSV::save('user-data', $data, $header);
    }

Demo

This is demo soure code.

JPostal Utility

CSV Utility

Auto-generated Repository Pattern in Laravel

Ngo Dinh Cuong — Sat, 26 Jun 2021 06:05:07 +0000

A repository is a separation between a domain and a persistent layer. The repository provides a collection interface to access data stored in a database, file system or external service. Data is returned in the form of objects.

The main idea to use Repository Pattern in a Laravel application is to create a bridge between models and controllers. This pattern keeps your Laravel code clean and safe, it is worth using repositories to separate the responsibility for which the model should never be responsible.

This package assists to automatically generate the Interface, Repository, Model and Controller files in saving your time and supporting to focus on implementing the logic. Especially, you do not need binding the interface and repository class in Service provider class

https://github.com/cuongnd88/lara-repository

1-Install cuongnd88/lara-repository using Composer.

$ composer require cuongnd88/lara-repository

2-Add the following service provider in config/app.php

<?php
// config/app.php
return [
    // ...
    'providers' => [
        // ...
        Cuongnd88\LaraRepo\LaraRepoServiceProvider::class,
    ]
    // ...
];

3-Run make:repository command

php artisan make:repository --interface=User/UserInterface --repository=User/UserRepository --model=Models/User --controller=User/UserController

--interface is to indicate the Interface file.

--repository is to indicate the Repository file.

--model is to allocate the Model. If not exists, it will confirm to create a model.

--controller option is to create the Controller file. With @resource, it generates a resource controller class.

Sample Usage

Let start code less by running the command:

php artisan make:repository --interface=Staff/StaffInterface --repository=Staff/StaffRepository --model=Models/Staff --controller=Staff/StaffController@resource

The Repositories directory is created when you run the command. All interface and repository files are stores in the app/Repositories/Language directory.

Now inside StaffController, StaffInterface already injected into the construct method. This action is called Dependency Injection

<?php

namespace App\Http\Controllers\Staff;

use App\Http\Controllers\Controller;
use App\Repositories\Staff\StaffInterface;
use Illuminate\Http\Request;

class StaffController extends Controller
{
    protected $staffInterface;

    public function __construct(StaffInterface $staffInterface)
    {
        $this->staffInterface = $staffInterface;        
    }

    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}

Please take a look the auto-generated repositories.php in config directory

<?php
//config/repositories.php
return [
    \App\Repositories\User\UserInterface::class => \App\Repositories\User\UserRepository::class,
    \App\Repositories\Staff\StaffInterface::class => \App\Repositories\Staff\StaffRepository::class,
    \App\Repositories\Language\LanguageInterface::class => \App\Repositories\Language\LanguageRepository::class,

];

The Repository Pattern also allows us to write less code inside our Controllers and that makes it even better rather having a giant code in the Controller which isn't what we want if we are aiming for better maintainability and readability. Let's keep it that way, clean controllers.

Demo

This is demo soure code

app/Repositories

Staff/StaffController.php

Forem: Ngo Dinh Cuong

OAuth Integration in NestJS: From Hours of Configuration to 2 Minutes

Deep dive into Laravel Pagination - PHP IteratorAggregate

Laravel Simple Datatable

Sample Usage

Build your own PHP framework

1.First things

Single Entry Point

2. Atom/Http/Server.php

3. Basic routing

Memo

4. Middleware

5. Basic Controller

6. Dependency Injection & Controllers

Constructor Injection

Method Injection

7. Model

Database: Query Builder

Retrieving Models

8. View and Template

View

Template

Understand more magic methods: __callStatic()

Handle OTP Auth via your own source code

Laravel OTP AUTH

Contents

Installation

Usage

Generate OTP

Verify OTP

Set up the credentials:

Basic identification

Demo

Credits

Make Laravel Permission by yourself

Laravel Guardian

Sample Usage

Import/Export data

Boost your Laravel models by Lara Query Kit

PHP Traits

Laravel local scope

Installation & Configuration

Available methods

insertDuplicate

getTableColumns

exclude

filter

searchFulltext

Create your own `upsert` method

Laravel Japanese Utility

Installation

Sample Usage

JPostal Utility via Javascript

JPostal Utility via PHP/Laravel

Japanese Localization Utility

CSV

Demo

Auto-generated Repository Pattern in Laravel

Sample Usage

Demo