@@ -0,0 +1,174 @@
+package storage
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"alin.ovh/searchix/internal/config"
+	"alin.ovh/searchix/internal/file"
+	"alin.ovh/searchix/internal/nix"
+	"alin.ovh/x/log"
+	"github.com/Southclaws/fault"
+	"github.com/Southclaws/fault/fmsg"
+	"github.com/asdine/storm/v3"
+	"github.com/asdine/storm/v3/codec/gob"
+	"go.uber.org/zap"
+
+	"go.etcd.io/bbolt"
+)
+
+var BatchSize = 10000
+
+type Options struct {
+	Root   *file.Root
+	Logger *log.Logger
+}
+
+type Store struct {
+	db  *storm.DB
+	log *log.Logger
+}
+
+func New(opts *Options) (*Store, error) {
+	//nolint:forbidigo // external package
+	path := opts.Root.JoinPath("searchix.bolt")
+	bb, err := storm.Open(path,
+		storm.Codec(gob.Codec),
+		storm.BoltOptions(0o600, &bbolt.Options{
+			Timeout: 1 * time.Second,
+			Logger: Logger{
+				opts.Logger.Named("bolt").GetLogger().Sugar().WithOptions(
+					zap.IncreaseLevel(zap.InfoLevel),
+				),
+			},
+		}),
+	)
+	if err != nil {
+		return nil, fault.Wrap(err, fmsg.With("failed to open database"))
+	}
+
+	return &Store{
+		db:  bb,
+		log: opts.Logger,
+	}, nil
+}
+
+func (s *Store) Close() error {
+	err := s.db.Close()
+	if err != nil {
+		return fault.Wrap(err, fmsg.With("failed to close database"))
+	}
+
+	return nil
+}
+
+func (s *Store) Import(
+	ctx context.Context,
+	source *config.Source,
+	objects <-chan nix.Importable,
+) <-chan error {
+	errs := make(chan error)
+	node := s.db.From(source.Key).WithBatch(true)
+
+	i := 0
+
+	var save func(storm.Node, nix.Importable) error
+	switch source.Importer {
+	case config.Packages:
+		save = saveGen[nix.Package]
+	case config.Options:
+		save = saveGen[nix.Option]
+	default:
+		errs <- fault.New("invalid importer")
+
+		return errs
+	}
+
+	go func() {
+		defer close(errs)
+		tx, err := node.Begin(true)
+		if err != nil {
+			errs <- fault.Wrap(err, fmsg.With("failed to begin transaction"))
+
+			return
+		}
+		defer func() {
+			if err := tx.Rollback(); err != nil {
+				if !errors.Is(err, storm.ErrNotInTransaction) {
+					errs <- fault.Wrap(err, fmsg.With("failed to rollback transaction"))
+				}
+			}
+		}()
+
+	outer:
+		for obj := range objects {
+			i++
+			select {
+			case <-ctx.Done():
+				s.log.Warn("import aborted")
+
+				break outer
+			default:
+			}
+
+			err := save(tx, obj)
+			if err != nil {
+				errs <- fault.Wrap(err, fmsg.With("failed to save object"))
+			}
+
+			if i%BatchSize == 0 {
+				s.log.Info("imported", "count", i)
+			}
+		}
+
+		if err := tx.Commit(); err != nil {
+			errs <- fault.Wrap(err, fmsg.With("failed to commit transaction"))
+		}
+	}()
+
+	return errs
+}
+
+func saveGen[T nix.Importable](node storm.Node, obj nix.Importable) error {
+	doc, ok := obj.(T)
+	if !ok {
+		return fault.Newf("invalid type: %T", obj)
+	}
+
+	if err := node.Save(&doc); err != nil {
+		return fault.Wrap(err, fmsg.With("failed to save document"))
+	}
+
+	return nil
+}
+
+func (s *Store) GetDocument(
+	source *config.Source,
+	id string,
+) (nix.Importable, error) {
+	var doc nix.Importable
+	var err error
+
+	node := s.db.From(source.Key)
+
+	switch source.Importer {
+	case config.Packages:
+		doc = &nix.Package{}
+		err = node.One("Attribute", id, doc)
+	case config.Options:
+		doc = &nix.Option{}
+		err = node.One("Name", id, doc)
+	default:
+		return nil, fault.New("invalid importer type")
+	}
+
+	if err != nil {
+		return nil, fault.Wrap(
+			err,
+			fmsg.Withf("failed to get document source: %s id: %s", source.Key, id),
+		)
+	}
+
+	return doc, nil
+}