DEV Community: Reza Khademi

ZORM: A Zero-Tag, Generic ORM for Golang

Reza Khademi — Fri, 30 Jan 2026 13:28:53 +0000

ZORM is a modern ORM for Go that lets you write fluent, type-safe, SQL-like queries using Go generics — all without struct tags or heavy reflection.

It is built for developers who want:

the ergonomics of an ORM,
the clarity of handwritten SQL,
and the safety guarantees of Go’s type system.

👉 GitHub: https://github.com/rezakhademix/zorm

The Problem with Typical Go ORMs

Many Go ORMs rely on:

struct tags for mapping
string-based queries with limited compile-time guarantees

This often leads to:

duplicated schema definitions
silent runtime errors due to typos
harder refactoring when models change

ZORM takes a different path.

What Makes ZORM Different?

1. No Struct Tags

You define a plain Go struct:

type User struct {
    ID        int64
    Name      string
    Email     string
    CreatedAt time.Time
}

ZORM automatically infers:

table name: users

columns: id, name, email, created_at

No db:"..." or json:"..." style tags are required for persistence.

This reduces boilerplate and keeps your models clean and idiomatic.

2. ZORM Type Safety with Generics

ZORM is built on Go generics, so queries are bound to a concrete type at compile time.

users, err := zorm.New[User]().Get(ctx)

3. Fluent, SQL-Like Query Builder

Queries are chainable and readable:

admins, err := zorm.New[User]().
    Where("role =", "admin").
    OrderBy("created_at DESC").
    Limit(10).
    Get(ctx)

You get composable queries without writing raw SQL everywhere.

You can also inspect the generated SQL:

q := zorm.New[User]().Where("age >", 18)
fmt.Println(q.Print())

Quick Start

Install


go get github.com/rezakhademix/zorm

Connect to the database

db, err := sql.Open("postgres", dsn)
if err != nil {
    log.Fatal(err)
}
defer db.Close()


zorm.SetDB(db)

ZORM Insert query

u := User{
    Name:  "Alice",
    Email: "alice@example.com",
}


err = zorm.New[User]().Insert(ctx, &u)
Query records
users, err := zorm.New[User]().
    Where("email LIKE", "%@example.com").
    OrderBy("id DESC").
    Get(ctx)

ZORM supports common relationships such as:

HasOne
HasMany
BelongsTo
Polymorphic relations

type User struct {
    ID      int64
    Name    string
    Posts   []*Post  // HasMany
    Profile *Profile // HasOne
}

// HasMany: User has many Posts
// Method can be named "Posts" or "PostsRelation"
func (u User) PostsRelation() zorm.HasMany[Post] {
    return zorm.HasMany[Post]{
        ForeignKey: "user_id",  // Column in posts table
        LocalKey:   "id",       // Optional, defaults to primary key
    }
}

// HasOne: User has one Profile
func (u User) ProfileRelation() zorm.HasOne[Profile] {
    return zorm.HasOne[Profile]{
        ForeignKey: "user_id",
    }
}

type Post struct {
    ID     int64
    UserID int64
    Title  string
    Author *User    // BelongsTo
}

// BelongsTo: Post belongs to User
func (p Post) AuthorRelation() zorm.BelongsTo[User] {
    return zorm.BelongsTo[User]{
        ForeignKey: "user_id",  // Column in posts table
        OwnerKey:   "id",       // Optional, defaults to primary key
    }
}

You can eager load related data without manual joins, keeping query logic centralized and reusable.

Transactions

Transactions are explicit and composable:

err := zorm.Transaction(ctx, func(tx *zorm.Tx) error {
    if err := tx.New[User]().Insert(ctx, &u); err != nil {
        return err
    }


    if err := tx.New[Profile]().Insert(ctx, &p); err != nil {
        return err
    }


    return nil
})

If any step fails, everything is rolled back.

Advanced Capabilities

ZORM is not limited to simple CRUD:

prepared statement caching
context-aware execution
subqueries and nested queries
support for complex SQL constructs when needed
Sync - Synchronize Associations

// Current roles in DB: [1, 2, 3]

// Sync to new set of roles
err := zorm.New[User]().Sync(ctx, user, "Roles", []any{1, 2, 4}, nil)
// Result:
// - Role 1: kept (exists in both)
// - Role 2: kept (exists in both)
// - Role 3: detached (was in DB, not in new list)
// - Role 4: attached (not in DB, is in new list)
// Final roles in DB: [1, 2, 4]

Main/Replica Splitting

zorm.ConfigureDBResolver(
    zorm.WithPrimary(primaryDB),
    zorm.WithReplicas(replica1, replica2),
    zorm.WithLoadBalancer(zorm.RoundRobinLB),
)

// Automatic routing
users, _ := zorm.New[User]().Get(ctx)          // Reads from replica
err := zorm.New[User]().Create(ctx, user)      // Writes to primary

// Force primary for consistency
users, _ := zorm.New[User]().UsePrimary().Get(ctx)

// Force specific replica
users, _ := zorm.New[User]().UseReplica(0).Get(ctx)

Common Table Expressions (CTEs)


// String CTE
users, _ := zorm.New[User]().
    WithCTE("active_users", "SELECT * FROM users WHERE active = true").
    Raw("SELECT * FROM active_users WHERE age > 18").
    Get(ctx)

// Subquery CTE
subQuery := zorm.New[User]().Where("active", true)
users, _ := zorm.New[User]().
    WithCTE("active_users", subQuery).
    Raw("SELECT * FROM active_users").
    Get(ctx)

You can stay high-level for most operations and drop lower when necessary.

FAQ

1. Does ZORM use reflection?

ZORM minimizes runtime reflection and relies primarily on Go generics and compile-time type information. This reduces overhead and avoids many of the runtime surprises common in reflection-heavy ORMs.

2. Why are there no struct tags?

ZORM follows convention over configuration.

Field names are automatically mapped from CamelCase to snake_case, and table names are inferred from the struct name. This removes duplication between struct definitions and tag metadata and makes refactoring safer and simpler.

3. Is ZORM faster than other Go ORMs?

ZORM is designed to be lightweight and predictable by avoiding heavy reflection and unnecessary abstractions. Actual performance depends on your queries, database, and indexes, but the goal is to stay close to the cost of using database/sql directly while providing higher-level ergonomics.

4. Can I run raw SQL queries?

Yes.

ZORM focuses on query building and mapping, not restricting SQL. You can always fall back to raw SQL when needed and still scan results into your structs.

5. Does ZORM support transactions?

Yes.

Transactions are explicit and type-safe. You pass a function that receives a transaction handle, and ZORM commits or rolls back automatically based on the returned error.

6. Which databases are supported?

Any database that works with Go’s standard database/sql drivers (e.g. PostgreSQL, MySQL, SQLite, SQL Server).

ZORM is driver-agnostic and does not lock you into a specific backend.

7. Does ZORM handle migrations?

No.

ZORM is focused on querying and data access. Schema migrations should be handled by dedicated tools such as Goose, Golang-Migrate depending on your stack.

8. Can I define relationships between models?

Yes.

Common relations like one-to-one, one-to-many, and polymorphic associations are supported, with optional eager loading to reduce manual join boilerplate.

9. Is ZORM safe to use concurrently?

Yes.

Query builders are independent values. As long as your underlying *sql.DB is safe for concurrent use (which it is by design), ZORM operations can be used across goroutines.

10. When should I not use ZORM?

If you require:

automatic schema generation and migrations
database-first code generation
deep integration with a specific database vendor feature set

In those cases, a migration framework or SQL code generator may be a better primary tool. ZORM is optimized for clean, type-safe query construction and data mapping in idiomatic Go.

Simplify Validation in Golang— No Struct Tags, No Reflection, TypeSafety: Meet GoValidator

Reza Khademi — Fri, 05 Sep 2025 08:44:03 +0000

Validation in Go often means wrestling with reflection-heavy libraries or juggling struct tags.

GoValidator takes a fresh, minimalist approach—delivering precise validation without those complications.

What Is GoValidator?

GoValidator is a Go library designed for simplicity, speed, and ease of use.

No struct tags: you don’t need to clutter your code with metadata.

No reflection: that means even faster performance and better type safety.

Lightweight and extendable: perfect for custom validation needs.

Getting Started

Installation:
go get github.com/rezakhademix/govalidator/v2

Importing:
import validator "github.com/rezakhademix/govalidator/v2"

Validation Rules at a Glance

GoValidator provides a wide range of built-in rules (customizable per field): (list of all rules)

Basic checks: RequiredInt, RequiredFloat, RequiredString, RequiredSlice
Range validations: BetweenInt, BetweenFloat, BetweenString, In
Specialized checks: Date, Email, URL, UUID
Database checks: Exists, NotExists, ExistExceptSelf
Advanced logic: CustomRule, When, RegexMatches, Time, Date

Why Use it?

Simplicity: No boilerplate or tags; validations are explicit and direct.
Extensibility: Define your own rules with the CustomRule() method
Go Packages
Performance: Skipping reflection yields better speed and less overhead. See the benchmark section:

Example:

Here’s a simple use case for validating a signup form:

v := validator.New()

ok := v.
  RequiredString(username, "username", "username is required").
  Email(email, "email", "email is required").
  BetweenInt(age, 18, 60, "age", "age must be between 18 and 60").
  IsPassed()

if !ok {
  log.Println("validation failed, errors:", v.Errors())
}

With this straightforward API, You define the field, its rule, and custom messages. No tags, no reflection—inline and ensure type safety.

Let dive in for a more complex situation:


type CategoryCreateReq struct {
    ParentID    *int   
    Name        string 
    Description string 
    Status      int   
    Meta        string
}

var req CategoryCreateReq

v := validator.New()

ok := v.
    RequiredString(req.Name, "name", "name of category is required").
    MaxString(req.Name, 500, "name", "name should be less than 500 characters").
    MinString(req.Name, 3, "name", "name should be more than 3 characters").
    NotExists(req.Name, "categories", "name", "name", "name already exists"). // ensure req.Name is unique in DB
    MaxString(req.Description, 1500, "description", "description should be less than 1500 characters").
    MinInt(req.Status, 1, "status", "status can not be less than 1").
    MaxInt(req.Status, 12, "status", "status can not be more than 12").
    IsJSON(req.Meta, "meta","meta should be JSON").
    When(req.ParentID != nil, func() {  
        v.Exists(*req.ParentID, "categories", "id", "parent_id","parent doest not exists")  
    }).
    IsPassed()

if !ok {
    return v.Errors()
}

FAQ

🔹 How do I validate structs in Go without tags?

Use GoValidator’s explicit validation methods (RequiredString, BetweenInt, etc.) instead of struct tags. This keeps your validation logic clear and type-safe.

🔹 Can I define custom validation rules?

Absolutely. You can extend GoValidator with CustomRule() and integrate your own validation logic.

🔹 Does it support database lookups?

Yes. GoValidator includes rules like Exists, NotExists, and ExistExceptSelf for database-backed validation.

Laravel Spy: Easily Log Your Application HTTP requests

Reza Khademi — Sun, 10 Aug 2025 13:36:45 +0000

These days, building a web app without using a third-party API is almost impossible!

One of the major things when making outgoing HTTP requests is to review the requests and responses to see what’s happening between our application and the third-party API.

Tracking and logging outgoing HTTP requests will help us improve observability, detect slow APIs, and monitor what’s wrong and why.

Another important thing is having a timeline of requests and responses, so we can review them and extract useful data that we might have missed during the API implementation.

Laravel Spy is a powerfull Laravel package designed to track and log outgoing HTTP requests made by your Laravel application.

Laravel Spy is useful for debugging, monitoring, and auditing external HTTP requests, providing an easy way to inspect details such as URLs, methods, headers, and responses.

To use this package, we first need to install it. So we run:

composer require farayaz/laravel-spy

After the installation, we publish the package configuration files:

php artisan vendor:publish --provider="Farayaz\LaravelSpy\LaravelSpyServiceProvider"

Then, run the migrations to prepare the database for storing request logs:

php artisan migrate

Now, If we go into config/spy.php, the configuration file has these options:

    'table_name' => 'http_logs', // table name for storing http logs

    'enabled' => env('SPY_ENABLED', true), // is laravel spy enabled or not
    'db_connection' => env('SPY_DB_CONNECTION'), // using another db connection for http logs

    'exclude_urls' => explode(',', env('SPY_EXCLUDE_URLS', '')), // add url which don't need to be logged by laravel-spy
    'obfuscates' => explode(',', env('SPY_OBFUSCATES', 'password')), // obfuscates and hide the sensitive data

Laravel Spy gives us an ability to use a separate database connection via the db_connection in cofing file, so we don't abuse the main database connection too much in high-traffic applications.

Also we should be mindful about setting the obfuscates option inside the config/spy.php to hide sensitive data in our API logs like: password, secret and etc.

To check that everything is working we just need to call a sample API through our application. We can add the below code inside our web.php or api.php in our laravel application:

Route::get("/spy", function () {
    Http::get('https://github.com/farayaz/laravel-spy/');
});

After calling the sample /spy route, head to the http_logs table to view the logged parameters in database.

Now for each request, We can easily see:

The full URL of the request
The HTTP method (e.g., GET, POST, PUT)
Request Headers
Request Body
Response Header
Response Body
Response HTTP Status code

That’s it! Laravel Spy is open-source under the MIT License, and we would be more than grateful for any contributions to this package.

Using Laravel Controllers, Events, Listeners, Services and Validation Together!

Reza Khademi — Sat, 16 Jul 2022 04:20:03 +0000

We can put all codes of a web application into controllers but this action sounds crazy and it’s quite not right to do!

In this article we will see how to structure a web-app with a well-known pattern. I must say you can do below examples in other different ways and probably all of them will be right, So this article is just some examples for doing things!

Let me explain the scenario:

Imagine we have a simple medium-app and it will have a Content section which a user can share a blog post and his/her followers will notice when a new article published!

1. Ugly Way

Make a ArticleController and put all codes in it, like below:

2. Better Way

First, we should replace Request $request an ArticleStoreRequest $request to validate data in a better way:

php artisan make:request ArticleStoreRequest

Don’t forget to return true in authorize() method, so user can do this action:

Second, we should make the ArticleService to move creation logic from controller to service. Because the only thing that a controller will do is passing data!

So we will make ArticleService in Services folder and write creation code to a simple related method and by considering Single Responsibility Principle move upload image to it’s method like below:

Let’s have another look at our ArticleController again see what have been changed so far:

Now let’s use Event and Listener for sending emails to followers of article writer:

php artisan make:event ArticlePublishedEventphp artisan make:listener ArticlePublishedListener --event=ArticlePublishedEvent

This philosophy help us to devide operations and the event will fire automatically when ever and where ever we want. Also this will pretend us to repeat ourselves!

The event class should accept the User model and Article model, which is then passed to ANY listener of that event:

Then, the Event is fired from the Controller, like this:

And, in the Listener class, we repeat the same logic:

That’s it…

Laravel 9: Full Text Index & SwiftMailer!

Reza Khademi — Mon, 07 Feb 2022 17:33:01 +0000

Here we are… This is the last article about Laravel 9!
In this episode we are looking at some tiny but useful features of Laravel 9.

1. server.php file: You can get rid of it!

Until this version of Laravel, we had a server.php file inside the framework root directory that allows us to emulate Apache’s mod_rewrite functionality from the built-in PHP web server.

This provides a convenient way to test a Laravel application without having installed a “real” web server software here. OK, I know! Let’s crack it down to simple words: actually php artisan serve will use this file to serve your website!

And Here is the magic, in Laravel 9 we can remove it for good and there is no problem with this action because it will be included inside the framework.

2. Full Text Indexes

Laravel 9 will support full-text indexes which will provide for us where clause method that we can use in our queries for text columns of MySQL or PostgreSQL tables. Laravel will automatically transform these methods to raw SQL. e.g:

generate full-text indexes for our table column(in migrations):

whereFullText() method:

3. Controller Route Groups

We can now use the controller() method to define the common controller for all of the routes within the same controller. e.g:

So we will define any route to in the UserController to invoke the related method like above.

4. SwiftMailer is a goner!

Previous versions of Laravel used the Swift Mailer library to send outgoing email. But, mentioned library is no longer maintained and has been succeeded by Symfony Mailer.

We can read the upgrade guide to find out our application is compatible with Symfony Mailer.

Laravel 9: Enums!

Reza Khademi — Sun, 30 Jan 2022 14:32:01 +0000

Soon, Laravel 9 wil release and there are some new features that we can use them.

This series is going to be a sequel about Laravel framework version 9 and in each article we will review a new feature!

And yes! Finally we have official support for Enums in php 8.1 although we could add them to Laravel framework by using third-party packages like spatie/enums.

But what are enums in php?

They are just singleton objects and the syntax to define them is as below:

Gladly, we can do so much thing with Laravel Enums and in this article we are going to cover some of the most important usages.

1. Route Bindings With Enums

Laravel 9.x has ability to type hint on our route… think it as a route-model binding but instead of model we have enums! Let see an example:

and in web.php:

With these codes, Laravel automatically will recognize category type and if we don’t pass any of predefined types, it will return an HTTP 404 response!

2. Enums And Migrations

We can use enum() method as following example to create a column with enum type, just be careful by choosing a proper name because renaming an enum column is not currently supported!

3. Enum Attribute Casting

Now our dearest, Eloquent ORM will let us to cast attributes to PHP enums. We just need to use $casts property array on desired model:

And we can access the attribute directly:

4. Enum Methods

According to Laravel docs, Almost all known methods we use on collections are also available on enums likes:

That’s it… Any question?

Laravel 9: New Helpers!

Reza Khademi — Tue, 25 Jan 2022 06:25:59 +0000

Soon, Laravel 9 wil release and there are some new features that we can use them.

This series is going to be a sequel about Laravel framework version 9 and in each article we will review a new feature!

1. str()

A new useful helper in Laravel 9 is str(). This function will return a new Stringable (Illuminate\Support\Stringable). We had this method on Str class and now it is more easier to use. eg:


$name = str('Reza')->append(' Khademi'); // 'Reza Khademi'

$snake = str()->snake('LaravelFramework'); // 'laravel_framework

We should know, if no argument passed to this function it will give us a new instance of Illuminate\Support\Str.

2. to_route()

If we want to redirect user to a specific route, this will come handy:


return to_route(
   'users.show',
   ['user' => 1],
   302,
   ['X-Framework' => 'Laravel']
);

we can pass the route name as the first, our desired data as the second and additional response headers as the third and fourth arguments to the to_route() method.

PHP 8 String Functions

Since PHP 8, str_contains(), str_starts_with() and str_ends_with() functions moved in to the \Illuminate\Support\Str class.

Laravel 9: New Designs!

Reza Khademi — Sat, 22 Jan 2022 07:28:30 +0000

Soon, Laravel 9 wil release and there are some new features that we can use them.

This series is going to be a sequel about Laravel framework version 9 and in each article we will review a new feature!

1. Say hello to new Error Page

New Laravel 9 Error Page will provide some new information, functionalities and help we understand code better.
This design will show us routes, stack, context parameters and so much more...

2. Beautiful Route List

Maybe, you are agreed with me about we needed a fresh design for showing the list of routes with php artisan route:list command and here it is with Laravel 9.

3. Test Coverage through Terminal

Nuno Madru said:

In Laravel 9, they will be introducing the artisan test --coverage option. This option displays the test coverage directly on the terminal.
This feature comes with an --min option, that you may use to indicate the minimum threshold enforcement for test coverage.

Farewell... till next episode!

Laravel 9: Stub Migrations!

Reza Khademi — Tue, 18 Jan 2022 12:34:03 +0000

Soon, Laravel 9 wil release and there are some new features that we can use them.

This series is going to be a sequel about Laravel framework version 9 and in each article we will review a new feature!

1. Laravel 9: Stub Migration

Since Laravel 8.37, there is no need to create a migration with a specific class name. If we have so many migrations and probably forgot about their class name or we are afraid to have collisions in new migration, this feature coming handy and nice.

According to the pull request on github this feature is backward compatible.

So how do we can create it?

Just run this command: php artisan make:migration and it will give you this:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;


return new class extends Migration {
    /**
     * Run the migrations.
     *
     * @return void
     */

    public function up()
    {
        Schema::table('users', function (Blueprint $table) {

            $table->string('nick_name')->nullable();
        });
    }
};

It's an anonymous migration which will do any things to any model you decide, just you have no worries about class names anymore.

That's it... Any question?

New way to define accessors and mutators in Laravel!

Reza Khademi — Tue, 28 Dec 2021 09:34:15 +0000

As you know there is a way to define accessor and mutator in laravel like below.

For example if we are in user model (App\Models\User):

For 'first name' Getter


 public function getFirstNameAttribute($value)
 {
        return ucfirst($value);
 }

For 'first name' Settter


 public function setFirstNameAttribute($value)
 {
        $this->attribute['first_name'] = strtolower($value);
 }

There is a new way to achieve this scenario But I must say Taylor Otwell actually mentioned it and it is quite useful and nice.

You can define both setter and getter in one single method like below:


public function firstName() :Attribute
{
    return new Attribute (
        get: fn($value, $attributes) => $attribute['first_name'],
        set: fn($value) => 'first_name' => $value
    );
}

and that would do it as another way to define accessors and mutators both in one attribute function. If don't want to write any of these you can simply pass a null value for get/set.

Lets see two more examples for user model to cracked it down:

 public function fullName() :Attribute
 {
        return new Attribute(
            get: fn($value, $attributes) => $attributes['first_name'] . ' ' . $attributes['last_name'],
            set: function($value) {
                [$firstName, $lastName] = explode(" ", $value);

                return [
                    'first_name' => $firstName,
                    'last_name' => $lastName
                ];
            }
        );
   }

    public function password() :Attribute
    {
        return new Attribute(
            get: null,
            set: fn($value) => bcrypt($value)
        );
    }

That's it... any questions?

How to use Observers in Laravel?

Reza Khademi — Sat, 04 Dec 2021 07:57:51 +0000

So what are observers in Laravel and why you should use them?

1. Definition

Observers in Laravel help you to fire multiple events or do a CRUD operation in database!

When you create an observer, it will listen to a specific condition for a model, e.g: if user create a post and he/she achieved a certain level, the observer will fire related method(event) and do what ever you wrote!

2. Real Example

In this world websites, there are so many things we want to do after a user registered in our website! e.g: send an email, send SMS and etc... So why not leave them to Observers!

First, run this command to make a user observer (for User model):

php artisan make:observer UserObserver --model=User

Second, you will see four methods in it, that will run when their condition are true. these methods are:

namespace App\Observers;

use App\Models\User;

class UserObserver
{
    /**
     *  Will do what you want When an instance of model created 
     *
     * @param  \App\Models\User  $user
     * @return void
     */
    public function created(User $user)
    {
        //
    } 

    /**
     * Will do what you want When an instance of model updated
     *
     * @param  \App\Models\User  $user
     * @return void
     */
    public function updated(User $user)
    {
        //
    }

    /**
     * Will do what you want When an instance of model deleted
     *
     * @param  \App\Models\User  $user
     * @return void
     */
    public function deleted(User $user)
    {
        //
    }

    /**
     * Will do what you want When an instance of model force deleted
     *
     * @param  \App\Models\User  $user
     * @return void
     */
    public function forceDeleted(User $user)
    {
        //
    }
}

You should know there is some other functions like: creating, updating, saving, afterSaving, restore and etc... so you have a handful feature observer for many situations.

Maybe we just want to send a welcome message to user whenever he/she registered!
we may use create() method, as below:

public function created(User $user)
{
    Mail::to($user)->send(newUserRegisteredMailable($user));
}

And third one is registering our observer in the boot method of your application's App\Providers\EventServiceProvider service provider:

use App\Models\User;
use App\Observers\UserObserver;

/**
 * Register any events for your application.
 *
 * @return void
 */
public function boot()
{
    User::observe(UserObserver::class);
}

That's it.

tmux or zsh?

Reza Khademi — Tue, 16 Nov 2021 06:42:37 +0000

This is my first article on dev.to, so go easy on me!

what is tmux?

tmux is an open-source terminal multiplexer for Linux operating distributions. It allows multiple terminal sessions to be accessed simultaneously in a single window.

what is zsh?

on the other hand, ZSH, also called as 'Z Shell', is an extended version of the Bourne Shell (sh), with plenty of new features, and support for plugins and themes. Since it’s based on the same shell as Bash, ZSH has many of the same features, and switching over is a breeze.

what you should choose?

If your editor for developing and coding is vim or sth like that, the best solution for you is tmux because you can always switch between tabs in a breeze and edit the code at the same time.
You should know tmux is very convenient with the vim editor and speeds up your developing.

But if you are like me and use VSCode as code editor, I recommend you to install zsh and even OhMyZsh to have some great features like: auto suggestion(Not recommended), syntax highlighting and etc.

So, both of them are great and offer you some helpful features. zsh is more like a handful featured terminal and tmux will bring your editor and terminal at same place to switch simultaneously!

you want both?

you can use both of them or install zash on tmux!