metaorm v1

MetaORM is a Go package that provides a simplified database interaction layer with support for MySQL, PostgreSQL, and SQLite databases. It includes features for connection management, query building, encryption, environment variable handling, and pagination/sorting utilities.

Repository

GitHub - metadiv-io/metaorm: Go Package: Gorm WrapperGitHub

Installation

go get -u github.com/metadiv-io/metaorm

Database Connection

Environment Variables

Set up your database connection using environment variables:

METAORM_HOST=localhost
METAORM_PORT=3306
METAORM_USERNAME=root
METAORM_PASSWORD=password
METAORM_DATABASE=mydb
METAORM_ENCRYPT_KEY=your-encryption-key

Connection Examples

package main

import "github.com/metadiv-io/metaorm"

func main() {
    // MySQL Connection
    db, err := metaorm.DefaultMySQL() // Using environment variables
    // or
    db, err := metaorm.MySQL("localhost", "3306", "root", "password", "mydb")

    // PostgreSQL Connection
    db, err := metaorm.DefaultPostgres() // Using environment variables
    // or
    db, err := metaorm.Postgres("localhost", "5432", "postgres", "password", "mydb")

    // SQLite Connection
    db, err := metaorm.SQLite("./database.db")
    // or in-memory
    db, err := metaorm.SqliteMemory()
}

Basic Operations

Model Definition

type User struct {
    ID        uint   `gorm:"primarykey"`
    Name      string
    Email     []byte // Encrypted field
    CreatedAt time.Time
}

CRUD Operations

package main

import (
    "github.com/metadiv-io/metaorm"
    "github.com/metadiv-io/metaorm/executor"
)

func main() {
    db, _ := metaorm.DefaultMySQL()

    // Create
    user := &User{Name: "John", Email: metaorm.DefaultEncrypt("[e-mail]")}
    user, err := executor.Save(db, user)

    // Read
    user, err := executor.FindOne[User](db, db.Eq("id", 1))

    // Update
    user.Name = "John Doe"
    user, err = executor.Save(db, user)

    // Delete
    err = executor.Delete(db, user)
}

Querying

Simple Queries

package main

func main() {
    db, _ := metaorm.DefaultMySQL()

    // Single condition
    users, err := executor.FindAll[User](db, db.Eq("name", "John"))

    // Multiple conditions using AND
    query := db.And(
        db.Eq("name", "John"),
        db.Gt("age", 18),
    )
    users, err = executor.FindAll[User](db, query)

    // Multiple conditions using OR
    query = db.Or(
        db.Eq("name", "John"),
        db.Eq("name", "Jane"),
    )
    users, err = executor.FindAll[User](db, query)
}

Advanced Queries

func main() {
    db, _ := metaorm.DefaultMySQL()

    // Like query
    users, err := executor.FindAll[User](db, db.Like("name", "Jo"))

    // In query
    users, err = executor.FindAll[User](db, db.In("id", []int{1, 2, 3}))

    // Null check
    users, err = executor.FindAll[User](db, db.IsNull("deleted_at"))

    // Encrypted field query
    users, err = executor.FindAll[User](db, db.DecryptedEq("email", "[e-mail]"))
}

Pagination and Sorting

func main() {
    db, _ := metaorm.DefaultMySQL()

    // Pagination
    page := &metaorm.Page{
        Page: 1,
        Size: 10,
    }

    // Sorting
    sort := &metaorm.Sort{
        Field: "created_at",
        Asc:   false,
    }

    // Complex query with pagination and sorting
    users, page, err := executor.FindAllComplex[User](
        db,
        db.Eq("status", "active"),
        page,
        sort,
    )
}

Encryption

func main() {
    // Encrypt data
    encryptedData := metaorm.DefaultEncrypt("sensitive data")

    // Decrypt data
    plainText := metaorm.DefaultDecrypt(encryptedData)

    // Using custom encryption key
    customKey := "your-custom-key"
    encryptedData = metaorm.Encrypt("sensitive data", customKey)
    plainText = metaorm.Decrypt(encryptedData, customKey)
}

Transactions

func main() {
    db, _ := metaorm.DefaultMySQL()

    // Start transaction
    tx := db.Begin()

    // Perform operations
    user := &User{Name: "John"}
    user, err := executor.Save(tx, user)
    if err != nil {
        tx.Rollback()
        return
    }

    // Commit transaction
    tx.Commit()
}

Additional Features

Preloading Relations

func main() {
    db, _ := metaorm.DefaultMySQL()

    // Preload related data
    db = db.Preload("Posts", "Comments")
    users, err := executor.FindAll[User](db, nil)
}

Joins

func main() {
    db, _ := metaorm.DefaultMySQL()

    // Join related tables
    db = db.Joins("Posts", "Comments")
    users, err := executor.FindAll[User](db, nil)
}