Forem: AdriánColom

⏰ Limited-Time VPS Offers: cheapest high-RAM VPS🚀

AdriánColom — Sat, 22 Feb 2025 11:46:19 +0000

Deploying your app shouldn’t feel like waiting for paint to dry. If you're a web developer looking for speed without draining your wallet, check out my ultimate guide on launching your app fast and cheap with Coolify, Namecheap, and LuxVPS: Deploy Your App Super Fast and Cheap.

But wait—there's more! LuxVPS is offering two killer high-RAM VPS packages that pack a punch:

⚫ Black Luxury Deal #1 – The Performance Beast

26GB DDR4 RAM
4 vCores (Xeon Gold-powered)
150GB NVMe Storage
40TB Traffic
Only €10/month (PERMANENT PRICE)
44 LEFT!

⚫ Black Luxury Deal #2 – The Smart Choice

20GB DDR4 RAM
4 vCores (Xeon Gold-powered)
150GB NVMe Storage
35TB Traffic
Only €7.99/month (PERMANENT PRICE)
39 LEFT!

Imagine your app running at lightning speed with enterprise-grade hardware, premium DDoS protection, and NVMe storage that keeps up with your coding frenzy—all at nearly 50% below market rates!

Ready to level up your deployment game? Grab your VPS through my affiliate link: Grab Your VPS before these deals vanish!

Happy coding!

Deploy Your App Super Fast and Cheap with Coolify 🤑⚡

AdriánColom — Tue, 04 Feb 2025 14:30:00 +0000

Are you tired of wasting money on clunky deployment services? Want your app deployed faster than you can say “continuous integration”? Look no further — this guide is your one-way ticket to speedy, cost-effective deployments using Coolify on a VPS. With a little help from LuxVPS and NameCheap, you’ll be up and running without emptying your wallet.

Note: While I use a Laravel app as an example, you can deploy whatever application you prefer. And when it comes to environment variables, don’t worry about checking sensitive info into your repository — you can easily configure them directly within Coolify.

1. Get the Right Tools Without Breaking the Bank

VPS: LuxVPS

I recommend LuxVPS for an affordable, reliable VPS solution. Their monthly pricing is hard to beat if you want performance without a premium price tag. If you want to support me use my link ❤ LINK

Domain: NameCheap

For your domain, NameCheap is the way to go. Their prices are budget-friendly, and setting up DNS is simple. Just create two A records:

One for @
One for * (the wildcard)

Both should point to the IP of your VPS.

If you want to support me use my link ❤ LINK

SSH Access: PuTTY for Windows

If you’re on Windows, I personally rely on PuTTY for SSH access. It’s straightforward and gets you connected without any fuss.

2. Installing Coolify on Your VPS

With your VPS ready, it’s time to install Coolify — your new deployment best friend. Log in to your VPS via SSH (using PuTTY if you’re on Windows) and run:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

This command pulls down and installs Coolify in a snap. Once it’s done, open your browser and navigate to:

http://your-vps-ip:8000

Register your account and log in. When prompted, choose the “install in localhost” option. Next, go to the sidebar settings and set your Coolify access domain (for example, coolify.yourdomain.com). Then, in the server settings, update the domain field with your wildcard domain. And just like that, Coolify is set up and ready to rock!

3. Deploying Your App from GitHub

Time to put the “deploy” in “deployment” and get your app live — be it Laravel or any other framework of your choosing.

Step 3.1: Create a New Project & Add a Resource

Log into Coolify:

Head to your Coolify dashboard in your browser.
Create a New Project:

Click on “Projects” and then “Add Resource.”
Select Private Repository using the GitHub app integration.
Click on Register New App, then Register Now to authorize Coolify with your GitHub account.
Once logged in, search for and select your repository.

Configure the Project Settings: A form will appear where you can specify:

The branch to deploy (typically main).
The build pack and the port. For instance, if you’re deploying a Laravel app, change the port to 80 (check out the Coolify docs for Laravel for details).

Tip: You’re not limited to Laravel — deploy what works best for your project!

Step 3.2: Set Up Your `nixpacks.toml` File

Inside your repository, create (or update) a nixpacks.toml file with your build configuration. Below is an example configuration for a Laravel app that uses Nginx, PHP-FPM, and Supervisord. Feel free to adjust it based on your app’s needs:

[phases.setup]
nixPkgs = ["...", "python311Packages.supervisor"]

[phases.build]
cmds = [
    "mkdir -p /etc/supervisor/conf.d/",
    "cp /assets/worker-*.conf /etc/supervisor/conf.d/",
    "cp /assets/supervisord.conf /etc/supervisord.conf",
    "chmod +x /assets/start.sh",
    "..."
]

[start]
cmd = '/assets/start.sh'

[staticAssets]
"start.sh" = '''
#!/bin/bash

# Transform the nginx configuration
node /assets/scripts/prestart.mjs /assets/nginx.template.conf /etc/nginx.conf

# Start supervisor
supervisord -c /etc/supervisord.conf -n
'''

"supervisord.conf" = '''
[unix_http_server]
file=/assets/supervisor.sock

[supervisord]
logfile=/var/log/supervisord.log
logfile_maxbytes=50MB
logfile_backups=10
loglevel=info
pidfile=/assets/supervisord.pid
nodaemon=false
silent=false
minfds=1024
minprocs=200

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=unix:///assets/supervisor.sock

[include]
files = /etc/supervisor/conf.d/*.conf
'''

"worker-nginx.conf" = '''
[program:worker-nginx]
process_name=%(program_name)s_%(process_num)02d
command=nginx -c /etc/nginx.conf
autostart=true
autorestart=true
stdout_logfile=/var/log/worker-nginx.log
stderr_logfile=/var/log/worker-nginx.log
'''

"worker-phpfpm.conf" = '''
[program:worker-phpfpm]
process_name=%(program_name)s_%(process_num)02d
command=php-fpm -y /assets/php-fpm.conf -F
autostart=true
autorestart=true
stdout_logfile=/var/log/worker-phpfpm.log
stderr_logfile=/var/log/worker-phpfpm.log
'''

"worker-laravel.conf" = '''
[program:worker-laravel]
process_name=%(program_name)s_%(process_num)02d
command=bash -c 'exec php /app/artisan queue:work --sleep=3 --tries=3 --max-time=3600'
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
numprocs=12
startsecs=0
stopwaitsecs=3600
stdout_logfile=/var/log/worker-laravel.log
stderr_logfile=/var/log/worker-laravel.log
'''

"php-fpm.conf" = '''
[www]
listen = 127.0.0.1:9000
user = www-data
group = www-data
listen.owner = www-data
listen.group = www-data
pm = dynamic
pm.max_children = 50
pm.min_spare_servers = 4
pm.max_spare_servers = 32
pm.start_servers = 18
clear_env = no
'''

"nginx.template.conf" = '''
user www-data www-data;
worker_processes 5;
daemon off;

worker_rlimit_nofile 8192;

events {
  worker_connections  4096;  # Default: 1024
}

http {
    include    $!{nginx}/conf/mime.types;
    index    index.html index.htm index.php;

    default_type application/octet-stream;
    log_format   main '$remote_addr - $remote_user [$time_local]  $status '
        '"$request" $body_bytes_sent "$http_referer" '
        '"$http_user_agent" "$http_x_forwarded_for"';
    access_log /var/log/nginx-access.log;
    error_log /var/log/nginx-error.log;
    sendfile     on;
    tcp_nopush   on;
    server_names_hash_bucket_size 128; # this seems to be required for some vhosts

    server {
        listen ${PORT};
        listen [::]:${PORT};
        server_name localhost;

        $if(NIXPACKS_PHP_ROOT_DIR) (
            root ${NIXPACKS_PHP_ROOT_DIR};
        ) else (
            root /app;
        )

        add_header X-Content-Type-Options "nosniff";

        client_max_body_size 35M;

        index index.php;

        charset utf-8;

        $if(NIXPACKS_PHP_FALLBACK_PATH) (
            location / {
                try_files $uri $uri/ ${NIXPACKS_PHP_FALLBACK_PATH}?$query_string;
            }
        ) else (
          location / {
                try_files $uri $uri/ /index.php?$query_string;
           }
        )

        location = /favicon.ico { access_log off; log_not_found off; }
        location = /robots.txt  { access_log off; log_not_found off; }

        $if(IS_LARAVEL) (
            error_page 404 /index.php;
        ) else ()

        location ~ \.php$ {
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
            include $!{nginx}/conf/fastcgi_params;
            include $!{nginx}/conf/fastcgi.conf;

            fastcgi_param PHP_VALUE "upload_max_filesize=30M \n post_max_size=35M";
        }

        location ~ /\.(?!well-known).* {
            deny all;
        }
    }
}
'''

Step 3.3: Environment Variables

Important: Do not commit your environment variables into your repository. Instead, add them in the Coolify project configuration. This keeps your sensitive data secure and separate from your codebase.

Step 3.4: Final Domain Tweaks

In your project settings within Coolify, update the domain configuration to your production domain. Once set up, every push to your main branch will trigger an automatic deployment. Sit back and watch the magic happen — deployments so fast you might even beat your coffee break!

Final Thoughts

Deploying your app doesn’t have to be expensive or complicated. With LuxVPS keeping costs low, NameCheap securing your domain, and Coolify automating the process, you’re ready to roll out updates faster than ever before. Whether you’re deploying a Laravel app or any other project, this setup is designed to be simple, efficient, and incredibly cost-effective.

Happy coding — and even happier deploying! Remember, every push to your main branch means another set-it-and-forget-it deployment. Enjoy the speed and savings!

Questions? Comments? Drop them below and let’s chat about all things fast, frugal, and full-stack!

The Ultimate VPS Showdown: Hetzner, Ionos, and LuxVPS — Who’s Your Budget Buddy? 🎉

AdriánColom — Tue, 14 Jan 2025 07:00:00 +0000

If you’ve ever wondered which VPS provider gives the best bang for your buck, you’ve come to the right corner of the internet. Let’s break down three popular options — Hetzner, Ionos, and LuxVPS — to find out where your precious euros (or dollars, or whatever) should go. Spoiler alert: It might depend on your project size, future plans, or just how much caffeine you’ve had when reading this.

Hetzner: The German Workhorse 🐴

Hetzner is like that overachieving friend who also runs marathons: reliable, robust, and always a good choice for big projects. With a variety of shared and dedicated plans, here’s what you can expect:

Shared VPS Highlights:

CX22: 2 vCPUs, 4 GB RAM, 40 GB NVMe — €4.59/month
CX42: 8 vCPUs, 16 GB RAM, 160 GB NVMe — €19.84/month
Perfect if you’re running scalable apps or testing production workloads.

Dedicated VPS Highlights:

CCX13: 2 vCPUs, 8 GB RAM, 80 GB NVMe — €15.11/month
CCX53: 32 vCPUs, 128 GB RAM, 600 GB NVMe — €232.91/month
Dedicated servers shine for serious app scaling. Paired with integrations like Coolify, Hetzner makes scaling a breeze.

Verdict: For high-performance apps or production environments, Hetzner is a clear winner. But for budget-friendly projects, it’s not the cheapest.

Ionos: The Budget-Friendly Newbie 🤑

If you’re just dipping your toes into the VPS world, Ionos feels like the dollar-store option that surprisingly works pretty well.

VPS Highlights:

Linux XS: 1 vCore, 1 GB RAM, 10 GB NVMe — €1/month (setup fee: €10)
Linux L: 4 vCores, 8 GB RAM, 240 GB NVMe — €10/month for six months (then 14€)
Prices increase after promotional periods, so read the fine print! 👀

Verdict: Great for small websites or projects on a shoestring budget. If you’re looking for sustained savings, though, you might outgrow it fast.

LuxVPS: The Underdog with Killer Deals 🎯

LuxVPS may not have the biggest brand name, but its pricing is unbeatable, especially during deals like Black Friday:

VPS Highlights:

Tiny Plan: 2 vCore, 6GB RAM DDR4, 30 GB NVMe — €5.50/month
Starter Plan: 2 vCores, 8 GB RAM DDR4, 50 GB NVMe — €7.45/month
Mega Plan: 4 vCores, 16 GB RAM DDR4, 150 GB NVMe — €11.45/month

Black Friday Magic:

4 vCores, 26 GB RAM — €10/month 🔥(I have this one)

Verdict: For budget-conscious users who love a good deal, LuxVPS is a no-brainer. While it lacks Hetzner’s fancy scaling options, the price-performance ratio is stellar for small to mid-sized projects. Bonus: Use my referral link to save a little extra. 😉

This is my favorite one to use with my clients, because it comes with an administration panel where you can put your brand and give only permission to the client to their server.

REFERAL LINK

TL;DR: Which VPS Wins? 🏆

Big, scalable apps? Go with Hetzner. Their dedicated servers and integrations make them the ideal choice for larger projects.
Tight budget or small projects? LuxVPS offers unbeatable value and frequent promotions. REFERAL LINK
Temporary or entry-level projects? Ionos’ initial discounts are tempting but come with a setup fee.

Final Thoughts:

When it comes to choosing a VPS, there’s no one-size-fits-all. Think about your project size, future growth, and budget. And hey, if you’re leaning toward LuxVPS, don’t forget that referral link — it might just cover my coffee for the month! ☕

Unlock Laravel Code Generation (Part 3): Automating Validation from Your Database Schema 🤯🚀

AdriánColom — Mon, 06 Jan 2025 07:00:00 +0000

In previous posts, we’ve explored using Laravel stubs to streamline code generation. In this installment, we’ll zoom in on a specific example: automatically creating validation rules for your models by extracting metadata from your database schema.

Ready to supercharge your Laravel development? Let’s dive in!

Why Automate Code Generation?

Building code by hand — especially boilerplate like CRUD and validation — is time-consuming, repetitive, and prone to human error. When you integrate automation into your workflow, you:

Stay in Sync: Whenever you add or remove columns from your database, you can regenerate code with a single command.
Improve Consistency: Every generated file follows a uniform structure and coding standard.
Reduce Manual Labor: Focus on your application’s unique features, not on repetitive tasks.
TIME: Reduce repetitive boilerplate when adding or modifying columns.

Extracting Your Database Schema

The first step in this automation journey is extracting your database schema. We want to transform our table definitions into a JSON file — a format that’s easy to read, modify, and feed into a code generation process.

Extracting the Schema into JSON

The first step is to pull table information — like columns and indexes — into a JSON file. Below is a minimal snippet (from a larger TableUtils class that I use in my bigger project, follow me for future projects and updates!) that demonstrates capturing columns for a given table:

// TableUtils snippet
public function getTableInfo(): Collection
{
    // Ensure the table exists
    if (!Schema::hasTable($this->table)) {
        throw new \Exception("Table {$this->table} not found");
    }

    $columns = Schema::getColumns($this->table);

    return collect([
        'model'   => Str::studly(Str::singular($this->table)),
        'table'   => $this->table,
        'columns' => $columns,
    ]);
}

You then convert this collection to JSON and save it to a file — say, schema/categories.json. ( For not do the query all the time )

{
  "model": "Category",
  "table": "categories",
  "columns": [
    {
      "name": "id",
      "type": "bigint(20) unsigned",
      "nullable": false
    },
    {
      "name": "name",
      "type": "varchar(255)",
      "nullable": false
    },
    {
      "name": "created_at",
      "type": "timestamp",
      "nullable": true
    },
    {
      "name": "updated_at",
      "type": "timestamp",
      "nullable": true
    }
  ]
}

Minimal Form Request Stub

Next, we create a tiny stub representing a Form Request in Laravel that we learned to do in the first part:

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class Store{{modelName}}Request extends FormRequest
{
    public function authorize()
    {
        return true;
    }

    public function rules()
    {
        return [
            {{validationRules}}
        ];
    }
}

Generating the Validation Rules Automatically

Here’s a small command that reads the JSON, analyzes each column, and injects an appropriate validation rule into the stub, we learned to combine the stub and the command in the part 2:

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\File;

class GenerateValidation extends Command
{
    protected $signature = 'generate:validation {table}';
    protected $description = 'Generates a Form Request validation file from a table schema JSON';

    public function handle()
    {
        $table = $this->argument('table');
        $schemaPath = base_path("schema/{$table}.json");

        if (! File::exists($schemaPath)) {
            $this->error("Schema JSON for table [{$table}] not found at: {$schemaPath}");
            return;
        }

        // Load the schema
        $schema = json_decode(File::get($schemaPath), true);

        // Load our stub
        $validationStub = File::get(base_path('stubs/validation.stub'));

        // Build rules based on columns
        $rules = collect($schema['columns'])->map(function ($column) {
            $ruleParts = [];

            // Required or nullable
            $ruleParts[] = $column['nullable'] ? 'nullable' : 'required';

            // Quick example for strings
            if (preg_match('/varchar\((\d+)\)/', $column['type'], $matches)) {
                $maxLength = $matches[1];
                $ruleParts[] = 'string';
                $ruleParts[] = "max:{$maxLength}";
            }

            // Could expand for other types (e.g., integer, date)
            return "'{$column['name']}' => '" . implode('|', $ruleParts) . "'";
        })->implode(",\n            ");

        // Insert the rules into the stub
        $validationStub = str_replace('{{modelName}}', $schema['model'], $validationStub);
        $validationStub = str_replace('{{validationRules}}', $rules, $validationStub);

        // Save to app/Http/Requests
        $filename = "Store{$schema['model']}Request.php";
        File::put(app_path("Http/Requests/{$filename}"), $validationStub);

        $this->info("Validation file for [{$schema['model']}] created: {$filename}");
    }
}

How It Works:

Load the JSON: We retrieve our table’s schema file (e.g., categories.json).
Parse Columns: Each column is analyzed to see if it’s nullable or has a varchar(x) type.
Build a Rule String: For instance, a non-nullable varchar(255) becomes required|string|max:255.
Inject into Stub: The placeholder {{validationRules}} is replaced with the built rule strings.
Generate a File: The final StoreCategoryRequest.php is written out, ready to use in your Laravel app.

Why This Matters

Saves Time: You never have to manually type out required|string|max:255 again.
Prevents Errors: Changes to the database propagate to your validation rules at the push of a button.
Easy to Extend: Add logic for integers, dates, or enums — whatever fits your schema.

Looking Ahead

This is just the tip of the iceberg. Once you’re comfortable with automating models, controllers, and validation, you can expand to:

View Generation: Use your schema to generate Blade templates for listing, creating, editing, and viewing records.
API Resources: Automatically build out API controllers, routes, and resource classes based on your schema.
Relationships: Incorporate foreign key data to automatically generate hasOne, hasMany, belongsTo, etc.

For now, the approach outlined here provides a powerful foundation for automating a large chunk of your Laravel development workflow.

Conclusion

By leveraging your database schema to generate validation rules, you take another step toward a fully automated code generation pipeline. You can apply the same principles to build models, controllers, and more—giving you a robust, scalable, and maintainable development process.

Key Takeaways

Centralize Validation: Keep your form requests always aligned with the actual database.
Minimize Manual Upkeep: Regenerate whenever columns change, letting the script do the heavy lifting.
Extend as Needed: Add rules for more data types (e.g., integer, decimal, date) as your application grows.

With this setup, you’ll never again have to track column changes in multiple places—your database schema becomes the single source of truth. Happy coding, and may all your validations be precise!

P.S. If you’re as excited as I am about this upcoming tool, be sure to subscribe to my newsletter or follow me on social media for the latest updates. Let’s revolutionize Laravel development together!

Unlock the code generation of Laravel (part 2): Stubs with Laravel Promts 💻🚀

AdriánColom — Tue, 24 Dec 2024 14:43:56 +0000

As developers, we’re always on the lookout for tools and techniques that make our work more efficient, customizable, and user-friendly. If you’re working with Laravel, you’re in luck! Today, I’ll show you how to combine Laravel stubs with the Laravel Prompts package to create a fully customizable and interactive code generation workflow.

By the end of this guide, you’ll be able to generate code templates dynamically based on user input, all while maintaining the power and flexibility of Laravel’s built-in tools. Ready to supercharge your development process? Let’s dive in! 💪

What Are Laravel Stubs?

Laravel stubs are template files used to generate boilerplate code in Laravel projects. Think of them as skeleton code that Laravel uses for commands like php artisan make:controller or php artisan make:model. You can customize these stubs to fit your project's needs, ensuring that your generated code matches your architecture and coding standards.

For example, by modifying the default controller.stub, you can automatically include traits, middleware, or other boilerplate code every time you generate a new controller.

How to Use and Customize Laravel Stubs

Locate and Publish Stubs:

Laravel keeps its default stubs hidden in the vendor directory. You’ll need to publish them into your project if you want to customize them:

php artisan stub:publish

This will generate a stubs directory in the root of your project where you can modify the available stubs, like controller.stub or model.stub.

2. Customize the Stub:

For example, let’s add a custom trait to the controller stub:

// controller.stub example
namespace {{ namespace }};

use App\Traits\YourCustomTrait;
use Illuminate\Http\Request;

class {{ class }} extends Controller
{
    use YourCustomTrait;

    // Custom methods
}

Now, every time you generate a new controller, it will include the YourCustomTrait by default.

To see more about stubs see part 1:

Unlock the Magic of Laravel Stubs: Supercharge Your Code Generation 🚀

Hello, Laravel enthusiasts! 🖐️ Welcome to the magical world of Laravel stubs — a powerful tool that can save you…

medium.com

What Is Laravel Prompts?

Laravel Prompts is an excellent package that adds interactive CLI prompts to your Laravel commands. Whether you need to gather user input or make your commands more dynamic, Laravel Prompts makes it easy.

Here’s how you can add interactive prompts to your Laravel commands using the package.

Installing Laravel Prompts

The latest versions of Laravel already include the Prompts package, so no need to install it separately. However, if you’re using a standalone PHP project, you can install it via Composer:

composer require laravel/prompts

More in https://laravel.com/docs/11.x/prompts

Combining Laravel Stubs and Prompts for Ultimate Flexibility

Let’s combine Laravel stubs with Laravel Prompts to create an Artisan command that dynamically generates a controller based on user input!

Step 1: Create a Custom Artisan Command

First, we’ll generate a new Artisan command using Laravel’s make:command command:

php artisan make:command GenerateCustomController

This will create a new command file in app/Console/Commands/GenerateCustomController.php. Now, let's edit this command to use Laravel Prompts and interact with our stubs.

Step 2: Add Interactive Prompts to the Command

In our command, we’ll use the Laravel Prompts package to gather user input. For example, we’ll ask the user for the name of the controller, whether it should be a resource controller, and if it should include any specific traits.

Here’s the updated command:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use function Laravel\Prompts\text;
use function Laravel\Prompts\confirm;

class GenerateCustomController extends Command
{
    /**
     * The name and signature of the console command.
     */
    protected $signature = 'make:custom-controller';

    /**
     * The console command description.
     */
    protected $description = 'Generate a custom controller with interactive prompts';

    public function handle()
    {
        // Prompt the user for the controller name
        $controllerName = text('Enter the name of the controller:');

        // Ask if the controller should be a resource controller
        $isResource = confirm(
            label: 'Should this be a resource controller?',
            default: true,
            yes: 'Yes, make it a resource controller',
            no: 'No, keep it simple'
        );

        // Confirm if a custom trait should be included
        $includeTrait = confirm(
            label: 'Do you want to include a custom trait?',
            default: false,
            hint: 'You can always add traits later if needed.'
        );

        // Create the file using the stub template
        $this->createController($controllerName, $isResource, $includeTrait);
    }

    private function createController($name, $isResource, $includeTrait)
    {
        // Define the stub file to use
        $stubPath = base_path('stubs/controller.stub');
        $stub = file_get_contents($stubPath);

        // Replace placeholders in the stub
        $stub = str_replace('{{ class }}', $name, $stub);

        if ($isResource) {
            // Modify stub to include resource methods
            $stub = str_replace('// Methods', 'public function index() {}', $stub);
        }

        if ($includeTrait) {
            // Add trait usage
            $stub = str_replace('// Traits', 'use App\\Traits\\YourCustomTrait;', $stub);
        } else {
            $stub = str_replace('// Traits', '', $stub);
        }

        // Save the generated file
        $filePath = app_path("Http/Controllers/{$name}.php");
        file_put_contents($filePath, $stub);

        $this->info("Controller {$name} created successfully!");
    }
}

Explanation:

Prompts: We ask the user for input using text for the controller name and confirm for yes/no questions. These prompts make the command more interactive and allow the user to customize the generated controller.
Custom Stub: We load the controller stub file, replace placeholders ({{ class }}), and adjust the content based on user input (whether to include a trait or resource methods).
Generating the File: The final controller is saved to the app/Http/Controllers directory.

See more of commands at https://laravel.com/docs/11.x/artisan#command-structure

Step 3: Customize the Stub for Dynamic Options

Now, let’s update the controller.stub file to accommodate the changes based on the user’s input.

Here’s an example of the updated controller.stub:

<?php

namespace {{ namespace }};

use Illuminate\Http\Request;
// Traits

class {{ class }} extends Controller
{
    // Traits

    // Methods
}

The placeholders like {{ class }} and // Traits will be replaced dynamically by the Artisan command based on the user’s selections.

Step 4: Testing the Command

With everything in place, run the command and watch the magic happen:

php artisan make:custom-controller

You’ll be prompted for the controller name, whether it should be a resource controller, and if it should include a custom trait. Based on your input, Laravel will generate a fully customized controller for you!

Advanced Customization

Once you’ve mastered the basics, feel free to add more prompts to capture even more details for your stubs. For example, you could:

Create more complex stubs for models, service classes, migrations, etc.
Use validation on your prompts to ensure the user enters valid data.
Use a more advanced file structure ( A class for stubs, interfaces, etc )

Laravel Prompts and stubs give you an incredible amount of flexibility. With this setup, you can automate code generation to fit your exact needs — saving time and boosting productivity. 🚀

Conclusion

By combining Laravel stubs with the Laravel Prompts package, you can create powerful, interactive command-line tools that streamline your development process. This approach not only saves time but also ensures consistency and customization across your entire codebase.

Ready to take your Laravel development to the next level? Try integrating Laravel Prompts and stubs in your next project and see the productivity boost for yourself!

Happy automating! 😄⚙️

Feel free to share your thoughts, ideas, and projects using this approach in the comments! Let’s grow together as Laravel developers.

Unlock the Magic of Laravel Stubs: Supercharge Your Code Generation 🚀

AdriánColom — Tue, 24 Dec 2024 14:41:28 +0000

Hello, Laravel enthusiasts! 🖐️ Welcome to the magical world of Laravel stubs — a powerful tool that can save you countless hours of repetitive coding. If you’ve ever wished for a coding assistant to handle the mundane tasks, your wish is about to come true. In this post, we’ll explore what Laravel stubs are, how to use them, and how they can be customized to fit your needs.

What Are Laravel Stubs? 🛠️

Think of Laravel stubs as the blueprint for your code. Imagine building a house: you wouldn’t start from scratch each time. Instead, you’d use a blueprint — adjusting it for each project but always starting from a solid foundation. Laravel stubs work the same way. They’re pre-designed templates that let you generate code quickly and consistently, just like laying a foundation for a new building.

Laravel uses these stubs to create boilerplate code when you run commands like php artisan make:controller, php artisan make:model, and others. By customizing these stubs, you can ensure that your generated code fits perfectly with your project’s specific needs, just as an architect customizes blueprints to fit the unique requirements of a building.

Why Should You Care About Stubs? 🧐

Consistency: Keep your codebase consistently clean and uniform across every file.
Efficiency: Accelerate your workflow by instantly generating repetitive code.
Customization: Fine-tune your stubs to precisely match your project’s unique needs.

Getting Started with Laravel Stubs

Step 1: Locate the Default Stubs 🗂️

Laravel’s default stubs are stored in the vendor/laravel/framework/src/Illuminate/Foundation/Console/stubs directory. Think of this directory as the storage room for all your construction blueprints. Take a moment to browse through it—you’ll find templates for controllers, models, migrations, and more.

Step 2: Publish the Stubs 🛠️

To start customizing stubs, you need to bring them into your project’s root directory. Run the following Artisan command:

php artisan stub:publish

This will create a stubs directory in the root of your Laravel application. It’s like setting up your own blueprint station on-site, ready for customization.

Step 3: Customize Your Stubs 🎨

Now, the real fun begins — customizing the stubs to suit your needs. Open the stubs directory and edit the files as you see fit. For example, if you want all your controllers to include a specific trait by default, you can modify the controller.stub:

// controller.stub example
namespace {{ namespace }};

use App\Traits\YourMagicTrait;
use Illuminate\Http\Request;
class {{ class }} extends Controller
{
    use YourMagicTrait;

    // Your custom methods
}

Step 4: Generate Code Using Customized Stubs ⚡

Once your custom stubs are in place, generating code becomes a breeze. Use Artisan commands as usual, and Laravel will use your custom stubs:

php artisan make:controller MagicController

It’s like having a construction crew that knows exactly where every beam and wall goes, saving you time and ensuring consistency.

Practical Examples 🎯

Example 1: Custom Controller Stub

Let’s say you always use a specific trait in your controllers. Modify controller.stub like this:

use App\Traits\YourMagicTrait;

class {{ class }} extends Controller
{
    use YourMagicTrait;

    // Additional methods
}

Example 2: Custom Migration Stub

If you want every new database table to include default columns, such as a column whose name is active, edit the migration.stub:

public function up()
{
    Schema::create('{{ table }}', function (Blueprint $table) {
        $table->id();
        $table->timestamps();
        $table->boolean('active')->default();
        // Your default columns
    });
}

Example 3: Advanced Controller Customization

Suppose you frequently add specific logic or dependencies to your controllers — like integrating a custom HVAC system into every new building. Customize your controller.stub to include these by default:

// controller.stub example
namespace {{ namespace }};

use App\Services\YourCustomService;
use Illuminate\Http\Request;

class {{ class }} extends Controller
{
    public function __construct(
      protected YourCustomService $service
    ) {}

    // Your custom methods
}

Advanced Customization Tips 🧠

1. Using Placeholder Variables

Laravel stubs use placeholder variables like {{ namespace }}, {{ class }}, and more, which are dynamically replaced when files are generated. You can even add custom placeholders, just like marking specific spots on your blueprint for unique features:

// custom.stub
namespace {{ namespace }};

class {{ class }}
{
    public function customMethod()
    {
        // {{ customPlaceholder }}
    }
}

2. Creating Custom Artisan Commands

If you want to take automation to the next level, creating custom Artisan commands can make your workflow even smoother. Laravel makes it easy to create your commands, which can leverage your custom stubs:

Create a New Command: Use the Artisan command to generate a new custom command:

php artisan make:command CustomMakeCommand

This command generates a new file in app/Console/Commands/CustomMakeCommand.php.

2. Define the Command Logic: Open the generated file and define the logic of your command. Here’s how you might use a custom stub within your new command:

// CustomMakeCommand.php
namespace App\Console\Commands;

use Illuminate\Console\Command;

class CustomMakeCommand extends Command
{
    protected $signature = 'make:custom {name}';
    protected $description = 'Create a custom class with a custom stub';

    public function handle()
    {
        $name = $this->argument('name');
        $stub = file_get_contents(base_path('stubs/custom.stub'));
        $content = str_replace('{{ class }}', $name, $stub);
        file_put_contents(app_path("{$name}.php"), $content);
        $this->info("Custom class {$name} created successfully!");
    }
}

3. Run Your Custom Command: You can now use this custom command just like any other Artisan command:

php artisan make:custom MyCustomClass

This command will generate a new class file using your custom stub template, saving you time and ensuring consistency.

Conclusion 🎉

Laravel stubs are a powerful feature that can save you time and ensure consistency across your projects. By customizing these templates, you can streamline your workflow and maintain high coding standards effortlessly. And with a bit of creativity, you could even turn your mastery of Laravel stubs into a profitable venture.

So, go ahead — unlock the magic of Laravel stubs, and let them work their wonders for you. Remember, with great power comes great responsibility.

Happy coding, and may the stubs be ever in your favor! 🚀

CodeFast⚡by Marc Lou: (A Review of a “Learn by Doing” Coding Course for Entrepreneurs Learn to Build a SaaS in Just Two Weeks)

AdriánColom — Tue, 24 Dec 2024 14:40:25 +0000

Introduction

As a developer with two years of professional experience in a different tech stack (Laravel, Vue, Inertia, and Tailwind), I was intrigued (and a bit skeptical) when I came across CodeFast — a course promising to help anyone build and launch a SaaS product in just 14 days. I wanted to see how Marc Lou’s “learn by doing” approach could benefit aspiring entrepreneurs, even if they don’t come from a traditional coding background.

After watching much of the course content and comparing it to my experience, here’s my honest take: CodeFast delivers a fast-paced, no-fluff approach to coding. It’s perfect for those who want to turn ideas into something tangible quickly — but it’s also beneficial to understand that theory still matters, especially if you’re starting from scratch.

Link to the course

The Promise: Launch a SaaS in 14 Days

CodeFast is structured around the bold claim that you can ship your first SaaS in two weeks:

Day 1: Fundamentals of coding
Day 4: Database integration, user logins, and authentication
Day 9: Setting up subscription payments
Day 14: Launching your product

From a strictly practical standpoint, this schedule encourages you to focus on what matters most — building a minimum viable product (MVP) and getting real-world feedback. However, if you’re truly starting at zero (no coding experience at all), you may find yourself lagging behind the 14-day timeline. And that’s okay! The purpose of the course is not to shame you if you don’t make it in two weeks — it’s to motivate you to move faster than typical theory-heavy courses would suggest.

Key takeaway: Even if you don’t finish in 14 days, you’ll have much more to show for your efforts than if you spent those two weeks passively watching endless hours of coding videos.

The Rapid “Learn by Doing” Approach

What I found refreshing was CodeFast’s emphasis on learning just enough to move forward, rather than covering every possible edge case or advanced theoretical concept. Many courses spend dozens of hours on abstract data structures or advanced algorithms (like inverting binary trees or memorizing Big O notation) that, in reality, most entrepreneurs rarely use.

Instead, Marc shows you how to:

Use AI tools (like GitHub Copilot) to write and fix code
Build frontend components quickly with React, Next.js, and Tailwind
Handle backend authentication via magic links, Google OAuth, and a MongoDB database
Integrate payment systems like Stripe or LemonSqueezy

The result: You progress from zero to an online product that can actually charge users and capture data — without getting stuck in deep theory. However, if you’re aiming to become a well-rounded developer, you’ll still need to supplement this approach with core computer science or backend theory at some point. That deeper knowledge can help you diagnose and prevent bigger issues down the line.

Expect (and Embrace) the Bugs

One realistic aspect I appreciated about CodeFast is the acknowledgment that your first projects will have errors. Marc’s philosophy is that bugs are inevitable and part of the learning process — especially when you’re trying to move fast. I completely agree. Even with two years of industry experience, I still run into unexpected behavior or deployment issues when spinning up new projects.

Launching with errors can actually be a strategic move if your goal is to validate your business idea as quickly as possible. Early users can provide feedback on what really matters, and you can fix the high-priority bugs first.

That said, be prepared to spend a fair amount of time post-launch polishing up issues you encounter. This “build fast, fix later” approach might not be right for every situation, but for an MVP or a proof of concept, it’s an efficient method to gauge interest before investing too heavily in perfection.

Link to the course

AI as Your Coding Co-Pilot

By now, you’ve probably heard that AI can generate code, debug issues, and even suggest design improvements. CodeFast integrates these tools into its lessons, showing you how to:

Quickly generate CSS or React components without memorizing syntax
Ask AI to fix error messages or refactor code for clarity
Develop UI/UX elements faster with AI-based prompts

As someone who’s used Laravel, Vue, and Inertia for quite a while, I can confirm that AI is a game-changer — if you understand the fundamentals well enough to guide it. AI can produce suboptimal code if you don’t know how to ask the right questions or read the output critically. That’s where theory comes back into play: understanding why your code works ensures you can spot AI-generated mistakes.

Course Structure & Content

CodeFast is broken into three core sections, delivered through roughly 12 hours of concise videos:

The Mindset (15 minutes)

Why coding as an entrepreneur differs from coding for a big tech job
How to maintain momentum and not get stuck in analysis paralysis

2. The Fundamentals (1 hour 15 minutes)

Basic web dev concepts (HTTP, HTML, CSS, JavaScript)
Enough understanding to use AI effectively

3. Your First SaaS (10+ hours)

Frontend: React, Next.js, Tailwind (and daisyUI)
Backend & Auth: MongoDB, user logins, cookies, sessions
Business & Deployment: Stripe subscriptions, domain setup, hosting, emails, SEO (soon)

For those of us used to Laravel and Vue, these tech choices might be outside our comfort zone. But the principles still carry over: learn how to structure your project, handle authentication, manage data, and roll out updates quickly. It’s valuable exposure to new tools and frameworks that complement your existing skill set.

The Importance of Supplementing with Theory

Though CodeFast focuses on fast execution, don’t overlook the value of diving deeper into theoretical or more advanced topics after (or alongside) the course. Here’s why:

Maintainable Code: Proper design patterns help you avoid spaghetti code.
Scalability: If your SaaS gains real traction, you’ll need to optimize queries, handle concurrency, and more.
Security: Basic authentication is great for an MVP, but larger user bases require stronger security measures and best practices.

Treat CodeFast as a launchpad and then shore up your skills with more comprehensive resources once you have a sense of which areas need extra attention.

My Experience & Final Thoughts

While I don’t use the exact stack that CodeFast teaches, I found tremendous value in seeing how Marc applies the “ship fast, learn fast” mindset to coding. For someone with a couple of years of experience, it was a good reminder that:

You don’t have to code “perfectly” for your app to be useful.
Launching with some bugs is often better than never launching at all.
AI can handle a surprising amount of grunt work — if you guide it well.

For complete beginners, CodeFast is an inspiring way to get started. Just remember that:

14 days is ambitious if you’re totally new. Don’t be discouraged if it takes longer.
Your first projects will have errors — learn from them.
Supplement with theory over time, especially if you want to grow as a developer.

Overall, CodeFast offers a fresh perspective on coding for entrepreneurship — balancing speed, practicality, and modern AI tools to help you launch your ideas into the world. It might not replace a deep dive into computer science fundamentals, but it absolutely works as a fast-track introduction to building a real SaaS product. Whether you use Laravel and Vue or prefer Next.js and Tailwind, you can apply these same principles: start small, launch quickly, and iterate.

If you’re tired of overly theoretical courses and want to see tangible progress on your first business idea, CodeFast is worth considering. And if you already have some experience? You might just pick up a new mindset — and maybe even a new MVP under your belt.

LINK TO THE COURSE

Forem: AdriánColom

⏰ Limited-Time VPS Offers: cheapest high-RAM VPS🚀

Deploy Your App Super Fast and Cheap with Coolify 🤑⚡

1. Get the Right Tools Without Breaking the Bank

VPS: LuxVPS

Domain: NameCheap

SSH Access: PuTTY for Windows

2. Installing Coolify on Your VPS

3. Deploying Your App from GitHub

Step 3.1: Create a New Project & Add a Resource

Step 3.2: Set Up Your nixpacks.toml File

Step 3.3: Environment Variables

Step 3.4: Final Domain Tweaks

Final Thoughts

The Ultimate VPS Showdown: Hetzner, Ionos, and LuxVPS — Who’s Your Budget Buddy? 🎉

Hetzner: The German Workhorse 🐴

Shared VPS Highlights:

Dedicated VPS Highlights:

Ionos: The Budget-Friendly Newbie 🤑

VPS Highlights:

LuxVPS: The Underdog with Killer Deals 🎯

Black Friday Magic:

TL;DR: Which VPS Wins? 🏆

Final Thoughts:

Unlock Laravel Code Generation (Part 3): Automating Validation from Your Database Schema 🤯🚀

Why Automate Code Generation?

Extracting Your Database Schema

Extracting the Schema into JSON

Minimal Form Request Stub

Generating the Validation Rules Automatically

How It Works:

Why This Matters

Looking Ahead

Conclusion

Unlock the code generation of Laravel (part 2): Stubs with Laravel Promts 💻🚀

What Are Laravel Stubs?

How to Use and Customize Laravel Stubs

Unlock the Magic of Laravel Stubs: Supercharge Your Code Generation 🚀

Hello, Laravel enthusiasts! 🖐️ Welcome to the magical world of Laravel stubs — a powerful tool that can save you…

What Is Laravel Prompts?

Installing Laravel Prompts

Combining Laravel Stubs and Prompts for Ultimate Flexibility

Step 1: Create a Custom Artisan Command

Step 2: Add Interactive Prompts to the Command

Step 3: Customize the Stub for Dynamic Options

Step 4: Testing the Command

Advanced Customization

Conclusion

Unlock the Magic of Laravel Stubs: Supercharge Your Code Generation 🚀

What Are Laravel Stubs? 🛠️

Why Should You Care About Stubs? 🧐

Getting Started with Laravel Stubs

Step 1: Locate the Default Stubs 🗂️

Step 2: Publish the Stubs 🛠️

Step 3: Customize Your Stubs 🎨

Step 4: Generate Code Using Customized Stubs ⚡

Practical Examples 🎯

Example 1: Custom Controller Stub

Example 2: Custom Migration Stub

Example 3: Advanced Controller Customization

Advanced Customization Tips 🧠

1. Using Placeholder Variables

2. Creating Custom Artisan Commands

Conclusion 🎉

CodeFast⚡by Marc Lou: (A Review of a “Learn by Doing” Coding Course for Entrepreneurs Learn to Build a SaaS in Just Two Weeks)

Introduction

The Promise: Launch a SaaS in 14 Days

The Rapid “Learn by Doing” Approach

Expect (and Embrace) the Bugs

AI as Your Coding Co-Pilot

Course Structure & Content

The Importance of Supplementing with Theory

My Experience & Final Thoughts

Step 3.2: Set Up Your `nixpacks.toml` File