fix: update to use db.Provider

server/db/arangodb.go

@@ -1,115 +0,0 @@
-package db
-
-import (
-	"context"
-	"log"
-
-	"github.com/arangodb/go-driver"
-	arangoDriver "github.com/arangodb/go-driver"
-	"github.com/arangodb/go-driver/http"
-	"github.com/authorizerdev/authorizer/server/constants"
-	"github.com/authorizerdev/authorizer/server/envstore"
-)
-
-// for this we need arangodb instance up and running
-// for local testing we can use dockerized version of it
-// docker run -p 8529:8529 -e ARANGO_ROOT_PASSWORD=root arangodb/arangodb:3.8.4
-
-func initArangodb() (arangoDriver.Database, error) {
-	ctx := context.Background()
-	conn, err := http.NewConnection(http.ConnectionConfig{
-		Endpoints: []string{envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseURL)},
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	arangoClient, err := arangoDriver.NewClient(arangoDriver.ClientConfig{
-		Connection: conn,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var arangodb driver.Database
-
-	arangodb_exists, err := arangoClient.DatabaseExists(nil, envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseName))
-
-	if arangodb_exists {
-		log.Println(envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseName) + " db exists already")
-		arangodb, err = arangoClient.Database(nil, envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseName))
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		arangodb, err = arangoClient.CreateDatabase(nil, envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseName), nil)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	userCollectionExists, err := arangodb.CollectionExists(ctx, Collections.User)
-	if userCollectionExists {
-		log.Println(Collections.User + " collection exists already")
-	} else {
-		_, err = arangodb.CreateCollection(ctx, Collections.User, nil)
-		if err != nil {
-			log.Println("error creating collection("+Collections.User+"):", err)
-		}
-	}
-	userCollection, _ := arangodb.Collection(nil, Collections.User)
-	userCollection.EnsureHashIndex(ctx, []string{"email"}, &arangoDriver.EnsureHashIndexOptions{
-		Unique: true,
-		Sparse: true,
-	})
-	userCollection.EnsureHashIndex(ctx, []string{"phone_number"}, &arangoDriver.EnsureHashIndexOptions{
-		Unique: true,
-		Sparse: true,
-	})
-
-	verificationRequestCollectionExists, err := arangodb.CollectionExists(ctx, Collections.VerificationRequest)
-	if verificationRequestCollectionExists {
-		log.Println(Collections.VerificationRequest + " collection exists already")
-	} else {
-		_, err = arangodb.CreateCollection(ctx, Collections.VerificationRequest, nil)
-		if err != nil {
-			log.Println("error creating collection("+Collections.VerificationRequest+"):", err)
-		}
-	}
-
-	verificationRequestCollection, _ := arangodb.Collection(nil, Collections.VerificationRequest)
-	verificationRequestCollection.EnsureHashIndex(ctx, []string{"email", "identifier"}, &arangoDriver.EnsureHashIndexOptions{
-		Unique: true,
-		Sparse: true,
-	})
-	verificationRequestCollection.EnsureHashIndex(ctx, []string{"token"}, &arangoDriver.EnsureHashIndexOptions{
-		Sparse: true,
-	})
-
-	sessionCollectionExists, err := arangodb.CollectionExists(ctx, Collections.Session)
-	if sessionCollectionExists {
-		log.Println(Collections.Session + " collection exists already")
-	} else {
-		_, err = arangodb.CreateCollection(ctx, Collections.Session, nil)
-		if err != nil {
-			log.Println("error creating collection("+Collections.Session+"):", err)
-		}
-	}
-
-	sessionCollection, _ := arangodb.Collection(nil, Collections.Session)
-	sessionCollection.EnsureHashIndex(ctx, []string{"user_id"}, &arangoDriver.EnsureHashIndexOptions{
-		Sparse: true,
-	})
-
-	configCollectionExists, err := arangodb.CollectionExists(ctx, Collections.Env)
-	if configCollectionExists {
-		log.Println(Collections.Env + " collection exists already")
-	} else {
-		_, err = arangodb.CreateCollection(ctx, Collections.Env, nil)
-		if err != nil {
-			log.Println("error creating collection("+Collections.Env+"):", err)
-		}
-	}
-
-	return arangodb, err
-}

server/db/db.go

@@ -3,158 +3,42 @@ package db
 import (
 	"log"
 
-	arangoDriver "github.com/arangodb/go-driver"
 	"github.com/authorizerdev/authorizer/server/constants"
 	"github.com/authorizerdev/authorizer/server/db/providers"
 	"github.com/authorizerdev/authorizer/server/db/providers/arangodb"
 	"github.com/authorizerdev/authorizer/server/db/providers/mongodb"
 	"github.com/authorizerdev/authorizer/server/db/providers/sql"
 	"github.com/authorizerdev/authorizer/server/envstore"
-	"go.mongodb.org/mongo-driver/mongo"
-	"gorm.io/driver/mysql"
-	"gorm.io/driver/postgres"
-	"gorm.io/driver/sqlite"
-	"gorm.io/driver/sqlserver"
-	"gorm.io/gorm"
-	"gorm.io/gorm/schema"
 )
 
-type Manager interface {
-	AddUser(user User) (User, error)
-	UpdateUser(user User) (User, error)
-	DeleteUser(user User) error
-	GetUsers() ([]User, error)
-	GetUserByEmail(email string) (User, error)
-	GetUserByID(email string) (User, error)
-	AddVerification(verification VerificationRequest) (VerificationRequest, error)
-	GetVerificationByToken(token string) (VerificationRequest, error)
-	DeleteVerificationRequest(verificationRequest VerificationRequest) error
-	GetVerificationRequests() ([]VerificationRequest, error)
-	GetVerificationByEmail(email string, identifier string) (VerificationRequest, error)
-	AddSession(session Session) error
-	DeleteUserSession(userId string) error
-	AddEnv(env Env) (Env, error)
-	UpdateEnv(env Env) (Env, error)
-	GetEnv() (Env, error)
-}
-
-type manager struct {
-	sqlDB    *gorm.DB
-	arangodb arangoDriver.Database
-	mongodb  *mongo.Database
-}
-
-// mainly used by nosql dbs
-type CollectionList struct {
-	User                string
-	VerificationRequest string
-	Session             string
-	Env                 string
-}
-
-var (
-	IsORMSupported bool
-	IsArangoDB     bool
-	IsMongoDB      bool
-	Mgr            Manager
-	Provider       providers.Provider
-	Prefix         = "authorizer_"
-	Collections    = CollectionList{
-		User:                Prefix + "users",
-		VerificationRequest: Prefix + "verification_requests",
-		Session:             Prefix + "sessions",
-		Env:                 Prefix + "env",
-	}
-)
+// Provider returns the current database provider
+var Provider providers.Provider
 
 func InitDB() {
-	var sqlDB *gorm.DB
 	var err error
 
-	IsORMSupported = envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) != constants.DbTypeArangodb && envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) != constants.DbTypeMongodb
-	IsArangoDB = envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) == constants.DbTypeArangodb
-	IsMongoDB = envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) == constants.DbTypeMongodb
+	isSQL := envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) != constants.DbTypeArangodb && envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) != constants.DbTypeMongodb
+	isArangoDB := envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) == constants.DbTypeArangodb
+	isMongoDB := envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) == constants.DbTypeMongodb
 
-	// sql db orm config
-	ormConfig := &gorm.Config{
-		NamingStrategy: schema.NamingStrategy{
-			TablePrefix: Prefix,
-		},
-	}
-
-	if IsORMSupported {
+	if isSQL {
 		Provider, err = sql.NewProvider()
 		if err != nil {
-			log.Println("=> error setting sql provider:", err)
+			log.Fatal("=> error setting sql provider:", err)
 		}
 	}
 
-	if IsArangoDB {
+	if isArangoDB {
 		Provider, err = arangodb.NewProvider()
 		if err != nil {
-			log.Println("=> error setting arangodb provider:", err)
+			log.Fatal("=> error setting arangodb provider:", err)
 		}
 	}
 
-	if IsMongoDB {
+	if isMongoDB {
 		Provider, err = mongodb.NewProvider()
 		if err != nil {
-			log.Println("=> error setting arangodb provider:", err)
-		}
-	}
-
-	log.Println("db type:", envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType))
-
-	switch envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) {
-	case constants.DbTypePostgres:
-		sqlDB, err = gorm.Open(postgres.Open(envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseURL)), ormConfig)
-		break
-	case constants.DbTypeSqlite:
-		sqlDB, err = gorm.Open(sqlite.Open(envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseURL)), ormConfig)
-		break
-	case constants.DbTypeMysql:
-		sqlDB, err = gorm.Open(mysql.Open(envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseURL)), ormConfig)
-		break
-	case constants.DbTypeSqlserver:
-		sqlDB, err = gorm.Open(sqlserver.Open(envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseURL)), ormConfig)
-		break
-	case constants.DbTypeArangodb:
-		arangodb, err := initArangodb()
-		if err != nil {
-			log.Fatal("error initializing arangodb:", err)
-		}
-
-		Mgr = &manager{
-			sqlDB:    nil,
-			arangodb: arangodb,
-			mongodb:  nil,
-		}
-
-		break
-	case constants.DbTypeMongodb:
-		mongodb, err := initMongodb()
-		if err != nil {
-			log.Fatal("error initializing mongodb connection:", err)
-		}
-
-		Mgr = &manager{
-			sqlDB:    nil,
-			arangodb: nil,
-			mongodb:  mongodb,
-		}
-	}
-
-	// common for all sql dbs that are configured via go-orm
-	if IsORMSupported {
-		if err != nil {
-			log.Fatal("Failed to init sqlDB:", err)
-		} else {
-			sqlDB.AutoMigrate(&User{}, &VerificationRequest{}, &Session{}, &Env{})
-		}
-		Mgr = &manager{
-			sqlDB:    sqlDB,
-			arangodb: nil,
-			mongodb:  nil,
+			log.Fatal("=> error setting arangodb provider:", err)
 		}
 	}
 }

server/db/env.go

@@ -1,161 +0,0 @@
-package db
-
-import (
-	"fmt"
-	"log"
-	"time"
-
-	arangoDriver "github.com/arangodb/go-driver"
-	"github.com/google/uuid"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo/options"
-)
-
-type Env struct {
-	Key       string `json:"_key,omitempty" bson:"_key"` // for arangodb
-	ID        string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id"`
-	EnvData   []byte `gorm:"type:text" json:"env" bson:"env"`
-	Hash      string `gorm:"type:hash" json:"hash" bson:"hash"`
-	UpdatedAt int64  `gorm:"autoUpdateTime" json:"updated_at" bson:"updated_at"`
-	CreatedAt int64  `gorm:"autoCreateTime" json:"created_at" bson:"created_at"`
-}
-
-// AddEnv function to add env to db
-func (mgr *manager) AddEnv(env Env) (Env, error) {
-	if env.ID == "" {
-		env.ID = uuid.New().String()
-	}
-
-	if IsORMSupported {
-		// copy id as value for fields required for mongodb & arangodb
-		env.Key = env.ID
-		result := mgr.sqlDB.Create(&env)
-
-		if result.Error != nil {
-			log.Println("error adding config:", result.Error)
-			return env, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		env.CreatedAt = time.Now().Unix()
-		env.UpdatedAt = time.Now().Unix()
-		configCollection, _ := mgr.arangodb.Collection(nil, Collections.Env)
-		meta, err := configCollection.CreateDocument(arangoDriver.WithOverwrite(nil), env)
-		if err != nil {
-			log.Println("error adding config:", err)
-			return env, err
-		}
-		env.Key = meta.Key
-		env.ID = meta.ID.String()
-	}
-
-	if IsMongoDB {
-		env.CreatedAt = time.Now().Unix()
-		env.UpdatedAt = time.Now().Unix()
-		env.Key = env.ID
-		configCollection := mgr.mongodb.Collection(Collections.Env, options.Collection())
-		_, err := configCollection.InsertOne(nil, env)
-		if err != nil {
-			log.Println("error adding config:", err)
-			return env, err
-		}
-	}
-
-	return env, nil
-}
-
-// UpdateEnv function to update env in db
-func (mgr *manager) UpdateEnv(env Env) (Env, error) {
-	env.UpdatedAt = time.Now().Unix()
-
-	if IsORMSupported {
-		result := mgr.sqlDB.Save(&env)
-
-		if result.Error != nil {
-			log.Println("error updating config:", result.Error)
-			return env, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		collection, _ := mgr.arangodb.Collection(nil, Collections.Env)
-		meta, err := collection.UpdateDocument(nil, env.Key, env)
-		if err != nil {
-			log.Println("error updating config:", err)
-			return env, err
-		}
-
-		env.Key = meta.Key
-		env.ID = meta.ID.String()
-	}
-
-	if IsMongoDB {
-		configCollection := mgr.mongodb.Collection(Collections.Env, options.Collection())
-		_, err := configCollection.UpdateOne(nil, bson.M{"_id": bson.M{"$eq": env.ID}}, bson.M{"$set": env}, options.MergeUpdateOptions())
-		if err != nil {
-			log.Println("error updating config:", err)
-			return env, err
-		}
-	}
-
-	return env, nil
-}
-
-// GetConfig function to get config
-func (mgr *manager) GetEnv() (Env, error) {
-	var env Env
-
-	if IsORMSupported {
-		result := mgr.sqlDB.First(&env)
-
-		if result.Error != nil {
-			return env, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf("FOR d in %s RETURN d", Collections.Env)
-
-		cursor, err := mgr.arangodb.Query(nil, query, nil)
-		if err != nil {
-			return env, err
-		}
-		defer cursor.Close()
-
-		for {
-			if !cursor.HasMore() {
-				if env.Key == "" {
-					return env, fmt.Errorf("config not found")
-				}
-				break
-			}
-			_, err := cursor.ReadDocument(nil, &env)
-			if err != nil {
-				return env, err
-			}
-		}
-	}
-
-	if IsMongoDB {
-		configCollection := mgr.mongodb.Collection(Collections.Env, options.Collection())
-		cursor, err := configCollection.Find(nil, bson.M{}, options.Find())
-		if err != nil {
-			return env, err
-		}
-		defer cursor.Close(nil)
-
-		for cursor.Next(nil) {
-			err := cursor.Decode(&env)
-			if err != nil {
-				return env, err
-			}
-		}
-
-		if env.ID == "" {
-			return env, fmt.Errorf("config not found")
-		}
-	}
-
-	return env, nil
-}

server/db/mongodb.go

@@ -1,80 +0,0 @@
-package db
-
-import (
-	"context"
-	"time"
-
-	"github.com/authorizerdev/authorizer/server/constants"
-	"github.com/authorizerdev/authorizer/server/envstore"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
-	"go.mongodb.org/mongo-driver/mongo/readpref"
-)
-
-func initMongodb() (*mongo.Database, error) {
-	mongodbOptions := options.Client().ApplyURI(envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseURL))
-	maxWait := time.Duration(5 * time.Second)
-	mongodbOptions.ConnectTimeout = &maxWait
-	mongoClient, err := mongo.NewClient(mongodbOptions)
-	if err != nil {
-		return nil, err
-	}
-	ctx, _ := context.WithTimeout(context.Background(), 30*time.Second)
-	err = mongoClient.Connect(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	err = mongoClient.Ping(ctx, readpref.Primary())
-	if err != nil {
-		return nil, err
-	}
-
-	mongodb := mongoClient.Database(envstore.EnvInMemoryStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseName), options.Database())
-
-	mongodb.CreateCollection(ctx, Collections.User, options.CreateCollection())
-	userCollection := mongodb.Collection(Collections.User, options.Collection())
-	userCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
-		mongo.IndexModel{
-			Keys:    bson.M{"email": 1},
-			Options: options.Index().SetUnique(true).SetSparse(true),
-		},
-	}, options.CreateIndexes())
-	userCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
-		mongo.IndexModel{
-			Keys: bson.M{"phone_number": 1},
-			Options: options.Index().SetUnique(true).SetSparse(true).SetPartialFilterExpression(map[string]interface{}{
-				"phone_number": map[string]string{"$type": "string"},
-			}),
-		},
-	}, options.CreateIndexes())
-
-	mongodb.CreateCollection(ctx, Collections.VerificationRequest, options.CreateCollection())
-	verificationRequestCollection := mongodb.Collection(Collections.VerificationRequest, options.Collection())
-	verificationRequestCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
-		mongo.IndexModel{
-			Keys:    bson.M{"email": 1, "identifier": 1},
-			Options: options.Index().SetUnique(true).SetSparse(true),
-		},
-	}, options.CreateIndexes())
-	verificationRequestCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
-		mongo.IndexModel{
-			Keys:    bson.M{"token": 1},
-			Options: options.Index().SetSparse(true),
-		},
-	}, options.CreateIndexes())
-
-	mongodb.CreateCollection(ctx, Collections.Session, options.CreateCollection())
-	sessionCollection := mongodb.Collection(Collections.Session, options.Collection())
-	sessionCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
-		mongo.IndexModel{
-			Keys:    bson.M{"user_id": 1},
-			Options: options.Index().SetSparse(true),
-		},
-	}, options.CreateIndexes())
-
-	mongodb.CreateCollection(ctx, Collections.Env, options.CreateCollection())
-
-	return mongodb, nil
-}

server/db/session.go

@@ -1,102 +0,0 @@
-package db
-
-import (
-	"fmt"
-	"log"
-	"time"
-
-	"github.com/google/uuid"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo/options"
-	"gorm.io/gorm/clause"
-)
-
-type Session struct {
-	Key       string `json:"_key,omitempty" bson:"_key,omitempty"` // for arangodb
-	ID        string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id"`
-	UserID    string `gorm:"type:char(36),index:" json:"user_id" bson:"user_id"`
-	User      User   `json:"-" bson:"-"`
-	UserAgent string `json:"user_agent" bson:"user_agent"`
-	IP        string `json:"ip" bson:"ip"`
-	CreatedAt int64  `gorm:"autoCreateTime" json:"created_at" bson:"created_at"`
-	UpdatedAt int64  `gorm:"autoUpdateTime" json:"updated_at" bson:"updated_at"`
-}
-
-// AddSession function to save user sessiosn
-func (mgr *manager) AddSession(session Session) error {
-	if session.ID == "" {
-		session.ID = uuid.New().String()
-	}
-
-	if IsORMSupported {
-		session.Key = session.ID
-		res := mgr.sqlDB.Clauses(
-			clause.OnConflict{
-				DoNothing: true,
-			}).Create(&session)
-		if res.Error != nil {
-			log.Println(`error saving session`, res.Error)
-			return res.Error
-		}
-	}
-
-	if IsArangoDB {
-		session.CreatedAt = time.Now().Unix()
-		session.UpdatedAt = time.Now().Unix()
-		sessionCollection, _ := mgr.arangodb.Collection(nil, Collections.Session)
-		_, err := sessionCollection.CreateDocument(nil, session)
-		if err != nil {
-			log.Println(`error saving session`, err)
-			return err
-		}
-	}
-
-	if IsMongoDB {
-		session.Key = session.ID
-		session.CreatedAt = time.Now().Unix()
-		session.UpdatedAt = time.Now().Unix()
-		sessionCollection := mgr.mongodb.Collection(Collections.Session, options.Collection())
-		_, err := sessionCollection.InsertOne(nil, session)
-		if err != nil {
-			log.Println(`error saving session`, err)
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (mgr *manager) DeleteUserSession(userId string) error {
-	if IsORMSupported {
-		result := mgr.sqlDB.Where("user_id = ?", userId).Delete(&Session{})
-
-		if result.Error != nil {
-			log.Println(`error deleting session:`, result.Error)
-			return result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf(`FOR d IN %s FILTER d.user_id == @userId REMOVE { _key: d._key } IN %s`, Collections.Session, Collections.Session)
-		bindVars := map[string]interface{}{
-			"userId": userId,
-		}
-		cursor, err := mgr.arangodb.Query(nil, query, bindVars)
-		if err != nil {
-			log.Println("=> error deleting arangodb session:", err)
-			return err
-		}
-		defer cursor.Close()
-	}
-
-	if IsMongoDB {
-		sessionCollection := mgr.mongodb.Collection(Collections.Session, options.Collection())
-		_, err := sessionCollection.DeleteMany(nil, bson.M{"user_id": userId}, options.Delete())
-		if err != nil {
-			log.Println("error deleting session:", err)
-			return err
-		}
-	}
-
-	return nil
-}

server/db/user.go

@@ -1,318 +0,0 @@
-package db
-
-import (
-	"fmt"
-	"log"
-	"strings"
-	"time"
-
-	"github.com/arangodb/go-driver"
-	arangoDriver "github.com/arangodb/go-driver"
-	"github.com/authorizerdev/authorizer/server/constants"
-	"github.com/authorizerdev/authorizer/server/envstore"
-	"github.com/google/uuid"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo/options"
-	"gorm.io/gorm/clause"
-)
-
-type User struct {
-	Key string `json:"_key,omitempty" bson:"_key"` // for arangodb
-	ID  string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id"`
-
-	Email                 string  `gorm:"unique" json:"email" bson:"email"`
-	EmailVerifiedAt       *int64  `json:"email_verified_at" bson:"email_verified_at"`
-	Password              *string `gorm:"type:text" json:"password" bson:"password"`
-	SignupMethods         string  `json:"signup_methods" bson:"signup_methods"`
-	GivenName             *string `json:"given_name" bson:"given_name"`
-	FamilyName            *string `json:"family_name" bson:"family_name"`
-	MiddleName            *string `json:"middle_name" bson:"middle_name"`
-	Nickname              *string `json:"nickname" bson:"nickname"`
-	Gender                *string `json:"gender" bson:"gender"`
-	Birthdate             *string `json:"birthdate" bson:"birthdate"`
-	PhoneNumber           *string `gorm:"unique" json:"phone_number" bson:"phone_number"`
-	PhoneNumberVerifiedAt *int64  `json:"phone_number_verified_at" bson:"phone_number_verified_at"`
-	Picture               *string `gorm:"type:text" json:"picture" bson:"picture"`
-	Roles                 string  `json:"roles" bson:"roles"`
-	UpdatedAt             int64   `gorm:"autoUpdateTime" json:"updated_at" bson:"updated_at"`
-	CreatedAt             int64   `gorm:"autoCreateTime" json:"created_at" bson:"created_at"`
-}
-
-// AddUser function to add user even with email conflict
-func (mgr *manager) AddUser(user User) (User, error) {
-	if user.ID == "" {
-		user.ID = uuid.New().String()
-	}
-
-	if user.Roles == "" {
-		user.Roles = strings.Join(envstore.EnvInMemoryStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyDefaultRoles), ",")
-	}
-
-	if IsORMSupported {
-		// copy id as value for fields required for mongodb & arangodb
-		user.Key = user.ID
-		result := mgr.sqlDB.Clauses(
-			clause.OnConflict{
-				UpdateAll: true,
-				Columns:   []clause.Column{{Name: "email"}},
-			}).Create(&user)
-
-		if result.Error != nil {
-			log.Println("error adding user:", result.Error)
-			return user, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		user.CreatedAt = time.Now().Unix()
-		user.UpdatedAt = time.Now().Unix()
-		userCollection, _ := mgr.arangodb.Collection(nil, Collections.User)
-		meta, err := userCollection.CreateDocument(arangoDriver.WithOverwrite(nil), user)
-		if err != nil {
-			log.Println("error adding user:", err)
-			return user, err
-		}
-		user.Key = meta.Key
-		user.ID = meta.ID.String()
-	}
-
-	if IsMongoDB {
-		user.CreatedAt = time.Now().Unix()
-		user.UpdatedAt = time.Now().Unix()
-		user.Key = user.ID
-		userCollection := mgr.mongodb.Collection(Collections.User, options.Collection())
-		_, err := userCollection.InsertOne(nil, user)
-		if err != nil {
-			log.Println("error adding user:", err)
-			return user, err
-		}
-	}
-
-	return user, nil
-}
-
-// UpdateUser function to update user with ID conflict
-func (mgr *manager) UpdateUser(user User) (User, error) {
-	user.UpdatedAt = time.Now().Unix()
-
-	if IsORMSupported {
-		result := mgr.sqlDB.Save(&user)
-
-		if result.Error != nil {
-			log.Println("error updating user:", result.Error)
-			return user, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		collection, _ := mgr.arangodb.Collection(nil, Collections.User)
-		meta, err := collection.UpdateDocument(nil, user.Key, user)
-		if err != nil {
-			log.Println("error updating user:", err)
-			return user, err
-		}
-
-		user.Key = meta.Key
-		user.ID = meta.ID.String()
-	}
-
-	if IsMongoDB {
-		userCollection := mgr.mongodb.Collection(Collections.User, options.Collection())
-		_, err := userCollection.UpdateOne(nil, bson.M{"_id": bson.M{"$eq": user.ID}}, bson.M{"$set": user}, options.MergeUpdateOptions())
-		if err != nil {
-			log.Println("error updating user:", err)
-			return user, err
-		}
-	}
-
-	return user, nil
-}
-
-// GetUsers function to get all users
-func (mgr *manager) GetUsers() ([]User, error) {
-	var users []User
-
-	if IsORMSupported {
-		result := mgr.sqlDB.Find(&users)
-		if result.Error != nil {
-			log.Println("error getting users:", result.Error)
-			return users, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf("FOR d in %s RETURN d", Collections.User)
-
-		cursor, err := mgr.arangodb.Query(nil, query, nil)
-		if err != nil {
-			return users, err
-		}
-		defer cursor.Close()
-
-		for {
-			var user User
-			meta, err := cursor.ReadDocument(nil, &user)
-
-			if driver.IsNoMoreDocuments(err) {
-				break
-			} else if err != nil {
-				return users, err
-			}
-
-			if meta.Key != "" {
-				users = append(users, user)
-			}
-		}
-	}
-
-	if IsMongoDB {
-		userCollection := mgr.mongodb.Collection(Collections.User, options.Collection())
-		cursor, err := userCollection.Find(nil, bson.M{}, options.Find())
-		if err != nil {
-			log.Println("error getting users:", err)
-			return users, err
-		}
-		defer cursor.Close(nil)
-
-		for cursor.Next(nil) {
-			var user User
-			err := cursor.Decode(&user)
-			if err != nil {
-				return users, err
-			}
-			users = append(users, user)
-		}
-	}
-
-	return users, nil
-}
-
-// GetUserByEmail function to get user by email
-func (mgr *manager) GetUserByEmail(email string) (User, error) {
-	var user User
-
-	if IsORMSupported {
-		result := mgr.sqlDB.Where("email = ?", email).First(&user)
-
-		if result.Error != nil {
-			return user, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf("FOR d in %s FILTER d.email == @email RETURN d", Collections.User)
-		bindVars := map[string]interface{}{
-			"email": email,
-		}
-
-		cursor, err := mgr.arangodb.Query(nil, query, bindVars)
-		if err != nil {
-			return user, err
-		}
-		defer cursor.Close()
-
-		for {
-			if !cursor.HasMore() {
-				if user.Key == "" {
-					return user, fmt.Errorf("user not found")
-				}
-				break
-			}
-			_, err := cursor.ReadDocument(nil, &user)
-			if err != nil {
-				return user, err
-			}
-		}
-	}
-
-	if IsMongoDB {
-		userCollection := mgr.mongodb.Collection(Collections.User, options.Collection())
-		err := userCollection.FindOne(nil, bson.M{"email": email}).Decode(&user)
-		if err != nil {
-			return user, err
-		}
-	}
-
-	return user, nil
-}
-
-// GetUserByID function to get user by ID
-func (mgr *manager) GetUserByID(id string) (User, error) {
-	var user User
-
-	if IsORMSupported {
-		result := mgr.sqlDB.Where("id = ?", id).First(&user)
-
-		if result.Error != nil {
-			return user, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf("FOR d in %s FILTER d._id == @id LIMIT 1 RETURN d", Collections.User)
-		bindVars := map[string]interface{}{
-			"id": id,
-		}
-
-		cursor, err := mgr.arangodb.Query(nil, query, bindVars)
-		if err != nil {
-			return user, err
-		}
-		defer cursor.Close()
-
-		for {
-			if !cursor.HasMore() {
-				if user.Key == "" {
-					return user, fmt.Errorf("user not found")
-				}
-				break
-			}
-			_, err := cursor.ReadDocument(nil, &user)
-			if err != nil {
-				return user, err
-			}
-		}
-	}
-
-	if IsMongoDB {
-		userCollection := mgr.mongodb.Collection(Collections.User, options.Collection())
-		err := userCollection.FindOne(nil, bson.M{"_id": id}).Decode(&user)
-		if err != nil {
-			return user, err
-		}
-	}
-
-	return user, nil
-}
-
-// DeleteUser function to delete user
-func (mgr *manager) DeleteUser(user User) error {
-	if IsORMSupported {
-		result := mgr.sqlDB.Delete(&user)
-
-		if result.Error != nil {
-			log.Println(`error deleting user:`, result.Error)
-			return result.Error
-		}
-	}
-
-	if IsArangoDB {
-		collection, _ := mgr.arangodb.Collection(nil, Collections.User)
-		_, err := collection.RemoveDocument(nil, user.Key)
-		if err != nil {
-			log.Println(`error deleting user:`, err)
-			return err
-		}
-	}
-
-	if IsMongoDB {
-		userCollection := mgr.mongodb.Collection(Collections.User, options.Collection())
-		_, err := userCollection.DeleteOne(nil, bson.M{"_id": user.ID}, options.Delete())
-		if err != nil {
-			log.Println("error deleting user:", err)
-			return err
-		}
-	}
-
-	return nil
-}

server/db/verification_requests.go

@@ -1,260 +0,0 @@
-package db
-
-import (
-	"fmt"
-	"log"
-	"time"
-
-	"github.com/arangodb/go-driver"
-	"github.com/google/uuid"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo/options"
-	"gorm.io/gorm/clause"
-)
-
-type VerificationRequest struct {
-	Key        string `json:"_key,omitempty" bson:"_key"` // for arangodb
-	ID         string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id"`
-	Token      string `gorm:"type:text" json:"token" bson:"token"`
-	Identifier string `gorm:"uniqueIndex:idx_email_identifier" json:"identifier" bson:"identifier"`
-	ExpiresAt  int64  `json:"expires_at" bson:"expires_at"`
-	CreatedAt  int64  `gorm:"autoCreateTime" json:"created_at" bson:"created_at"`
-	UpdatedAt  int64  `gorm:"autoUpdateTime" json:"updated_at" bson:"updated_at"`
-	Email      string `gorm:"uniqueIndex:idx_email_identifier" json:"email" bson:"email"`
-}
-
-// AddVerification function to add verification record
-func (mgr *manager) AddVerification(verification VerificationRequest) (VerificationRequest, error) {
-	if verification.ID == "" {
-		verification.ID = uuid.New().String()
-	}
-	if IsORMSupported {
-		// copy id as value for fields required for mongodb & arangodb
-		verification.Key = verification.ID
-		result := mgr.sqlDB.Clauses(clause.OnConflict{
-			Columns:   []clause.Column{{Name: "email"}, {Name: "identifier"}},
-			DoUpdates: clause.AssignmentColumns([]string{"token", "expires_at"}),
-		}).Create(&verification)
-
-		if result.Error != nil {
-			log.Println(`error saving verification record`, result.Error)
-			return verification, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		verification.CreatedAt = time.Now().Unix()
-		verification.UpdatedAt = time.Now().Unix()
-		verificationRequestCollection, _ := mgr.arangodb.Collection(nil, Collections.VerificationRequest)
-		meta, err := verificationRequestCollection.CreateDocument(nil, verification)
-		if err != nil {
-			log.Println("error saving verification record:", err)
-			return verification, err
-		}
-		verification.Key = meta.Key
-		verification.ID = meta.ID.String()
-	}
-
-	if IsMongoDB {
-		verification.CreatedAt = time.Now().Unix()
-		verification.UpdatedAt = time.Now().Unix()
-		verification.Key = verification.ID
-		verificationRequestCollection := mgr.mongodb.Collection(Collections.VerificationRequest, options.Collection())
-		_, err := verificationRequestCollection.InsertOne(nil, verification)
-		if err != nil {
-			log.Println("error saving verification record:", err)
-			return verification, err
-		}
-	}
-
-	return verification, nil
-}
-
-// GetVerificationRequests function to get all verification requests
-func (mgr *manager) GetVerificationRequests() ([]VerificationRequest, error) {
-	var verificationRequests []VerificationRequest
-
-	if IsORMSupported {
-		result := mgr.sqlDB.Find(&verificationRequests)
-		if result.Error != nil {
-			log.Println("error getting verification requests:", result.Error)
-			return verificationRequests, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf("FOR d in %s RETURN d", Collections.VerificationRequest)
-
-		cursor, err := mgr.arangodb.Query(nil, query, nil)
-		if err != nil {
-			return verificationRequests, err
-		}
-		defer cursor.Close()
-
-		for {
-			var verificationRequest VerificationRequest
-			meta, err := cursor.ReadDocument(nil, &verificationRequest)
-
-			if driver.IsNoMoreDocuments(err) {
-				break
-			} else if err != nil {
-				return verificationRequests, err
-			}
-
-			if meta.Key != "" {
-				verificationRequests = append(verificationRequests, verificationRequest)
-			}
-
-		}
-	}
-
-	if IsMongoDB {
-		verificationRequestCollection := mgr.mongodb.Collection(Collections.VerificationRequest, options.Collection())
-		cursor, err := verificationRequestCollection.Find(nil, bson.M{}, options.Find())
-		if err != nil {
-			log.Println("error getting verification requests:", err)
-			return verificationRequests, err
-		}
-		defer cursor.Close(nil)
-
-		for cursor.Next(nil) {
-			var verificationRequest VerificationRequest
-			err := cursor.Decode(&verificationRequest)
-			if err != nil {
-				return verificationRequests, err
-			}
-			verificationRequests = append(verificationRequests, verificationRequest)
-		}
-	}
-
-	return verificationRequests, nil
-}
-
-func (mgr *manager) GetVerificationByToken(token string) (VerificationRequest, error) {
-	var verification VerificationRequest
-
-	if IsORMSupported {
-		result := mgr.sqlDB.Where("token = ?", token).First(&verification)
-
-		if result.Error != nil {
-			log.Println(`error getting verification request:`, result.Error)
-			return verification, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf("FOR d in %s FILTER d.token == @token LIMIT 1 RETURN d", Collections.VerificationRequest)
-		bindVars := map[string]interface{}{
-			"token": token,
-		}
-
-		cursor, err := mgr.arangodb.Query(nil, query, bindVars)
-		if err != nil {
-			return verification, err
-		}
-		defer cursor.Close()
-
-		for {
-			if !cursor.HasMore() {
-				if verification.Key == "" {
-					return verification, fmt.Errorf("verification request not found")
-				}
-				break
-			}
-			_, err := cursor.ReadDocument(nil, &verification)
-			if err != nil {
-				return verification, err
-			}
-		}
-	}
-
-	if IsMongoDB {
-		verificationRequestCollection := mgr.mongodb.Collection(Collections.VerificationRequest, options.Collection())
-		err := verificationRequestCollection.FindOne(nil, bson.M{"token": token}).Decode(&verification)
-		if err != nil {
-			return verification, err
-		}
-	}
-
-	return verification, nil
-}
-
-func (mgr *manager) GetVerificationByEmail(email string, identifier string) (VerificationRequest, error) {
-	var verification VerificationRequest
-	if IsORMSupported {
-		result := mgr.sqlDB.Where("email = ? AND identifier = ?", email, identifier).First(&verification)
-
-		if result.Error != nil {
-			log.Println(`error getting verification token:`, result.Error)
-			return verification, result.Error
-		}
-	}
-
-	if IsArangoDB {
-		query := fmt.Sprintf("FOR d in %s FILTER d.email == @email FILTER d.identifier == @identifier LIMIT 1 RETURN d", Collections.VerificationRequest)
-		bindVars := map[string]interface{}{
-			"email":      email,
-			"identifier": identifier,
-		}
-
-		cursor, err := mgr.arangodb.Query(nil, query, bindVars)
-		if err != nil {
-			return verification, err
-		}
-		defer cursor.Close()
-
-		for {
-			if !cursor.HasMore() {
-				if verification.Key == "" {
-					return verification, fmt.Errorf("verification request not found")
-				}
-				break
-			}
-			_, err := cursor.ReadDocument(nil, &verification)
-			if err != nil {
-				return verification, err
-			}
-		}
-	}
-
-	if IsMongoDB {
-		verificationRequestCollection := mgr.mongodb.Collection(Collections.VerificationRequest, options.Collection())
-		err := verificationRequestCollection.FindOne(nil, bson.M{"email": email, "identifier": identifier}).Decode(&verification)
-		if err != nil {
-			return verification, err
-		}
-	}
-
-	return verification, nil
-}
-
-func (mgr *manager) DeleteVerificationRequest(verificationRequest VerificationRequest) error {
-	if IsORMSupported {
-		result := mgr.sqlDB.Delete(&verificationRequest)
-
-		if result.Error != nil {
-			log.Println(`error deleting verification request:`, result.Error)
-			return result.Error
-		}
-	}
-
-	if IsArangoDB {
-		collection, _ := mgr.arangodb.Collection(nil, Collections.VerificationRequest)
-		_, err := collection.RemoveDocument(nil, verificationRequest.Key)
-		if err != nil {
-			log.Println(`error deleting verification request:`, err)
-			return err
-		}
-	}
-
-	if IsMongoDB {
-		verificationRequestCollection := mgr.mongodb.Collection(Collections.VerificationRequest, options.Collection())
-		_, err := verificationRequestCollection.DeleteOne(nil, bson.M{"_id": verificationRequest.ID}, options.Delete())
-		if err != nil {
-			log.Println("error deleting verification request::", err)
-			return err
-		}
-	}
-
-	return nil
-}