...

2025-09-16 12:01:06 +02:00
parent 64c7efca5e
commit 5215843308
11 changed files with 202 additions and 151 deletions
--- a/lib/hero/db/core_methods.v
+++ b/lib/hero/db/core_methods.v
@@ -2,10 +2,10 @@ module db

 import freeflowuniverse.herolib.data.ourtime
 import freeflowuniverse.herolib.data.encoder
-import time

-pub fn (mut self DB) set[T](mut obj T) ! {
+pub fn (mut self DB) set[T](obj_ T) !T {
 	// Get the next ID	
+	mut obj := obj_
 	if obj.id == 0 {
 		obj.id = self.new_id()!
 	}
@@ -32,6 +32,8 @@ pub fn (mut self DB) set[T](mut obj T) ! {

 	obj.dump(mut e)!
 	self.redis.hset(self.db_name[T](), obj.id.str(), e.data.bytestr())!
+
+	return obj
 }

 // return the data, cannot return the object as we do not know the type
--- a/lib/hero/herofs/README.md
+++ b/lib/hero/herofs/README.md
@@ -38,63 +38,70 @@ mut fs_factory := herofs.new()!
 ### Creating a Filesystem

 ```v
-fs_id := fs_factory.fs.set(fs_factory.fs.new(
+mut fs := fs_factory.fs.new(
 	name: 'my_filesystem'
 	quota_bytes: 1000000000 // 1GB quota
-)!)!
+)!
+fs = fs_factory.fs.set(fs)!
+fs_id := fs.id
 ```

 ### Working with Directories

 ```v
 // Create root directory
-root_dir_id := fs_factory.fs_dir.set(fs_factory.fs_dir.new(
+mut root_dir := fs_factory.fs_dir.new(
 	name: 'root'
 	fs_id: fs_id
 	parent_id: 0
-)!)!
+)!
+root_dir_id := fs_factory.fs_dir.set(root_dir)!

 // Create subdirectory
-sub_dir_id := fs_factory.fs_dir.set(fs_factory.fs_dir.new(
+mut sub_dir := fs_factory.fs_dir.new(
 	name: 'documents'
 	fs_id: fs_id
 	parent_id: root_dir_id
-)!)!
+)!
+sub_dir_id := fs_factory.fs_dir.set(sub_dir)!
 ```

 ### Working with Blobs

 ```v
 // Create a blob with binary data
-blob_id := fs_factory.fs_blob.set(fs_factory.fs_blob.new(
+mut blob := fs_factory.fs_blob.new(
 	data: content_bytes
 	mime_type: 'text/plain'
-)!)!
+)!
+blob_id := fs_factory.fs_blob.set(blob)!
 ```

 ### Working with Files

 ```v
 // Create a file
-file_id := fs_factory.fs_file.set(fs_factory.fs_file.new(
+mut file := fs_factory.fs_file.new(
 	name: 'example.txt'
 	fs_id: fs_id
 	directories: [root_dir_id]
 	blobs: [blob_id]
-)!)!
+)!
+file_id := fs_factory.fs_file.set(file)!
 ```

 ### Working with Symbolic Links

 ```v
 // Create a symbolic link to a file
-symlink_id := fs_factory.fs_symlink.set(fs_factory.fs_symlink.new(
+mut symlink := fs_factory.fs_symlink.new(
 	name: 'example_link.txt'
 	fs_id: fs_id
 	parent_id: root_dir_id
 	target_id: file_id
 	target_type: .file
-)!)!
+)!
+symlink_id := fs_factory.fs_symlink.set(symlink)!
 ```

 ## API Reference
--- a/lib/hero/herofs/aiinstructions/set_changes.md
+++ b/lib/hero/herofs/aiinstructions/set_changes.md
@@ -0,0 +1,17 @@
+```v
+pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
+```
+
+becomes
+
+```v
+pub fn (mut self DBFsBlobMembership) set(o FsBlobMembership) FsBlobMembership! {
+    ... the other code
+    return o
+}
+```
+
+we need to change each set in this module to be like this, then we need to make sure that _test.v programs use it the same way
+
+see how we don't use the mut statement in set.
+
--- a/lib/hero/herofs/factory.v
+++ b/lib/hero/herofs/factory.v
@@ -21,7 +21,7 @@ pub mut:
 }

 pub fn new(args DBArgs) !FsFactory {
-	mut mydb := db.new(redis:args.redis)!
+	mut mydb := db.new(redis: args.redis)!
 	mut f := FsFactory{
 		fs:                 DBFs{
 			db: &mydb
@@ -59,13 +59,13 @@ pub fn new_fs(args FsArg) !Fs {
 }

 pub fn new_fs_test() !Fs {
-	mut r:=redisclient.test_get()!
-	mut f := new(redis:r)!
+	mut r := redisclient.test_get()!
+	mut f := new(redis: r)!
 	mut fs := f.fs.new_get_set(name: 'test')!
 	return fs
 }

 pub fn delete_fs_test() ! {
-	mut r:=redisclient.test_get()!
-	r.flush()!
+	mut r := redisclient.test_get()!
+	r.flushdb()!
 }
--- a/lib/hero/herofs/fs.v
+++ b/lib/hero/herofs/fs.v
@@ -107,21 +107,23 @@ pub fn (mut self DBFs) new_get_set(args_ FsArg) !Fs {
 	return o
 }

-pub fn (mut self DBFs) set(mut o Fs) ! {
-	if o.root_dir_id == 0 {
+pub fn (mut self DBFs) set(o Fs) !Fs {
+	mut o_mut := o
+	if o_mut.root_dir_id == 0 {
 		// If no root directory is set, create one
 		mut root_dir := self.factory.fs_dir.new(
 			name:      'root'
-			fs_id:     o.id
+			fs_id:     o_mut.id
 			parent_id: 0 // Root has no parent
 		)!
-		self.factory.fs_dir.set(mut root_dir)!
-		o.root_dir_id = root_dir.id
+		root_dir = self.factory.fs_dir.set(root_dir)!
+		o_mut.root_dir_id = root_dir.id
 		// Update the filesystem with the new root directory ID
 	}
-	self.db.redis.hset('fs:names', o.name, o.id.str())!
+	self.db.redis.hset('fs:names', o_mut.name, o_mut.id.str())!
 	// Use db set function which now modifies the object in-place	
-	self.db.set[Fs](mut o)!
+	self.db.set[Fs](o_mut)!
+	return o_mut
 }

 pub fn (mut self DBFs) delete(id u32) ! {
--- a/lib/hero/herofs/fs_blob.v
+++ b/lib/hero/herofs/fs_blob.v
@@ -68,12 +68,14 @@ pub fn (mut self DBFsBlob) new(args FsBlobArg) !FsBlob {
 	return o
 }

-pub fn (mut self DBFsBlob) set(mut o FsBlob) ! {
+pub fn (mut self DBFsBlob) set(o_ FsBlob) !FsBlob {
 	// Use db set function which now modifies the object in-place
-	self.db.set[FsBlob](mut o)!
+	o := self.db.set[FsBlob](o_)!

 	// Store the hash -> id mapping for lookup
 	self.db.redis.hset('fsblob:hashes', o.hash, o.id.str())!
+
+	return o
 }

 pub fn (mut self DBFsBlob) delete(id u32) ! {
--- a/lib/hero/herofs/fs_blob_membership.v
+++ b/lib/hero/herofs/fs_blob_membership.v
@@ -22,13 +22,13 @@ pub fn (self FsBlobMembership) type_name() string {
 	return 'fs_blob_membership'
 }

-pub fn (self FsBlobMembership) dump(mut e encoder.Encoder) ! {
+pub fn (self FsBlobMembership) dump(e encoder.Encoder) ! {
 	e.add_string(self.hash)
 	e.add_list_u32(self.fsid)
 	e.add_u32(self.blobid)
 }

-fn (mut self DBFsBlobMembership) load(mut o FsBlobMembership, mut e encoder.Decoder) ! {
+fn (self DBFsBlobMembership) load(o FsBlobMembership, e encoder.Decoder) ! {
 	o.hash = e.get_string()!
 	o.fsid = e.get_list_u32()!
 	o.blobid = e.get_u32()!
@@ -42,8 +42,8 @@ pub mut:
 	blobid u32    @[required]
 }

-pub fn (mut self DBFsBlobMembership) new(args FsBlobMembershipArg) !FsBlobMembership {
-	mut o := FsBlobMembership{
+pub fn (self DBFsBlobMembership) new(args FsBlobMembershipArg) !FsBlobMembership {
+	o := FsBlobMembership{
 		hash:   args.hash
 		fsid:   args.fsid
 		blobid: args.blobid
@@ -52,7 +52,7 @@ pub fn (mut self DBFsBlobMembership) new(args FsBlobMembershipArg) !FsBlobMember
 	return o
 }

-pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
+pub fn (self DBFsBlobMembership) set(o FsBlobMembership) !FsBlobMembership {
 	// Validate that the blob exists
 	if o.blobid == 0 {
 		return error('Blob ID cannot be 0')
@@ -62,19 +62,21 @@ pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
 		return error('Blob with ID ${o.blobid} does not exist')
 	}

-	if o.hash == '' {
-		mut blob := self.factory.fs_blob.get(o.blobid) or {
-			return error('Failed to retrieve blob with ID ${o.blobid}: ${err.msg()}')
+	o_mut := o
+
+	if o_mut.hash == '' {
+		blob := self.factory.fs_blob.get(o_mut.blobid) or {
+			return error('Failed to retrieve blob with ID ${o_mut.blobid}: ${err.msg()}')
 		}
-		o.hash = blob.hash
+		o_mut.hash = blob.hash
 	}

-	if o.fsid.len == 0 {
+	if o_mut.fsid.len == 0 {
 		return error('Blob membership filesystem IDs cannot be empty')
 	}

 	// Validate that all filesystems exist
-	for fs_id in o.fsid {
+	for fs_id in o_mut.fsid {
 		fs_exists := self.factory.fs.exist(fs_id)!
 		if !fs_exists {
 			return error('Filesystem with ID ${fs_id} does not exist')
@@ -82,22 +84,24 @@ pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
 	}

 	// Encode the object
-	mut e_encoder := encoder.new()
-	o.dump(mut e_encoder)!
+	e_encoder := encoder.new()
+	o_mut.dump(e_encoder)!

 	// Store using hash as key in the blob_membership hset
-	self.db.redis.hset('fs_blob_membership', o.hash, e_encoder.data.bytestr())!
+	self.db.redis.hset('fs_blob_membership', o_mut.hash, e_encoder.data.bytestr())!
+
+	return o_mut
 }

-pub fn (mut self DBFsBlobMembership) delete(hash string) ! {
+pub fn (self DBFsBlobMembership) delete(hash string) ! {
 	self.db.redis.hdel('fs_blob_membership', hash)!
 }

-pub fn (mut self DBFsBlobMembership) exist(hash string) !bool {
+pub fn (self DBFsBlobMembership) exist(hash string) !bool {
 	return self.db.redis.hexists('fs_blob_membership', hash)!
 }

-pub fn (mut self DBFsBlobMembership) get(hash string) !FsBlobMembership {
+pub fn (self DBFsBlobMembership) get(hash string) !FsBlobMembership {
 	// Get the data from Redis
 	data := self.db.redis.hget('fs_blob_membership', hash)!
 	if data == '' {
@@ -105,34 +109,34 @@ pub fn (mut self DBFsBlobMembership) get(hash string) !FsBlobMembership {
 	}
 	data2 := data.bytes()
 	// Create object and decode
-	mut o := FsBlobMembership{}
-	mut e_decoder := encoder.decoder_new(data2)
-	self.load(mut o, mut e_decoder)!
+	o := FsBlobMembership{}
+	e_decoder := encoder.decoder_new(data2)
+	self.load(o, e_decoder)!

 	return o
 }

 // Add a filesystem to an existing blob membership
-pub fn (mut self DBFsBlobMembership) add_filesystem(hash string, fs_id u32) ! {
+pub fn (self DBFsBlobMembership) add_filesystem(hash string, fs_id u32) ! {
 	// Validate filesystem exists
 	fs_exists := self.factory.fs.exist(fs_id)!
 	if !fs_exists {
 		return error('Filesystem with ID ${fs_id} does not exist')
 	}

-	mut membership := self.get(hash)!
+	membership := self.get(hash)!

 	// Check if filesystem is already in the list
 	if fs_id !in membership.fsid {
 		membership.fsid << fs_id
 	}

-	self.set(mut membership)!
+	self.set(membership)!
 }

 // Remove a filesystem from an existing blob membership
-pub fn (mut self DBFsBlobMembership) remove_filesystem(hash string, fs_id u32) ! {
-	mut membership := self.get(hash)!
+pub fn (self DBFsBlobMembership) remove_filesystem(hash string, fs_id u32) ! {
+	membership := self.get(hash)!

 	// Remove filesystem from the list
 	membership.fsid = membership.fsid.filter(it != fs_id)
@@ -143,7 +147,7 @@ pub fn (mut self DBFsBlobMembership) remove_filesystem(hash string, fs_id u32) !
 		return
 	}

-	self.set(mut membership)!
+	self.set(membership)!
 }

 // BlobList represents a simplified blob structure for listing purposes
@@ -156,10 +160,10 @@ pub mut:

 // list_by_hash_prefix lists blob memberships where hash starts with the given prefix
 // Returns maximum 10000 items as FsBlobMembership entries
-pub fn (mut self DBFsBlobMembership) list_prefix(prefix string) ![]FsBlobMembership {
-	mut result := []FsBlobMembership{}
-	mut cursor := 0
-	mut count := 0
+pub fn (self DBFsBlobMembership) list_prefix(prefix string) ![]FsBlobMembership {
+	result := []FsBlobMembership{}
+	cursor := 0
+	count := 0

 	for {
 		if count >= 10000 {
@@ -174,7 +178,7 @@ pub fn (mut self DBFsBlobMembership) list_prefix(prefix string) ![]FsBlobMembers

 		// Process the returned field-value pairs
 		// hscan returns alternating field-value pairs, so we iterate by 2
-		mut i := 0
+		i := 0
 		for i < values.len && count < 10000 {
 			hash := values[i]
 			// Skip the value (we don't need it since we'll get the object by hash)
--- a/lib/hero/herofs/fs_blob_membership_test.v
+++ b/lib/hero/herofs/fs_blob_membership_test.v
@@ -1,38 +1,38 @@
 module herofs

 import freeflowuniverse.herolib.hero.db
+import freeflowuniverse.herolib.core.redisclient

-fn test_cleanup()!{
+fn test_cleanup() ! {
 	delete_fs_test()!
 }

-fn test_basic() {
-
+fn test_basic() ! {
 	defer {
-		test_cleanup()
+		test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
 	}
 	// Initialize the HeroFS factory for test purposes
-	mut my_fs:=new_fs_test()!
-	mut fs_factory := my_fs.factory
+	mut r := redisclient.test_get()!
+	mut fs_factory := new(redis: r)!

 	// Create a new filesystem (required for FsBlobMembership validation)
-	mut test_fs := fs_factory.fs.new(
+	mut test_fs := fs_factory.fs.new_get_set(
 		name:        'test_filesystem'
 		description: 'Filesystem for testing FsBlobMembership functionality'
 		quota_bytes: 1024 * 1024 * 1024 // 1GB quota
 	)!
-	fs_factory.fs.set(mut test_fs)!
-	fs_id := test_fs.id
+	test_fs = fs_factory.fs.set(test_fs)!
 	println('Created test filesystem with ID: ${test_fs.id}')

 	// Create root directory for the filesystem
 	mut root_dir := fs_factory.fs_dir.new(
 		name:        'root'
-		fs_id:       fs_id
+		fs_id:       test_fs.id
 		parent_id:   0 // Root has no parent
 		description: 'Root directory for testing'
 	)!
-	root_dir_id := fs_factory.fs_dir.set(root_dir)!
+	fs_factory.fs_dir.set(root_dir)!
+	root_dir_id := root_dir.id

 	// Update the filesystem with the root directory ID
 	test_fs.root_dir_id = root_dir_id
@@ -41,35 +41,41 @@ fn test_basic() {
 	// Create test blob for membership
 	test_data := 'This is test content for blob membership'.bytes()
 	mut test_blob := fs_factory.fs_blob.new(data: test_data)!
-	blob_id := fs_factory.fs_blob.set(test_blob)!
+	test_blob = fs_factory.fs_blob.set(test_blob)!
+	blob_id := test_blob.id
 	println('Created test blob with ID: ${blob_id}')

 	// Create test file to get a valid fsid (file ID) for membership
 	mut test_file := fs_factory.fs_file.new(
 		name:        'test_file.txt'
-		fs_id:       fs_id
-		directories: [root_dir_id]
+		fs_id:       test_fs.id
 		blobs:       [blob_id]
 		description: 'Test file for blob membership'
 		mime_type:   .txt
 	)!
-	fs_factory.fs_file.set(mut test_file)!
+	test_file = fs_factory.fs_file.set(test_file)!
 	file_id := test_file.id
 	println('Created test file with ID: ${file_id}')

+	// Add file to directory
+	mut dir := fs_factory.fs_dir.get(root_dir_id)!
+	dir.files << file_id
+	fs_factory.fs_dir.set(dir)!
+
 	// Create test blob membership
 	mut test_membership := fs_factory.fs_blob_membership.new(
 		hash:   test_blob.hash
-		fsid:   [fs_id] // Use filesystem ID
+		fsid:   [test_fs.id] // Use filesystem ID
 		blobid: blob_id
 	)!

 	// Save the test membership
-	membership_hash := fs_factory.fs_blob_membership.set(test_membership)!
+	test_membership = fs_factory.fs_blob_membership.set(test_membership)!
+	membership_hash := test_membership.hash
 	println('Created test blob membership with hash: ${membership_hash}')

 	// Test loading membership by hash
-	println('\nTesting blob membership loading...')
+	println('Testing blob membership loading...')

 	loaded_membership := fs_factory.fs_blob_membership.get(membership_hash)!
 	assert loaded_membership.hash == test_membership.hash
@@ -78,12 +84,12 @@ fn test_basic() {
 	println('✓ Loaded blob membership: ${loaded_membership.hash} (Blob ID: ${loaded_membership.blobid})')

 	// Verify that loaded membership matches the original one
-	println('\nVerifying data integrity...')
+	println('Verifying data integrity...')
 	assert loaded_membership.hash == test_blob.hash
 	println('✓ Blob membership data integrity check passed')

 	// Test exist method
-	println('\nTesting blob membership existence checks...')
+	println('Testing blob membership existence checks...')

 	mut exists := fs_factory.fs_blob_membership.exist(membership_hash)!
 	assert exists == true
@@ -95,83 +101,92 @@ fn test_basic() {
 	assert exists == false
 	println('✓ Non-existent blob membership exists: ${exists}')

-	println('\nFsBlobMembership basic test completed successfully!')
+	println('FsBlobMembership basic test completed successfully!')
 }

-fn test_filesystem_operations() {
-	println('\nTesting FsBlobMembership filesystem operations...')
+fn test_filesystem_operations() ! {
+	println('Testing FsBlobMembership filesystem operations...')

 	defer {
-		test_cleanup()
+		test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
 	}
 	// Initialize the HeroFS factory for test purposes
-	
-	mut my_fs:=new_fs_test()!
-	mut fs_factory := my_fs.factory
+	mut r := redisclient.test_get()!
+	mut fs_factory := new(redis: r)!

 	// Create filesystems for testing
-	mut fs1 := fs_factory.fs.new(
+	mut fs1 := fs_factory.fs.new_get_set(
 		name:        'test_filesystem_1'
 		description: 'First filesystem for testing'
 		quota_bytes: 1024 * 1024 * 1024 // 1GB quota
 	)!
-	fs_factory.fs.set(mut fs1)!
+	fs_factory.fs.set(fs1)!
 	fs1_id := fs1.id

-	mut fs2 := fs_factory.fs.new(
+	mut fs2 := fs_factory.fs.new_get_set(
 		name:        'test_filesystem_2'
 		description: 'Second filesystem for testing'
 		quota_bytes: 1024 * 1024 * 1024 // 1GB quota
 	)!
-	fs_factory.fs.set(mut fs2)!
+	fs_factory.fs.set(fs2)!
 	fs1_root_dir_id := fs1.root_dir_id
 	fs2_id := fs2.id

 	// Create test blob
 	test_data := 'This is test content for filesystem operations'.bytes()
 	mut test_blob := fs_factory.fs_blob.new(data: test_data)!
-	blob_id := fs_factory.fs_blob.set(test_blob)!
+	fs_factory.fs_blob.set(test_blob)!
+	blob_id := test_blob.id

 	// Create test files to get valid fsid (file IDs) for membership
 	mut test_file1 := fs_factory.fs_file.new(
 		name:        'test_file1.txt'
 		fs_id:       fs1_id
-		directories: [fs1_root_dir_id]
 		blobs:       [blob_id]
 		description: 'Test file 1 for blob membership'
 		mime_type:   .txt
 	)!
-	fs_factory.fs_file.set(mut test_file1)!
+	test_file1 = fs_factory.fs_file.set(test_file1)!
 	file1_id := test_file1.id
 	println('Created test file 1 with ID: ${file1_id}')

+	// Add file to directory
+	mut fs1_root_dir := fs_factory.fs_dir.get(fs1.root_dir_id)!
+	fs1_root_dir.files << file1_id
+	fs_factory.fs_dir.set(fs1_root_dir)!
+
 	mut test_file2 := fs_factory.fs_file.new(
 		name:        'test_file2.txt'
 		fs_id:       fs2_id
-		directories: [fs2.root_dir_id]
 		blobs:       [blob_id]
 		description: 'Test file 2 for blob membership'
 		mime_type:   .txt
 	)!
-	fs_factory.fs_file.set(mut test_file2)!
+	test_file2 = fs_factory.fs_file.set(test_file2)!
 	file2_id := test_file2.id
 	println('Created test file 2 with ID: ${file2_id}')

+	// Add file to directory
+	mut fs2_root_dir := fs_factory.fs_dir.get(fs2.root_dir_id)!
+	fs2_root_dir.files << file2_id
+	fs_factory.fs_dir.set(fs2_root_dir)!
+
 	// Create blob membership with first filesystem
 	mut membership := fs_factory.fs_blob_membership.new(
 		hash:   test_blob.hash
-		fsid:   [fs1_id] // Use filesystem ID
+		fsid:   [fs1_id]
 		blobid: blob_id
 	)!
-	membership_hash := fs_factory.fs_blob_membership.set(membership)!
+	fs_factory.fs_blob_membership.set(membership)!
+	membership_hash := membership.hash
 	println('Created blob membership with filesystem 1: ${membership_hash}')

 	// Test adding a filesystem to membership
 	println('Testing add_filesystem operation...')

 	// Add second filesystem
-	updated_hash := fs_factory.fs_blob_membership.add_filesystem(membership_hash, fs2_id)!
-	updated_membership := fs_factory.fs_blob_membership.get(updated_hash)!
+	fs_factory.fs_blob_membership.add_filesystem(membership_hash, fs2_id)!
+	mut updated_membership := fs_factory.fs_blob_membership.get(membership_hash)!

 	// Verify both filesystems are in the list
 	assert updated_membership.fsid.len == 2
@@ -183,9 +198,8 @@ fn test_filesystem_operations() {
 	println('Testing remove_filesystem operation...')

 	// Remove first filesystem
-	mut updated_hash2 := fs_factory.fs_blob_membership.remove_filesystem(membership_hash,
-		fs1_id)!
-	mut updated_membership2 := fs_factory.fs_blob_membership.get(updated_hash2)!
+	fs_factory.fs_blob_membership.remove_filesystem(membership_hash, fs1_id)!
+	mut updated_membership2 := fs_factory.fs_blob_membership.get(membership_hash)!

 	// Verify only second filesystem is in the list
 	assert updated_membership2.fsid.len == 1
@@ -193,8 +207,7 @@ fn test_filesystem_operations() {
 	println('✓ Removed filesystem 1 from blob membership')

 	// Test removing the last filesystem (should delete the membership)
-	mut updated_hash3 := fs_factory.fs_blob_membership.remove_filesystem(membership_hash,
-		fs2_id)!
+	fs_factory.fs_blob_membership.remove_filesystem(membership_hash, fs2_id)!

 	// Verify membership no longer exists
 	exists := fs_factory.fs_blob_membership.exist(membership_hash)!
@@ -204,24 +217,23 @@ fn test_filesystem_operations() {
 	println('FsBlobMembership filesystem operations test completed successfully!')
 }

-fn test_validation() {
-	println('\nTesting FsBlobMembership validation...')
+fn test_validation() ! {
+	println('Testing FsBlobMembership validation...')

 	defer {
-		test_cleanup()
+		test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
 	}
 	// Initialize the HeroFS factory for test purposes
-	
-	mut my_fs:=new_fs_test()!
-	mut fs_factory := my_fs.factory
+	mut r := redisclient.test_get()!
+	mut fs_factory := new(redis: r)!

 	// Create a filesystem for validation tests
-	mut test_fs := fs_factory.fs.new(
+	mut test_fs := fs_factory.fs.new_get_set(
 		name:        'validation_filesystem'
 		description: 'Filesystem for validation tests'
 		quota_bytes: 1024 * 1024 * 1024 // 1GB quota
 	)!
-	fs_factory.fs.set(mut test_fs)!
+	test_fs = fs_factory.fs.set(test_fs)!
 	fs_id := test_fs.id

 	// Test setting membership with non-existent blob (should fail)
@@ -230,12 +242,12 @@ fn test_validation() {
 	// Create a membership with a non-existent blob ID
 	mut test_membership := fs_factory.fs_blob_membership.new(
 		hash:   '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef'
-		fsid:   [fs_id]
+		fsid:   [test_fs.id]
 		blobid: 999999 // Non-existent blob ID
 	)!

 	// Try to save it, which should fail
-	validation_result_hash := fs_factory.fs_blob_membership.set(test_membership) or {
+	fs_factory.fs_blob_membership.set(test_membership) or {
 		println('✓ Membership set correctly failed with non-existent blob')
 		return
 	}
@@ -247,7 +259,8 @@ fn test_validation() {
 	// Create a test blob
 	test_data := 'This is test content for validation'.bytes()
 	mut test_blob := fs_factory.fs_blob.new(data: test_data)!
-	blob_id := fs_factory.fs_blob.set(test_blob)!
+	fs_factory.fs_blob.set(test_blob)!
+	blob_id := test_blob.id

 	// Create a membership with a non-existent filesystem ID
 	mut test_membership2 := fs_factory.fs_blob_membership.new(
@@ -257,7 +270,7 @@ fn test_validation() {
 	)!

 	// Try to save it, which should fail
-	validation_result_hash2 := fs_factory.fs_blob_membership.set(test_membership2) or {
+	fs_factory.fs_blob_membership.set(test_membership2) or {
 		println('✓ Membership set correctly failed with non-existent filesystem')
 		return
 	}
@@ -266,24 +279,24 @@ fn test_validation() {
 	println('FsBlobMembership validation test completed successfully!')
 }

-fn test_list_by_prefix() {
-	println('\nTesting FsBlobMembership list by prefix...')
+fn test_list_by_prefix() ! {
+	println('
+Testing FsBlobMembership list by prefix...')

 	defer {
-		test_cleanup()
+		test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
 	}
 	// Initialize the HeroFS factory for test purposes
-	
-	mut my_fs:=new_fs_test()!
-	mut fs_factory := my_fs.factory
+	mut r := redisclient.test_get()!
+	mut fs_factory := new(redis: r)!

 	// Create a filesystem
-	mut test_fs := fs_factory.fs.new(
+	mut test_fs := fs_factory.fs.new_get_set(
 		name:        'list_test_filesystem'
 		description: 'Filesystem for list testing'
 		quota_bytes: 1024 * 1024 * 1024 // 1GB quota
 	)!
-	fs_factory.fs.set(mut test_fs)!
+	test_fs = fs_factory.fs.set(test_fs)!
 	fs_id := test_fs.id

 	// Create root directory for the filesystem
@@ -293,11 +306,12 @@ fn test_list_by_prefix() {
 		parent_id:   0 // Root has no parent
 		description: 'Root directory for testing'
 	)!
-	root_dir_id := fs_factory.fs_dir.set(root_dir)!
+	fs_factory.fs_dir.set(root_dir)!
+	root_dir_id := root_dir.id

 	// Update the filesystem with the root directory ID
-	my_fs.root_dir_id = root_dir_id
-	fs_factory.fs.set(my_fs)!
+	test_fs.root_dir_id = root_dir_id
+	fs_factory.fs.set(test_fs)!

 	// Create multiple test blobs
 	test_data1 := 'This is test content 1'.bytes()
@@ -308,44 +322,49 @@ fn test_list_by_prefix() {
 	mut blob2 := fs_factory.fs_blob.new(data: test_data2)!
 	mut blob3 := fs_factory.fs_blob.new(data: test_data3)!

-	blob1_id := fs_factory.fs_blob.set(blob1)!
-	blob2_id := fs_factory.fs_blob.set(blob2)!
-	blob3_id := fs_factory.fs_blob.set(blob3)!
+	fs_factory.fs_blob.set(blob1)!
+	blob1_id := blob1.id
+	fs_factory.fs_blob.set(blob2)!
+	blob2_id := blob2.id
+	fs_factory.fs_blob.set(blob3)!
+	blob3_id := blob3.id

 	// Create test files to get valid fsid (file IDs) for membership
 	mut test_file := fs_factory.fs_file.new(
 		name:        'test_file.txt'
 		fs_id:       fs_id
-		directories: [root_dir_id]
 		blobs:       [blob1_id]
 		description: 'Test file for blob membership'
 		mime_type:   .txt
 	)!
-	fs_factory.fs_file.set(mut test_file)!
+	fs_factory.fs_file.set(test_file)!
 	file_id := test_file.id
 	println('Created test file with ID: ${file_id}')

 	// Create memberships with similar hashes (first 16 characters)
 	mut membership1 := fs_factory.fs_blob_membership.new(
 		hash:   blob1.hash
-		fsid:   [fs_id] // Use filesystem ID
+		fsid:   [test_fs.id]
 		blobid: blob1_id
 	)!
-	membership1_hash := fs_factory.fs_blob_membership.set(membership1)!
+	membership1 = fs_factory.fs_blob_membership.set(membership1)!
+	membership1_hash := membership1.hash

 	mut membership2 := fs_factory.fs_blob_membership.new(
 		hash:   blob2.hash
-		fsid:   [fs_id] // Use filesystem ID
+		fsid:   [test_fs.id]
 		blobid: blob2_id
 	)!
-	membership2_hash := fs_factory.fs_blob_membership.set(membership2)!
+	fs_factory.fs_blob_membership.set(membership2)!
+	membership2_hash := membership2.hash

 	mut membership3 := fs_factory.fs_blob_membership.new(
 		hash:   blob3.hash
-		fsid:   [fs_id] // Use filesystem ID
+		fsid:   [test_fs.id]
 		blobid: blob3_id
 	)!
-	membership3_hash := fs_factory.fs_blob_membership.set(membership3)!
+	membership3 = fs_factory.fs_blob_membership.set(membership3)!
+	membership3_hash := membership3.hash

 	println('Created test memberships:')
 	println('- Membership 1 hash: ${membership1_hash}')
--- a/lib/hero/herofs/fs_dir.v
+++ b/lib/hero/herofs/fs_dir.v
@@ -113,8 +113,9 @@ pub fn (mut self DBFsDir) new(args FsDirArg) !FsDir {
 	return o
 }

-pub fn (mut self DBFsDir) set(mut o FsDir) ! {
-	self.db.set[FsDir](mut o)!
+pub fn (mut self DBFsDir) set(o FsDir) !FsDir {
+	self.db.set[FsDir](o)!
+	return o
 }

 pub fn (mut self DBFsDir) delete(id u32) ! {
--- a/lib/hero/herofs/fs_file.v
+++ b/lib/hero/herofs/fs_file.v
@@ -133,14 +133,8 @@ pub fn (mut self DBFsFile) new(args FsFileArg) !FsFile {
 	return o
 }

-pub fn (mut self DBFsFile) set(mut o FsFile) ! {
-	// Check that directories exist
-	for dir_id in o.directories {
-		dir_exists := self.db.exists[FsDir](dir_id)!
-		if !dir_exists {
-			return error('Directory with ID ${dir_id} does not exist')
-		}
-	}
+pub fn (mut self DBFsFile) set(o_ FsFile) !FsFile {
+	mut o := o_

 	// Check that blobs exist
 	for blob_id in o.blobs {
@@ -149,7 +143,9 @@ pub fn (mut self DBFsFile) set(mut o FsFile) ! {
 			return error('Blob with ID ${blob_id} does not exist')
 		}
 	}
-	self.db.set[FsFile](mut o)!
+	self.db.set[FsFile](o)!
+
+	return o
 }

 pub fn (mut self DBFsFile) delete(id u32) ! {
--- a/lib/hero/herofs/fs_symlink.v
+++ b/lib/hero/herofs/fs_symlink.v
@@ -82,7 +82,7 @@ pub fn (mut self DBFsSymlink) new(args FsSymlinkArg) !FsSymlink {
 	return o
 }

-pub fn (mut self DBFsSymlink) set(mut o FsSymlink) ! {
+pub fn (mut self DBFsSymlink) set(o FsSymlink) !FsSymlink {
 	// Check parent directory exists
 	if o.parent_id > 0 {
 		parent_exists := self.db.exists[FsDir](o.parent_id)!
@@ -104,7 +104,8 @@ pub fn (mut self DBFsSymlink) set(mut o FsSymlink) ! {
 		}
 	}

-	self.db.set[FsSymlink](mut o)!
+	self.db.set[FsSymlink](o)!
+	return o
 }

 pub fn (mut self DBFsSymlink) delete(id u32) ! {