Tutorial:  Implementing Repository with GORM and SQLite

Tutorial: Implementing Repository with GORM and SQLite

In the previous part of the series we created the required interface for you invoice generation/management web application.

In this post we are going to provide and implementation of the CompanyRepository .

In our requirements in the first part of the series we decided that we are going to use SQLite as our DBMS. Let's implement together the integration with SQLite.

Implementing the CompanyRepository

We are going to use GORM to interact with the database. However, we are going to ensure that our database models and code will be decoupled so we can switch ORM/driver or even database in the future.

We are going to work in the sqlite package.

Let's first create a branch

 git checkout -b company-repo

and then install the dependencies:

go get gorm.io/gorm
go get gorm.io/driver/sqlite
go get gorm.io/datatypes"

then in our sqlite/sqlite.go add

package sqlite

import (

func SetupDB(path string) (*gorm.DB, error) {
    db, err := gorm.Open(sqlite.Open(path), &gorm.Config{})
    if err != nil {
        return nil, err

    err = db.AutoMigrate(
    if err != nil {
        return nil, err

    return db, nil


SetupDB function creates a connection to the SQLite database and runs the migrations, meaning it creates the required tables if not exists or modifies them according to our schema.

and then create a file sqlite/company.go

package sqlite

import (


var _ invoicehub.CompanyRepository = (*companyRepository)(nil)

type dbcompany struct {
    ID           int    `gorm:"primaryKey"`
    Name         string `gorm:"type:text"`
    Address      datatypes.JSONType[invoicehub.Address]
    Email        string `gorm:"type:text"`
    TaxID        string `gorm:"type:text"`
    VatID        string `gorm:"type:text"`
    BankAccounts datatypes.JSONSlice[invoicehub.BankAccount]

type companyRepository struct {
    db *gorm.DB

func NewCompanyRepository(db *gorm.DB) invoicehub.CompanyRepository {
    return &companyRepository{db: db}

func (r *companyRepository) Create(ctx context.Context, company *invoicehub.Company) (int, error) {
    // Convert invoicehub.Company to dbcompany
    dbCompany := dbcompany{
        Name:         company.Name,
        Address:      datatypes.NewJSONType(company.Address),
        Email:        company.Email,
        TaxID:        company.TaxID,
        VatID:        company.VatID,
        BankAccounts: datatypes.NewJSONSlice(company.BankAccounts),

    // Save to database

    if err := r.db.WithContext(ctx).Create(&dbCompany).Error; err != nil {
        return 0, err

    company.ID = dbCompany.ID

    return company.ID, nil

func (r *companyRepository) Update(ctx context.Context, company *invoicehub.Company) error {
    var existingCompany dbcompany
    if err := r.db.WithContext(ctx).First(&existingCompany, company.ID).Error; err != nil {
        return err

    existingCompany.Name = company.Name
    existingCompany.Address = datatypes.NewJSONType(company.Address)
    existingCompany.Email = company.Email
    existingCompany.TaxID = company.TaxID
    existingCompany.VatID = company.VatID
    existingCompany.BankAccounts = datatypes.NewJSONSlice(company.BankAccounts)

    if err := r.db.WithContext(ctx).Save(&existingCompany).Error; err != nil {
        return err

    return nil

func (r *companyRepository) Get(ctx context.Context, id int) (invoicehub.Company, error) {
    var dbCompany dbcompany
    if err := r.db.WithContext(ctx).First(&dbCompany, id).Error; err != nil {
        return invoicehub.Company{}, err

    company := invoicehub.Company{
        ID:           dbCompany.ID,
        Name:         dbCompany.Name,
        Address:      dbCompany.Address.Data(),
        Email:        dbCompany.Email,
        TaxID:        dbCompany.TaxID,
        VatID:        dbCompany.VatID,
        BankAccounts: dbCompany.BankAccounts,

    return company, nil

❓why I used a dbcompany structs that basically reassembles our invoicehub.Company struct

We want our repository implementation to be decoupled with the domain Entity. The reason is flexibility to change in the future. We don't want our domain Entity to include any gorm related code (see the struct tags).

Writing unit tests

We have to verify that our implementation works. Let's write a unit test for that.

For unit test I like to use the testify package

go get github.com/stretchr/testify

Create a file sqlite/company_test.go .

package sqlite_test

import (


func Test_companyRepository(t *testing.T) {
    db, err := sqlite.SetupDB(":memory:")
    require.NoError(t, err)

    repo := sqlite.NewCompanyRepository(db)
    ctx := context.Background()

    company := invoicehub.Company{
        Name:  "Example Ltd",
        Email: "info@example.com",
        TaxID: "123456789",
        VatID: "987654321",
        Address: invoicehub.Address{
            Street:     "123 Example St",
            City:       "Limassol",
            PostalCode: "12345",
            Country:    "CY",
        BankAccounts: []invoicehub.BankAccount{
                BankName:      "Example Bank",
                AccountNumber: "1234567890",
                IBAN:          "EX12345678901234567890",
                BIC:           "EXBIC123",

    // Create a new company
    id, err := repo.Create(ctx, &company)
    require.NoError(t, err)
    require.NotZero(t, id)
    require.Equal(t, id, company.ID)

    // Get the company
    company2, err := repo.Get(ctx, id)
    require.NoError(t, err)
    require.Equal(t, company, company2)

    // Update the company
    company.Name = "Example Ltd 2"
    err = repo.Update(ctx, &company)
    require.NoError(t, err)

    updatedCompany, err := repo.Get(ctx, id)
    require.NoError(t, err)
    require.Equal(t, company, updatedCompany)

    // not found
    _, err = repo.Get(ctx, 999)
    require.Error(t, err)

💥 We cover just the basics test cases so we have some confidence that it works.

Let's run the tests

go test -v ./...

and you should get something like:

Pass the dependency in our main.go

Open cmd/main.go and do the following changes:

Pay attention, that I set a default path that will work with our docker setup

Also add to the .gitignore the data.sqlite3 file.

echo "data.sqlite3" >> .gitignore

Now let's test our docker setup.

make dev

notice the created file:

Let's open the file with an sqlite client. On Linux run:

Let's now commit our code so far

As usual you can find the code so far in the relate github branch .


We need to setup a new environment variable in our production .env .

Login to your VPS and add the line:


Now you can go back to your machine and run

make deploy

After deployment check that the invoices.sqlite3 file was created .


In this tutorial, we successfully implemented the CompanyRepository using GORM and SQLite, ensuring our code remains flexible and decoupled from the domain entity. We also wrote unit tests to verify our implementation and made necessary adjustments to our main.go to integrate the repository. Finally, we configured our production environment and verified the deployment.

In the next article we are going to implement the InvoiceRepository .

❤️ Please follow me on X or LinkedIn

If you have any questions please reach out to me via a comment or a DM in X.

Find the rest of the tutorials in this series here