feat: add Attribute base class for custom model casts and sqlite cast tests

- Add `Attribute(BaseModel)` to caster.py as a reusable mixin for custom
  ORM casts — subclasses get JSON serialize/deserialize for free via
  `get`/`set` classmethods backed by Pydantic's model_dump_json
- Export `Attribute` from `fastapi_startkit.masoniteorm`
- Fix `get_attributes_for_insert` to apply `set` casts to `_attributes`
  so `Address` instances and dicts can be passed directly to `create()`
  without manual JSON serialization
- Add `preferences` (dict/list) and `address` (Attribute) columns to the
  users fixture table; seed and model updated accordingly
- Add `test_sqlite_model_casts.py` covering int, str, bool, dict, list,
  and custom Pydantic Attribute casts including insert with instance/dict

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: tmgbedu

fastapi_startkit/src/fastapi_startkit/masoniteorm/__init__.py

@@ -3,6 +3,7 @@
 from .migrations.Migration import Migration
 from .migrations.Migrator import Migrator
 from .models import Model
+from .models.caster import Attribute
 from .providers import DatabaseProvider
 
-__all__ = ["DatabaseProvider", "PostgresConfig", "MySQLConfig", "SQLiteConfig", "Model", "DB", "Migration", "Migrator"]
+__all__ = ["Attribute", "DatabaseProvider", "PostgresConfig", "MySQLConfig", "SQLiteConfig", "Model", "DB", "Migration", "Migrator"]

fastapi_startkit/src/fastapi_startkit/masoniteorm/models/attribute.py

@@ -105,4 +105,7 @@ def get_dirty(self) -> dict:
         }
 
     def get_attributes_for_insert(self) -> dict:
-        return {**self._attributes, **self._dirty_attributes}
+        # _dirty_attributes already went through set_attribute (casts applied on assignment).
+        # _attributes is set raw via new_model_instance, so apply set casts here.
+        casted = {k: self.caster.set(k, v) for k, v in self._attributes.items()}
+        return {**casted, **self._dirty_attributes}

fastapi_startkit/src/fastapi_startkit/masoniteorm/models/caster.py

@@ -5,13 +5,35 @@
 from enum import Enum
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, get_type_hints, Optional
+from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 from fastapi_startkit.carbon import Carbon
 
 if TYPE_CHECKING:
     from .model import Model
 
 
+class Attribute(BaseModel):
+    @classmethod
+    def get(cls, value):
+        if value is None:
+            return None
+        if isinstance(value, cls):
+            return value
+        data = json.loads(value) if isinstance(value, str) else value
+        return cls(**data)
+
+    @classmethod
+    def set(cls, value) -> Optional[str]:
+        if value is None:
+            return None
+        if isinstance(value, cls):
+            return value.model_dump_json()
+        if isinstance(value, dict):
+            return json.dumps(value)
+        return value
+
+
 @dataclass
 class BaseCast:
     """Base class for all casters"""

fastapi_startkit/tests/masoniteorm/fixtures/casts.py

@@ -0,0 +1,10 @@
+from typing import Optional
+
+from fastapi_startkit.masoniteorm.models.caster import Attribute
+
+
+class Address(Attribute):
+    address: Optional[str] = None
+    city: Optional[str] = None
+    state: Optional[str] = None
+    country: Optional[str] = None

fastapi_startkit/tests/masoniteorm/fixtures/migration.py

@@ -15,6 +15,8 @@ async def migrate(schema: Schema) -> None:
         table.string("email").unique()
         table.boolean("is_admin").default(False)
         table.timestamp("email_verified_at").nullable()
+        table.json("preferences").nullable()
+        table.text("address").nullable()
         table.timestamps()
 
     async with await schema.create_table_if_not_exists("profiles") as table:

fastapi_startkit/tests/masoniteorm/fixtures/model.py

@@ -1,4 +1,5 @@
 from fastapi_startkit.carbon.carbon import Carbon
+from tests.masoniteorm.fixtures.casts import Address
 from fastapi_startkit.masoniteorm.models.fields import Field, DateTimeField
 from fastapi_startkit.masoniteorm.relationships import (
     HasOne,
@@ -18,6 +19,8 @@ class User(Model):
     email: str
     email_verified_at: Carbon = DateTimeField(fmt="%Y-%m-%d %H:%M:%S", tz="UTC")
     is_admin: bool
+    preferences: dict
+    address: Address
 
     profile: "Profile" = HasOne("Profile", "user_id", "id")
     articles: "Articles" = HasMany("Articles", "id", "user_id")

fastapi_startkit/tests/masoniteorm/fixtures/seeder.py

@@ -1,9 +1,11 @@
+import json
+
 from .model import User, Profile, Articles, Logo, Country, Port, IncomingShipment, Like, Product
 
 
 async def seeder():
     user = await User.query().create(
-        {"email": "admin@admin.com", "name": "Joe", "is_admin": True}
+        {"email": "admin@admin.com", "name": "Joe", "is_admin": True, "preferences": json.dumps({"theme": "dark", "language": "en"}), "address": json.dumps({"address": "123 Main St", "city": "Sydney", "state": "NSW", "country": "Australia"})}
     )
     await Profile.create({"name": "Joe Profile", "user_id": user.id})
     article = await Articles.create(

fastapi_startkit/tests/masoniteorm/sqlite/models/test_sqlite_model_casts.py

@@ -0,0 +1,103 @@
+from ...fixtures.casts import Address
+from ...fixtures.model import User
+from ..test_case import TestCase
+
+
+class SqliteModelCastsTest(TestCase):
+    async def test_sqlite_model_casts_int(self):
+        user = await User.first()
+
+        # id: int annotation → IntCast
+        self.assertIsInstance(user.id, int)
+
+    async def test_sqlite_model_casts_str(self):
+        user = await User.first()
+
+        # name: str annotation → str cast
+        self.assertIsInstance(user.name, str)
+
+    async def test_sqlite_model_casts_bool_true(self):
+        user = await User.first()
+
+        # is_admin: bool annotation → BoolCast; SQLite stores booleans as 0/1
+        self.assertIsInstance(user.is_admin, bool)
+        self.assertTrue(user.is_admin)
+
+    async def test_sqlite_model_casts_bool_false(self):
+        user = await User.where("email", "guest@guest.com").first()
+
+        # A user seeded with is_admin=False should cast to bool False
+        self.assertIsInstance(user.is_admin, bool)
+        self.assertFalse(user.is_admin)
+
+    async def test_sqlite_model_casts_dict(self):
+        user = await User.where("email", "admin@admin.com").first()
+
+        # preferences: dict annotation → JsonCast; stored as JSON string in SQLite
+        self.assertIsInstance(user.preferences, dict)
+        self.assertEqual(user.preferences["theme"], "dark")
+        self.assertEqual(user.preferences["language"], "en")
+
+    async def test_sqlite_model_casts_dict_none(self):
+        user = await User.where("email", "guest@guest.com").first()
+
+        # guest user has no preferences seeded — should remain None
+        self.assertIsNone(user.preferences)
+
+    async def test_sqlite_model_casts_list(self):
+        user = await User.where("email", "admin@admin.com").first()
+
+        # Update preferences to a JSON array and verify list cast on re-fetch
+        await user.update({"preferences": ["reading", "coding"]})
+        updated = await User.where("email", "admin@admin.com").first()
+
+        self.assertIsInstance(updated.preferences, list)
+        self.assertIn("reading", updated.preferences)
+        self.assertIn("coding", updated.preferences)
+
+    async def test_sqlite_model_casts_pydantic_object(self):
+        user = await User.where("email", "admin@admin.com").first()
+
+        # address: Address annotation → custom Pydantic cast
+        # DB stores JSON text, get() deserializes it into an Address instance
+        self.assertIsInstance(user.address, Address)
+        self.assertEqual(user.address.address, "123 Main St")
+        self.assertEqual(user.address.city, "Sydney")
+        self.assertEqual(user.address.state, "NSW")
+        self.assertEqual(user.address.country, "Australia")
+
+    async def test_sqlite_model_casts_pydantic_object_none(self):
+        user = await User.where("email", "guest@guest.com").first()
+
+        # guest user has no address seeded — should remain None
+        self.assertIsNone(user.address)
+
+    async def test_sqlite_model_casts_pydantic_object_insert_with_instance(self):
+        address = Address(address="456 Queen St", city="Melbourne", state="VIC", country="Australia")
+
+        await User.create({
+            "email": "instance@example.com",
+            "name": "Instance User",
+            "is_admin": False,
+            "address": address,
+        })
+
+        fetched = await User.where("email", "instance@example.com").first()
+
+        self.assertIsInstance(fetched.address, Address)
+        self.assertEqual(fetched.address.address, "456 Queen St")
+        self.assertEqual(fetched.address.city, "Melbourne")
+
+    async def test_sqlite_model_casts_pydantic_object_insert_with_dict(self):
+        await User.create({
+            "email": "dict@example.com",
+            "name": "Dict User",
+            "is_admin": False,
+            "address": {"address": "789 King St", "city": "Brisbane", "state": "QLD", "country": "Australia"},
+        })
+
+        fetched = await User.where("email", "dict@example.com").first()
+
+        self.assertIsInstance(fetched.address, Address)
+        self.assertEqual(fetched.address.address, "789 King St")
+        self.assertEqual(fetched.address.city, "Brisbane")