DEV Community: Astra Techno

Breaking the MVC Barrier: Introducing TES Architecture (Task-Entity-SQL)

Astra Techno — Thu, 31 Jul 2025 01:54:37 +0000

For the past 15 years, I’ve worked across countless enterprise apps — and one thing always frustrated me:

🧱 The traditional MVC pattern breaks down under complexity.
📉 Business logic gets bloated.
🔄 Repetitive CRUD code everywhere.
🧩 Poor separation between workflows, smart data, and queries.

So, I designed a new architectural system for modern full-stack apps:
🎯 TES – Task, Entity, SQL

🧠 What is TES?
🔸 Task Layer – Handles workflows, jobs, and reusable logic
🔸 Entity Layer – Smart objects with "magic properties" & data relationships
🔸 SQL Layer – Pure data queries, filters, and access rules
🔹 All 3 are coordinated via a Dynamic Query Class system.

💥 Why is this better than MVC?
✅ 10× cleaner than Controllers
✅ Business logic is reusable across APIs/UI
✅ Entity models are smarter — like Laravel Models on steroids
✅ Named queries + filters = secure & efficient data access
✅ Scales perfectly for multi-tenant, SaaS, or modular platforms

🔨 Built with DataForge
This architecture powers my tool: https://data-forge.tech
→ Laravel backend + Vue3 frontend
→ Multi-tenant app builder
→ 80% less repetitive code
→ Build complex modules in 10–20 lines

🤝 I’m Looking For
🔍 Early-stage startups who need this architecture

💼 CTOs who want faster product delivery

📈 Companies looking to scale multi-tenant apps faster

🧠 CTOs or Product Heads curious to try something new

Let’s connect. I’m open to:

🎯 Remote consulting (as Technical Architect)

🧪 Pilot integrations for real-world use

💬 Product demos or tech validation

🙏 I Need Your Help
If this resonates:
✔️ Drop a comment
✔️ Share with your tech circle
✔️ Or just DM — I’m happy to talk

Let’s push past MVC. Let’s build better.

Beyond MVC: Redefining Backend Development with DataForge

Astra Techno — Sun, 12 Jan 2025 06:37:42 +0000

In the world of backend frameworks, the MVC (Model-View-Controller) architecture has become the de facto standard for organizing application layers. Tools like Laravel's Eloquent ORM provide an excellent structure for most use cases, but as projects grow in complexity, developers often face challenges:

How do you manage modular and reusable SQL logic without duplicating code?
How do you efficiently adapt queries to return different result formats like lists, single rows, or single columns?
How do you build advanced inter-entity relationships and lazy-load attributes for optimal performance?
How do you design APIs that are both powerful and easy to scale?

These challenges led to the creation of DataForge, a Laravel-based framework that goes beyond MVC. Unlike traditional frameworks, DataForge introduces a product-first approach to backend development, addressing real-world needs like modularity, scalability, and maintainability.

Why DataForge Stands Out

1. Modular SQL Class Architecture

Eloquent simplifies database interactions but often requires repetitive code for different query formats (e.g., fetching lists vs. single rows).

DataForge Solution: SQL classes in DataForge allow developers to write reusable query logic in one place while providing modular select types to handle multiple use cases effortlessly.

Example:

php

$query = new Query('ProductList');
$query->select('list', 'p.id, p.name, p.price, c.name AS category'); 
$query->select('item', 'p.id, p.name, p.description, p.price, c.name AS category');
$query->select('options', 'p.id, p.name'); 
$query->select('total', 'COUNT(p.id) AS totalCount'); 
$query->filterOptional('p.category_id = {category_id}'); 
$query->filterOptional('p.name LIKE {%keyword%}'); 
$query->order('{sort}', '{order}');

With this structure, you can reuse the same query logic to fetch:

A list of products:

$products = Sql('Product:list', ['select' => 'list'])->fetchRowList();

Details for a single product:

$product = Sql('Product:list', ['select' => 'item', 'id' => 123])->fetchRow();

A total count:

$count = Sql('Product:list', ['select' => 'total'])->fetchColumn();

2. Advanced Entity Features

Eloquent models often mix data access with business logic, leading to less maintainable code. DataForge’s Entity class enhances modularity by cleanly separating these concerns while introducing advanced features:

Lazy Loading: Entity attributes are only loaded when accessed, improving performance by avoiding unnecessary queries.

  $product = DataForge::getProduct(123); 
  echo $product->Price; // Triggers the `getPrice()` method only when accessed.

Inter-Entity Connectivity: Build seamless relationships between entities, making it easier to fetch related data.

  $product = DataForge::getProduct(123); 

  $category = $product->Category; // Directly fetches the related Category entity.

Example: Product Entity

class Product extends Entity
{
    function init($id)
    {
        return \Sql('Product:list', ['id' => $id, 'select' => 'entity'])->fetchRow();
    }

    function getCategory()
    {
        return DataForge::getCategory($this->category_id);
    }
}

3. Versatile API Endpoints

DataForge provides 7 powerful API endpoints, offering developers a structured, scalable way to interact with their backend systems:

/api/list: Fetch paginated lists of records.
/api/all: Fetch all matched records without pagination.
/api/item: Retrieve a single record.
/api/field: Fetch a single column value.
/api/entity: Work directly with entities, including lazy-loaded attributes and inter-entity relationships.
/api/Task: Handle complex workflows, combining SQL and Entity operations.
/api/GuestTask: Provide secure, limited guest access to specific workflows.

Example: Fetching paginated product lists

/api/list/Product:list?keyword=test&pageNo=1&limit=10&sort=price&order=asc

Response:

json

{
  "total": 150,
  "items": [
    {"id": 1, "name": "Laptop", "price": 1000.00, "category": "Electronics"},
    {"id": 2, "name": "Headphones", "price": 50.00, "category": "Accessories"},
    {"id": 3, "name": "Smartphone", "price": 800.00, "category": "Electronics"},
    {"id": 4, "name": "Watch", "price": 200.00, "category": "Accessories"},
    {"id": 5, "name": "T-Shirt", "price": 25.00, "category": "Clothing"},
    {"id": 6, "name": "Jeans", "price": 70.00, "category": "Clothing"},
    {"id": 7, "name": "Shoes", "price": 120.00, "category": "Shoes"},
    {"id": 8, "name": "Book", "price": 15.00, "category": "Books"},
    {"id": 9, "name": "Game Console", "price": 300.00, "category": "Electronics"},
    {"id": 10, "name": "Sunglasses", "price": 50.00, "category": "Accessories"}
  ]
}

Example: Fetching product lists

/api/all/Product:list?&limit=5&select=options

Response:

json

[
    {"id": 1, "name": "Laptop"},
    {"id": 2, "name": "Headphones"},
    {"id": 3, "name": "Smartphone"},
    {"id": 4, "name": "Watch"},
    {"id": 5, "name": "T-Shirt"},
]

Example: Fetching single record

/api/item/Product:list?id=7

Response:

json

{"id": 7, "name": "Shoes", "description":"Beautiful kids shoes" "price": 120.00, "category": "Shoes"}

Example: Fetching single column

/api/field/Product:list?select=total

Response:

json

150

By combining modular SQL classes and these endpoints, developers can create robust APIs with minimal effort while maintaining flexibility and scalability.

4. SQL-Based Workflows

Traditional frameworks often require different methods to fetch lists, single rows, or aggregated data.

DataForge Solution: By defining modular select types in SQL classes, developers can dynamically adjust queries to return the desired data format without rewriting logic.

How DataForge Enhances Laravel

By integrating DataForge into your Laravel projects, you can:

Streamline Query Logic: Write modular SQL queries once and reuse them dynamically.
Enhance Entity Relationships: Build advanced inter-entity relationships and lazy-loaded attributes.
Adapt Easily: Fetch data in multiple formats (list, row, column) without duplicating logic.
Design Powerful APIs: Use pre-built endpoints to simplify API development.
Ensure Performance and Security: Features like filterOptional and filterAnyOneRequired ensure precise filtering and safe query execution.

Learn More and Get Started

DataForge is a complete backend development toolkit, not just another framework. It’s designed to help developers build structured, scalable products effortlessly.

Explore Documentation: data-forge.tech
Follow Updates: LinkedIn Page
Try It Out: GitHub Repository

We’d love to hear your feedback! How do you think DataForge compares with your current tools? Let’s start a discussion.

Call to Action

How do you currently manage SQL queries, API endpoints, and entity relationships in your projects?
What challenges do you face with traditional ORM tools like Eloquent?

Let’s collaborate to redefine backend development.

🚀 Introducing DataForge: A Laravel-Based Framework to Transform Backend Development

Astra Techno — Sat, 11 Jan 2025 02:26:39 +0000

🚀 Introducing DataForge: A Laravel-Based Framework to Transform Backend Development
Hello Developers,

I'm excited to share DataForge, a game-changing Laravel-based framework designed to simplify and supercharge backend development. If you've ever struggled with managing dynamic SQL queries, modular APIs, or scalable workflows, DataForge is here to solve those pain points.

🔑 Key Features
Dynamic SQL Query Control:
Features like filterOptional and filterAnyOneRequired for precise, secure, and flexible query management.
Modular Architecture:
Manage entities, tasks, and queries seamlessly.
Scalability & Performance:
Optimized for both small applications and enterprise-grade systems.
Ease of Use:
Pre-built components and intuitive syntax to save development time.

📖 Why Choose DataForge?
DataForge empowers developers to focus on crafting innovative business logic while the framework handles complex backend operations. From APIs to service-oriented systems, it’s a complete toolkit for modern backend solutions.

🛠️ Explore DataForge
Check out the official documentation for detailed guides, API endpoints, and demo projects.

🌟 Join the Community
I’d love to hear your thoughts, feedback, or suggestions! Let’s collaborate to make backend development simpler and more powerful.

📩 Questions or ideas? Drop them here!
🔗 Follow us for updates: LinkedIn Page

Let’s redefine how we approach backend development together!