protodb.go

// Copyright 2021 Linka Cloud  All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package protodb

import (
	"context"

	"go.linka.cloud/protofilters/filters"

	"go.linka.cloud/protodb/internal/badgerd/replication"
	"go.linka.cloud/protodb/internal/client"
	"go.linka.cloud/protodb/internal/db"
	"go.linka.cloud/protodb/internal/protodb"
	"go.linka.cloud/protodb/internal/server"
	"go.linka.cloud/protodb/protodb/v1alpha1"
)

var (
	Where = filters.Where
)

type DB = protodb.DB

type Tx = protodb.Tx

type Reader = protodb.Reader

type Watcher = protodb.Watcher

type Writer = protodb.Writer

type TxProvider = protodb.TxProvider

type Committer = protodb.Committer

type Registerer = protodb.Registerer

type Leader = protodb.Leader

type Locker = protodb.Locker

type Resolver = protodb.Resolver

// Deprecated: use Resolver.
type Resolverer = protodb.Resolverer

type EventType = v1alpha1.WatchEventType

const (
	EventTypeEnter  = v1alpha1.WatchEventEnter
	EventTypeLeave  = v1alpha1.WatchEventLeave
	EventTypeUpdate = v1alpha1.WatchEventUpdate
)

type Event = protodb.Event

var DefaultPath = db.DefaultPath

var Open = db.Open

type Option = db.Option

var (
	WithPath                      = db.WithPath
	WithInMemory                  = db.WithInMemory
	WithBadgerOptionsFunc         = db.WithBadgerOptionsFunc
	WithLogger                    = db.WithLogger
	WithApplyDefaults             = db.WithApplyDefaults
	WithIgnoreProtoRegisterErrors = db.WithIgnoreProtoRegisterErrors
	WithProtoRegisterErrHandler   = db.WithProtoRegisterErrHandler
	WithWireBreakingCheck         = db.WithWireBreakingCheck
	WithOnClose                   = db.WithOnClose
	WithReplication               = db.WithReplication
	WithIndexCompaction           = db.WithIndexCompaction
)

type GetOption = protodb.GetOption

var (
	WithPaging             = protodb.WithPaging
	WithFilter             = protodb.WithFilter
	WithReadFieldMaskPaths = protodb.WithReadFieldMaskPaths
	WithReadFieldMask      = protodb.WithReadFieldMask
	WithReverse            = protodb.WithReverse
	WithOne                = protodb.WithOne
	WithOrderBy            = protodb.WithOrderBy
	WithOrderByAsc         = protodb.WithOrderByAsc
	WithOrderByDesc        = protodb.WithOrderByDesc
)

type TxOption = protodb.TxOption

var WithReadOnly = protodb.WithReadOnly

type SetOption = protodb.SetOption

var (
	WithTTL                 = protodb.WithTTL
	WithWriteFieldMaskPaths = protodb.WithWriteFieldMaskPaths
	WithWriteFieldMask      = protodb.WithWriteFieldMask
)

type ReplicationMode = replication.Mode

var (
	ReplicationModeNone  = replication.ModeNone
	ReplicationModeAsync = replication.ModeAsync
	ReplicationModeSync  = replication.ModeSync
)

type ReplicationOption = replication.Option

var (
	WithMode       = replication.WithMode
	WithName       = replication.WithName
	WithAddrs      = replication.WithAddrs
	WithGossipPort = replication.WithGossipPort
	WithGRPCPort   = replication.WithGRPCPort
	WithTick       = replication.WithTick
	// WithEncryptionKey set a key to encrypt gossip messages
	WithEncryptionKey = replication.WithEncryptionKey
	WithServerCert    = replication.WithServerCert
	WithServerKey     = replication.WithServerKey
	WithClientCert    = replication.WithClientCert
	WithClientKey     = replication.WithClientKey
	WithClientCA      = replication.WithClientCA
	WithTLSConfig     = replication.WithTLSConfig
)

type (
	Paging     = v1alpha1.Paging
	PagingInfo = v1alpha1.PagingInfo
	FilterExpr = filters.Expression
	Filter     = filters.FieldFilterer
	OrderBy    = v1alpha1.OrderBy
)

type OrderDirection = v1alpha1.OrderDirection

const (
	OrderDirectionUnspecified = v1alpha1.OrderDirectionUnspecified
	OrderDirectionAsc         = v1alpha1.OrderDirectionAsc
	OrderDirectionDesc        = v1alpha1.OrderDirectionDesc
)

type Client = client.Client

var NewClient = client.NewClient

type Server = server.Server

var NewServer = server.NewServer

func WithTx(ctx context.Context, db TxProvider, fn func(ctx context.Context, tx Tx) error, opts ...TxOption) error {
	tx, err := db.Tx(ctx, opts...)
	if err != nil {
		return err
	}
	defer tx.Close()
	if err := fn(ctx, tx); err != nil {
		return err
	}
	return tx.Commit(ctx)
}

func WithTx2[R any](ctx context.Context, db TxProvider, fn func(ctx context.Context, tx Tx) (R, error), opts ...TxOption) (R, error) {
	var o R
	tx, err := db.Tx(ctx, opts...)
	if err != nil {
		return o, err
	}
	defer tx.Close()
	o, err = fn(ctx, tx)
	if err != nil {
		return o, err
	}
	if err := tx.Commit(ctx); err != nil {
		return o, err
	}
	return o, nil
}