feat: postgres setup

Author: tmgbedu

docker-compose.yml

@@ -13,3 +13,16 @@ services:
             interval: 5s
             timeout: 5s
             retries: 10
+    postgres:
+        image: postgres:17
+        environment:
+            POSTGRES_DB: database_app_test
+            POSTGRES_USER: app
+            POSTGRES_PASSWORD: secret
+        ports:
+            - "5432:5432"
+        healthcheck:
+            test: [ "CMD", "pg_isready", "-U", "app", "-d", "database_app_test" ]
+            interval: 5s
+            timeout: 5s
+            retries: 10

fastapi_startkit/src/fastapi_startkit/masoniteorm/connections/manager.py

@@ -39,7 +39,7 @@ def get_schema_builder(self):
 
         return Schema(self)
 
-    def clear(self):
+    async def clear(self):
         for conn in self.connections.values():
-            conn.engine.dispose()
+            await conn.engine.dispose()
         self.connections.clear()

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

@@ -1,4 +1,4 @@
-from typing import Any
+from sqlalchemy import text
 from fastapi_startkit.masoniteorm.query.grammars import PostgresGrammar
 from fastapi_startkit.masoniteorm.query.processors import PostgresPostProcessor
 from fastapi_startkit.masoniteorm.schema.platforms import PostgresPlatform
@@ -20,18 +20,20 @@ def get_default_platform(cls):
     def get_post_processor(cls):
         return PostgresPostProcessor
 
-    async def insert(self, query: str, bindings: list | None = None) -> Any:
-        """Postgres uses RETURNING to get the inserted id/row."""
-        query, params = self.sql_alchemy_bindings(query, bindings)
+    async def insert(self, query: str, bindings: list | None = None) -> int | None:
+        """Execute an INSERT ... RETURNING * and return the generated primary key."""
+        query_str, params = self.sql_alchemy_bindings(query, bindings)
+        conn = await self.get_connection()
+        result = await conn.execute(text(query_str), params or {})
 
-        from sqlalchemy import text
-
-        async with self.engine.connect() as conn:
-            result = await conn.execute(text(query), params)
+        if not self.transactions:
             await conn.commit()
 
-            row = result.fetchone()
-            if row:
-                return dict(zip(result.keys(), row))
+        row = result.fetchone()
+        if row:
+            return row[0]
 
-        return None
+        # Fallback for cases where RETURNING result is unavailable
+        val_result = await conn.execute(text("SELECT lastval()"))
+        val_row = val_result.fetchone()
+        return val_row[0] if val_row else None

fastapi_startkit/tests/masoniteorm/fixtures/migration.py

@@ -1,16 +1,14 @@
-from .db import DB
+from fastapi_startkit.masoniteorm.schema import Schema
 
-schema = DB.get_schema_builder()
 
-
-async def wipe():
+async def wipe(schema: Schema) -> None:
     for connection in ("default", "dev"):
         tables = await schema.on(connection).get_all_tables()
         for table in tables:
             await schema.on(connection).drop_table_if_exists(table)
 
 
-async def migrate():
+async def migrate(schema: Schema) -> None:
     async with await schema.on("default").create_table_if_not_exists("users") as table:
         table.id()
         table.string("name")

fastapi_startkit/tests/masoniteorm/postgres/__init__.py

@@ -0,0 +1,25 @@
+from fastapi_startkit.masoniteorm.connections.factory import ConnectionFactory
+from fastapi_startkit.masoniteorm.connections.manager import DatabaseManager
+
+URL = "postgresql+asyncpg://app:secret@localhost:5432/database_app_test"
+
+DB = DatabaseManager(
+    ConnectionFactory(),
+    {
+        "default": "postgres",
+        "connections": {
+            "postgres": {
+                "driver": "postgres",
+                "url": URL,
+                "database": "database_app_test",
+            },
+            "dev": {
+                "driver": "postgres",
+                "url": URL,
+                "database": "database_app_test",
+            },
+        },
+    },
+)
+
+schema = DB.get_schema_builder()

fastapi_startkit/tests/masoniteorm/postgres/fixtures/__init__.py

@@ -0,0 +1,27 @@
+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 ...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()
+
+    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")

fastapi_startkit/tests/masoniteorm/postgres/fixtures/db.py

@@ -1,6 +1,6 @@
 from unittest.mock import AsyncMock
 
-from ...fixtures.db import DB
+from ..fixtures.db import DB
 from ...fixtures.model import User
 from ..test_case import TestCase