github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/generic/repository/memcached/generic.repository.go

package memcached

import (
	"context"
	"fmt"
	"time"

	"github.com/google/uuid"
	"github.com/redis/go-redis/v9"

	"github.com/angryronald/go-kit/cast"
	"github.com/angryronald/go-kit/generic/repository"
)

const defaultIDPropertyName string = "ID"

type KeyIdentifier struct {
	key                  string
	isCollection         bool
	propertyNameMapToKey string
}

func NewKeyIdentifier(
	key string,
	isCollection bool,
	propertyNameMapToKey string,
) *KeyIdentifier {
	return &KeyIdentifier{
		key:                  key,
		isCollection:         isCollection,
		propertyNameMapToKey: propertyNameMapToKey,
	}
}

type GenericRepository struct {
	client             *redis.Client
	key                string
	expirationDuration time.Duration
	keyIdentifiers     []*KeyIdentifier
}

func (r *GenericRepository) isKeyIdentifierRegistered(key string) bool {
	for _, keyIdentifier := range r.keyIdentifiers {
		if keyIdentifier.key == key {
			return true
		}
	}
	return false
}

func (r *GenericRepository) getKeyIdentifier(key string) *KeyIdentifier {
	for _, keyIdentifier := range r.keyIdentifiers {
		if keyIdentifier.key == key {
			return keyIdentifier
		}
	}
	return nil
}

func (r *GenericRepository) findByKeyIdentifier(ctx context.Context, keyIdentifierWanted string, key string, model interface{}) (interface{}, error) {
	for _, keyIdentifier := range r.keyIdentifiers {
		if keyIdentifier.key == keyIdentifierWanted {
			var result interface{}
			if keyIdentifier.isCollection {
				result = CreateStructPointerSlice(model, 0)
			} else {
				result = CreateNewStructObject(model)
			}

			resultRaw, err := r.client.Get(ctx, fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key)).Result()
			if err != nil {
				return nil, err
			}

			cast.FromBytes([]byte(resultRaw), &result)

			if !keyIdentifier.isCollection {
				return cast.ObjectToStructPointerSlice(result), nil
			}

			return result, nil
		}
	}
	return nil, repository.ErrNotFound
}

// isParametersValid return
// 1. true if either all parameters are key identifiers or all parameters are filtered parameters
// 2. true if all parameters are key identifiers
func (r *GenericRepository) isParametersValidAndAllParametersAreKeyIdentifiers(params map[string]interface{}) (bool, bool) {
	numberOfKeyIdentifierParams := 0

	for key, _ := range params {
		if r.isKeyIdentifierRegistered(key) {
			numberOfKeyIdentifierParams++
		}
	}

	return (numberOfKeyIdentifierParams == len(params)) || (numberOfKeyIdentifierParams == 0), (numberOfKeyIdentifierParams == len(params))
}

func (r *GenericRepository) insertInAllKeys(ctx context.Context, data interface{}) error {
	for _, keyIdentifier := range r.keyIdentifiers {
		key, err := repository.GetStructPropertyAsString(data, keyIdentifier.propertyNameMapToKey)
		if err != nil {
			return err
		}

		if keyIdentifier.isCollection {
			dataInArray := CreateStructPointerSlice(data, 0)

			resultRaw, err := r.client.Get(ctx, fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key)).Result()
			if err != nil && err != redis.Nil {
				return err
			}

			cast.FromBytes([]byte(resultRaw), &dataInArray)

			resultInArray := cast.StructPointerArrayToInterfacePointerArray(dataInArray)
			resultInArray = append(resultInArray, data)

			dataBytes, err := cast.ToBytes(resultInArray)
			if err != nil {
				return err
			}

			if err = r.client.Set(
				ctx,
				fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key),
				dataBytes,
				r.expirationDuration).Err(); err != nil {
				return err
			}
		} else {
			dataBytes, err := cast.ToBytes(data)
			if err != nil {
				return err
			}

			if err = r.client.Set(
				ctx,
				fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key),
				dataBytes,
				r.expirationDuration).Err(); err != nil {
				return err
			}
		}
	}

	return nil
}

func (r *GenericRepository) upsertInAllKeys(ctx context.Context, data interface{}) error {
	for _, keyIdentifier := range r.keyIdentifiers {
		key, err := repository.GetStructPropertyAsString(data, keyIdentifier.propertyNameMapToKey)
		if err != nil {
			return err
		}

		if keyIdentifier.isCollection {
			dataInArray := CreateStructPointerSlice(data, 0)

			resultRaw, err := r.client.Get(ctx, fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key)).Result()
			if err != nil && err != redis.Nil {
				return err
			}

			cast.FromBytes([]byte(resultRaw), &dataInArray)

			// ignore error if not found
			resultInArray, err := UpdateCollection(dataInArray, data)
			if err == repository.ErrNotFound {
				resultInArray = append(resultInArray, data)
			}

			dataBytes, err := cast.ToBytes(resultInArray)
			if err != nil {
				return err
			}

			if err = r.client.Set(
				ctx,
				fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key),
				dataBytes,
				r.expirationDuration).Err(); err != nil {
				return err
			}
		} else {
			dataBytes, err := cast.ToBytes(data)
			if err != nil {
				return err
			}

			if err = r.client.Set(
				ctx,
				fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key),
				dataBytes,
				r.expirationDuration).Err(); err != nil {
				return err
			}
		}
	}

	return nil
}

func (r *GenericRepository) deleteInAllKeys(ctx context.Context, data interface{}) error {
	for _, keyIdentifier := range r.keyIdentifiers {
		key, err := repository.GetStructPropertyAsString(data, keyIdentifier.propertyNameMapToKey)
		if err != nil {
			return err
		}

		if keyIdentifier.isCollection {
			dataInArray := CreateStructPointerSlice(data, 0)

			resultRaw, err := r.client.Get(ctx, fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key)).Result()
			if err != nil {
				return err
			}

			cast.FromBytes([]byte(resultRaw), &dataInArray)

			// ignore error if not found
			resultInArray, err := DeleteCollection(dataInArray, data)
			if err == repository.ErrNotFound {
				resultInArray = append(resultInArray, data)
			}

			dataBytes, err := cast.ToBytes(resultInArray)
			if err != nil {
				return err
			}

			if err = r.client.Set(
				ctx,
				fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key),
				dataBytes,
				r.expirationDuration).Err(); err != nil {
				return err
			}
		} else {
			if err = r.client.Del(ctx, fmt.Sprintf("%s%s%s", keyIdentifier.key, CONJUNCTION, key)).Err(); err != nil {
				return err
			}
		}
	}

	return nil
}

func (r *GenericRepository) bulkInsertInAllKeys(ctx context.Context, data map[string]map[string][]interface{}) error {
	for keyIdentifier, dataInKeyMap := range data {
		registeredKeyIdentifier := r.getKeyIdentifier(keyIdentifier)
		if registeredKeyIdentifier.isCollection {
			for key, dataInArray := range dataInKeyMap {
				dataBytes, err := cast.ToBytes(dataInArray)
				if err != nil {
					return err
				}

				if err = r.client.Set(
					ctx,
					fmt.Sprintf("%s%s%s", keyIdentifier, CONJUNCTION, key),
					dataBytes,
					r.expirationDuration).Err(); err != nil {
					return err
				}
			}
		} else {
			for key, dataInArray := range dataInKeyMap {
				dataBytes, err := cast.ToBytes(dataInArray[0])
				if err != nil {
					return err
				}

				if err = r.client.Set(
					ctx,
					fmt.Sprintf("%s%s%s", keyIdentifier, CONJUNCTION, key),
					dataBytes,
					r.expirationDuration).Err(); err != nil {
					return err
				}
			}
		}
	}
	return nil
}

func (r *GenericRepository) bulkUpsertInAllKeys(ctx context.Context, data map[string]map[string][]interface{}) error {
	for keyIdentifier, dataInKeyMap := range data {
		registeredKeyIdentifier := r.getKeyIdentifier(keyIdentifier)
		if registeredKeyIdentifier.isCollection {
			for key, dataInArray := range dataInKeyMap {
				dataBytes, err := cast.ToBytes(dataInArray)
				if err != nil {
					return err
				}

				if err = r.client.Del(ctx, fmt.Sprintf("%s%s%s", keyIdentifier, CONJUNCTION, key)).Err(); err != nil {
					return err
				}

				if err = r.client.Set(
					ctx,
					fmt.Sprintf("%s%s%s", keyIdentifier, CONJUNCTION, key),
					dataBytes,
					r.expirationDuration).Err(); err != nil {
					return err
				}
			}
		} else {
			for key, dataInArray := range dataInKeyMap {
				dataBytes, err := cast.ToBytes(dataInArray[0])
				if err != nil {
					return err
				}

				if err = r.client.Del(ctx, fmt.Sprintf("%s%s%s", keyIdentifier, CONJUNCTION, key)).Err(); err != nil {
					return err
				}

				if err = r.client.Set(
					ctx,
					fmt.Sprintf("%s%s%s", keyIdentifier, CONJUNCTION, key),
					dataBytes,
					r.expirationDuration).Err(); err != nil {
					return err
				}
			}
		}
	}
	return nil
}

func (r *GenericRepository) transformDataToKeyMap(data interface{}) map[string]map[string][]interface{} {
	dataMapToKey := map[string]map[string][]interface{}{}
	for _, keyIdentifier := range r.keyIdentifiers {
		dataMapToKey[keyIdentifier.key] = map[string][]interface{}{}
	}

	dataInArray := cast.StructPointerArrayToInterfacePointerArray(data)
	for _, dt := range dataInArray {
		for _, keyIdentifier := range r.keyIdentifiers {
			key, err := repository.GetStructPropertyAsString(dt, keyIdentifier.propertyNameMapToKey)
			if err != nil {
				return nil
			}
			if dataMapToKey[keyIdentifier.key][key] == nil {
				dataMapToKey[keyIdentifier.key][key] = []interface{}{}
			}
			dataMapToKey[keyIdentifier.key][key] = append(dataMapToKey[keyIdentifier.key][key], dt)
		}
	}

	return dataMapToKey
}

// FindAll to get all the data with filtered by parameters given (Not Recommended passing the params on memcached, the process might slowed down and take more memory since it is relying on reflect)
func (r *GenericRepository) FindAll(ctx context.Context, params map[string]interface{}, conditionalOperations []repository.ConditionalOperation, relationalOperations []repository.RelationalOperation, page int, limit int, result interface{}) (interface{}, error) {
	var isConditionFulfill bool
	var err error

	if !repository.IsValidOperations(conditionalOperations, relationalOperations, params) {
		return nil, repository.ErrBadParameters
	}

	resultRaw, err := r.client.Get(ctx, r.key).Result()
	if err != nil {
		if err == redis.Nil {
			return nil, repository.ErrNotFound
		}
		return nil, err
	}

	resultInArray := CreateStructPointerSlice(result, 0)
	cast.FromBytes([]byte(resultRaw), &resultInArray)

	filteredResult := cast.StructPointerArrayToInterfacePointerArray(resultInArray)

	var finalResult []interface{}
	if len(params) > 0 {
		isParametersValid, allParametersAreKeyIdentifiers := r.isParametersValidAndAllParametersAreKeyIdentifiers(params)
		if !isParametersValid {
			return nil, repository.ErrOperationIsNotAllowed
		}

		if allParametersAreKeyIdentifiers {
			for key, value := range params {
				valueInString, err := cast.ToString(value)
				if err != nil {
					return nil, err
				}

				singleResultRaw, err := r.findByKeyIdentifier(ctx, key, valueInString, result)
				if err != nil {
					if err == redis.Nil {
						return nil, repository.ErrNotFound
					}
					return nil, err
				}

				singleResult := cast.StructPointerArrayToInterfacePointerArray(singleResultRaw)
				finalResult = append(finalResult, singleResult...)
			}
		} else {
			for _, singleResult := range filteredResult {
				if isConditionFulfill, err = extractObjectAndCheckConditions(singleResult, params, conditionalOperations, relationalOperations); err != nil {
					return nil, err
				}

				if isConditionFulfill {
					finalResult = append(finalResult, singleResult)
				}
			}
		}
	} else {
		finalResult = filteredResult
	}

	if page == 0 && limit == 0 {
		return finalResult, nil
	}

	if page == 0 {
		page = 1
	}

	if limit == 0 {
		limit = 10
	}

	finalResult = finalResult[(page-1)*limit:]
	if len(finalResult) > 0 {
		if limit > len(finalResult) {
			limit = len(finalResult)
		}
		finalResult = finalResult[:limit]
	}
	return finalResult, nil
}

func (r *GenericRepository) FindOne(ctx context.Context, key string, value interface{}, result interface{}) (interface{}, error) {
	singleResultRaw, err := r.FindAll(ctx, map[string]interface{}{key: value}, []repository.ConditionalOperation{repository.EQUAL_WITH}, nil, 1, 1, result)
	if err != nil {
		return nil, err
	}
	singleResult := cast.StructPointerArrayToInterfaceArray(singleResultRaw)
	if len(singleResult) == 0 {
		return nil, repository.ErrNotFound
	}
	return singleResult[0], nil
}

func (r *GenericRepository) FindByID(ctx context.Context, id uuid.UUID, result interface{}) (interface{}, error) {
	resultRaw, err := r.client.Get(ctx, fmt.Sprintf("%s%s%s", r.key, CONJUNCTION, id)).Result()
	if err != nil {
		if err == redis.Nil {
			return nil, repository.ErrNotFound
		}
		return nil, err
	}

	cast.FromBytes([]byte(resultRaw), &result)
	return result, nil
}

func (r *GenericRepository) Insert(ctx context.Context, data interface{}) (interface{}, error) {
	result := CreateStructPointerSlice(data, 0)
	resultRaw, err := r.client.Get(ctx, r.key).Result()
	if err != nil && err != redis.Nil {
		return nil, err
	}

	cast.FromBytes([]byte(resultRaw), &result)

	resultInArray := cast.StructPointerArrayToInterfacePointerArray(result)
	resultInArray = append([]interface{}{data}, resultInArray...)

	dataBytes, err := cast.ToBytes(resultInArray)
	if err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		r.key,
		dataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	singleDataBytes, err := cast.ToBytes(data)
	if err != nil {
		return nil, err
	}

	id, err := repository.GetStructPropertyAsString(data, defaultIDPropertyName)
	if err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		fmt.Sprintf("%s%s%s", r.key, CONJUNCTION, id),
		singleDataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	if err = r.insertInAllKeys(ctx, data); err != nil {
		return nil, err
	}

	return data, nil
}

func (r *GenericRepository) Update(ctx context.Context, data interface{}) (interface{}, error) {
	result := CreateStructPointerSlice(data, 0)
	resultRaw, err := r.client.Get(ctx, r.key).Result()
	if err != nil {
		if err == redis.Nil {
			return nil, repository.ErrNotFound
		}
		return nil, err
	}

	cast.FromBytes([]byte(resultRaw), &result)

	resultInArray, err := UpdateCollection(result, data)
	if err != nil {
		return nil, err
	}

	dataBytes, err := cast.ToBytes(resultInArray)
	if err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		r.key,
		dataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	singleDataBytes, err := cast.ToBytes(data)
	if err != nil {
		return nil, err
	}

	id, err := repository.GetStructPropertyAsString(data, defaultIDPropertyName)
	if err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		fmt.Sprintf("%s%s%s", r.key, CONJUNCTION, id),
		singleDataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	if err = r.upsertInAllKeys(ctx, data); err != nil {
		return nil, err
	}

	return data, nil
}

func (r *GenericRepository) Delete(ctx context.Context, data interface{}) (interface{}, error) {
	result := CreateStructPointerSlice(data, 0)
	resultRaw, err := r.client.Get(ctx, r.key).Result()
	if err != nil {
		if err == redis.Nil {
			return nil, repository.ErrNotFound
		}
		return nil, err
	}

	cast.FromBytes([]byte(resultRaw), &result)

	resultInArray, err := DeleteCollection(result, data)
	if err != nil {
		return nil, err
	}

	dataBytes, err := cast.ToBytes(resultInArray)
	if err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		r.key,
		dataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	id, err := repository.GetStructPropertyAsString(data, defaultIDPropertyName)
	if err != nil {
		return nil, err
	}

	if err = r.client.Del(ctx, fmt.Sprintf("%s%s%s", r.key, CONJUNCTION, id)).Err(); err != nil {
		return nil, err
	}

	if err = r.deleteInAllKeys(ctx, data); err != nil {
		return nil, err
	}

	return data, nil
}

func (r *GenericRepository) Upsert(ctx context.Context, data interface{}) (interface{}, error) {
	result := CreateStructPointerSlice(data, 0)
	resultRaw, err := r.client.Get(ctx, r.key).Result()
	if err != nil && err != redis.Nil {
		return nil, err
	}

	cast.FromBytes([]byte(resultRaw), &result)

	resultInArray, err := UpdateCollection(result, data)
	if err == repository.ErrNotFound {
		resultInArray = append(cast.StructPointerArrayToInterfacePointerArray(result), data)
	}

	dataBytes, err := cast.ToBytes(resultInArray)
	if err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		r.key,
		dataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	singleDataBytes, err := cast.ToBytes(data)
	if err != nil {
		return nil, err
	}

	id, err := repository.GetStructPropertyAsString(data, defaultIDPropertyName)
	if err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		fmt.Sprintf("%s%s%s", r.key, CONJUNCTION, id),
		singleDataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	if err = r.upsertInAllKeys(ctx, data); err != nil {
		return nil, err
	}

	return data, nil
}

// BulkInsert for now just going to do bulkinsert for whole data
/*
consideration - trade offs:
+ much faster
- needs to implement sharding services for reading and writing to cutoff the data size as soon as possible
*/
func (r *GenericRepository) BulkInsert(ctx context.Context, data interface{}) (interface{}, error) {
	dataBytes, err := cast.ToBytes(data)
	if err != nil && err != redis.Nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		r.key,
		dataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	dataInArray := cast.StructPointerArrayToInterfacePointerArray(data)
	for _, dt := range dataInArray {
		singleDataBytes, err := cast.ToBytes(dt)
		if err != nil {
			return nil, err
		}

		id, err := repository.GetStructPropertyAsString(dt, defaultIDPropertyName)
		if err != nil {
			return nil, err
		}

		if err = r.client.Set(
			ctx,
			fmt.Sprintf("%s%s%s", r.key, CONJUNCTION, id),
			singleDataBytes,
			r.expirationDuration).Err(); err != nil {
			return nil, err
		}
	}

	if err = r.bulkInsertInAllKeys(ctx, r.transformDataToKeyMap(data)); err != nil {
		return nil, err
	}

	return data, nil
}

// BulkUpsert for now just going to do bulkupsert for whole data by removing and reinsert new data
/*
consideration - trade offs:
+ much faster
- needs to implement sharding services for reading and writing to cutoff the data size as soon as possible
*/
func (r *GenericRepository) BulkUpsert(ctx context.Context, data interface{}) (interface{}, error) {
	dataBytes, err := cast.ToBytes(data)
	if err != nil && err != redis.Nil {
		return nil, err
	}

	if err = r.client.Del(ctx, r.key).Err(); err != nil {
		return nil, err
	}

	if err = r.client.Set(
		ctx,
		r.key,
		dataBytes,
		r.expirationDuration).Err(); err != nil {
		return nil, err
	}

	dataInArray := cast.StructPointerArrayToInterfacePointerArray(data)
	for _, dt := range dataInArray {
		singleDataBytes, err := cast.ToBytes(dt)
		if err != nil {
			return nil, err
		}

		id, err := repository.GetStructPropertyAsString(dt, defaultIDPropertyName)
		if err != nil {
			return nil, err
		}

		if err = r.client.Set(
			ctx,
			fmt.Sprintf("%s%s%s", r.key, CONJUNCTION, id),
			singleDataBytes,
			r.expirationDuration).Err(); err != nil {
			return nil, err
		}
	}

	if err = r.bulkUpsertInAllKeys(ctx, r.transformDataToKeyMap(data)); err != nil {
		return nil, err
	}

	return data, nil
}

func (r *GenericRepository) Query(ctx context.Context, query string, params []interface{}, result interface{}) (interface{}, error) {
	// Not Implemented on memcached
	return nil, repository.ErrNotImplement
}

func NewRepository(client *redis.Client, key string, expirationDuration time.Duration, keyIdentifiers []*KeyIdentifier) repository.GenericRepositoryInterface {
	return &GenericRepository{
		client:             client,
		key:                key,
		expirationDuration: expirationDuration,
		keyIdentifiers:     keyIdentifiers,
	}
}

func NewMutableRepository(client *redis.Client, key string, expirationDuration time.Duration, keyIdentifiers []*KeyIdentifier) repository.MutableGenericRepositoryInterface {
	return &GenericRepository{
		client:             client,
		key:                key,
		expirationDuration: expirationDuration,
		keyIdentifiers:     keyIdentifiers,
	}
}

func NewImmutableRepository(client *redis.Client, key string, expirationDuration time.Duration, keyIdentifiers []*KeyIdentifier) repository.ImmutableGenericRepositoryInterface {
	return &GenericRepository{
		client:             client,
		key:                key,
		expirationDuration: expirationDuration,
		keyIdentifiers:     keyIdentifiers,
	}
}