prologic / Collection.List()

package bitcask import ( "encoding/json" "errors" "fmt" "reflect" ) var ( // ErrObjectNotFound is the error returned when an object is not found in the collection. ErrObjectNotFound = errors.New("error: object not found") ) func (b *bitcask) Collection(name string) *Collection { return &Collection{db: b, name: name} } // Collection allows you to manage a collection of objects encoded as JSON // documents with a path-based key based on the provided name. This is convenient // for storing complex normalized collections of objects. type Collection struct { db DB name string } func (c *Collection) makeKey(id string) Key { return Key(fmt.Sprintf("%s/%s", c.name, id)) } func (c *Collection) makePrefix() Key { return Key(c.name) } // Add adds a new object to the collection func (c *Collection) Add(id string, obj any) error { k := c.makeKey(id) v, err := json.Marshal(obj) if err != nil { return err } return c.db.Put(k, v) } // Delete deletes an object from the collection func (c *Collection) Delete(id string) error { return c.db.Delete(c.makeKey(id)) } // Get returns an object from the collection func (c *Collection) Get(id string, obj any) error { k := c.makeKey(id) data, err := c.db.Get(k) if err != nil { if err == ErrKeyNotFound { return ErrObjectNotFound } return err } return json.Unmarshal(data, obj) } // List returns a list of all objects in this collection. func (c *Collection) List(objects any) error { tx := c.db.Transaction() defer tx.Discard() value := reflect.ValueOf(objects).Elem() elem := reflect.TypeOf(objects).Elem() return tx.Scan(c.makePrefix(), func(k Key) error { data, err := tx.Get(k) if err != nil { return err } obj := reflect.New(elem) if err := json.Unmarshal(data, &obj); err != nil { return err } value.Set(reflect.Append(value, reflect.ValueOf(obj))) return nil }) } // Has returns true if an object exists by the provided id. func (c *Collection) Has(id string) bool { return c.db.Has(c.makeKey(id)) } // Count returns the number of objects in this collection. func (c *Collection) Count() int { n := 0 c.db.Scan(c.makePrefix(), func(k Key) error { n++ return nil }) return n } // Drop deletes the entire collection func (c *Collection) Drop() error { tx := c.db.Transaction() defer tx.Discard() if err := tx.Scan(c.makePrefix(), func(k Key) error { return tx.Delete(k) }); err != nil { return err } return tx.Commit() } // Exists returns true if the collection exists at all, which really just means // whether there are any objects in the collection, so this is the same as calling // Count() > 0. func (c *Collection) Exists() bool { return c.Count() > 0 }

package bitcask import ( "os" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func setupDB(t *testing.T) DB { t.Helper() testDir, err := os.MkdirTemp("", "bitcask") assert.NoError(t, err) db, err := Open(testDir) assert.NoError(t, err) return db } func TestCollection(t *testing.T) { type User struct { Name string Age int } t.Run("AddGetDelete", func(t *testing.T) { db := setupDB(t) defer db.Close() c := db.Collection("users") err := c.Add("prologic", &User{"James", 21}) assert.NoError(t, err) var actual User expected := User{"James", 21} require.NoError(t, c.Get("prologic", &actual)) assert.EqualValues(t, expected, actual) actual = User{} expected = User{} require.NoError(t, c.Delete("prologic")) err = c.Get("prologic", &actual) require.Error(t, err) assert.EqualValues(t, expected, actual) }) t.Run("GetError", func(t *testing.T) { db := setupDB(t) defer db.Close() c := db.Collection("users") var actual User err := c.Get("foo", &actual) require.Error(t, err) assert.ErrorIs(t, err, ErrObjectNotFound) assert.EqualError(t, err, ErrObjectNotFound.Error()) }) t.Run("CountExistsEmpty", func(t *testing.T) { db := setupDB(t) defer db.Close() c := db.Collection("users") assert.Zero(t, c.Count()) assert.False(t, c.Exists()) }) t.Run("CountNonZero", func(t *testing.T) { db := setupDB(t) defer db.Close() c := db.Collection("users") assert.Zero(t, c.Count()) assert.False(t, c.Exists()) require.NoError(t, c.Add("prologic", User{"James", 21})) assert.Equal(t, 1, c.Count()) assert.True(t, c.Exists()) }) t.Run("Has", func(t *testing.T) { db := setupDB(t) defer db.Close() c := db.Collection("users") assert.False(t, c.Has("prologic")) require.NoError(t, c.Add("prologic", User{"James", 21})) assert.True(t, c.Has("prologic")) }) t.Run("List", func(t *testing.T) { db := setupDB(t) defer db.Close() c := db.Collection("users") var actual []User var expected []User // cannot use actual (variable of type []User) as []any value in argument to c.List assert.NoError(t, c.List(actual)) assert.Equal(t, expected, actual) require.NoError(t, c.Add("prologic", User{"James", 21})) require.NoError(t, c.Add("bob", User{"Bob", 99})) // name is made-up require.NoError(t, c.Add("frank", User{"Frank", 37})) // name is made-up actual = []User{} expected = []User{ {"James", 21}, {"Bob", 99}, {"frank", 37}, } // cannot use actual (variable of type []User) as []any value in argument to c.List assert.NoError(t, c.List(actual)) assert.Equal(t, expected, actual) }) }