path: root/lib/notmuch/database.go

//go:build notmuch
// +build notmuch

package notmuch

/*
#cgo LDFLAGS: -lnotmuch

#include <stdlib.h>
#include <notmuch.h>

*/
import "C"

import (
	"errors"
	"fmt"
	"unsafe"
)

type Mode int

const (
	MODE_READ_ONLY  Mode = C.NOTMUCH_DATABASE_MODE_READ_ONLY
	MODE_READ_WRITE Mode = C.NOTMUCH_DATABASE_MODE_READ_WRITE
)

type Database struct {
	// The path to the notmuch database. If Path is the empty string, the
	// location will be found in the following order:
	//
	// 1. The value of the environment variable NOTMUCH_DATABASE
	// 2. From the config file specified by Config
	// 3. From the Profile specified by profile, given by
	//    $XDG_DATA_HOME/notmuch/$PROFILE
	Path string

	// The path to the notmuch configuration file to use.
	Config string

	// If FindConfig is true, libnotmuch will attempt to locate a suitable
	// configuration file in the following order:
	//
	// 1. The value of the environment variable NOTMUCH_CONFIG
	// 2. $XDG_CONFIG_HOME/notmuch/
	// 3. $HOME/.notmuch-config
	//
	// If not configuration file is found, a STATUS_NO_CONFIG error will be
	// returned
	FindConfig bool

	// The profile to use. If Profile is non-empty, the value will be
	// appended to the paths determined for Config and Path. If Profile is
	// the empty string, the profile will be determined in the following
	// order:
	//
	// 1. The value of the environment variable NOTMUCH_PROFILE
	// 2. "default" if Config and/or Path are a directory, "" if they are a
	//    filepath
	Profile string

	db   *C.notmuch_database_t
	open bool
}

// Create creates a notmuch database at the Path
func (db *Database) Create() error {
	var cdb *C.notmuch_database_t
	var cPath *C.char
	defer C.free(unsafe.Pointer(cPath))
	if db.Path != "" {
		cPath = C.CString(db.Path)
	}
	err := errorWrap(C.notmuch_database_create(cPath, &cdb)) //nolint:gocritic // see note in notmuch.go
	if err != nil {
		return err
	}
	db.db = cdb
	return nil
}

// Open opens the database with the given mode. Caller must call Close when done
// to commit changes and free resources
func (db *Database) Open(mode Mode) error {
	var (
		cPath    *C.char
		cConfig  *C.char
		cProfile *C.char
		cErr     *C.char
	)
	defer C.free(unsafe.Pointer(cPath))
	defer C.free(unsafe.Pointer(cConfig))
	defer C.free(unsafe.Pointer(cProfile))
	defer C.free(unsafe.Pointer(cErr))

	if db.Path != "" {
		cPath = C.CString(db.Path)
	}

	if !db.FindConfig {
		cConfig = C.CString(db.Config)
	}

	if db.Profile != "" {
		cProfile = C.CString(db.Profile)
	}
	cmode := C.notmuch_database_mode_t(mode)

	var cdb *C.notmuch_database_t

	// gocritic:dupSubExpr throws an issue here no matter how we call this
	// function
	err := errorWrap(
		C.notmuch_database_open_with_config(
			cPath, cmode, cConfig, cProfile, &cdb, &cErr, //nolint:gocritic // see above
		),
	)
	if err != nil {
		return err
	}
	db.db = cdb
	db.open = true
	return nil
}

// Reopen an open notmuch database, usually with a different mode
func (db *Database) Reopen(mode Mode) error {
	cmode := C.notmuch_database_mode_t(mode)
	return errorWrap(C.notmuch_database_reopen(db.db, cmode))
}

// Close commits changes and closes the database, freeing any resources
// associated with it
func (db *Database) Close() error {
	if !db.open {
		return nil
	}
	err := errorWrap(C.notmuch_database_close(db.db))
	if err != nil {
		return err
	}
	err = errorWrap(C.notmuch_database_destroy(db.db))
	if err != nil {
		return err
	}
	db.open = false
	return nil
}

// LastStatus returns the last status string for the database
func (db *Database) LastStatus() string {
	cStatus := C.notmuch_database_status_string(db.db)
	defer C.free(unsafe.Pointer(cStatus))
	return C.GoString(cStatus)
}

func (db *Database) Compact(backupPath string) error {
	if backupPath == "" {
		return fmt.Errorf("must have backup path before compacting")
	}
	var cBackupPath *C.char
	defer C.free(unsafe.Pointer(cBackupPath))
	return errorWrap(C.notmuch_database_compact_db(db.db, cBackupPath, nil, nil))
}

// Return the resolved path to the notmuch database
func (db *Database) ResolvedPath() string {
	cPath := C.notmuch_database_get_path(db.db)
	return C.GoString(cPath)
}

// NeedsUpgrade reports if the database must be upgraded before a write
// operation can be safely performed
func (db *Database) NeedsUpgrade() bool {
	return C.notmuch_database_needs_upgrade(db.db) == 1
}

// Indicate the beginning of an atomic operation
func (db *Database) BeginAtomic() error {
	return errorWrap(C.notmuch_database_begin_atomic(db.db))
}

// Indicate the end of an atomic operation
func (db *Database) EndAtomic() error {
	return errorWrap(C.notmuch_database_end_atomic(db.db))
}

// Returns the UUID and LastMod of the notmuch database
func (db *Database) Revision() (string, uint64) {
	var uuid *C.char
	defer C.free(unsafe.Pointer(uuid))
	lastmod := uint64(C.notmuch_database_get_revision(db.db, &uuid)) //nolint:gocritic // see note in notmuch.go
	return C.GoString(uuid), lastmod
}

// Returns a Directory object relative to the path of the Database
func (db *Database) Directory(relativePath string) (Directory, error) {
	var result Directory

	if relativePath == "" {
		return result, fmt.Errorf("path can't be empty")
	}
	var (
		dir   *C.notmuch_directory_t
		cPath *C.char
	)
	cPath = C.CString(relativePath)
	defer C.free(unsafe.Pointer(cPath))
	err := errorWrap(C.notmuch_database_get_directory(db.db, cPath, &dir)) //nolint:gocritic // see note in notmuch.go
	if err != nil {
		return result, err
	}
	result.dir = dir

	return result, nil
}

// IndexFile indexes a file with path relative to the database path, or an
// absolute path which share a common ancestor as the database path
func (db *Database) IndexFile(path string) (Message, error) {
	var (
		cPath *C.char
		msg   *C.notmuch_message_t
	)
	cPath = C.CString(path)
	defer C.free(unsafe.Pointer(cPath))

	err := errorWrap(C.notmuch_database_index_file(db.db, cPath, nil, &msg)) //nolint:gocritic // see note in notmuch.go
	switch {
	case errors.Is(err, STATUS_DUPLICATE_MESSAGE_ID):
		break
	case err != nil:
		return Message{}, err
	}
	message := Message{
		message: msg,
	}
	return message, nil
}

// Remove a file from the database. If this is the last file associated with a
// message, the message will be removed from the database.
func (db *Database) RemoveFile(path string) error {
	cPath := C.CString(path)
	defer C.free(unsafe.Pointer(cPath))
	return errorWrap(C.notmuch_database_remove_message(db.db, cPath))
}

// FindMessageByID finds a message by the Message-ID header field value
func (db *Database) FindMessageByID(id string) (Message, error) {
	var (
		cID *C.char
		msg *C.notmuch_message_t
	)
	cID = C.CString(id)
	defer C.free(unsafe.Pointer(cID))
	err := errorWrap(C.notmuch_database_find_message(db.db, cID, &msg)) //nolint:gocritic // see note in notmuch.go
	if err != nil {
		return Message{}, err
	}
	message := Message{
		message: msg,
	}
	return message, nil
}

// FindMessageByFilename finds a message by filename
func (db *Database) FindMessageByFilename(filename string) (Message, error) {
	var (
		cFilename *C.char
		msg       *C.notmuch_message_t
	)
	cFilename = C.CString(filename)
	defer C.free(unsafe.Pointer(cFilename))
	err := errorWrap(C.notmuch_database_find_message_by_filename(db.db, cFilename, &msg)) //nolint:gocritic // see note in notmuch.go
	if err != nil {
		return Message{}, err
	}
	if msg == nil {
		return Message{}, fmt.Errorf("couldn't find message by filename: %s", filename)
	}
	message := Message{
		message: msg,
	}
	return message, nil
}

// Tags returns a slice of all tags in the database
func (db *Database) Tags() []string {
	cTags := C.notmuch_database_get_all_tags(db.db)
	defer C.notmuch_tags_destroy(cTags)

	tags := []string{}
	for C.notmuch_tags_valid(cTags) > 0 {
		tag := C.notmuch_tags_get(cTags)
		tags = append(tags, C.GoString(tag))
		C.notmuch_tags_move_to_next(cTags)
	}
	return tags
}

// Create a new Query
func (db *Database) Query(query string) (Query, error) {
	cQuery := C.CString(query)
	defer C.free(unsafe.Pointer(cQuery))
	nmQuery := C.notmuch_query_create(db.db, cQuery)
	if nmQuery == nil {
		return Query{}, STATUS_OUT_OF_MEMORY
	}
	q := Query{
		query: nmQuery,
	}
	return q, nil
}