DEV Community: Viktor Le

->cursor() or -> chunk()

Viktor Le — Fri, 20 Mar 2026 08:41:52 +0000

In Laravel, the cursor() method is used to iterate through large database datasets efficiently by keeping only a single record in memory at a time. Unlike get(), which loads the entire result set into an array, cursor() uses PHP generators to yield records one by one.

1. Basic Usage

You can call cursor() at the end of an Eloquent or Query Builder chain. It returns a LazyCollection instance that you can loop through.

use App\Models\User;

foreach (User::where('active', true)->cursor() as $user) {
    // Process one user at a time
    echo $user->name;
}

2. Key Characteristics

Single Query Execution: Unlike chunk(), which executes a new query for every batch of records, cursor() executes only one SQL query against the database.
Memory Efficiency: It significantly reduces memory usage because it doesn't build a massive collection of all retrieved objects in PHP memory.
Lazy Collections: Starting from Laravel 6.0, cursor() returns a LazyCollection, allowing you to chain collection methods like filter(), map(), and each() without loading everything at once.
Eager Loading Limitation: Using with() with cursor() can be inefficient because Laravel may still need to load all parent IDs to perform the eager loading query, potentially negating some memory benefits.

Comparison with Other Methods

While cursor() is extremely memory-efficient, Laravel still includes chunk() because they solve different problems. Use chunk() when you need to perform batch operations (like updating records) or load relationships, and use cursor() when memory is your absolute top priority and you only need to read data.

When to use each

The right choice depends on your specific task:

Use chunk() for batch updates or heavy processing.

Why: It processes data in groups (e.g., 1,000 at a time), which is faster for database operations because it minimizes overhead per record compared to a cursor.
Safeguard: Use chunkById() if you are updating the same records you are querying to avoid skipping or repeating data.

Use cursor() for massive datasets (1M+ records) or streaming.

Why: It fetches one record at a time using a single query, keeping memory usage constant regardless of the total result size.
Best for: Simple exports (like generating a large CSV) or read-only loops where you don't need to load many related models.

Use each() for simple iteration on smaller collections.

Note: In the context of large datasets, each() is often used as a method on a chunk or collection. If you call Model::all()->each(), you still load everything into memory first, which is dangerous for large sets.

What is OCR Pre-fill?

Viktor Le — Fri, 19 Dec 2025 18:08:35 +0000

OCR Pre-fill is a technology that uses Optical Character Recognition to automatically extract data from images or scanned documents (like IDs, invoices, forms) and instantly fill those details into digital forms or fields, significantly speeding up data entry, improving accuracy, and boosting efficiency in processes like onboarding, accounting, and customer service. It works by converting visual text into machine-readable data, allowing systems to populate fields like names, addresses, amounts, and dates without manual typing.

How it Works

Image Capture: A user scans or uploads a document (e.g., takes a photo of an ID).
Pre-processing: The software cleans the image (deskews, removes noise) to enhance text recognition.
OCR Extraction: An OCR engine identifies and extracts text, recognizing specific fields based on document type (e.g., name, date, total amount).
Data Mapping: The extracted text is mapped to corresponding fields in a digital form.
Form Pre-fill: The form fields are automatically populated with the extracted data.
Validation (Optional): The system can validate the data for accuracy before final submission.

Key Benefits

Saves Time & Cost: Automates manual data entry, reducing labor and processing time.
Increases Accuracy: Minimizes human errors associated with manual input, especially with AI-driven improvements.
Improves User Experience: Makes mobile applications and digital processes smoother and faster.
Streamlines Workflows: Integrates seamlessly into systems for quicker document processing.

Common Use Cases

Insurance & Banking (BFSI): Processing claims, customer onboarding, identity verification.
Hospitality & Tourism: Digitizing registration forms and guest information.
Accounting: Automating invoice and bill processing.
Mobile Apps: Filling out forms by scanning IDs or other documents.

OCR references

https://ocr.space
https://www.miteksystems.com
https://extend.ai
https://eastgate-software.com
https://formtify.app/ocr-landing

How to revert a committed & pushed file

Viktor Le — Tue, 09 Sep 2025 02:16:39 +0000

If you've already committed the changes and want to revert the FooFile.php file to its original state without affecting other changes in your branch, you can follow these steps:

1. Identify the Commt:

First, identify the commit where the file was last in its desired state. You can use the following command to view the commit history for the file.

Note: the commit hash of the commit where the file was last correct.

git log -- FooFile.php

2. Revert the File to a Specific Commit:

Use the following command to revert the file to the state it was in a specific commit:

git checkout <commit-hash> -- FooFile.php

3. Commit the Reversion:

After reverting the file, you need to commit this change to your branch:

git add FooFile.php
git commit -m "Revert FooFile.php to its original state"

4. Push the Changes:

Finally, push the changes to your remote repository:

git push

How to setup Amazon S3 Compatible Filesystems - MinIO on MacOS for Laravel Application

Viktor Le — Wed, 25 Jun 2025 11:26:47 +0000

By default, your application's filesystems configuration file contains a disk configuration for the s3 disk. In addition to using this disk to interact with Amazon S3, you may use it to interact with any S3-compatible file storage service , and MiniIO is the greate choice here.

Let's say, the .env file has this block

FILESYSTEM_DISK=s3

AWS_ACCESS_KEY_ID=access_key
AWS_SECRET_ACCESS_KEY=secrete_key
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=xxxxxxx
AWS_ENDPOINT=xxxxxxx

There are two ways to setup MiniIO locally

Set up directly in the localhost Easy step with 1 command

brew install minio/stable/minio

Then launch the MinIO Server by running the following command. If desired, you can replace ~/data with another localtion of Storage to read, write and delete access for the MinIO instance

export MINIO_CONFIG_ENV_FILE=/etc/default/minio
minio server ~/data --address :9001 ### API (S3 compatible)
minio server ~/data --console-address :9002 ### Web UI (User Interface)

After you run these above commands, it will print out

Status:         1 Online, 0 Offline.
API: http://192.168.2.100:9001  http://127.0.0.1:9001
RootUser: myminioadmin
RootPass: minio-secret-key-change-me
Console: http://192.168.2.100:9002 http://127.0.0.1:9002
RootUser: myminioadmin
RootPass: minio-secret-key-change-me

Command-line: https://min.io/docs/minio/linux/reference/minio-mc.html
   $ mc alias set myminio http://10.0.2.100:9001 myminioadmin minio-secret-key-change-me

Documentation: https://min.io/docs/minio/linux/index.html

Now, you have access_key and secrete_key which is RootUser, and RootPass. And let's paste to the .env file

FILESYSTEM_DISK=s3

AWS_ACCESS_KEY_ID=myminioadmin
AWS_SECRET_ACCESS_KEY=minio-secret-key-change-me
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=<name_bucket_desire>
AWS_ENDPOINT=http://127.0.0.1:9001

You can connect and interact with MinIO from Laravel Application

Open browser with address: http://127.0.0.1:9002, bummmm MinIO UI appears excellently

Setup by using Docker the docker-compose.yml will look like

version: '3.8'
services:
  minio:
    image: quay.io/minio/minio:latest  # Or your preferred MinIO image
    container_name: minio
    ports:
      - "9001:9001"  # Expose the MinIO server port
      - "9002:9002"  # Expose the MinIO console port
    environment:
      MINIO_ACCESS_KEY: minioadmin  # Replace with your desired username
      MINIO_SECRET_KEY: minioadmin  # Replace with your desired password
      MINIO_DEFAULT_BUCKETS: "my-test-bucket" # Optional: create a default bucket
    volumes:
      - ./data:/data  # Persistent storage for MinIO data
    command: server /data --address ":9001" --console-address ":9002"  # Start MinIO server with console on port 9001
    restart: unless-stopped  # Restart policy for the container

And all the rest is like the option#1 to connect and interact with MinIO

Reference:

Integration Question List

Viktor Le — Wed, 14 May 2025 10:39:53 +0000

When we come into integrating your system with third party? What is question list to be asked?

What is the primary purpose of the integration?
Cost and How a request being charged?
How to handle errors and exceptions or the service is unavailable?
Testing and Deployment?

What else can you think to contribute to the list?

How to review Code better with VS Code

Viktor Le — Thu, 20 Mar 2025 07:40:37 +0000

To review code in GitHub using VS Code, install the "GitHub Pull Requests and Issues" extension, sign in, and then navigate to the pull request in the VS Code activity bar to view changes, add comments, and manage the review process.
Here's a more detailed breakdown:

1. Prerequisites

Install Git: Ensure you have Git installed and configured on your system.
Create a GitHub Account: You'll need a GitHub account to access and review code.
Open VS Code: Launch Visual Studio Code.

2. Install the Extension

Open the Extensions view in VS Code (Ctrl+Shift+X or Cmd+Shift+X).
Search for "GitHub Pull Requests and Issues".
Install th e extension by the Microsoft organization.

3. Sign in to GitHub

Click on the GitHub icon in the activity bar (it should appear after installing the extension).
Click "Sign in to GitHub".
Follow the on-screen instructions to authenticate with your GitHub account.

4. Navigate to a Pull Request

Go to the pull request you want to review in the VS Code activity bar.
You can find pull requests under the "Pull Requests" section.

5. Review the Code

View Changed Files: The extension displays the changed files in the pull request.
Add Comments: Click on the "+" icon next to a line of code to add a comment.
Add a Review: You can add a general review comment to the pull request.
Checkout the Branch: Use the extension to checkout the pull request branch directly from VS Code.
Check GitHub Actions: View the status of GitHub Actions workflows related to th e pull request.

6. Additional Features

GitHub Copilot Integration: Use GitHub Copilot for AI-powered code review suggestions.
Customizable Queries: Configure the extension to filter and organize pull requests based on your needs.
Issue Management: Manage and create issues from within VS Code.

This video demonstrates how to review a pull request from Visual Studio Code

Link: https://www.youtube.com/watch?v=DSl-L6B_Qb4

Laravel Policies and Gates, when to use

Viktor Le — Tue, 18 Mar 2025 06:40:20 +0000

I have an use case like this - "User has permission to export Transaction from Admin Dashboard, because he has Admin Role". For this use case, I ask myself, "What shoud I use Policy or Gate in Laravel to implement it?". Boomb, I think Gate is fast and simple to implement it. However keep asking myself, When should I use Policy, any context to have a strong decision tree here? Searching in Official docs and over the Internet, it comes up for me with the summary.

Policies

Best for Resource-Based Authorization: Policies are ideal when you need to authorize actions on a specific model or resource. They are typically used for CRUD operations on models.
Automatic Resolution: Laravel can automatically resolve policies for models if you follow naming conventions and register them in the AuthServiceProvider.
Organized and Scalable: Policies provide a structured way to organize authorization logic, especially when dealing with multiple actions on a model.

Gates

Best for General Authorization: Gates are more suited for general authorization that is not tied to a specific model. They are often used for actions that apply to the entire application or multiple models.
Simple and Flexible: Gates are simple to define and can be used for quick checks that don't require the structure of a policy.

Recommendation for Your Scenario

Given your scenario where a user with an Admin role and a specific permission (export) needs to export all transactions, a Gate might be more appropriate. This is because the action of exporting all transactions is not tied to a specific instance of a model but is a general action that applies to the entire application.

The N+1 query problem in Laravel and how to solve it

Viktor Le — Fri, 14 Mar 2025 08:59:14 +0000

The N+1 query problem in Laravel (and other ORMs) occurs when an application makes inefficient database queries, leading to performance issues. This problem typically arises in scenarios where a query is executed for each item in a collection, resulting in a large number of queries being executed.

Let's explain the N+1 problem

Inital Query (N): You start with a query that retrieves a collection of items. For example, fetching all users from a database.
Subsequent Queries (+1): For each item in the collection, an additional query is executed to fetch related data. For instance, if you want to retrieve each user's posts, a separate query is executed for each user to get their posts.

Code example:

Consider the following example in Laravel:

$users = User::all(); // N query
foreach ($users as $user) {
   echo $user->posts; // +1 query for each user
}

In this example, if there are 100 users, the code will execute 1 query to get all 100 users, then 100 additional queries to get the posts for each user, resulting in 101 queries.

How to Solve the N+1 Problem

So, Laravel provides several ways to solve the N+1 problem:

Eager Loading: Use eager loading to retrieve related data in a single query. This is done using the with method.

$users = User::with('posts')->get(); // N query
foreach ($users as $user) {
   echo $user->posts; // No additional query for each user
}

In this improvement, Laravel will execute only two queries: one to get all users, and another to get all posts for those users.

Lazy Eager Loading: If you need to load relationships after the initial query, you can use lazy eager loading with the load method.

$users = User::all();
$users->load('posts');

Query Optimization: Sometimes, restructuring your queries or using database indexes can help improve performance. By using eager loading and other optimization teachniques, you can significantly reduce the number of queries executed and improve the performance of your system.

Have you ever wondered when to use $this->app->environment() and app()->environment() in Laravel?

Viktor Le — Tue, 11 Mar 2025 06:54:30 +0000

Here I would like to show you when to use it properly and be headless. Just remember. Hope it could make your decisions stronger.

Boost fast your development with Laravel Market

Viktor Le — Mon, 10 Mar 2025 10:51:25 +0000

Boost fast Product Launching for a back-office website with Laravel market

Laravel Nova https://nova.laravel.com/docs/v5
Laravel Activity Log https://spatie.be/docs/laravel-activitylog/v4/
Laravel Permission https://spatie.be/docs/laravel-permission/v6/
Laravel Ticket https://coderflex.com/open-source/docs

The combination of these packages is completely game-changing in the product builder.

💁 Don't forget to say BIG THANKS TO AI ( ChatGPT and Cursor)

How to review all git changes in a file

Viktor Le — Thu, 20 Feb 2025 23:15:51 +0000

Have you ever come into a situation that a production issue happened in the last two months but it was automatically fixed after that? Then, you brainstorm that it might a good side-effect change in a file which fixed that issue inadvertently.

To investigate the issue with a hard-work you need a tool like viewing all changes in the last two months. And in this post, I will show you two handy tools:

Git command will list all commits for a file:

git log --oneline --follow -- the-path-to-the-file

For example, you have a file, named: foo.js in a src/app folder. The command you should type is:

git log --oneline --follow -- src/app/foo.js

It's a handy little command for those times where you want to see all the Git commit ids associated with a file.

Gitk command

A website needs a browser, and a file also needs Gitk to view too. You can read more in git docs

In Mac, if you do not still have it, then run brew install git-gui to install it. You can read this StackOverflow post in case you have trouble during the installation.

So, to view the changes in a foo.js visually, just run the below command:

gitk src/app/foo.js

How to visualize bar chart with react-chart-2, showing label on the bar

Viktor Le — Thu, 28 Nov 2024 14:24:31 +0000

To create a bar chart in React using react-chartjs-2 and display labels directly on the bars (not in the tooltip), you can use the react-chartjs-2 library combined with the Chart.js DataLabels plugin.

Steps to Implement

Install the Required Libraries: Ensure you have both react-chartjs-2 and chart.js installed in your project. Additionally, install the chartjs-plugin-datalabels plugin:

npm install react-chartjs-2 chart.js chartjs-plugin-datalabels

Import the Necessary Components: Import the chart component, plugin, and register them with Chart.js.
Set Up the Chart Configuration: Configure the options object to include the datalabels plugin.
ender the Chart: Use the Bar component from react-chartjs-2 to render your chart.

Example Code

Here’s an example to create a bar chart with labels shown directly on the bars:

import React from "react";
import { Bar } from "react-chartjs-2";
import {
  Chart as ChartJS,
  CategoryScale,
  LinearScale,
  BarElement,
  Title,
  Tooltip,
  Legend,
} from "chart.js";
import ChartDataLabels from "chartjs-plugin-datalabels";

// Register Chart.js components and plugins
ChartJS.register(
  CategoryScale,
  LinearScale,
  BarElement,
  Title,
  Tooltip,
  Legend,
  ChartDataLabels // Register the DataLabels plugin
);

const BarChartWithLabels = () => {
  // Chart data
  const data = {
    labels: ["January", "February", "March", "April", "May"],
    datasets: [
      {
        label: "Sales",
        data: [30, 20, 50, 40, 60],
        backgroundColor: "rgba(75, 192, 192, 0.6)",
        borderColor: "rgba(75, 192, 192, 1)",
        borderWidth: 1,
      },
    ],
  };

  // Chart options
  const options = {
    responsive: true,
    plugins: {
      legend: {
        display: true,
        position: "top",
      },
      datalabels: {
        color: "black", // Label color
        anchor: "end", // Position the label near the bar's edge
        align: "top", // Align the label to the top of the bar
        formatter: (value) => value, // Format the label (e.g., show the value)
      },
    },
    scales: {
      y: {
        beginAtZero: true,
      },
    },
  };

  return (
    <div style={{ width: "600px", margin: "0 auto" }}>
      <Bar data={data} options={options} />
    </div>
  );
};

export default BarChartWithLabels;

QA for you:

How to customize datalabels for each dataset when using stacked bar ?