fastapi-startkit 0.19.0__tar.gz → 0.21.0__tar.gz

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.19.0
+Version: 0.21.0
 Summary: Fastapi Starter kit components
 Author: Bedram Tamang
 Author-email: Bedram Tamang <tmgbedu@gmail.com>
@@ -14,6 +14,9 @@ Requires-Dist: pydantic>=2.12.5
 Requires-Dist: faker>=40.13.0 ; extra == 'database'
 Requires-Dist: sqlalchemy[asyncio]>=2.0.38 ; extra == 'database'
 Requires-Dist: fastapi[standard]>=0.124.4,<0.125.0 ; extra == 'fastapi'
+Requires-Dist: itsdangerous>=2.2.0 ; extra == 'fastapi'
+Requires-Dist: jinja2>=3.1 ; extra == 'inertia'
+Requires-Dist: markupsafe>=2.0 ; extra == 'inertia'
 Requires-Dist: aiomysql>=0.2.0 ; extra == 'mysql'
 Requires-Dist: asyncpg>=0.29.0 ; extra == 'postgres'
 Requires-Dist: aiosqlite>=0.22.1 ; extra == 'sqlite'
@@ -21,6 +24,7 @@ Requires-Dist: jinja2>=3.1 ; extra == 'vite'
 Requires-Python: >=3.12, <4.0
 Provides-Extra: database
 Provides-Extra: fastapi
+Provides-Extra: inertia
 Provides-Extra: mysql
 Provides-Extra: postgres
 Provides-Extra: sqlite

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.19.0"
+version = "0.21.0"
 description = "Fastapi Starter kit components"
 authors = [
     {name = "Bedram Tamang", email = "tmgbedu@gmail.com"}
@@ -19,6 +19,7 @@ dependencies = [
 [project.optional-dependencies]
 fastapi = [
     "fastapi[standard] (>=0.124.4,<0.125.0)",
+    "itsdangerous>=2.2.0",
 ]
 database = [
     "faker>=40.13.0",
@@ -41,6 +42,11 @@ vite=[
     "jinja2>=3.1",
 ]
 
+inertia = [
+    "jinja2>=3.1",
+    "markupsafe>=2.0",
+]
+
 [dependency-groups]
 dev = [
     "dumpdie>=1.5.0",
@@ -48,6 +54,7 @@ dev = [
     "pytest-asyncio>=1.3.0",
     "ruff>=0.9.0",
     "twine>=6.2.0",
+    "itsdangerous>=2.2.0",
 ]
 
 

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/application.py

@@ -112,6 +112,12 @@ class Application(Container, Generic[TConfig]):
     def use_base_path(self, path: str):
         return self.base_path / path
 
+    def storage_path(self, path: str = "") -> str:
+        return str(self.base_path / "storage" / path)
+
+    def public_path(self, path: str = "") -> str:
+        return str(self.base_path / "public" / path)
+
     def get(self, path: str, **kwargs) -> Callable:
         return self.fastapi.get(path, **kwargs)
 

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/exceptions/__init__.py

@@ -27,6 +27,7 @@ from .exceptions import (
     InvalidPackageName,
     LoaderNotFound,
     QueueException,
+    ValidationException,
     AmbiguousError,
     MethodNotAllowedException,
     ModelNotFoundException,

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/exceptions/exceptions.py

@@ -216,3 +216,9 @@ class InvalidPackageName(Exception):
 
 class LoaderNotFound(Exception):
     pass
+
+
+class ValidationException(Exception):
+    def __init__(self, errors: dict):
+        super().__init__("The given data was invalid.")
+        self.errors = errors

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/facades/__init__.py

@@ -11,7 +11,6 @@ from .Auth import Auth
 from .Config import Config
 from .Loader import Loader
 from .Notification import Notification
-from .Storage import Storage
 from .Dump import Dump
 from .Queue import Queue
 from .Cache import Cache

fastapi_startkit-0.21.0/src/fastapi_startkit/fastapi/__init__.py

@@ -0,0 +1,5 @@
+from .providers.fastapi_provider import FastAPIProvider
+from .routers.router import Router
+from .requests.model import RequestModel
+
+__all__ = ["FastAPIProvider", "Router", "RequestModel"]

fastapi_startkit-0.21.0/src/fastapi_startkit/fastapi/exceptions.py

@@ -0,0 +1,70 @@
+class HTTPExceptionHandler:
+    """
+    The base exception handler for FastAPI applications.
+    """
+
+    async def render(self, request, exc):
+        import traceback
+        from fastapi.responses import JSONResponse
+        from fastapi_startkit.container import Container
+
+        app = Container.instance()
+        if app.is_debug():
+            tb = exc.__traceback__
+            frames = traceback.extract_tb(tb)
+            content = {
+                "message": str(exc),
+                "exception": f"{type(exc).__module__}.{type(exc).__qualname__}",
+                "file": frames[-1].filename if frames else None,
+                "line": frames[-1].lineno if frames else None,
+                "trace": [
+                    {"file": f.filename, "line": f.lineno, "function": f.name}
+                    for f in frames
+                ],
+            }
+        else:
+            content = {"message": "Server Error"}
+
+        return JSONResponse(status_code=500, content=content)
+
+
+class ValidationExceptionHandler:
+    """
+    Handles RequestValidationError with content negotiation.
+
+    JSON requests (API clients) receive a 422 Unprocessable Entity response.
+    Non-JSON requests (browser/Inertia) have errors flashed to the session
+    and are redirected back to the referring page.
+    """
+
+    def report(self, exc) -> None:
+        pass
+
+    async def render(self, request, exc):
+        accept = request.headers.get("accept", "")
+        content_type = request.headers.get("content-type", "")
+
+        wants_json = (
+            "application/json" in accept
+            or content_type.startswith("application/json")
+        )
+
+        errors = {}
+        for err in exc.errors():
+            field = ".".join(str(x) for x in err["loc"][1:])
+            errors.setdefault(field, []).append(err["msg"])
+
+        if wants_json:
+            from fastapi.responses import JSONResponse
+
+            return JSONResponse(status_code=422, content={"errors": errors})
+
+        if "session" in request.scope:
+            request.session["errors"] = errors
+
+        from starlette.responses import RedirectResponse
+
+        return RedirectResponse(
+            url=request.headers.get("referer", "/"),
+            status_code=303,
+        )

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/fastapi/providers/fastapi_provider.py

@@ -1,4 +1,4 @@
-from fastapi_startkit.fastapi.exceptions import HTTPExceptionHandler
+from fastapi_startkit.fastapi.exceptions import HTTPExceptionHandler, ValidationExceptionHandler
 from fastapi import FastAPI
 
 from fastapi_startkit.fastapi.commands import ServeCommand
@@ -21,10 +21,19 @@ class FastAPIProvider(Provider):
 
     def _register_exception_handlers(self):
         """Wire exception_manager as a catch-all handler for all exceptions."""
+        from fastapi import HTTPException
+        from fastapi.exceptions import RequestValidationError
+
         exception_manager = self.app.exception_manager
         exception_manager.register_handler(Exception, HTTPExceptionHandler())
+        exception_manager.register_handler(HTTPException, HTTPExceptionHandler())
+        exception_manager.register_handler(RequestValidationError, ValidationExceptionHandler())
 
         async def handler(request, exc):
             return await exception_manager.handle(exc, {"request": request})
 
+        # FastAPI registers its own handlers for these two types internally,
+        # so they must be overridden explicitly
+        self.app.fastapi.add_exception_handler(HTTPException, handler)
+        self.app.fastapi.add_exception_handler(RequestValidationError, handler)
         self.app.fastapi.add_exception_handler(Exception, handler)

fastapi_startkit-0.21.0/src/fastapi_startkit/fastapi/requests/model.py

@@ -0,0 +1,34 @@
+import inspect
+
+from fastapi import Form
+from fastapi.params import Query as QueryParam
+from pydantic import BaseModel
+
+
+class RequestModel(BaseModel):
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs):
+        super().__pydantic_init_subclass__(**kwargs)
+
+        params = []
+        for name, field in cls.model_fields.items():
+            if isinstance(field, QueryParam):
+                default = field
+            elif field.is_required():
+                default = Form(...)
+            else:
+                default = Form(default=field.default)
+
+            params.append(
+                inspect.Parameter(
+                    name,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    default=default,
+                    annotation=field.annotation,
+                )
+            )
+
+        cls.__signature__ = inspect.Signature(params)
+
+    def validated(self) -> dict:
+        return {k: v for k, v in self.model_dump().items() if v}

fastapi_startkit-0.21.0/src/fastapi_startkit/helpers/app.py

@@ -0,0 +1,9 @@
+def storage_path(path: str = "") -> str:
+    """Get the path to the storage directory."""
+    from fastapi_startkit.application import app
+    return app().storage_path(path)
+
+def public_path(path: str = "") -> str:
+    """Get the path to the public directory."""
+    from fastapi_startkit.application import app
+    return app().public_path(path)

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/inertia/middleware.py

@@ -94,7 +94,7 @@ class InertiaMiddleware(BaseHTTPMiddleware):
     def resolve_validation_errors(request: Request) -> dict:
         if "session" not in request.scope:
             return {}
-        return request.session.get("errors", {})
+        return request.session.pop("errors", {})
 
     @staticmethod
     def reflash(request: Request) -> None:

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/inertia/provider.py

@@ -1,4 +1,5 @@
 import json
+from markupsafe import Markup
 from fastapi_startkit.providers import Provider
 from .inertia import Inertia
 from .middleware import InertiaMiddleware
@@ -8,33 +9,20 @@ class InertiaProvider(Provider):
     provider_key = "inertia"
 
     def register(self) -> None:
-        """Bind the Inertia class to the container."""
-        self.app.bind("inertia", Inertia(self.app))
+        self.app.bind("inertia", Inertia)
 
     def boot(self) -> None:
-        """Configure template globals and middleware."""
-        # 1. Register Middleware
-        # We add it to the FastAPI instance via the application helper
         self.app.add_middleware(InertiaMiddleware)
 
-        # 2. Register Template Globals
         if self.app.has("templates"):
             templates = self.app.make("templates")
 
-            try:
-                from markupsafe import Markup
-            except ImportError:
-                Markup = str
-
             def inertia_helper(page):
-                """Jinja2 helper to render the root div for Inertia."""
                 encoded_page = json.dumps(page)
-                # Ensure single quotes are used for the attribute to avoid conflict with JSON double quotes
                 return Markup(
                     f'<script data-page="app" type="application/json">{encoded_page}</script><div id="app"></div>'
                 )
 
             templates.env.globals["inertia"] = inertia_helper
-
-            # Also share the inertia instance itself if needed
             templates.env.globals["Inertia"] = self.app.make("inertia")
+

fastapi_startkit-0.21.0/src/fastapi_startkit/masoniteorm/__init__.py

@@ -0,0 +1,6 @@
+from .config.config import MySQLConfig, PostgresConfig, SQLiteConfig
+from .facades import DB
+from .models import Model
+from .providers import DatabaseProvider
+
+__all__ = ["DatabaseProvider", "PostgresConfig", "MySQLConfig", "SQLiteConfig", "Model", "DB"]

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/masoniteorm/connections/connection.py

@@ -1,8 +1,9 @@
 from typing import List
 
-from fastapi_startkit.masoniteorm.models.builder import QueryBuilder
 from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncConnection, AsyncTransaction
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, AsyncTransaction
+
+from fastapi_startkit.masoniteorm.models.builder import QueryBuilder
 
 
 class Connection:
@@ -69,7 +70,6 @@ class Connection:
     async def reconnect(self) -> None:
         await self.close()
 
-
     @staticmethod
     def sql_alchemy_bindings(query: str, bindings: list | None = None):
         params = {}
@@ -84,8 +84,12 @@ class Connection:
         query, bindings = self.sql_alchemy_bindings(query, bindings)
 
         conn = await self.get_connection()
+        result = await conn.execute(text(query), bindings or {})
 
-        return await conn.execute(text(query), bindings or {})
+        if not self.transactions:
+            await conn.commit()
+
+        return result
 
     async def execute(self, query: str, bindings: list | None = None):
         query, bindings = self.sql_alchemy_bindings(query, bindings)
@@ -103,6 +107,10 @@ class Connection:
 
         return getattr(result, "lastrowid", None)
 
+    async def insert_get_id(self, query: str, bindings: list | None = None) -> int | None:
+        result = await self.execute(query, bindings)
+        return getattr(result, "lastrowid", None)
+
     async def update(self, query: str, bindings: list | None = None) -> int:
         result = await self.execute(query, bindings)
 
@@ -114,13 +122,16 @@ class Connection:
 
     async def select(self, query: str, bindings: list | None = None) -> list[dict]:
         result = await self.run(query, bindings)
-        keys = result.keys()
-        return [dict(zip(keys, row)) for row in result.fetchall()]
+
+        return result.mappings().all()
 
     async def select_one(self, query: str, bindings: list | None = None) -> dict | None:
         result = await self.run(query, bindings)
         row = result.fetchone()
-        return dict(zip(result.keys(), row)) if row else None
+        result_dict = dict(zip(result.keys(), row)) if row else None
+        if not self.transactions and self.connection is not None:
+            await self.connection.commit()
+        return result_dict
 
     async def statement(self, query: str, bindings: list | None = None) -> bool:
         query, bindings = self.sql_alchemy_bindings(query, bindings)

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/masoniteorm/connections/manager.py

@@ -39,7 +39,7 @@ class DatabaseManager:
 
         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-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/masoniteorm/connections/postgres_connection.py

@@ -1,4 +1,3 @@
-from typing import Any
 from fastapi_startkit.masoniteorm.query.grammars import PostgresGrammar
 from fastapi_startkit.masoniteorm.query.processors import PostgresPostProcessor
 from fastapi_startkit.masoniteorm.schema.platforms import PostgresPlatform
@@ -8,6 +7,14 @@ from .connection import Connection
 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
@@ -19,19 +26,3 @@ class PostgresConnection(Connection):
     @classmethod
     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)
-
-        from sqlalchemy import text
-
-        async with self.engine.connect() as conn:
-            result = await conn.execute(text(query), params)
-            await conn.commit()
-
-            row = result.fetchone()
-            if row:
-                return dict(zip(result.keys(), row))
-
-        return None

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/masoniteorm/facades/DB.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from fastapi_startkit.orm.connections.connection import Connection
-    from fastapi_startkit.orm.connections.manager import DatabaseManager
-    from fastapi_startkit.orm.models.builder import QueryBuilder
+    from fastapi_startkit.masoniteorm.connections.connection import Connection
+    from fastapi_startkit.masoniteorm.connections.manager import DatabaseManager
+    from fastapi_startkit.masoniteorm.models.builder import QueryBuilder
 
 
 class DB:
@@ -52,3 +52,15 @@ class DB:
     @classmethod
     async def statement(cls, query: str, bindings: list | None = None) -> bool:
         return await cls.instance().connection(None).statement(query, bindings)
+
+    @classmethod
+    async def begin_transaction(cls, name: str | None = None) -> None:
+        await cls.instance().connection(name).begin_transaction()
+
+    @classmethod
+    async def commit(cls, name: str | None = None) -> None:
+        await cls.instance().connection(name).commit_transaction()
+
+    @classmethod
+    async def rollback(cls, name: str | None = None) -> None:
+        await cls.instance().connection(name).rollback()

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/masoniteorm/models/builder.py

@@ -1,6 +1,5 @@
 import inspect
-
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from fastapi_startkit.masoniteorm.expressions.expressions import (
     JoinClause,
@@ -107,9 +106,9 @@ class QueryBuilder(EagerLoadMixin, SupportMixin):
         collection = self._model.hydrate(models)
 
         if (
-            self._eager_relation.eagers
-            or self._eager_relation.nested_eagers
-            or self._eager_relation.callback_eagers
+                self._eager_relation.eagers
+                or self._eager_relation.nested_eagers
+                or self._eager_relation.callback_eagers
         ):
             await self._load_eagers(collection, self._model)
 
@@ -216,26 +215,27 @@ class QueryBuilder(EagerLoadMixin, SupportMixin):
         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:
@@ -257,6 +257,15 @@ class QueryBuilder(EagerLoadMixin, SupportMixin):
 
         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")
 
@@ -275,6 +284,16 @@ class QueryBuilder(EagerLoadMixin, SupportMixin):
         bindings = [val for row in values for val in row.values()]
         return await self.connection.insert(sql, bindings)
 
+    async def insert_get_id(
+            self,
+            values: dict[str, Any] | list[dict[str, Any]],
+            sequences: str | None = None,
+    ) -> int | None:
+        sql = self.grammar().compile_insert_get_id(self, values, sequences)
+        bindings = self.clean_bindings(values)
+
+        return await self.connection.insert_get_id(sql, bindings)
+
     async def update(self, values: dict) -> int:
         updates = [UpdateQueryExpression(col, val) for col, val in values.items()]
         grammar = self.grammar()
@@ -290,9 +309,7 @@ class QueryBuilder(EagerLoadMixin, SupportMixin):
         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()
@@ -386,3 +403,9 @@ class QueryBuilder(EagerLoadMixin, SupportMixin):
         else:
             related.query_has(self, method="or_where_exists")
         return self
+
+    @classmethod
+    def clean_bindings(cls, values):
+        if isinstance(values, dict):
+            values = [values]
+        return [val for row in values for val in row.values()]

{fastapi_startkit-0.19.0 → fastapi_startkit-0.21.0}/src/fastapi_startkit/masoniteorm/models/model.py

@@ -13,7 +13,7 @@ from fastapi_startkit.masoniteorm.models.attribute import Attribute
 from fastapi_startkit.masoniteorm.models.relationship import Relationship
 
 if TYPE_CHECKING:
-    from fastapi_startkit.orm.models.builder import QueryBuilder
+    from fastapi_startkit.masoniteorm.models.builder import QueryBuilder
 
 
 class Model(Attribute, Relationship, ObservesEvents):
@@ -21,6 +21,7 @@ class Model(Attribute, Relationship, ObservesEvents):
     __table__ = None
     __primary_key__ = "id"
     __timestamps__ = True
+    __incrementing__ = True
 
     __has_events__ = True
     __observers__ = {}
@@ -118,6 +119,10 @@ class Model(Attribute, Relationship, ObservesEvents):
     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
 
@@ -174,6 +179,12 @@ class Model(Attribute, Relationship, ObservesEvents):
     ) -> "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)
@@ -215,12 +226,15 @@ class Model(Attribute, Relationship, ObservesEvents):
     async def perform_insert(self, query) -> bool:
         attributes = self.get_attributes_for_insert()
 
-        inserted_id = await query.insert(attributes)
-
-        # Store the auto-generated primary key so subsequent saves do an UPDATE
-        if inserted_id is not None:
+        """if the model set auto incrementing, we need to set back the primary key to the inserted id."""
+        if self.__incrementing__:
+            inserted_id = await query.insert_get_id(attributes)
+            self._attributes[self.__primary_key__] = inserted_id
             self._dirty_attributes[self.__primary_key__] = inserted_id
 
+        else:
+            await query.insert(attributes)
+
         self._exists = True
         self._was_recently_created = True
         self.observe_events(self, "created")