ddbmap

type CreateTableOptions struct {
	// CreateTableIfAbsent determines if a table should be created when missing.
	// If true, users must also set the HashKeyType and, if there is a range key, the RangeKeyType,
	// and may also choose to set CreateTableReadCapacity and CreateTableWriteCapacity
	CreateTableIfAbsent bool
	// CreateTableReadCapacity is the read capacity of the new table, if created. 1 is used if less than 1.
	CreateTableReadCapacity int
	// CreateTableReadCapacity is the write capacity of the new table, if created. 1 is used if less than 1.
	CreateTableWriteCapacity int
	// The type of the hash key attribute.
	HashKeyType dynamodb.ScalarAttributeType
	// The type of the range key attribute, if any.
	RangeKeyType dynamodb.ScalarAttributeType
	// If true, Server Side Encryption (SSE) is enabled.
	ServerSideEncryption bool
}

type DynamoMap struct {
	TableConfig
	Client *dynamodb.Client
}

type Item map[string]dynamodb.AttributeValue

type ItemMap interface {
	// DeleteItem deletes any existing item with the same key(s) as the given item.
	DeleteItem(keys Itemable) error

	// LoadItem returns the existing item, if present, with the same key(s) as the given item.
	// The ok result returns true if the value was found.
	LoadItem(keys Itemable) (item Item, ok bool, err error)

	// StoreItem stores the given item, clobbering any existing item with the same key(s).
	StoreItem(item Itemable) error

	// LoadOrStoreItem returns the existing item, if present, with the same key(s) as the given item.
	// Otherwise, it stores and returns the given item.
	// The loaded result is true if the value was loaded, false if stored.
	LoadOrStoreItem(item Itemable) (actual Item, loaded bool, err error)

	// StoreIfAbsent stores the given value if there is no existing value with the same key(s),
	// returning true if stored.
	StoreIfAbsent(val interface{}) (stored bool, err error)

	// StoreItemIfAbsent stores the given item if there is no existing item with the same key(s),
	// returning true if stored.
	StoreItemIfAbsent(item Itemable) (stored bool, err error)

	// RangeItems calls the given consumer for each stored item.
	// If the consumer returns false, range eventually stops the iteration.
	RangeItems(consumer func(Item) (resume bool)) error

	// StoreIfVersion stores the given item if there is an existing item with the same key(s) and the given version.
	// Returns true if the item was stored.
	StoreIfVersion(val interface{}, version int64) (ok bool)

	// StoreItemIfVersion stores the given item if there is an existing item with the same key(s) and the given version.
	// Returns true if the item was stored.
	StoreItemIfVersion(item Itemable, version int64) (ok bool, err error)
}

type ItemUnmarshaller func(Item) (interface{}, error)

type Itemable interface {
	AsItem() Item
}

type KeyFromValue func(interface{}) (interface{}, error)

type Map interface {
	// Delete delete the value stored under the given key, if any.
	Delete(toDelete interface{}) error
	// Load returns the value stored under the given key, if any.
	// The ok result indicates if there a value was found for the key.
	Load(toLoad interface{}) (result interface{}, ok bool, err error)
	// LoadOrStore returns the value stored under the same key as the given value, if any,
	// else stores and returns the given value.
	// The loaded result is true if the value was loaded, false if stored.
	LoadOrStore(value interface{}) (actual interface{}, loaded bool, err error)
	// Range iterates over the map and applies the given function to every value.
	// Range stops iteration if the given function returns false.
	Range(consumer func(value interface{}) (resume bool)) error
	// Store stores the given value.
	Store(toStore interface{}) error
	// Store stores the given value is no value with the same key is stored.
	// The stored result is true if the value was stored.
	StoreIfAbsent(toStore interface{}) (stored bool, err error)
}

type TableConfig struct {
	// The name of the table.
	TableName string
	// The name of the hash key attribute.
	HashKeyName string
	// The name of the range key attribute, if any.
	RangeKeyName string
	// The name of the numeric version field, if any.
	// Used only for those conditional methods that use versions.
	VersionName string
	// The name of the ttl field, if any.
	// If empty and TimeToLiveDuration is not zero, DefaultTimeToLiveName ("TTL") will be used.
	// A ttl field should be either an int type or dynamodbattribute.UnixTime.
	TimeToLiveName string
	// The Time To Live Duration, if any.
	TimeToLiveDuration time.Duration
	// The concurrency used in table scans (Range calls).
	// If less than 2, scan is done serially.
	ScanConcurrency int
	// If the client should use strongly consistent reads.
	// This costs twice as much as eventually consistent reads.
	ReadWithStrongConsistency bool
	// If true, debug logging in this library is enabled.
	Debug bool
	// Logger is the logger used by this library for debug and error logging.
	Logger aws.Logger
	// ValueUnmarshaller can be used to change what is returned by Load, LoadOrStore, and Range.
	// These methods return an Item if ValueUnmarshaller is nil.
	// If ValueUnmarshaller is not nil, the result of passing the value item to the unmarshaller
	// is returned as the value instead of the item.
	ValueUnmarshaller ItemUnmarshaller
	// Options for creating the table
	CreateTableOptions
}