Forem: Ko Phyo

3 things to consider migrating WordPress database from local to production

Ko Phyo — Sat, 21 Sep 2024 02:31:31 +0000

Migrating a database from local environment to production server can feel overwhelming, but with the right approach, it doesn’t have to be. In this guide, I'll walk through the key points you need to consider ensuring a smooth migration process.

Key Considerations for Database Migration

1. Scheme (Protocol)
Example: http or https

2. Domain Name
Local examples: localhost, localhost/wordpress, wordpress.test
Production example: acme.com

3. URLs in the WordPress Database

1. Scheme (Protocol)

This is fairly simple. When developing locally, we often start with http, but as the project progresses or when we prepare for production, we might switch to https. The key is to make sure that all URLs in the database's table use the same scheme as your production site. If your production site uses https, you’ll need to update the local URLs before migration.

2. Domain Name

In local development, your site might use a URL like localhost/wordpress, but in production, it will use your live domain, such as acme.com. During migration, all instances of the local domain need to be replaced with the live production domain in your database's table.

3. Types of URLs in WordPress

WordPress stores URLs in different formats across the database's table.

Literal URL:
- Example: http://localhost/wordpress
Escaped URL: Used in serialized data where characters need to be escaped.
- Example: http:\\/\\/localhost\\/wordpress
Encoded URL:
- Example: http%3A%2F%2Flocalhost%2Fwordpress

Quick tips:

%3A stands for :
%2F stands for /

To manually check or convert encoded URLs, you can use online tools like URL Decoder/Encoder.

Migration Process

To successfully migrate, you’ll need to search for all occurrences of your local URLs (in all three formats) and replace them with your production URLs. Most database tools or plugins, like WP Migrate DB or Search-Replace-DB, can help automate this process.

By paying attention to the scheme, domain name, and the different URL formats in your WordPress database, you can ensure a smooth and successful migration. Happy migrating!

Alias your module directory with Node standard import mapping

Ko Phyo — Thu, 22 Aug 2024 03:27:39 +0000

If you've ever struggled with requiring/importing files using long, nested relative paths, you're in the right place. In this article, I'll show a method for importing files using standard Node.js solution—no need to rely on additional packages. The import mapping is available starting from Node.js 12+, offers a cleaner way to import files and works for both require and import (ESM), but for packages that have large numbers of subpaths, this might cause package.json bloat and maintenance issues.

Let's say you have the directory structure.

node_modules/
src/
  controllers/
    user.controller.js
  routes/
    users.route.js
  models/
    user.model.js
  services/
    user.service.js
test/
.env
index.js
package.json

Firstly, define imports property in package.json. In the codes below, #root is the project root, #src houses the source code, and #controllers is the specific directory.

{
  "imports": {
    "#root/*.js": "./*.js", 
    "#src/*.js": "./src/*.js", 
    "#controllers/*.js": "./src/controllers/*.js"
  }
}

Require/import it file using the path alias.

// users.route.js
const express = require("express");
const router = express.Router();
const userController = require("#src/controllers/user.controller.js");

router.get("/users/profile", userController.getProfile);

module.exports = router;

Note: Do not forget .js extension when you import or require a file.

If you have "type": "module" in the package.json file, you should use import syntax. If you don't, you should use require syntax. Adding "type": "module" to the package.json enables ES 6 modules. For more info, see here.

Getting data from resource responses before sending it to the client

Ko Phyo — Wed, 24 Apr 2024 14:28:33 +0000

Before telling the cliffhanger from the previous article and want to know what is going on here, check out those articles first in order.

As you have already read, resources can be returned from the controller method.

use App\Http\Resources\UserCollection;
use App\Models\User;

public function index()
{
    return new UserCollection(User::paginate());
}

You want to respond with this format for the success response and achieve it by adding meta data to the resource collection class, knowing that every response contains success and statusCode keys.

{
    "success": true,
    "statusCode": 200,
    "data": [
        {}, 
        {}
    ],
    "pagination": {
        "current_page": "",
        "last_page": "",
        "per_page": "",
        "total": ""
    }
}

Today, I am going to show you how to create a trait class and use it everywhere you want to be.

You may use the trait class in the controller.

use App\Http\Resources\UserCollection;
use App\Models\User;
use App\Traits\ResponseJson;

class UserController extends Controller
{
    use ResponseJson;

    public function index()
    {
        return $this->paginateResponse(
            new UserCollection(User::paginate())
        );
    }
}

I will create a file called ResponseJson.php under the App/Traits directory with two methods.

<?php

namespace App\Traits;

use Illuminate\Http\Response;

trait ResponseJson
{
    protected $successJson = [
        'success' => true,
        'status_code' => 200,
        'message' => '',
        'data' => [],
    ];

    public function paginateResponse($collection)
    {
        // this is the trick
        $class = $collection->response()->getData();

        $this->successJson['data'] = $class->data;

        $this->successJson['pagination'] = $class->pagination;

        return response()->json($this->successJson, 200);
    }
}

As you see, response() method on the resource collection class return Illuminate\Http\JsonResponse class contains headers, content, data, and other attributes and methods.

dd($collection->response());

You need to call the getter method getData() on the result and access the class properties that are returned by stdClass.

Finally, there is no need to create and extend a base resource collection class to include the desired keys. Now you have a dedicated trait class and can add new methods if necessary.

For example

<?php

namespace App\Traits;

use Illuminate\Http\Response;

trait ResponseJson
{
    protected $successJson = [
        'success' => true,
        'status_code' => 200,
        'message' => '',
        'data' => [],
    ];

    protected $errorJson = [
        'success' => false,
        'status_code' => 500,
        'message' => '',
        'errors' => [],
    ];

    public function successResponse($data = [], $message = '', $statusCode = Response::HTTP_OK)
    {
        $this->successJson['data'] = $data;

        $this->successJson['message'] = $message;

        return response()->json($this->successJson, $statusCode);
    }

    public function errorResponse($error = [], $message, $statusCode)
    {
        $this->errorJson['errors'] = $error;

        $this->errorJson['status_code'] = $statusCode;

        $this->errorJson['message'] = $message;

        return response()->json($this->errorJson, $statusCode);
    }

    public function paginateResponse($collection)
    {
        $class = $collection->response()->getData();

        $this->successJson['data'] = $class->data;

        $this->successJson['pagination'] = $class->pagination;

        return response()->json($this->successJson, 200);
    }
}

Happy Tinkering ✌️

Including extra meta data with a resource response

Ko Phyo — Mon, 22 Apr 2024 18:55:21 +0000

In the previous article, I explained about customizing pagination structure.

Today, I want to show returing a JSON response from the controller method with extra top-level keys along with data and pagination keys using the resource class.

As you may know, there is also an organizational standard or preferred format for JSON API responses. I will stick with a pretty basic format.

Success Response Format

{
    "success": true,
    "statusCode": 200,
    "data": [
        {}, 
        {}
    ],
    "pagination": {
        "current_page": "",
        "last_page": "",
        "per_page": "",
        "total": ""
    }
}

A very simple way to return a response from the controller method will be

use App\Http\Resources\UserCollection;
use App\Models\User;

public function index()
{
    return new UserCollection(User::paginate());
}

💡Why use resource collection over resource?

If you would like to customize the resource collection response, you may create a dedicated resource to represent the collection

As you have read and followed the previous article, the return format will be

{
    "data": [
        {}, 
        {}
    ],
    "pagination": {
        "current_page": "",
        "last_page": "",
        "per_page": "",
        "total": ""
    }
}

If not, the default structure will return

{
    "data": [],
    "links": {},
    "meta": {}
}

So how can we achieve the response format described above?

Well, you might have guessed, but

public function index()
{
    return response()->json([
        'success' => true,
        'statusCode' => 200,
        // how should I use the resource collection class here?
    ], 200);
}

Or you might be going the other way around. Create a new resource collection class and add success and statusCode keys.

Method #1 (Adding Meta Data)

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\ResourceCollection;

class UserCollection extends ResourceCollection
{
    public function toArray(Request $request): array
    {
        return [
            'success' => true,
            'statusCode' => 200,
            'data' => $this->collection,
        ];
    }
}

Method #2 (Top Level Meta Data)

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\ResourceCollection;

class UserCollection extends ResourceCollection
{
    public function toArray(Request $request): array
    {
        return parent::toArray($request);
    }

    public function with(Request $request): array
    {
        return [
            'success' => true,
            'statusCode' => 200,
        ];
    }
}

As you see, success and statusCode sit inside the resource collection class. You already know what kind of approach to use to reduce code duplication.

A cliffhanger: What if I want to create a trait and use it in the controller file?

Happy Tinkering ✌️

Customizing API Resource Pagination Structure

Ko Phyo — Sun, 21 Apr 2024 20:00:56 +0000

We have been in the same boat, trying to figure out customizing the pagination structure that was returned from the resource or resource collection. Records are wrapped in data key with additional links and meta that might be unnecessary or want to modify for a different scenario.

Before Laravel 10, you need extra steps to create base resource class that extends JsonResource, modify the collection method from the JsonResource and stuffs. Check this github discussion to modify the structure.

Starting from Laravel 10, there is a method called paginationInformation that can customize pagination data structure. All you have to do is define the method on the resource collection and modify the structure.

As docs per se

This method will receive the $paginated data and the array of $default information, which is an array containing the links and meta keys:

public function paginationInformation($request, $paginated, $default)
{
    $default['pagination']['current_page'] = $default['meta']['current_page'];
    $default['pagination']['last_page'] = $default['meta']['last_page'];
    $default['pagination']['per_page'] = $default['meta']['per_page'];
    $default['pagination']['total'] = $default['meta']['total'];

    unset($default['links']);
    unset($default['meta']);
}

The JSON response structure will be

{
    "data": [
        {}, 
        {}
    ],
    "pagination": {
        "current_page": "",
        "last_page": "",
        "per_page": "",
        "total": ""
    }
}

You may create a base class, define the function and extends the class from resource collection class to prevent code duplication.

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\ResourceCollection;

class BaseResourceCollection extends ResourceCollection
{
    public function paginationInformation($request, $paginated, $default)
    {
        $default['pagination']['current_page'] = $default['meta']['current_page'];
        $default['pagination']['last_page'] = $default['meta']['last_page'];
        $default['pagination']['per_page'] = $default['meta']['per_page'];
        $default['pagination']['total'] = $default['meta']['total'];

        unset($default['links']);
        unset($default['meta']);

        return $default;
    }
}

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;

class UserCollection extends BaseResourceCollection
{
    public function toArray(Request $request): array
    {
        return parent::toArray($request);
    }
}

Happy Tinkering ✌️