feat: method added

Author: tmgbedu

example/config-app/uv.lock

@@ -104,11 +104,7 @@ async def insert(self, query: str, bindings: list | None = None) -> int | None:
 
     async def insert_get_id(self, query: str, bindings: list | None = None) -> int | None:
         result = await self.execute(query, bindings)
-        last_insert_id = getattr(result, "lastrowid", None)
-        if not last_insert_id:
-            row = result.fetchone()
-            last_insert_id = row[0] if row else None
-        return last_insert_id
+        return getattr(result, "lastrowid", None)
 
     async def update(self, query: str, bindings: list | None = None) -> int:
         result = await self.execute(query, bindings)

example/database-app/uv.lock

@@ -7,6 +7,14 @@
 class PostgresConnection(Connection):
     """Async PostgreSQL connection backed by asyncpg via SQLAlchemy."""
 
+    async def insert_get_id(self, query: str, bindings: list | None = None) -> int | None:
+        result = await self.run(query, bindings)
+        row = result.fetchone()
+        if not self.transactions:
+            conn = await self.get_connection()
+            await conn.commit()
+        return row[0] if row is not None else None
+
     @classmethod
     def get_query_grammar(cls):
         return PostgresGrammar

fastapi_startkit/src/fastapi_startkit/masoniteorm/connections/connection.py

@@ -218,26 +218,27 @@ def distinct(self) -> "QueryBuilder":
         self._distinct = True
         return self
 
-    def aggregate(self, aggregate_type: str, column: str, alias: str = None) -> "QueryBuilder":
-        if alias:
-            column = f"{column} as {alias}"
-        self._aggregates += (AggregateExpression(aggregate_type, column),)
-        return self
+    async def aggregate(self, function: str, column: str):
+        self._aggregates += (AggregateExpression(function, column),)
+        row = await self.connection.select_one(self.to_qmark(), self.get_bindings())
+        if row is None:
+            return None
+        return next(iter(row.values()))
 
-    def count(self, column: str = "*") -> "QueryBuilder":
-        return self.aggregate("COUNT", column)
+    async def count(self, column: str = "*"):
+        return await self.aggregate("COUNT", column)
 
-    def sum(self, column: str) -> "QueryBuilder":
-        return self.aggregate("SUM", column)
+    async def sum(self, column: str):
+        return await self.aggregate("SUM", column)
 
-    def max(self, column: str) -> "QueryBuilder":
-        return self.aggregate("MAX", column)
+    async def max(self, column: str):
+        return await self.aggregate("MAX", column)
 
-    def min(self, column: str) -> "QueryBuilder":
-        return self.aggregate("MIN", column)
+    async def min(self, column: str):
+        return await self.aggregate("MIN", column)
 
-    def avg(self, column: str) -> "QueryBuilder":
-        return self.aggregate("AVG", column)
+    async def avg(self, column: str):
+        return await self.aggregate("AVG", column)
 
     async def delete(self, column=None, value=None):
         if column is not None:
@@ -259,6 +260,15 @@ async def first_or_create(self, search: dict, attributes: dict | None = None):
 
         return await self.create({**(attributes or {}), **search})
 
+    async def update_or_create(self, search: dict, attributes: dict | None = None):
+        instance = await self.where(search).first()
+        if instance is not None:
+            if attributes:
+                await instance.update(attributes)
+            return instance
+
+        return await self.create({**(attributes or {}), **search})
+
     async def insert(self, values: dict | list) -> int | None:
         self.set_action("bulk_create")
 
@@ -302,9 +312,7 @@ async def paginate(self, per_page: int = 15, page: int = 1):
         count_builder._wheres = list(self._wheres)
         count_builder._joins = self._joins
         count_builder._global_scopes = self._global_scopes
-        count_builder.count()
-        count_result = await self.connection.select(count_builder.to_qmark(), count_builder.get_bindings())
-        total = list(count_result[0].values())[0] if count_result else 0
+        total = await count_builder.count() or 0
 
         offset = (page - 1) * per_page
         results = await self.limit(per_page).offset(offset).get()

fastapi_startkit/src/fastapi_startkit/masoniteorm/connections/postgres_connection.py

@@ -119,6 +119,10 @@ def on(cls, connection: str):
     async def all(cls):
         return await cls.query().get()
 
+    @classmethod
+    async def count(cls, column: str = "*"):
+        return await cls.query().count(column)
+
     def set_connection(self, connection: str):
         self.connection = connection
 
@@ -175,6 +179,12 @@ async def first_or_create(
     ) -> "Model":
         return await cls.query().first_or_create(search, attributes)
 
+    @classmethod
+    async def update_or_create(
+        cls, search: dict, attributes: dict | None = None
+    ) -> "Model":
+        return await cls.query().update_or_create(search, attributes)
+
     @classmethod
     async def create(cls, attributes: dict):
         instance = cls().new_model_instance(attributes)

fastapi_startkit/src/fastapi_startkit/masoniteorm/models/builder.py

@@ -53,7 +53,7 @@ def bulk_insert_format(self):
         return f"INSERT INTO {{table}} ({{columns}}) VALUES {{values}} RETURNING {self._returning}"
 
     def delete_format(self):
-        return "DELETE FROM {TABLE} {wheres}"
+        return "DELETE FROM {table} {wheres}"
 
     def aggregate_string_with_alias(self):
         return "{aggregate_function}({column}) AS {alias}"

fastapi_startkit/src/fastapi_startkit/masoniteorm/models/model.py

@@ -1,27 +1,135 @@
-from unittest import IsolatedAsyncioTestCase
-
-from fastapi_startkit.masoniteorm.models.model import Model
-from fastapi_startkit.masoniteorm.testing.transaction import RefreshDatabase
-from ..fixtures.db import DB, schema
-from ...fixtures.migration import migrate, wipe
+from ..test_case import TestCase
 from ...fixtures.model import User
 
 
-class TestPostGresModel(RefreshDatabase, IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        Model.db_manager = DB
-        await DB.clear()
-        await wipe(schema)
-        await migrate(schema)
-
-    async def asyncTearDown(self):
-        await wipe(schema)
-        await DB.clear()
-
+class TestPostGresModel(TestCase):
     async def test_can_create_and_find_user(self):
         user = await User.create({"name": "Alice", "email": "alice@example.com", "is_admin": False})
         self.assertIsNotNone(user.id)
 
         found = await User.find(user.id)
         self.assertEqual(found.name, "Alice")
         self.assertEqual(found.email, "alice@example.com")
+
+    async def test_find_returns_none_for_missing_id(self):
+        found = await User.find(99999)
+        self.assertIsNone(found)
+
+    async def test_first_returns_first_record(self):
+        await User.create({"name": "Bob", "email": "bob@example.com", "is_admin": False})
+        await User.create({"name": "Carol", "email": "carol@example.com", "is_admin": True})
+
+        user = await User.first()
+        self.assertIsNotNone(user)
+        self.assertEqual(user.name, "Bob")
+
+    async def test_first_returns_none_when_table_is_empty(self):
+        user = await User.first()
+        self.assertIsNone(user)
+
+    async def test_update_changes_attributes(self):
+        user = await User.create({"name": "Dave", "email": "dave@example.com", "is_admin": False})
+
+        await user.update({"name": "David"})
+
+        refreshed = await User.find(user.id)
+        self.assertEqual(refreshed.name, "David")
+        self.assertEqual(refreshed.email, "dave@example.com")
+
+    async def test_update_only_dirty_fields(self):
+        user = await User.create({"name": "Eve", "email": "eve@example.com", "is_admin": False})
+
+        await user.update({"name": "Eve", "is_admin": True})
+
+        refreshed = await User.find(user.id)
+        self.assertTrue(refreshed.is_admin)
+        self.assertEqual(refreshed.name, "Eve")
+
+    async def test_delete_removes_record(self):
+        user = await User.create({"name": "Frank", "email": "frank@example.com", "is_admin": False})
+        user_id = user.id
+
+        await User.where("id", user_id).delete()
+
+        found = await User.find(user_id)
+        self.assertIsNone(found)
+
+    async def test_delete_by_column_removes_matching_records(self):
+        await User.create({"name": "Grace", "email": "grace@example.com", "is_admin": False})
+        await User.create({"name": "Heidi", "email": "heidi@example.com", "is_admin": True})
+
+        await User.query().delete("is_admin", True)
+
+        admin = await User.where("is_admin", True).first()
+        self.assertIsNone(admin)
+
+        non_admin = await User.where("is_admin", False).first()
+        self.assertIsNotNone(non_admin)
+
+    async def test_where_filters_results(self):
+        await User.create({"name": "Ivan", "email": "ivan@example.com", "is_admin": False})
+        await User.create({"name": "Judy", "email": "judy@example.com", "is_admin": True})
+
+        admins = await User.where("is_admin", True).get()
+        self.assertEqual(len(admins), 1)
+        self.assertEqual(admins[0].name, "Judy")
+
+    async def test_first_or_create_creates_when_not_found(self):
+        user = await User.first_or_create(
+            {"email": "newuser@example.com"},
+            {"name": "New User", "is_admin": False},
+        )
+        self.assertIsNotNone(user.id)
+        self.assertEqual(user.email, "newuser@example.com")
+        self.assertEqual(user.name, "New User")
+
+    async def test_first_or_create_returns_existing_when_found(self):
+        existing = await User.create({"name": "Existing", "email": "existing@example.com", "is_admin": False})
+
+        user = await User.first_or_create(
+            {"email": "existing@example.com"},
+            {"name": "Should Not Be Created", "is_admin": True},
+        )
+        self.assertEqual(user.id, existing.id)
+        self.assertEqual(user.name, "Existing")
+
+        # Confirm no duplicate was inserted
+        all_users = await User.where("email", "existing@example.com").get()
+        self.assertEqual(len(all_users), 1)
+
+    async def test_all_returns_all_records(self):
+        await User.create({"name": "Karl", "email": "karl@example.com", "is_admin": False})
+        await User.create({"name": "Laura", "email": "laura@example.com", "is_admin": False})
+
+        users = await User.all()
+        self.assertEqual(len(users), 2)
+
+    async def test_update_or_create_creates_when_not_found(self):
+        user = await User.update_or_create(
+            {"email": "new@example.com"},
+            {"name": "New User", "is_admin": False},
+        )
+        self.assertIsNotNone(user.id)
+        self.assertEqual(user.email, "new@example.com")
+        self.assertEqual(user.name, "New User")
+
+    async def test_update_or_create_updates_when_found(self):
+        await User.create({"name": "Original", "email": "update@example.com", "is_admin": False})
+
+        user = await User.update_or_create(
+            {"email": "update@example.com"},
+            {"name": "Updated", "is_admin": True},
+        )
+        self.assertEqual(user.name, "Updated")
+        self.assertTrue(user.is_admin)
+
+        # Confirm no duplicate was inserted
+        count = await User.where("email", "update@example.com").count()
+        self.assertEqual(count, 1)
+
+    async def test_count_returns_correct_number(self):
+        await User.create({"name": "Mallory", "email": "mallory@example.com", "is_admin": False})
+        await User.create({"name": "Niaj", "email": "niaj@example.com", "is_admin": False})
+
+        count = await User.count()
+        self.assertEqual(count, 2)

fastapi_startkit/src/fastapi_startkit/masoniteorm/query/grammars/PostgresGrammar.py

@@ -0,0 +1,18 @@
+from unittest import IsolatedAsyncioTestCase
+
+from fastapi_startkit.masoniteorm import Model
+from fastapi_startkit.masoniteorm.testing.transaction import RefreshDatabase
+from .fixtures.db import DB, schema
+from ..fixtures.migration import migrate, wipe
+
+
+class TestCase(RefreshDatabase, IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        Model.db_manager = DB
+        await DB.clear()
+        await wipe(schema)
+        await migrate(schema)
+
+    async def asyncTearDown(self):
+        await wipe(schema)
+        await DB.clear()

fastapi_startkit/tests/masoniteorm/postgres/models/test_model.py

@@ -1,6 +1,7 @@
 from unittest import IsolatedAsyncioTestCase
 
 from fastapi_startkit.masoniteorm.testing.transaction import RefreshDatabase
+from fastapi_startkit.masoniteorm import Model
 
 from .fixtures.db import DB
 from ..fixtures.migration import migrate, wipe
@@ -10,6 +11,7 @@
 class TestCase(RefreshDatabase, IsolatedAsyncioTestCase):
     async def asyncSetUp(self):
         self.db = DB
+        Model.db_manager = DB
         self.schema = DB.get_schema_builder()
         await self.migrate_database()