refactor(crud): Remove .c accessor for direct field access

BREAKING CHANGE (In PR level): Remove Entity.c / Relation.c accessor in favor of direct
class-level field access for query building.

Before: Person.c.age.gt(Age(30))
After:  Person.age.gt(Age(30))

This improves DX by:
- Enabling IDE autocomplete for field names (real class attributes)
- Providing type-safe method hints via FieldRef @overload signatures
- Removing cognitive overhead of the .c indirection

Implementation:
- Add __pydantic_init_subclass__ to TypeDBType that injects FieldDescriptor
  instances after Pydantic completes model initialization
- Remove c: ClassVar[Any] declaration and FieldsAccessor initialization
- Delete type_bridge/models/fields_accessor.py
- Update all .c. usages in tests and docstrings

Author: ds1sqe

tests/integration/queries/test_expressions.py

@@ -170,7 +170,7 @@ def test_greater_than_filter(setup_schema):
     manager = Person.manager(setup_schema)
 
     # age > 30
-    results = manager.filter(Person.c.age.gt(PersonAge(30))).execute()
+    results = manager.filter(Person.age.gt(PersonAge(30))).execute()
 
     assert len(results) == 3  # Bob(35), Charlie(45), Eve(52) - Frank(30) excluded
     ages = [p.age.value for p in results]
@@ -184,7 +184,7 @@ def test_less_than_filter(setup_schema):
     manager = Person.manager(setup_schema)
 
     # age < 30
-    results = manager.filter(Person.c.age.lt(PersonAge(30))).execute()
+    results = manager.filter(Person.age.lt(PersonAge(30))).execute()
 
     assert len(results) == 2  # Alice(25), Diana(28)
     ages = [p.age.value for p in results]
@@ -198,9 +198,7 @@ def test_range_query(setup_schema):
     manager = Person.manager(setup_schema)
 
     # 28 <= age <= 35
-    results = manager.filter(
-        Person.c.age.gte(PersonAge(28)), Person.c.age.lte(PersonAge(35))
-    ).execute()
+    results = manager.filter(Person.age.gte(PersonAge(28)), Person.age.lte(PersonAge(35))).execute()
 
     assert len(results) == 3  # Diana(28), Frank(30), Bob(35)
     ages = [p.age.value for p in results]
@@ -214,7 +212,7 @@ def test_equality_filter(setup_schema):
     manager = Person.manager(setup_schema)
 
     # age == 35
-    results = manager.filter(Person.c.age.eq(PersonAge(35))).execute()
+    results = manager.filter(Person.age.eq(PersonAge(35))).execute()
 
     assert len(results) == 1
     assert results[0].age.value == 35
@@ -228,7 +226,7 @@ def test_not_equal_filter(setup_schema):
     manager = Person.manager(setup_schema)
 
     # age != 35
-    results = manager.filter(Person.c.age.neq(PersonAge(35))).execute()
+    results = manager.filter(Person.age.neq(PersonAge(35))).execute()
 
     assert len(results) == 5  # All except Bob
     ages = [p.age.value for p in results]
@@ -247,7 +245,7 @@ def test_contains_filter(setup_schema):
     manager = Person.manager(setup_schema)
 
     # email contains '@company.com'
-    results = manager.filter(Person.c.email.contains(PersonEmail("@company.com"))).execute()
+    results = manager.filter(Person.email.contains(PersonEmail("@company.com"))).execute()
 
     assert len(results) == 4  # All except Charlie and Frank (gmail)
     for person in results:
@@ -261,7 +259,7 @@ def test_like_regex_filter(setup_schema):
     manager = Person.manager(setup_schema)
 
     # name starts with 'A' or 'B'
-    results = manager.filter(Person.c.name.like(PersonName("^[AB].*"))).execute()
+    results = manager.filter(Person.name.like(PersonName("^[AB].*"))).execute()
 
     assert len(results) == 2  # Alice, Bob
     for person in results:
@@ -281,7 +279,7 @@ def test_or_logic(setup_schema):
 
     # age < 28 OR age > 45
     results = manager.filter(
-        Person.c.age.lt(PersonAge(28)).or_(Person.c.age.gt(PersonAge(45)))
+        Person.age.lt(PersonAge(28)).or_(Person.age.gt(PersonAge(45)))
     ).execute()
 
     assert len(results) == 2  # Alice(25), Eve(52)
@@ -297,7 +295,7 @@ def test_and_logic_explicit(setup_schema):
 
     # Engineering AND age > 40
     results = manager.filter(
-        Person.c.department.eq(PersonDepartment("Engineering")).and_(Person.c.age.gt(PersonAge(40)))
+        Person.department.eq(PersonDepartment("Engineering")).and_(Person.age.gt(PersonAge(40)))
     ).execute()
 
     assert len(results) == 1  # Eve(52, Engineering)
@@ -314,7 +312,7 @@ def test_and_logic_implicit(setup_schema):
 
     # Engineering AND age > 30 (implicit AND)
     results = manager.filter(
-        Person.c.department.eq(PersonDepartment("Engineering")), Person.c.age.gt(PersonAge(30))
+        Person.department.eq(PersonDepartment("Engineering")), Person.age.gt(PersonAge(30))
     ).execute()
 
     assert len(results) == 2  # Bob(35), Eve(52)
@@ -330,9 +328,7 @@ def test_not_logic(setup_schema):
     manager = Person.manager(setup_schema)
 
     # NOT Engineering
-    results = manager.filter(
-        Person.c.department.eq(PersonDepartment("Engineering")).not_()
-    ).execute()
+    results = manager.filter(Person.department.eq(PersonDepartment("Engineering")).not_()).execute()
 
     assert len(results) == 3  # Charlie, Diana, Frank (not Engineering)
     for person in results:
@@ -347,8 +343,8 @@ def test_complex_boolean(setup_schema):
 
     # (age > 40 AND salary > 100k) OR score > 95
     results = manager.filter(
-        Person.c.age.gt(PersonAge(40))
-        .and_(Person.c.salary.gt(PersonSalary(100000.0)))
+        Person.age.gt(PersonAge(40))
+        .and_(Person.salary.gt(PersonSalary(100000.0)))
         .or_(PersonScore.gt(PersonScore(95.0)))
     ).execute()
 
@@ -372,7 +368,7 @@ def test_single_aggregation(setup_schema):
     manager = Person.manager(setup_schema)
 
     # Average age
-    result = manager.filter().aggregate(Person.c.age.avg())
+    result = manager.filter().aggregate(Person.age.avg())
 
     assert "avg_age" in result
     # Average of [25, 35, 45, 28, 52, 30] = 35.83...
@@ -387,11 +383,11 @@ def test_multiple_aggregations(setup_schema):
 
     # Multiple stats
     result = manager.filter().aggregate(
-        Person.c.age.avg(),
-        Person.c.salary.avg(),
-        Person.c.salary.sum(),
-        Person.c.salary.max(),
-        Person.c.salary.min(),
+        Person.age.avg(),
+        Person.salary.avg(),
+        Person.salary.sum(),
+        Person.salary.max(),
+        Person.salary.min(),
     )
 
     assert "avg_age" in result
@@ -413,8 +409,8 @@ def test_filtered_aggregation(setup_schema):
     manager = Person.manager(setup_schema)
 
     # Average salary for Engineering only
-    result = manager.filter(Person.c.department.eq(PersonDepartment("Engineering"))).aggregate(
-        Person.c.salary.avg()
+    result = manager.filter(Person.department.eq(PersonDepartment("Engineering"))).aggregate(
+        Person.salary.avg()
     )
 
     assert "avg_salary" in result
@@ -433,10 +429,8 @@ def test_group_by_single_field(setup_schema):
     """Test grouping by single field."""
     manager = Person.manager(setup_schema)
 
-    # Group by department using FieldsAccessor (Person.c.field)
-    result = manager.group_by(Person.c.department).aggregate(
-        Person.c.age.avg(), Person.c.salary.avg()
-    )
+    # Group by department using direct field access (Person.field)
+    result = manager.group_by(Person.department).aggregate(Person.age.avg(), Person.salary.avg())
 
     # Should have 3 departments
     assert len(result) == 3
@@ -460,9 +454,9 @@ def test_group_by_with_filter(setup_schema):
 
     # Group by department, only age > 30
     result = (
-        manager.filter(Person.c.age.gt(PersonAge(30)))
-        .group_by(Person.c.department)
-        .aggregate(Person.c.salary.avg())
+        manager.filter(Person.age.gt(PersonAge(30)))
+        .group_by(Person.department)
+        .aggregate(Person.salary.avg())
     )
 
     # Should have groups, but filtered
@@ -480,8 +474,8 @@ def test_group_by_multiple_fields(setup_schema):
     """Test grouping by multiple fields."""
     manager = Person.manager(setup_schema)
 
-    # Group by city AND department using FieldsAccessor
-    result = manager.group_by(Person.c.city, Person.c.department).aggregate(Person.c.age.avg())
+    # Group by city AND department using direct field access
+    result = manager.group_by(Person.city, Person.department).aggregate(Person.age.avg())
 
     # Should have tuple keys
     assert len(result) >= 3
@@ -533,7 +527,7 @@ def test_first(setup_schema):
     manager = Person.manager(setup_schema)
 
     # Get first Engineering employee
-    first = manager.filter(Person.c.department.eq(PersonDepartment("Engineering"))).first()
+    first = manager.filter(Person.department.eq(PersonDepartment("Engineering"))).first()
 
     assert first is not None
     assert first.department.value == "Engineering"
@@ -546,7 +540,7 @@ def test_count(setup_schema):
     manager = Person.manager(setup_schema)
 
     # Count Engineering employees
-    count = manager.filter(Person.c.department.eq(PersonDepartment("Engineering"))).count()
+    count = manager.filter(Person.department.eq(PersonDepartment("Engineering"))).count()
 
     assert count == 3  # Alice, Bob, Eve
 
@@ -566,8 +560,8 @@ def test_complex_query_promotion_candidates(setup_schema):
     # score > 90 AND salary < 100k AND age < 50
     candidates = manager.filter(
         PersonScore.gt(PersonScore(90.0)),
-        Person.c.salary.lt(PersonSalary(100000.0)),
-        Person.c.age.lt(PersonAge(50)),
+        Person.salary.lt(PersonSalary(100000.0)),
+        Person.age.lt(PersonAge(50)),
     ).execute()
 
     # Should find Alice(92.5, 75k, 25) - Frank(90, 82k, 30) excluded (score == 90, not > 90)
@@ -587,7 +581,7 @@ def test_complex_query_with_aggregation(setup_schema):
 
     # High performers' average salary
     result = manager.filter(PersonScore.gt(PersonScore(90.0))).aggregate(
-        Person.c.salary.avg(), Person.c.age.avg()
+        Person.salary.avg(), Person.age.avg()
     )
 
     assert "avg_salary" in result
@@ -620,7 +614,7 @@ def test_mixed_dict_and_expression_filters(setup_schema):
 
     # Mix old and new style
     results = manager.filter(
-        Person.c.age.gt(PersonAge(30)),  # Expression
+        Person.age.gt(PersonAge(30)),  # Expression
         department="Engineering",  # Dict filter
     ).execute()
 

tests/unit/exceptions/test_exceptions.py

@@ -312,8 +312,8 @@ class BoolTestPerson(Entity):
             name: BoolTestName = Flag(Key)
             age: BoolTestAge
 
-        expr1 = BoolTestPerson.c.age.gt(BoolTestAge(18))
-        expr2 = BoolTestPerson.c.age.lt(BoolTestAge(65))
+        expr1 = BoolTestPerson.age.gt(BoolTestAge(18))
+        expr2 = BoolTestPerson.age.lt(BoolTestAge(65))
 
         with pytest.raises(ValueError, match="NOT operation requires exactly 1 operand"):
             BooleanExpr("not", [expr1, expr2])
@@ -335,7 +335,7 @@ class AndTestPerson(Entity):
             name: AndTestName = Flag(Key)
             age: AndTestAge
 
-        expr = AndTestPerson.c.age.gt(AndTestAge(18))
+        expr = AndTestPerson.age.gt(AndTestAge(18))
 
         with pytest.raises(ValueError, match="AND operation requires at least 2 operands"):
             BooleanExpr("and", [expr])
@@ -357,7 +357,7 @@ class OrTestPerson(Entity):
             name: OrTestName = Flag(Key)
             age: OrTestAge
 
-        expr = OrTestPerson.c.age.gt(OrTestAge(18))
+        expr = OrTestPerson.age.gt(OrTestAge(18))
 
         with pytest.raises(ValueError, match="OR operation requires at least 2 operands"):
             BooleanExpr("or", [expr])
@@ -379,8 +379,8 @@ class AndOkPerson(Entity):
             name: AndOkName = Flag(Key)
             age: AndOkAge
 
-        expr1 = AndOkPerson.c.age.gt(AndOkAge(18))
-        expr2 = AndOkPerson.c.age.lt(AndOkAge(65))
+        expr1 = AndOkPerson.age.gt(AndOkAge(18))
+        expr2 = AndOkPerson.age.lt(AndOkAge(65))
 
         # Should not raise
         result = BooleanExpr("and", [expr1, expr2])
@@ -404,7 +404,7 @@ class NotOkPerson(Entity):
             name: NotOkName = Flag(Key)
             age: NotOkAge
 
-        expr = NotOkPerson.c.age.eq(NotOkAge(30))
+        expr = NotOkPerson.age.eq(NotOkAge(30))
 
         # Should not raise
         result = BooleanExpr("not", [expr])