Allow virtual entities to delete references as well and improvements.

Author: immmdreza

src/examples/embed_props.py

@@ -22,7 +22,7 @@ class Student(TEntity):
 
     student_id = props.string(required=True)
     first_name = props.string(required=True)
-    last_name = props.optional(props.string())
+    last_name = props.string().optional()
     grades = props.array(Grade)
 
     def __init__(

src/examples/engine_configs_1.py

@@ -0,0 +1,81 @@
+import asyncio
+from typing import Optional
+
+from sjd import Engine, TEntity, properties as props
+
+
+class _Days(TEntity):
+    employee_id = props.reference()
+
+    def __init__(self, days: int) -> None:
+        self.days = days
+
+
+@props.auto_collect()
+class RestInfo(_Days):
+    pass
+
+
+@props.auto_collect()
+class StandbyInfo(_Days):
+    pass
+
+
+@props.auto_collect()  # This won't override attributes you've already defined ( rest_info & standby_info here ).
+class Employee(TEntity):
+
+    rest_info = props.from_entity(RestInfo, "employee_id")
+    standby_info = props.from_entity(StandbyInfo, "employee_id")
+
+    def __init__(
+        self,
+        employee_id: int,
+        first_name: str,
+        last_name: str,
+        rest_info: Optional[RestInfo] = None,
+        standby_info: Optional[StandbyInfo] = None,
+    ) -> None:
+        self.employee_id = employee_id
+        self.first_name = first_name
+        self.last_name = last_name
+        self.rest_info = rest_info
+        self.standby_info = standby_info
+
+
+class AppEngine(Engine):
+
+    employees = Engine.set(Employee)
+    # No need to add rest_info & standby_info collections here. but you can.
+    # rest_info = Engine.set(RestInfo)
+    # standby_info = Engine.set(StandbyInfo)
+
+    def __init__(self):
+        super().__init__("__test_db__")
+
+        # Say welcome to lambda hell ...
+        self._configs.config_collection(
+            lambda engine: engine.employees,
+            lambda collection: collection.config_property(
+                lambda employee: employee.rest_info,
+                lambda config: config.delete_whole_reference(),
+            ).config_property(
+                lambda employee: employee.standby_info,
+                lambda config: config.delete_reference_prop(),
+            ),
+        ),
+
+
+async def main():
+    engine = AppEngine()
+    employees_col = engine.employees
+
+    await employees_col.add(Employee(1, "John", "Doe", RestInfo(5), StandbyInfo(5)))
+
+    async for item in employees_col:
+        await employees_col.delete(item)
+    # Due to engine configs, this'll delete the rest_info entity too.
+    # But the standby_info entity will not be deleted entirely only StandbyInfo.employee_id will be None.
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/sjd/database/_collection.py

@@ -195,10 +195,6 @@ async def _manage_referral_properties(self, entity: TEntity):
 
                                 # get a collection for reference type
                                 col = self._engine.get_collection(prop.type_of_entity)  # type: ignore
-                                if col is None:
-                                    raise ValueError(
-                                        f"No collection for referenced type {prop.type_of_entity} found"  # type: ignore
-                                    )
 
                                 await col.add(value)  # type: ignore
                                 delattr(entity, prop.actual_name)
@@ -288,6 +284,34 @@ async def _update_async(
             else:
                 os.remove(tmp_path.absolute())
 
+    async def _care_about_virtual_props(self, entity: TEntity):
+        col_config = self.configuration
+        if col_config is None:
+            return
+
+        for prop in entity.get_properties():
+            if isinstance(prop, (VirtualComplexProperty, VirtualListProperty)):
+                prop_config = col_config.get_property_config(prop.actual_name)
+                if prop_config is None:
+                    continue
+
+                match prop_config.delete_action.value:
+                    case "delete_entity":
+                        entity_col = self._engine.get_collection(prop.type_of_entity)
+
+                        async for item in self.iter_referenced_by(entity, lambda _: prop):  # type: ignore
+                            await entity_col.delete(item)
+
+                    case "delete_reference":
+                        entity_col = self._engine.get_collection(prop.type_of_entity)
+
+                        async for item in self.iter_referenced_by(entity, lambda _: prop):  # type: ignore
+                            setattr(item, prop.refers_to, None)
+                            await entity_col.update(item)
+
+                    case "ignore":
+                        continue
+
     @final
     async def _update_entity_async(self, entity: T, delete: bool = False) -> None:
 
@@ -319,6 +343,9 @@ async def _update_entity_async(self, entity: T, delete: bool = False) -> None:
             if modified:
                 os.remove(file_path.absolute())
                 os.rename(tmp_path.absolute(), file_path.absolute())
+
+                if delete:
+                    await self._care_about_virtual_props(entity)  # type: ignore
             else:
                 os.remove(tmp_path.absolute())
 
@@ -520,10 +547,6 @@ async def load_virtual_props(self, entity: T, *props: str):
                     except_one = isinstance(prop, VirtualComplexProperty)
                     # get a collection for reference type
                     col = self._engine.get_collection(prop.type_of_entity)  # type: ignore
-                    if col is None:
-                        raise ValueError(
-                            f"No collection for referenced type {prop.type_of_entity} found"  # type: ignore
-                        )
 
                     # TODO: Is this performance wise ?
                     results: list[Any] = []
@@ -554,10 +577,7 @@ async def iter_referenced_by(
             if isinstance(prop, (VirtualComplexProperty, VirtualListProperty)):
                 # get a collection for reference type
                 col = self._engine.get_collection(prop.type_of_entity)
-                if col is None:
-                    raise ValueError(
-                        f"No collection for referenced type {prop.type_of_entity} found"
-                    )
+
                 async for item in col.iterate_by(prop.refers_to, entity.id):
                     yield item  # type: ignore
         else:

src/sjd/database/_configuration.py

@@ -14,13 +14,25 @@
 
 
 class DeleteAction(Enum):
-    DELETE_VIRTUAL = "delete"
+    DELETE_ENTITY = "delete_entity"
     """ Deletes all virtual entities associated with the entity. """
     DELETE_REFERENCE = "delete_reference"
     """ Removes the reference property from the virtual entities. """
     IGNORE = "ignore"
     """ Ignores the virtual entities. """
 
+    @property
+    def ignore(self) -> bool:
+        return self == DeleteAction.IGNORE
+
+    @property
+    def delete_reference(self) -> bool:
+        return self == DeleteAction.DELETE_REFERENCE
+
+    @property
+    def delete_entity(self) -> bool:
+        return self == DeleteAction.DELETE_ENTITY
+
 
 @dataclasses.dataclass(repr=True)
 class PropertyConfiguration:
@@ -39,6 +51,14 @@ def set_delete_action(self, action: DeleteAction) -> "PropertyConfiguration":
         self.delete_action = action
         return self
 
+    def delete_whole_reference(self) -> "PropertyConfiguration":
+        """Indicates if the entity which this property referees to should be deleted when current entity is deleted."""
+        return self.set_delete_action(DeleteAction.DELETE_ENTITY)
+
+    def delete_reference_prop(self) -> "PropertyConfiguration":
+        """Indicates if the reference property should be deleted ( from reference entity ) when current entity is deleted."""
+        return self.set_delete_action(DeleteAction.DELETE_REFERENCE)
+
 
 @dataclasses.dataclass(repr=True)
 class CollectionConfiguration(Generic[T]):

src/sjd/database/_descriptors.py

@@ -41,10 +41,7 @@ def __get__(
     ) -> "__Collection__[T]" | AbstractCollection[T]:
         if obj is None:
             return self
-        col = cast("Engine", obj).get_collection(self._entity_type)
-        if col is None:
-            raise AttributeError(f"Can't get such collection {self._entity_type}")
-        return col
+        return cast("Engine", obj).get_collection(self._entity_type)
 
     def __set__(self, obj: object, value: T) -> None:
         raise AttributeError("Engine collections are read-only.")
@@ -82,10 +79,6 @@ def __get__(
         if obj is None:
             return self
         t_col = cast("Engine", obj).get_collection(self._entity_type)
-        if t_col is None:
-            raise AttributeError(
-                f"Can't get such typed collection {self._entity_type}, {self._collection_type}"
-            )
         return cast(_TCol, t_col)
 
     def __set__(self, obj: object, value: T) -> None:

src/sjd/database/_engine.py

@@ -70,9 +70,7 @@ def __getitem__(self, entity_type: type[T]) -> AbstractCollection[T]:
         Args:
             entity_type (`type[T]`): The entity type of the collection.
         """
-        if (col := self.get_collection(entity_type)) is not None:
-            return col
-        raise KeyError(f"Collection of type {entity_type} is not registered")
+        return self.get_collection(entity_type)
 
     def __set_collections(self):
         for _, col in inspect.getmembers(type(self)):
@@ -111,7 +109,7 @@ def get_base_path(self, collection: AbstractCollection[Any]) -> Path:
         return self._base_path
 
     @final
-    def get_collection(self, entity_type: type[T]) -> Optional[AbstractCollection[T]]:
+    def get_collection(self, entity_type: type[T]) -> AbstractCollection[T]:
         """Returns the collection of the entity type.
 
         Args:
@@ -126,7 +124,7 @@ def get_collection(self, entity_type: type[T]) -> Optional[AbstractCollection[T]
         if not self.__initialized:
             raise EngineNotInitialized()
         if entity_type not in self.__collections:
-            return None
+            self.register_collection(entity_type)
         return self.__collections[entity_type]
 
     @final
@@ -158,9 +156,13 @@ def register_collection(
             raise CollectionEntityTypeDuplicated(
                 name or entity_type.__name__, entity_type
             )
+
+        if entity_type is None or not issubclass(entity_type, TEntity):
+            raise ValueError("entity_type must be a TEntity.")
+
         col = Collection(self, entity_type, name)
         self.__collections[entity_type] = col
-        return col
+        return col  # type: ignore
 
     def register_typed_collection(
         self, collection: type[AbstractCollection[T]]

src/sjd/entity/_property.py

@@ -139,3 +139,21 @@ def default_factory(self) -> Optional[Callable[[], Optional[T]]]:
     def is_virtual(self) -> bool:
         """Whether the property is virtual."""
         return getattr(self, "__virtual__", False)
+
+    def optional(self):
+        """Returns a clone of the property with the required flag set to False and hints as optional."""
+
+        if self.required:
+            raise ValueError(
+                "Cannot create an optional property from a required property."
+            )
+
+        return TProperty[Optional[T]](
+            self.type_of_entity,
+            init=self.init,
+            required=False,
+            default_factory=lambda: None,
+            is_list=self.is_list,
+            json_property_name=self.json_property_name,
+            is_complex=self.is_complex,
+        )

src/sjd/entity/properties/__init__.py

@@ -98,21 +98,10 @@ def entity(
     )
 
 
-def optional(property: TProperty[T]) -> OptionalProperty[T]:
+def optional(property: TProperty[T]) -> TProperty[Optional[T]]:
     if isinstance(property, OptionalProperty):
         return property  # type: ignore
-
-    if property.required:
-        raise ValueError("Cannot create an optional property from a required property.")
-
-    return OptionalProperty(
-        property.type_of_entity,
-        init=property.init,
-        default_factory=lambda: None,
-        is_list=property.is_list,
-        json_property_name=property.json_property_name,
-        is_complex=property.is_complex,
-    )
+    return property.optional()
 
 
 def from_entity(
@@ -146,7 +135,7 @@ def reference():
 
 
 __all__ = [
-    "collect_props_from_init",
+    "auto_collect",
     "integer",
     "string",
     "double",

src/sjd/entity/properties/_property_grabber.py

@@ -67,7 +67,7 @@ def __grab_props(__init__: Callable[..., Any]):
 
 def auto_collect(
     *, method_name: str = "__init__", ignore_params: Optional[list[str]] = None
-) -> Callable[..., Any]:
+) -> Callable[[type[T]], type[T]]:
     """Automatically collect properties from `__init__` method.
 
     Note that only valid types are allowed.