Forem: Michal Czerski

BoltJS: pure JavaScript, components, and zero compilation

Michal Czerski — Fri, 24 Oct 2025 16:49:21 +0000

When I started in web development, there was no division into frontend/backend/fullstack developers.
There was simply the web developer - one person doing everything. We built both frontend and backend, most often with PHP and jQuery, and it just worked.
Later came frontend frameworks introducing components, like React.
Then TypeScript entered the scene. And that's when things started to get complicated. Too complicated. I feel it's overengineered for many use cases.

Why BoltJS?
I had two options:
bend myself to the tools that slow down the path from idea to working code,
or build my own solution.

I chose the second.
The goal of BoltJS was to get closer to the ideal: from idea to result in the shortest possible time.
The better the tool, the simpler and more intuitive the interface should be.

BoltJS principles
Zero compilation - pure JS, ready right away
Single source - just plug it in from jsDelivr
Components - encapsulated, reusable functions
SSR + CSR - full support for hybrid rendering
Events - communication via an event subscription system
DOM manipulation - directly (querySelector) or through an abstraction layer
Two-way binding - works with input, checkbox, textarea, select
Loaders, conditions, classes - built-in mechanisms in the framework
Completeness - aiming for a self-contained ecosystem without extra libraries

Example - TODO list
Live demo

<x-todo-form>
    <input type="text" placeholder="Your todo" x-enter-pressed="add" value="{{todo}}"/>
    <button x-click="add">Add</button>
</x-todo-form>
<x-todo-list>
    <div>Tasks todo: {{left}} of {{count}}</div>
    <div x-list="items"></div>
</x-todo-list>
<script type="text/javascript">
    function TodoForm(self)  {
        self.todo = "";
        self.add = () => {
            if (!self.todo) {
                alert("TODO can not be empty.");
                return;
            }
            self.emit("new-todo", self.todo);
            self.todo = "";
        }
    }
    function TodoList(self) {
        self.items = new WatchList([$(TodoItem, "My first TODO")]);
        self.left = 1;
        self.count = 1;

        self.countTasks = () => {
            self.left = self.items.count(x => x.done == false);
            self.count = self.items.count();
        }
        self.on('new-todo', todo => {
            let item = $(TodoItem, todo);
            self.items.add(item)
            self.countTasks()
        });
        self.on('del-todo', todo => {
            self.items.delete(x => x == todo)
            self.countTasks()
        });
        self.on('task-changed', self.countTasks);
    }
    function TodoItem(self, name) {
        self.name = name;
        self.done = false;
        self.delete = () => self.emit('del-todo', self);
        self.changed = () => {
            self.done = !self.done;
            self.emit('task-changed');
        }
        self.template =
            `<div class="todo-item">
                <input type="checkbox" x-change="changed" />
                <div x-class="done:done">{{name}}</div>
                <div x-click="delete" class="del">delete</div>
            </div>`;
    }
    $([TodoForm, TodoList, TodoItem]);
</script>

The whole thing fits in just a handful of lines - with events, binding, and rendering.
No build steps. No configuration. No extra libraries.

Result
I worked on this code after hours. In the end, I managed to keep it under 20KB.
GitHub repository
Live demos
Documentation with examples
BoltJS on jsDelivr

Join me
BoltJS is just the beginning.
I'm building it to get closer to the ideal: from thought to working code in the shortest possible time.
If this goal resonates with you - check out the repo, play with the code, and share your thoughts.
Your feedback, issues, or pull requests would mean a lot to me.

StormQueries – A Query Builder with ORM Superpowers

Michal Czerski — Thu, 18 Sep 2025 23:23:44 +0000

StormQueries – A Query Builder with ORM Superpowers

Over the years working in web development, I’ve tried countless tools for working with databases.
Most of the time, they fell into one of two categories:

Query Builders (QB) – lightweight, fast, no schema configuration required. Great for quick queries. The downside? Once you need hierarchical data (1 invoice → many items), you’re on your own.
ORMs (Object-Relational Mappers) – powerful for handling relationships, but heavy and often require models, annotations, or schema definitions.

And I kept thinking: why isn’t there something in between?
So I built StormQueries 🚀

Why StormQueries?

StormQueries combines the simplicity of a Query Builder with the power of an ORM.
Here’s what it gives you out of the box:

✅ Build dynamic queries depending on runtime parameters.
✅ Reusable query structures.
✅ Hierarchical data fetching (one-to-many).
✅ Map results to your own objects without modifying models.
✅ Zero schema configuration – just connect to the database.
✅ Support for subqueries.
✅ Intuitive syntax.

One example:
With StormQueries, you can run an incremental update (field = field + 1) — something that’s oddly tricky or impossible in many other tools.

Quick examples

Basic CRUD:

$product = $queries->find('products', ['id' => 5]);

$id = $queries->insert('products', [
    'name' => 'Golden watch',
    'price' => 465
]);

$queries->update('products', ['id' => $id], ['name' => 'Renamed product']);

$queries->delete('products', ['id' => $id]);

Dynamic filtering:

$query = $queries
    ->select('products')
    ->join('product_photos', ['product_photos.product_id' => 'products.id'])
    ->where('is_in_sale', true);

if ($criteria->hasCategory()) {
    $query->where('category_id', $criteria->getCategoryId());
}

$products = $query->findAll();

Subqueries:

$queries
    ->select(SubQuery::create($queries->select('products'), 'p'))
    ->where('p.product_id', 7)
    ->find();

ORM-style relationships (without schema config):

$customer = $queries
    ->select('customers c', Map::select([
        'customer_id',
        'customer_name'
    ], Customer::class, classId: 'customer_id'))
    ->leftJoin('orders o', 'o.customer_id = c.customer_id', Map::many("orders", [
        'order_id'
    ], Order::class, classId: 'order_id'))
    ->where('c.customer_id', 90)
    ->find();

foreach ($customer->orders as $order) {
    echo $customer->customer_name . " - " . $order->id;
}

How is it different?

Doctrine / Eloquent (PHP) – require schema definitions and models. StormQueries works right after connecting.
SQLAlchemy, Hibernate – powerful but heavy, with lots of boilerplate. StormQueries is lightweight and fast.
Pure Query Builders – flexible, but no hierarchical mapping. StormQueries bridges the gap.

Try it out

🔗 GitHub: storm-php-queries
📖 Docs & examples: stormmoredev.github.io/storm-php-queries

Final thoughts

StormQueries was born out of real-world needs: I wanted the simplicity of Query Builders with the convenience of ORMs, without their usual trade-offs.

If this sounds useful, check it out, give it a ⭐ on GitHub, or drop me some feedback.
Issues, discussions, and pull requests are more than welcome 🙌

This is just the beginning — I’m planning more features inspired by real application use cases. Stay tuned!

Overloading methods with types in PHP 8.0 and above. The way it should be.

Michal Czerski — Fri, 10 Jan 2025 04:13:07 +0000

Since PHP 7.4 we have types and I have feeling I was programming in languages like Java or C# which is really nice but then I noticed I can’t overload my methods way I used to in other projects with typed languages.

Solutions given on StackOverflow are unacceptable so I was thinking how to overload methods in most efficient and clean way and made library to support it. I want to share it with you because it’s best You could find. You can get it on GitHub and learn more.

I think short snippet of code beneath is sufficient to understand how does it work.

$userRepository = new UserRepository();
$userRepository->add('Michael', 'Jordan', 23);
$userRepository->add(name: 'Michael Jordan', number: 23);
$userRepository->add(new User("Micheal", "Jordan", 23));
$userRepository->add(player: new Player("Michael", "Jordan", 23));
$userRepository->add(['fist_name' => 'Michael', 'last_name' => 'Jordan', 'number' => 23]);

public function add(mixed ...$args): void
{
        $addMethodOverloader = MethodOverloader::create($this)
        ->register($this->addByFirstNameLastNameAndNumber(...),'string', 'string', 'int')
        ->register($this->adddByUser(...), User::class)
        ->register($this->addByPlayer(...), Player::class)
        ->register($this->addByArray(...), 'array')
        ->register($this->addNyNameAndNumber(...), 'string', 'int')
        ->onFailure(function() {
            throw new MyCustomException();
        });

    $addMethodOverloader->invoke($args);
}

It's my first post so please let me know if it's ok. If you have any questions feel free to ask.