Complete and total rework ahead.

crudkit/core/base.py

@@ -0,0 +1,26 @@
+from sqlalchemy import Column, Integer, DateTime, Boolean, String, JSON, func
+from sqlalchemy.orm import declarative_mixin, declarative_base
+
+Base = declarative_base()
+
+@declarative_mixin
+class CRUDMixin:
+    id = Column(Integer, primary_key=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    def as_dict(self):
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+
+class Version(Base):
+    __tablename__ = "versions"
+
+    id = Column(Integer, primary_key=True)
+    model_name = Column(String, nullable=False)
+    object_id = Column(Integer, nullable=False)
+    change_type = Column(String, nullable=False)
+    data = Column(JSON, nullable=True)
+    timestamp = Column(DateTime, default=func.now())
+
+    actor = Column(String, nullable=True)
+    metadata = Column(JSON, nullable=True)

crudkit/core/service.py

@@ -0,0 +1,104 @@
+from typing import Type, TypeVar, Generic
+from sqlalchemy.orm import Session
+from crudkit.core.base import Version
+from crudkit.core.spec import CRUDSpec
+
+T = TypeVar("T")
+
+def _is_truthy(val):
+    return str(val).lower() in ('1', 'true', 'yes', 'on')
+
+class CRUDService(Generic[T]):
+    def __init__(self, model: Type[T], session: Session):
+        self.model = model
+        self.session = session
+        self.supports_soft_delete = hasattr(model, 'is_deleted')
+
+    def get(self, id: int, include_deleted: bool = False) -> T | None:
+        obj = self.session.get(self.model, id)
+        if obj is None:
+            return None
+        if self.supports_soft_delete and not include_deleted and obj.is_deleted:
+            return None
+        return obj
+
+    def list(self, params=None) -> list[T]:
+        query = self.session.query(self.model)
+
+        if params:
+            if self.supports_soft_delete:
+                include_deleted = False
+                include_deleted = _is_truthy(params.get('include_deleted'))
+                if not include_deleted:
+                    query = query.filter(self.model.is_deleted == False)
+            spec = CRUDSpec(self.model, params)
+            filters = spec.parse_filters()
+            order_by = spec.parse_sort()
+            limit, offset = spec.parse_pagination()
+
+            for parent, relationship_attr, alias in spec.get_join_paths():
+                query = query.join(alias, relationship_attr.of_type(alias), isouter=True)
+
+            for eager in spec.get_eager_loads():
+                query = query.options(eager)
+
+            if filters:
+                query = query.filter(*filters)
+            if order_by:
+                query = query.order_by(*order_by)
+            query = query.offset(offset).limit(limit)
+        return query.all()
+
+    def create(self, data: dict, actor=None) -> T:
+        obj = self.model(**data)
+        self.session.add(obj)
+        self.session.commit()
+
+        self._log_version("create", obj, actor)
+        return obj
+
+    def update(self, id: int, data: dict, actor=None) -> T:
+        obj = self.get(id)
+        if not obj:
+            raise ValueError(f"{self.model.__name__} with ID {id} not found.")
+
+        valid_fields = {c.name for c in self.model.__table__.columns}
+        for k, v in data.items():
+            if k in valid_fields:
+                setattr(obj, k, v)
+        self.session.commit()
+
+        self._log_version("update", obj, actor)
+        return obj
+
+    def delete(self, id: int, hard: bool = False, actor = False):
+        obj = self.session.get(self.model, id)
+        if not obj:
+            return None
+
+        if hard or not self.supports_soft_delete:
+            self.session.delete(obj)
+        else:
+            obj.is_deleted = True
+
+        self.session.commit()
+
+        self._log_version("delete", obj, actor)
+        return obj
+
+    def _log_version(self, change_type: str, obj: T, actor=None, metadata: dict = {}):
+        try:
+            data = obj.as_dict()
+        except Exception:
+            data = {"error": "Failed to serialize object."}
+
+        version = Version(
+            model_name=self.model.__name__,
+            object_id=obj.id,
+            change_type=change_type,
+            data=data,
+            actor=str(actor) if actor else None,
+            metadata=metadata
+        )
+        self.session.add(version)
+        self.session.commit()

crudkit/core/spec.py

@@ -0,0 +1,110 @@
+from typing import List, Tuple, Set, Dict
+from sqlalchemy import asc, desc
+from sqlalchemy.orm import joinedload, aliased
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+
+OPERATORS = {
+    'eq': lambda col, val: col == val,
+    'lt': lambda col, val: col < val,
+    'lte': lambda col, val: col <= val,
+    'gt': lambda col, val: col > val,
+    'gte': lambda col, val: col >= val,
+    'ne': lambda col, val: col != val,
+    'icontains': lambda col, val: col.ilike(f"%{val}%"),
+}
+
+class CRUDSpec:
+    def __init__(self, model, params):
+        self.model = model
+        self.params = params
+        self.eager_paths: Set[Tuple[str, ...]] = set()
+        self.join_paths: List[Tuple[object, InstrumentedAttribute, object]] = []
+        self.alias_map: Dict[Tuple[str, ...], object] = {}
+
+    def _resolve_column(self, path: str):
+        current_model = self.model
+        current_alias = self.model
+        parts = path.split('.')
+        join_path = []
+
+        for i, attr in enumerate(parts):
+            if not hasattr(current_model, attr):
+                return None, None
+            attr_obj = getattr(current_model, attr)
+            if isinstance(attr_obj, InstrumentedAttribute):
+                if hasattr(attr_obj.property, 'direction'):
+                    join_path.append(attr)
+                    path_key = tuple(join_path)
+                    alias = self.alias_map.get(path_key)
+                    if not alias:
+                        alias = aliased(attr_obj.property.mapper.class_)
+                        self.alias_map[path_key] = alias
+                        self.join_paths.append((current_alias, attr_obj, alias))
+                    current_model = attr_obj.property.mapper.class_
+                    current_alias = alias
+                else:
+                    return getattr(current_alias, attr), tuple(join_path) if join_path else None
+        return None, None
+
+    def parse_filters(self):
+        filters = []
+        for key, value in self.params.items():
+            if key in ('sort', 'limit', 'offset'):
+                continue
+            if '__' in key:
+                path_op = key.rsplit('__', 1)
+                if len(path_op) != 2:
+                    continue
+                path, op = path_op
+            else:
+                path, op = key, 'eq'
+            col, join_path = self._resolve_column(path)
+            if col and op in OPERATORS:
+                filters.append(OPERATORS[op](col, value))
+                if join_path:
+                    self.eager_paths.add(join_path)
+        return filters
+
+    def parse_sort(self):
+        sort_args = self.params.get('sort', '')
+        result = []
+        for part in sort_args.split(','):
+            part = part.strip()
+            if not part:
+                continue
+            if part.startswith('-'):
+                field = part[1:]
+                order = desc
+            else:
+                field = part
+                order = asc
+            col, join_path = self._resolve_column(field)
+            if col:
+                result.append(order(col))
+                if join_path:
+                    self.eager_paths.add(join_path)
+        return result
+
+    def parse_pagination(self):
+        limit = int(self.params.get('limit', 100))
+        offset = int(self.params.get('offset', 0))
+        return limit, offset
+
+    def get_eager_loads(self):
+        loads = []
+        for path in self.eager_paths:
+            current = self.model
+            loader = None
+            for attr in path:
+                attr_obj = getattr(current, attr)
+                if loader is None:
+                    loader = joinedload(attr_obj)
+                else:
+                    loader = loader.joinedload(attr_obj)
+                current = attr_obj.property.mapper.class_
+            if loader:
+                loads.append(loader)
+        return loads
+
+    def get_join_paths(self):
+        return self.join_paths