flask-construct-ui 0.9.5__py3-none-any.whl

flask_construct_ui/crud.py

@@ -0,0 +1,1641 @@
+from __future__ import annotations
+from math import ceil
+from flask import (
+    current_app,
+    flash,
+    redirect,
+    render_template,
+    request,
+    url_for,
+)
+
+from . import schema
+from .data import DataBase
+from .forms import FormData, validate_form_data
+from .navigation import resolve_next
+from .pagination import RELATED_SEARCH_LIMIT, get_pagination
+from .base import PageBase, expose
+
+
+def _parse_many_related_field(field, type_info, form):
+    """Parse a ManyRelated field from submitted form data.
+
+    Returns ``(pks, staged)`` where ``pks`` is the list of selected
+    existing primary keys and ``staged`` is ``{"quick": [values]}`` /
+    ``{"new": [sub-field dicts]}`` or ``None``. Staged inputs are only
+    honored for the creation mode the field opted into, so a stray
+    ``-quicknew``/``-newrel-`` input can never force record creation on
+    a field that didn't enable it.
+    """
+    pks = form.getlist(field)
+    staged = {}
+    if type_info.create == "quick":
+        seen = set()
+        quick = []
+        for value in form.getlist(f"{field}-quicknew"):
+            value = value.strip()
+            if value and value not in seen:
+                seen.add(value)
+                quick.append(value)
+        if quick:
+            staged["quick"] = quick
+    elif type_info.create == "form":
+        prefix = f"{field}-newrel-"
+        indices = set()
+        for key in form:
+            if key.startswith(prefix):
+                try:
+                    indices.add(int(key[len(prefix) :].split("-", 1)[0]))
+                except (ValueError, IndexError):
+                    continue
+        new_items = []
+        for i in sorted(indices):
+            item_prefix = f"{prefix}{i}-"
+            new_item = {}
+            has_data = False
+            for sub_field, sub_type in type_info.inline_form_fields():
+                form_key = item_prefix + sub_field
+                if sub_type.field_type == "bool":
+                    new_item[sub_field] = form_key in form
+                    if form_key in form:
+                        has_data = True
+                elif sub_type.field_type == "set":
+                    values = form.getlist(form_key)
+                    if values:
+                        new_item[sub_field] = set(values)
+                        has_data = True
+                elif form_key in form and form[form_key]:
+                    new_item[sub_field] = form[form_key]
+                    has_data = True
+                elif sub_type.default is not None:
+                    # A default alone never materializes a row (has_data
+                    # stays False), matching the List new-row parser.
+                    new_item[sub_field] = sub_type.default
+            if has_data:
+                new_items.append(new_item)
+        if new_items:
+            staged["new"] = new_items
+    return pks, (staged or None)
+
+
+class RelatedCrudTab:
+    """Advanced related-item tab that embeds a full CRUD experience inside an edit tab.
+
+    Pass either ``child_dataclass`` (a :class:`DataBase` subclass) or
+    ``child_crud_class`` (a :class:`CrudPageBase` subclass). When
+    ``child_crud_class`` is used its ``dataclass`` attribute is extracted
+    automatically, and any ``related_crud_tabs`` declared on that class are
+    registered as a second nesting level, enabling chains like
+    Section → Article → Comment.
+
+    Simple usage (dataclass)::
+
+        class ArticleCrudPage(CrudPageBase):
+            related_crud_tabs = [
+                RelatedCrudTab(
+                    tab_key="comments",
+                    child_dataclass=CommentData,
+                    filter_field="article_id",
+                    name="demo-comments-name",
+                    icon="bi-chat-left-text",
+                )
+            ]
+
+    Chained usage (crud class)::
+
+        class ArticleCrudPage(CrudPageBase):
+            related_crud_tabs = [
+                RelatedCrudTab(
+                    tab_key="comments",
+                    child_dataclass=CommentData,
+                    filter_field="article_id",
+                    name="demo-comments-name",
+                    icon="bi-chat-left-text",
+                )
+            ]
+
+        class SectionCrudPage(CrudPageBase):
+            related_crud_tabs = [
+                RelatedCrudTab(
+                    tab_key="articles",
+                    child_crud_class=ArticleCrudPage,   # pulls dataclass + nested tabs
+                    filter_field="section_id",
+                    name="demo-articles-name",
+                    icon="bi-newspaper",
+                )
+            ]
+
+    ``filter_field`` must be present in the child dataclass schema
+    (enforced at construction time). Use ``visible_form=False`` to hide it
+    from the child edit form.
+
+    With Unpoly (JS enabled), navigation within the tab only swaps the tab
+    content pane — the rest of the page is untouched. Without JS, standard
+    full-page navigation is used as a graceful fallback.
+    """
+
+    def __init__(
+        self,
+        tab_key,
+        filter_field,
+        name,
+        icon="list",
+        child_dataclass=None,
+        child_crud_class=None,
+        create_url=None,
+    ):
+        if child_crud_class is not None:
+            self.child_dataclass = child_crud_class.dataclass
+            self.child_crud_class = child_crud_class
+        elif child_dataclass is not None:
+            self.child_dataclass = child_dataclass
+            self.child_crud_class = None
+        else:
+            raise ValueError(
+                "Either child_dataclass or child_crud_class must be provided"
+            )
+        if filter_field not in self.child_dataclass._schema:
+            raise ValueError(
+                f"filter_field '{filter_field}' is not declared in the schema "
+                f"of {self.child_dataclass.__name__}. Declare it (e.g. "
+                f"schema.Integer(..., visible_form=False, visible_list=False)) "
+                f"to use it for related-crud filtering."
+            )
+        self.tab_key = tab_key
+        self.filter_field = filter_field
+        self.name = name
+        self.icon = icon
+        self.create_url = create_url
+
+    def get_list_fields(
+        self, ds: DataBase, construct
+    ) -> list[tuple[str, schema.SchemaField]]:
+        if self.child_crud_class:
+            child_view = self.child_crud_class()
+            child_view.construct = construct
+            return child_view.get_list_fields(ds)
+        return [
+            (k, v)
+            for k, v in ds._schema.items()
+            if not isinstance(v, (schema.PK, schema.List)) and v.visible_list
+        ]
+
+    def get_form_fields(
+        self, ds: DataBase, construct, data=None
+    ) -> list[tuple[str, schema.SchemaField]]:
+        if self.child_crud_class:
+            child_view = self.child_crud_class()
+            child_view.construct = construct
+            return child_view.get_form_fields(ds, data)
+        return [
+            (k, v)
+            for k, v in ds._schema.items()
+            if not isinstance(v, schema.PK) and v.visible_form
+        ]
+
+    @property
+    def _child_nested_tabs(self):
+        if self.child_crud_class:
+            return list(self.child_crud_class.related_crud_tabs)
+        return []
+
+    @property
+    def list_endpoint(self):
+        return f"rcrud_{self.tab_key}"
+
+    @property
+    def create_endpoint(self):
+        return f"rcrud_{self.tab_key}_create"
+
+    @property
+    def edit_endpoint(self):
+        return f"rcrud_{self.tab_key}_edit"
+
+    @property
+    def delete_endpoint(self):
+        return f"rcrud_{self.tab_key}_delete"
+
+    def get_tab_action(self):
+        return {
+            "endpoint": self.list_endpoint,
+            "name": self.name,
+            "icon": self.icon,
+            "url": f"/rcrud/{self.tab_key}/",
+        }
+
+    def _process_form_data(self, ds, parent_id, construct, rec=None):
+        raw_data = request.form.to_dict()
+        form_fields = {k: v for k, v in self.get_form_fields(ds, construct, rec)}
+        data = {}
+        # Only take fields that are in the form_fields and are not readonly/hidden
+        for field, type_info in form_fields.items():
+            if type_info.readonly or not type_info.visible_form:
+                continue
+            if field in raw_data:
+                data[field] = raw_data[field]
+        data[self.filter_field] = parent_id
+
+        for field, type_info in ds._schema.items():
+            if (
+                field not in form_fields
+                or type_info.readonly
+                or not type_info.visible_form
+            ):
+                continue
+            if type_info.secret:
+                if f"{field}-change" not in request.form:
+                    data.pop(field, None)
+                    continue
+            if hasattr(type_info, "field_type"):
+                if type_info.field_type == "bool":
+                    data[field] = field in request.form
+                elif type_info.field_type == "set":
+                    data[field] = set(request.form.getlist(field))
+                elif isinstance(type_info, schema.ManyRelated):
+                    pks, staged = _parse_many_related_field(
+                        field, type_info, request.form
+                    )
+                    data[field] = pks
+                    if staged:
+                        data.setdefault("many_related_new", {})[field] = staged
+                elif isinstance(type_info, schema.List):
+                    if type_info.readonly:
+                        continue
+                    if "list_items" not in data:
+                        data["list_items"] = {}
+                    if field not in data["list_items"]:
+                        data["list_items"][field] = {}
+
+                    delete_ids = request.form.getlist(f"{field}-delete")
+                    if delete_ids:
+                        data["list_items"][field]["delete"] = delete_ids
+
+                    update_items = []
+                    item_ids = request.form.getlist(f"{field}-id")
+                    list_cls_schema = type_info.list_class._schema
+                    for item_id in item_ids:
+                        if item_id in delete_ids:
+                            continue
+                        item_data = {"id": item_id}
+                        prefix = f"{field}-{item_id}-"
+                        for sub_field, sub_type in list_cls_schema.items():
+                            if (
+                                sub_type.field_type == "pk"
+                                or sub_type.readonly
+                                or not sub_type.visible_form
+                            ):
+                                continue
+                            form_key = prefix + sub_field
+                            if sub_type.field_type == "bool":
+                                item_data[sub_field] = form_key in request.form
+                            elif sub_type.field_type == "set":
+                                item_data[sub_field] = set(
+                                    request.form.getlist(form_key)
+                                )
+                            elif form_key in request.form:
+                                item_data[sub_field] = request.form[form_key]
+                        update_items.append(item_data)
+                    if update_items:
+                        data["list_items"][field]["update"] = update_items
+
+                    indices = set()
+                    new_prefix = f"{field}-new-"
+                    for key in request.form:
+                        if key.startswith(new_prefix):
+                            try:
+                                indices.add(
+                                    int(key[len(new_prefix) :].split("-", 1)[0])
+                                )
+                            except (ValueError, IndexError):
+                                continue
+                    new_items = []
+                    for i in sorted(indices):
+                        item_prefix = f"{new_prefix}{i}-"
+                        new_item = {}
+                        has_data = False
+                        for sub_field, sub_type in list_cls_schema.items():
+                            if (
+                                sub_type.field_type == "pk"
+                                or sub_type.readonly
+                                or not sub_type.visible_form
+                            ):
+                                continue
+                            form_key = item_prefix + sub_field
+                            if sub_type.field_type == "bool":
+                                new_item[sub_field] = form_key in request.form
+                                if form_key in request.form:
+                                    has_data = True
+                            elif sub_type.field_type == "set":
+                                values = request.form.getlist(form_key)
+                                if values:
+                                    new_item[sub_field] = set(values)
+                                    has_data = True
+                            elif form_key in request.form and request.form[form_key]:
+                                new_item[sub_field] = request.form[form_key]
+                                has_data = True
+                        if has_data:
+                            new_items.append(new_item)
+                    if new_items:
+                        data["list_items"][field]["new"] = new_items
+        return data
+
+    def _register(self, parent_view, blueprint, construct):
+        tab_key = self.tab_key
+        filter_field = self.filter_field
+        child_dataclass = self.child_dataclass
+        theme = construct.theme
+        content_id = f"rcrud-content-{tab_key}"
+        content_target = f"#{content_id}"
+        list_ep = self.list_endpoint
+        create_ep = self.create_endpoint
+        edit_ep = self.edit_endpoint
+        delete_ep = self.delete_endpoint
+        rct = self
+        child_nested_tabs = self._child_nested_tabs
+
+        def _ctx(parent_id):
+            return dict(
+                construct=construct,
+                view=parent_view,
+                tab_actions=parent_view.tab_actions,
+                active_tab=list_ep,
+                id=parent_id,
+                tab_content_id=content_id,
+                content_target=content_target,
+                tab_key=tab_key,
+                list_ep=list_ep,
+                create_ep=create_ep,
+                edit_ep=edit_ep,
+                delete_ep=delete_ep,
+            )
+
+        def _child_ctx(parent_id, child_id):
+            nested_content_id = f"rcrud-child-content-{tab_key}-{child_id}"
+            tab_action_list = [
+                {
+                    "endpoint": f"rcrud_{tab_key}_{t.tab_key}",
+                    "name": t.name,
+                    "icon": t.icon,
+                }
+                for t in child_nested_tabs
+            ]
+            if rct.child_crud_class:
+                for _ta in rct.child_crud_class.tab_actions:
+                    tab_action_list.append(
+                        {
+                            "endpoint": f"rcrud_{tab_key}_{_ta['endpoint']}",
+                            "name": _ta["name"],
+                            "icon": _ta["icon"],
+                        }
+                    )
+            return dict(
+                **_ctx(parent_id),
+                child_id=child_id,
+                nested_content_id=nested_content_id,
+                nested_content_target=f"#{nested_content_id}",
+                child_tab_actions=tab_action_list,
+                child_entity_name_key=(
+                    rct.child_crud_class.name if rct.child_crud_class else rct.name
+                ),
+            )
+
+        def list_view(id):
+            ds = child_dataclass()
+            page, per_page, limit = get_pagination(
+                getattr(rct.child_crud_class, "page_size", None)
+                if rct.child_crud_class
+                else None
+            )
+            data, total = ds.filter({filter_field: str(id)}, limit=limit)
+            pagination = None
+            if total > per_page:
+                pages = ceil(total / per_page)
+                pw = 2
+                pagination = {
+                    "page": page,
+                    "per_page": per_page,
+                    "total": total,
+                    "pages": int(pages),
+                    "start_page": max(1, page - pw),
+                    "end_page": min(int(pages), page + pw),
+                }
+            fields = [
+                (k, v)
+                for k, v in rct.get_list_fields(ds, construct)
+                if k != filter_field
+            ]
+            if rct.create_url:
+                _list_base = url_for(f"{parent_view.endpoint}.{list_ep}", id=id).rstrip(
+                    "/"
+                )
+                create_href = f"{_list_base}/{rct.create_url.lstrip('/')}"
+            else:
+                create_href = url_for(f"{parent_view.endpoint}.{create_ep}", id=id)
+            rcrud_list_actions = [
+                {
+                    "endpoint": f"rcrud_{tab_key}_{a['endpoint']}",
+                    "name": a["name"],
+                    "icon": a["icon"],
+                }
+                for a in (
+                    rct.child_crud_class.list_actions if rct.child_crud_class else []
+                )
+            ]
+            return render_template(
+                f"themes/{theme}/crud/related_crud_tab_list.html",
+                **_ctx(id),
+                parent_id=id,
+                data=data,
+                fields=fields,
+                primary_key=ds._primary_key,
+                pagination=pagination,
+                create_href=create_href,
+                list_actions=rcrud_list_actions,
+            )
+
+        list_view.__name__ = list_ep
+        blueprint.add_url_rule(
+            f"/<int:id>/rcrud/{tab_key}/", list_ep, list_view, methods=["GET"]
+        )
+
+        def create_view(id):
+            ds = child_dataclass()
+            errors = None
+            form_data = None
+            status = 200
+            if request.method == "POST":
+                data = rct._process_form_data(ds, id, construct)
+                errors = validate_form_data(
+                    ds,
+                    rct.get_form_fields(ds, construct),
+                    data,
+                    row=FormData(data),
+                    skip=(filter_field,),
+                )
+                if not errors:
+                    rec = None
+                    try:
+                        rec = ds.create(data)
+                        flash("crud-item-created", "success")
+                    except Exception:
+                        if current_app.debug:
+                            raise
+                        flash("crud-error-creating-item", "danger")
+                    record_url = None
+                    if rec is not None:
+                        record_url = url_for(
+                            f"{parent_view.endpoint}.{edit_ep}",
+                            id=id,
+                            child_id=getattr(rec, ds._primary_key),
+                        )
+                    return redirect(
+                        resolve_next(
+                            url_for(f"{parent_view.endpoint}.{list_ep}", id=id),
+                            record_url,
+                        )
+                    )
+                form_data = FormData(data)
+                status = 400
+            child_fields = [
+                (k, v)
+                for k, v in rct.get_form_fields(ds, construct)
+                if k != filter_field
+            ]
+            child_url = (
+                url_for(f"{parent_view.endpoint}.{list_ep}", id=id).rstrip("/")
+                if rct.child_crud_class
+                else None
+            )
+            return render_template(
+                f"themes/{theme}/crud/related_crud_tab_form.html",
+                **_ctx(id),
+                parent_id=id,
+                form_data=form_data,
+                child_fields=child_fields,
+                ds=ds,
+                child_primary_key=ds._primary_key,
+                is_edit=False,
+                child_id=None,
+                child_url=child_url,
+                edit_actions=[],
+                errors=errors,
+            ), status
+
+        create_view.__name__ = create_ep
+        blueprint.add_url_rule(
+            f"/<int:id>/rcrud/{tab_key}/create",
+            create_ep,
+            create_view,
+            methods=["GET", "POST"],
+        )
+
+        def edit_view(id, child_id):
+            ds = child_dataclass()
+            rec = ds.read(child_id)
+            if rec is None:
+                flash("crud-error-not-found", "danger")
+                return redirect(url_for(f"{parent_view.endpoint}.{list_ep}", id=id))
+            errors = None
+            form_data = rec
+            status = 200
+            if request.method == "POST":
+                data = rct._process_form_data(ds, id, construct, rec)
+                errors = validate_form_data(
+                    ds,
+                    rct.get_form_fields(ds, construct, rec),
+                    data,
+                    row=FormData(data, rec),
+                    partial=True,
+                    skip=(filter_field,),
+                )
+                if not errors:
+                    try:
+                        ds.update(child_id, data)
+                        flash("crud-item-updated", "success")
+                    except Exception:
+                        if current_app.debug:
+                            raise
+                        flash("crud-error-updating-item", "danger")
+                    record_url = url_for(
+                        f"{parent_view.endpoint}.{edit_ep}", id=id, child_id=child_id
+                    )
+                    if child_nested_tabs:
+                        default = record_url
+                    else:
+                        default = url_for(f"{parent_view.endpoint}.{list_ep}", id=id)
+                    return redirect(resolve_next(default, record_url))
+                form_data = FormData(data, rec)
+                status = 400
+            child_fields = [
+                (k, v)
+                for k, v in rct.get_form_fields(ds, construct, rec)
+                if k != filter_field
+            ]
+            child_url = (
+                url_for(f"{parent_view.endpoint}.{list_ep}", id=id).rstrip("/")
+                if rct.child_crud_class
+                else None
+            )
+            rcrud_edit_actions = []
+            if rct.child_crud_class:
+                for _ea in rct.child_crud_class.edit_actions:
+                    _ep = f"rcrud_{tab_key}_{_ea['endpoint']}"
+                    rcrud_edit_actions.append(
+                        {
+                            "href": url_for(
+                                f"{parent_view.endpoint}.{_ep}",
+                                id=id,
+                                child_id=child_id,
+                            ),
+                            "name": _ea["name"],
+                            "icon": _ea["icon"],
+                        }
+                    )
+            child_has_inner_tabs = child_nested_tabs or (
+                rct.child_crud_class and rct.child_crud_class.tab_actions
+            )
+            if child_has_inner_tabs:
+                ctx = _child_ctx(id, child_id)
+                form_action = url_for(
+                    f"{parent_view.endpoint}.{edit_ep}", id=id, child_id=child_id
+                )
+                cancel_url = url_for(f"{parent_view.endpoint}.{list_ep}", id=id)
+                nested_content = render_template(
+                    f"themes/{theme}/crud/_related_child_form.html",
+                    construct=construct,
+                    view=parent_view,
+                    ds=ds,
+                    form_data=form_data,
+                    child_fields=child_fields,
+                    is_edit=True,
+                    form_action=form_action,
+                    cancel_url=cancel_url,
+                    nested_content_target=ctx["nested_content_target"],
+                    child_url=child_url,
+                    edit_actions=rcrud_edit_actions,
+                    errors=errors,
+                )
+                return render_template(
+                    f"themes/{theme}/crud/related_crud_tab_child_view.html",
+                    **ctx,
+                    nested_active_tab="edit",
+                    nested_content=nested_content,
+                ), status
+            return render_template(
+                f"themes/{theme}/crud/related_crud_tab_form.html",
+                **_ctx(id),
+                parent_id=id,
+                form_data=form_data,
+                child_fields=child_fields,
+                ds=ds,
+                child_primary_key=ds._primary_key,
+                is_edit=True,
+                child_id=child_id,
+                child_url=child_url,
+                edit_actions=rcrud_edit_actions,
+                errors=errors,
+            ), status
+
+        edit_view.__name__ = edit_ep
+        blueprint.add_url_rule(
+            f"/<int:id>/rcrud/{tab_key}/<int:child_id>/edit",
+            edit_ep,
+            edit_view,
+            methods=["GET", "POST"],
+        )
+
+        def delete_view(id, child_id):
+            ds = child_dataclass()
+            try:
+                ds.delete(child_id)
+                flash("crud-item-deleted", "success")
+            except Exception:
+                if current_app.debug:
+                    raise
+                flash("crud-error-deleting-item", "danger")
+            return redirect(
+                resolve_next(url_for(f"{parent_view.endpoint}.{list_ep}", id=id))
+            )
+
+        delete_view.__name__ = delete_ep
+        blueprint.add_url_rule(
+            f"/<int:id>/rcrud/{tab_key}/<int:child_id>/delete",
+            delete_ep,
+            delete_view,
+            methods=["POST"],
+        )
+
+        _STANDARD_CRUD = frozenset({"index", "create", "get", "patch", "delete"})
+
+        def _url_params(url):
+            params = set()
+            for part in url.split("/"):
+                if part.startswith("<") and part.endswith(">"):
+                    name = part.strip("<>")
+                    if ":" in name:
+                        name = name.split(":", 1)[1]
+                    params.add(name)
+            return params
+
+        def _register_exposed(
+            child_cls, url_prefix, ep_prefix, child_id_kwarg, child_ctx_fn=None
+        ):
+            """Register all non-standard @expose routes from child_cls on the blueprint."""
+            # Params in the URL prefix (beyond the leading 'id') must not be forwarded
+            # to the child method — they belong to the parent context.
+            prefix_params = _url_params(url_prefix) - {"id"}
+
+            def _make_view(method_name, ep_name):
+                def exposed_view(id, **kwargs):
+                    child = child_cls()
+                    child.construct = construct
+                    for p in prefix_params:
+                        kwargs.pop(p, None)
+                    if child_id_kwarg in kwargs:
+                        kwargs["id"] = kwargs.pop(child_id_kwarg)
+                    child._rcrud_context = {
+                        "parent_endpoint": parent_view.endpoint,
+                        "ep_prefix": ep_prefix,
+                        "child_id_kwarg": child_id_kwarg,
+                        "parent_id": id,
+                        "child_id": kwargs.get("id"),
+                        "_child_ctx": child_ctx_fn,
+                    }
+                    return getattr(child, method_name)(**kwargs)
+
+                exposed_view.__name__ = ep_name
+                return exposed_view
+
+            for url, name, methods in child_cls._curls:
+                if name in _STANDARD_CRUD:
+                    continue
+                ep_name = f"{ep_prefix}_{name}"
+                adjusted_url = url.replace(
+                    "<int:id>", f"<int:{child_id_kwarg}>"
+                ).replace("<id>", f"<{child_id_kwarg}>")
+                view_func = _make_view(name, ep_name)
+                blueprint.add_url_rule(
+                    f"/{url_prefix}{adjusted_url}",
+                    ep_name,
+                    view_func,
+                    methods=list(methods),
+                )
+
+        if self.child_crud_class:
+            _register_exposed(
+                self.child_crud_class,
+                f"<int:id>/rcrud/{tab_key}",
+                f"rcrud_{tab_key}",
+                "child_id",
+                child_ctx_fn=_child_ctx,
+            )
+
+        def _make_nested_views(nested_rct):
+            ntk = nested_rct.tab_key
+            n_filter = nested_rct.filter_field
+            n_dc = nested_rct.child_dataclass
+            n_list = f"rcrud_{tab_key}_{ntk}"
+            n_create = f"rcrud_{tab_key}_{ntk}_create"
+            n_edit = f"rcrud_{tab_key}_{ntk}_edit"
+            n_delete = f"rcrud_{tab_key}_{ntk}_delete"
+            n_rct = nested_rct
+
+            def nested_list(id, child_id):
+                ds = n_dc()
+                page, per_page, limit = get_pagination(
+                    getattr(n_rct.child_crud_class, "page_size", None)
+                    if n_rct.child_crud_class
+                    else None
+                )
+                data, total = ds.filter({n_filter: str(child_id)}, limit=limit)
+                pagination = None
+                if total > per_page:
+                    pages = ceil(total / per_page)
+                    pw = 2
+                    pagination = {
+                        "page": page,
+                        "per_page": per_page,
+                        "total": total,
+                        "pages": int(pages),
+                        "start_page": max(1, page - pw),
+                        "end_page": min(int(pages), page + pw),
+                    }
+                fields = [
+                    (k, v)
+                    for k, v in n_rct.get_list_fields(ds, construct)
+                    if k != n_filter
+                ]
+                ctx = _child_ctx(id, child_id)
+                if n_rct.create_url:
+                    _n_list_base = url_for(
+                        f"{parent_view.endpoint}.{n_list}", id=id, child_id=child_id
+                    ).rstrip("/")
+                    n_create_href = f"{_n_list_base}/{n_rct.create_url.lstrip('/')}"
+                else:
+                    n_create_href = url_for(
+                        f"{parent_view.endpoint}.{n_create}", id=id, child_id=child_id
+                    )
+                n_rcrud_list_actions = [
+                    {
+                        "endpoint": f"rcrud_{tab_key}_{ntk}_{a['endpoint']}",
+                        "name": a["name"],
+                        "icon": a["icon"],
+                    }
+                    for a in (
+                        n_rct.child_crud_class.list_actions
+                        if n_rct.child_crud_class
+                        else []
+                    )
+                ]
+                nested_content = render_template(
+                    f"themes/{theme}/crud/_related_child_list.html",
+                    construct=construct,
+                    view=parent_view,
+                    data=data,
+                    fields=fields,
+                    primary_key=ds._primary_key,
+                    pagination=pagination,
+                    outer_id=id,
+                    child_id=child_id,
+                    create_ep=n_create,
+                    edit_ep=n_edit,
+                    delete_ep=n_delete,
+                    list_ep=n_list,
+                    list_actions=n_rcrud_list_actions,
+                    nested_content_target=ctx["nested_content_target"],
+                    create_href=n_create_href,
+                )
+                return render_template(
+                    f"themes/{theme}/crud/related_crud_tab_child_view.html",
+                    **ctx,
+                    nested_active_tab=n_list,
+                    nested_content=nested_content,
+                )
+
+            nested_list.__name__ = n_list
+            blueprint.add_url_rule(
+                f"/<int:id>/rcrud/{tab_key}/<int:child_id>/rcrud/{ntk}/",
+                n_list,
+                nested_list,
+                methods=["GET"],
+            )
+
+            def nested_create(id, child_id):
+                ds = n_dc()
+                errors = None
+                form_data = None
+                status = 200
+                if request.method == "POST":
+                    data = n_rct._process_form_data(ds, child_id, construct)
+                    errors = validate_form_data(
+                        ds,
+                        n_rct.get_form_fields(ds, construct),
+                        data,
+                        row=FormData(data),
+                        skip=(n_filter,),
+                    )
+                    if not errors:
+                        rec = None
+                        try:
+                            rec = ds.create(data)
+                            flash("crud-item-created", "success")
+                        except Exception:
+                            if current_app.debug:
+                                raise
+                            flash("crud-error-creating-item", "danger")
+                        record_url = None
+                        if rec is not None:
+                            record_url = url_for(
+                                f"{parent_view.endpoint}.{n_edit}",
+                                id=id,
+                                child_id=child_id,
+                                gcid=getattr(rec, ds._primary_key),
+                            )
+                        return redirect(
+                            resolve_next(
+                                url_for(
+                                    f"{parent_view.endpoint}.{n_list}",
+                                    id=id,
+                                    child_id=child_id,
+                                ),
+                                record_url,
+                            )
+                        )
+                    form_data = FormData(data)
+                    status = 400
+                child_fields = [
+                    (k, v)
+                    for k, v in n_rct.get_form_fields(ds, construct)
+                    if k != n_filter
+                ]
+                ctx = _child_ctx(id, child_id)
+                form_action = url_for(
+                    f"{parent_view.endpoint}.{n_create}", id=id, child_id=child_id
+                )
+                cancel_url = url_for(
+                    f"{parent_view.endpoint}.{n_list}", id=id, child_id=child_id
+                )
+                n_child_url = (
+                    url_for(
+                        f"{parent_view.endpoint}.{n_list}", id=id, child_id=child_id
+                    ).rstrip("/")
+                    if n_rct.child_crud_class
+                    else None
+                )
+                nested_content = render_template(
+                    f"themes/{theme}/crud/_related_child_form.html",
+                    construct=construct,
+                    view=parent_view,
+                    ds=ds,
+                    form_data=form_data,
+                    child_fields=child_fields,
+                    is_edit=False,
+                    form_action=form_action,
+                    cancel_url=cancel_url,
+                    nested_content_target=ctx["nested_content_target"],
+                    child_url=n_child_url,
+                    edit_actions=[],
+                    errors=errors,
+                )
+                return render_template(
+                    f"themes/{theme}/crud/related_crud_tab_child_view.html",
+                    **ctx,
+                    nested_active_tab=n_list,
+                    nested_content=nested_content,
+                ), status
+
+            nested_create.__name__ = n_create
+            blueprint.add_url_rule(
+                f"/<int:id>/rcrud/{tab_key}/<int:child_id>/rcrud/{ntk}/create",
+                n_create,
+                nested_create,
+                methods=["GET", "POST"],
+            )
+
+            def nested_edit(id, child_id, gcid):
+                ds = n_dc()
+                rec = ds.read(gcid)
+                if rec is None:
+                    flash("crud-error-not-found", "danger")
+                    return redirect(
+                        url_for(
+                            f"{parent_view.endpoint}.{n_list}", id=id, child_id=child_id
+                        )
+                    )
+                errors = None
+                form_data = rec
+                status = 200
+                if request.method == "POST":
+                    data = n_rct._process_form_data(ds, child_id, construct, rec)
+                    errors = validate_form_data(
+                        ds,
+                        n_rct.get_form_fields(ds, construct, rec),
+                        data,
+                        row=FormData(data, rec),
+                        partial=True,
+                        skip=(n_filter,),
+                    )
+                    if not errors:
+                        try:
+                            ds.update(gcid, data)
+                            flash("crud-item-updated", "success")
+                        except Exception:
+                            if current_app.debug:
+                                raise
+                            flash("crud-error-updating-item", "danger")
+                        record_url = url_for(
+                            f"{parent_view.endpoint}.{n_edit}",
+                            id=id,
+                            child_id=child_id,
+                            gcid=gcid,
+                        )
+                        return redirect(
+                            resolve_next(
+                                url_for(
+                                    f"{parent_view.endpoint}.{n_list}",
+                                    id=id,
+                                    child_id=child_id,
+                                ),
+                                record_url,
+                            )
+                        )
+                    form_data = FormData(data, rec)
+                    status = 400
+                child_fields = [
+                    (k, v)
+                    for k, v in n_rct.get_form_fields(ds, construct, rec)
+                    if k != n_filter
+                ]
+                ctx = _child_ctx(id, child_id)
+                form_action = url_for(
+                    f"{parent_view.endpoint}.{n_edit}",
+                    id=id,
+                    child_id=child_id,
+                    gcid=gcid,
+                )
+                cancel_url = url_for(
+                    f"{parent_view.endpoint}.{n_list}", id=id, child_id=child_id
+                )
+                n_child_url = (
+                    url_for(
+                        f"{parent_view.endpoint}.{n_list}", id=id, child_id=child_id
+                    ).rstrip("/")
+                    if n_rct.child_crud_class
+                    else None
+                )
+                n_rcrud_edit_actions = []
+                if n_rct.child_crud_class:
+                    for _ea in n_rct.child_crud_class.edit_actions:
+                        _ep = f"rcrud_{tab_key}_{ntk}_{_ea['endpoint']}"
+                        n_rcrud_edit_actions.append(
+                            {
+                                "href": url_for(
+                                    f"{parent_view.endpoint}.{_ep}",
+                                    id=id,
+                                    child_id=child_id,
+                                    gcid=gcid,
+                                ),
+                                "name": _ea["name"],
+                                "icon": _ea["icon"],
+                            }
+                        )
+                nested_content = render_template(
+                    f"themes/{theme}/crud/_related_child_form.html",
+                    construct=construct,
+                    view=parent_view,
+                    ds=ds,
+                    form_data=form_data,
+                    child_fields=child_fields,
+                    is_edit=True,
+                    form_action=form_action,
+                    cancel_url=cancel_url,
+                    nested_content_target=ctx["nested_content_target"],
+                    child_url=n_child_url,
+                    edit_actions=n_rcrud_edit_actions,
+                    errors=errors,
+                )
+                return render_template(
+                    f"themes/{theme}/crud/related_crud_tab_child_view.html",
+                    **ctx,
+                    nested_active_tab=n_list,
+                    nested_content=nested_content,
+                ), status
+
+            nested_edit.__name__ = n_edit
+            blueprint.add_url_rule(
+                f"/<int:id>/rcrud/{tab_key}/<int:child_id>/rcrud/{ntk}/<int:gcid>/edit",
+                n_edit,
+                nested_edit,
+                methods=["GET", "POST"],
+            )
+
+            def nested_delete(id, child_id, gcid):
+                ds = n_dc()
+                try:
+                    ds.delete(gcid)
+                    flash("crud-item-deleted", "success")
+                except Exception:
+                    if current_app.debug:
+                        raise
+                    flash("crud-error-deleting-item", "danger")
+                return redirect(
+                    resolve_next(
+                        url_for(
+                            f"{parent_view.endpoint}.{n_list}",
+                            id=id,
+                            child_id=child_id,
+                        )
+                    )
+                )
+
+            nested_delete.__name__ = n_delete
+            blueprint.add_url_rule(
+                f"/<int:id>/rcrud/{tab_key}/<int:child_id>/rcrud/{ntk}/<int:gcid>/delete",
+                n_delete,
+                nested_delete,
+                methods=["POST"],
+            )
+
+            if nested_rct.child_crud_class:
+                _register_exposed(
+                    nested_rct.child_crud_class,
+                    f"<int:id>/rcrud/{tab_key}/<int:child_id>/rcrud/{ntk}",
+                    f"rcrud_{tab_key}_{ntk}",
+                    "gcid",
+                )
+
+        for nested_rct in child_nested_tabs:
+            _make_nested_views(nested_rct)
+
+
+class CrudPageBase(PageBase):
+    dataclass: type[DataBase]
+    related_crud_tabs: list = []
+
+    #: Optional template path overrides for the create/edit forms. Set these to
+    #: a template that ``{% extends %}`` the theme default to override individual
+    #: blocks (e.g. ``form_scripts``) without copying the whole template. Leave
+    #: as ``None`` to use the packaged theme template.
+    create_template: str | None = None
+    edit_template: str | None = None
+
+    def _form_template(self, name: str, override: str | None) -> str:
+        """Resolve the template for a CRUD form, honouring per-page overrides."""
+        return override or f"themes/{self.construct.theme}/crud/{name}"
+
+    def form_scripts(self, ds: DataBase, data=None) -> str:
+        """HTML/JS injected after the CRUD create/edit forms.
+
+        Override this to add client-side behaviour (e.g. an Unpoly compiler that
+        toggles field visibility) without overriding the form templates. The
+        returned markup is rendered ``| safe`` inside the ``form_scripts`` block.
+        """
+        return ""
+
+    def get_blueprint(self, construct):
+        blueprint = super().get_blueprint(construct)
+        if self.__class__.related_crud_tabs:
+            self.tab_actions = list(self.__class__.tab_actions)
+            for rct in self.__class__.related_crud_tabs:
+                self.tab_actions.append(rct.get_tab_action())
+                rct._register(self, blueprint, construct)
+        return blueprint
+
+    def default_index(self):
+        return ""
+
+    def _run_view(self, f, *args, **kwargs):
+        return f(self, *args, **kwargs)
+
+    def get_edit_url(self, new_id: int) -> str:
+        """Return the edit URL for a record with *new_id*.
+
+        Works in both standalone and rcrud contexts.  In an rcrud context the
+        parent URL args are read from the current request automatically, so the
+        only argument needed is the ID of the record to edit.
+        """
+        ctx = getattr(self, "_rcrud_context", None)
+        if ctx is None:
+            return url_for(f"{self.endpoint}.get", id=new_id)
+        parent_args = dict(request.view_args)
+        parent_args[ctx["child_id_kwarg"]] = new_id
+        return url_for(
+            f"{ctx['parent_endpoint']}.{ctx['ep_prefix']}_edit", **parent_args
+        )
+
+    def get_list_url(self) -> str:
+        """Return the list URL for this CRUD page.
+
+        Works in both standalone and rcrud contexts.  In an rcrud context the
+        parent URL args are read from the current request automatically.
+        """
+        ctx = getattr(self, "_rcrud_context", None)
+        if ctx is None:
+            return url_for(f"{self.endpoint}.index")
+        return url_for(
+            f"{ctx['parent_endpoint']}.{ctx['ep_prefix']}", **request.view_args
+        )
+
+    def get_success_url(self, action, rec=None):
+        """Where to redirect once a CRUD form action has been handled.
+
+        ``action`` is ``"create"``, ``"update"`` or ``"delete"``; ``rec`` is
+        the affected record — ``None`` after a delete or when the action
+        failed (the redirect still happens, with the outcome flashed).
+
+        The default honors the ``next`` request parameter — including the
+        ``:record`` sentinel (see ``navigation.py``) — and falls back to the
+        list view, preserving the historical behavior when no ``next`` is
+        present. Override for page-level policies; e.g. to land on the new
+        record after every create::
+
+            def get_success_url(self, action, rec=None):
+                if action == "create" and rec is not None:
+                    return self.get_edit_url(
+                        getattr(rec, self.dataclass._primary_key)
+                    )
+                return super().get_success_url(action, rec)
+
+        Applies to the page's own create/edit/delete views. RCRUD tab views
+        honor ``next``/``:record`` directly and keep their tab-list default.
+        """
+        record_url = None
+        if rec is not None:
+            record_url = self.get_edit_url(
+                getattr(rec, self.dataclass._primary_key)
+            )
+        return resolve_next(self.get_list_url(), record_url)
+
+    def get_list_fields(self, ds: DataBase) -> list[tuple[str, schema.SchemaField]]:
+        """
+        Return a list of (name, field_info) tuples to be shown in the list view.
+        Override this to dynamically customize the list columns.
+        """
+        return [
+            (k, v)
+            for k, v in ds._schema.items()
+            if not isinstance(v, (schema.PK, schema.List)) and v.visible_list
+        ]
+
+    def get_form_fields(
+        self, ds: DataBase, data=None
+    ) -> list[tuple[str, schema.SchemaField]]:
+        """
+        Return a list of (name, field_info) tuples to be shown in the form (create/edit).
+        Override this to dynamically customize the form fields based on the record data.
+        """
+        return [
+            (k, v)
+            for k, v in ds._schema.items()
+            if not isinstance(v, schema.PK) and v.visible_form
+        ]
+
+    @expose("/", methods=["GET"])
+    def index(self):
+        ds = self.dataclass()
+
+        page, per_page, limit = get_pagination(getattr(self, "page_size", None))
+
+        reserved_args = ["page", "query", "advanced_filter"]
+        # Only fields rendered in the list view (and not skipfilter) may be
+        # filtered on; anything else in the query string is a probe on
+        # columns the UI never exposes (e.g. password_hash) and is ignored.
+        filterable_fields = {
+            fld for fld, ftype in self.get_list_fields(ds) if not ftype.skipfilter
+        }
+        filter_params = {
+            k: v
+            for k, v in request.args.items()
+            if k not in reserved_args and k in filterable_fields and v
+        }
+
+        total = 0
+        data = []
+        if "query" in request.args and request.args["query"]:
+            data, total = ds.search(request.args["query"], limit=limit)
+        elif filter_params:
+            data, total = ds.filter(filter_params, limit=limit)
+        else:
+            data, total = ds.search(limit=limit)
+
+        pagination = None
+        if total > per_page:
+            pages = ceil(total / per_page)
+            page_window = 2
+            start_page = max(1, page - page_window)
+            end_page = min(pages, page + page_window)
+            pagination = {
+                "page": page,
+                "per_page": per_page,
+                "total": total,
+                "pages": int(pages),
+                "start_page": start_page,
+                "end_page": int(end_page),
+            }
+
+        return render_template(
+            f"themes/{self.construct.theme}/crud/listindex.html",
+            construct=self.construct,
+            view=self,
+            data=data,
+            pagination=pagination,
+            fields=self.get_list_fields(ds),
+            primary_key=ds._primary_key,
+            list_actions=self.list_actions,
+        )
+
+    @expose("/<int:id>")
+    def get(self, id):
+        ds = self.dataclass()
+        data = ds.read(id)
+        return render_template(
+            self._form_template("edit.html", self.edit_template),
+            construct=self.construct,
+            view=self,
+            data=data,
+            ds=ds,
+            fields=self.get_form_fields(ds, data),
+            primary_key=ds._primary_key,
+            tab_actions=self.tab_actions,
+            edit_actions=self.edit_actions,
+            form_scripts=self.form_scripts(ds, data),
+        )
+
+    def render_tab(self, id, active_tab, **kwargs):
+        ctx = getattr(self, "_rcrud_context", None)
+        if ctx and ctx.get("_child_ctx"):
+            child_ctx = ctx["_child_ctx"](ctx["parent_id"], id)
+            return render_template(
+                f"themes/{self.construct.theme}/crud/related_crud_tab_child_view.html",
+                **child_ctx,
+                nested_active_tab=f"{ctx['ep_prefix']}_{active_tab}",
+                nested_content=kwargs.get("tab_content", ""),
+            )
+        return render_template(
+            f"themes/{self.construct.theme}/crud/tab_view.html",
+            construct=self.construct,
+            view=self,
+            id=id,
+            active_tab=active_tab,
+            tab_actions=self.tab_actions,
+            **kwargs,
+        )
+
+    @expose("/search/<field_name>")
+    def search_related(self, field_name):
+        ds = self.dataclass()
+        query = request.args.get("q")
+        field_type = ds._schema[field_name]
+        if not isinstance(field_type, schema.Related):
+            return "Not a related field", 400
+
+        related_ds = field_type.related_class()
+        results, _ = related_ds.search(query, limit=(0, RELATED_SEARCH_LIMIT))
+
+        return render_template(
+            f"themes/{self.construct.theme}/crud/_related_options.html",
+            results=results,
+            field_type=field_type,
+            field_name=field_name,
+        )
+
+    @expose("/search-many/<field_name>")
+    def search_many_related(self, field_name):
+        ds = self.dataclass()
+        query = request.args.get("q")
+        field_type = ds._schema[field_name]
+        if not isinstance(field_type, schema.ManyRelated):
+            return "Not a many-related field", 400
+
+        related_ds = field_type.related_class()
+        search_kwargs = {"limit": (0, RELATED_SEARCH_LIMIT)}
+        if field_type.search_fields:
+            search_kwargs["fields"] = field_type.search_fields
+        results, _ = related_ds.search(query, **search_kwargs)
+
+        # The quick-add row is suppressed on an exact quick_field match —
+        # the same rule the save-time dedupe applies, so the dropdown never
+        # offers to create a record that would only be linked.
+        quick_exact = False
+        if field_type.create == "quick" and query:
+            quick_field = field_type.resolve_quick_field()
+            quick_exact = any(
+                str(getattr(result, quick_field, "")) == query for result in results
+            )
+
+        return render_template(
+            f"themes/{self.construct.theme}/crud/_many_related_options.html",
+            construct=self.construct,
+            results=results,
+            field_type=field_type,
+            field_name=field_name,
+            query=query,
+            quick_exact=quick_exact,
+        )
+
+    @expose("/create", methods=["GET", "POST"])
+    def create(self):
+        ds = self.dataclass()
+        if request.method == "POST":
+            raw_data = request.form.to_dict()
+            form_fields = {k: v for k, v in self.get_form_fields(ds)}
+            data = {}
+            # Only take fields that are in the form_fields and are not readonly/hidden
+            for field, type_info in form_fields.items():
+                if type_info.readonly or not type_info.visible_form:
+                    continue
+                if field in raw_data:
+                    data[field] = raw_data[field]
+                elif type_info.default is not None:
+                    # Apply the schema default when the field was omitted entirely
+                    # (e.g. JS-hidden or rendered without an input), so defaults
+                    # hold even when the browser submits nothing for the field.
+                    data[field] = type_info.default
+
+            for field, type_info in ds._schema.items():
+                if (
+                    field not in form_fields
+                    or type_info.readonly
+                    or not type_info.visible_form
+                ):
+                    continue
+
+                if hasattr(type_info, "field_type"):
+                    if type_info.field_type == "bool":
+                        if field in raw_data:
+                            data[field] = True
+                        else:
+                            data[field] = False
+                    elif type_info.field_type == "set":
+                        data[field] = set(request.form.getlist(field))
+                    elif isinstance(type_info, schema.ManyRelated):
+                        pks, staged = _parse_many_related_field(
+                            field, type_info, request.form
+                        )
+                        data[field] = pks
+                        if staged:
+                            data.setdefault("many_related_new", {})[field] = staged
+                    elif isinstance(type_info, schema.List):
+                        indices = set()
+                        prefix = f"{field}-new-"
+                        for key in request.form:
+                            if key.startswith(prefix):
+                                try:
+                                    index_str = key[len(prefix) :].split("-", 1)[0]
+                                    indices.add(int(index_str))
+                                except (ValueError, IndexError):
+                                    continue
+
+                        new_items = []
+                        list_cls_schema = type_info.list_class._schema
+                        for i in sorted(list(indices)):
+                            item_prefix = f"{prefix}{i}-"
+                            new_item = {}
+                            has_data = False
+                            for sub_field, sub_type in list_cls_schema.items():
+                                if (
+                                    sub_type.field_type == "pk"
+                                    or sub_type.readonly
+                                    or not sub_type.visible_form
+                                ):
+                                    continue
+
+                                form_key = item_prefix + sub_field
+                                if sub_type.field_type == "bool":
+                                    if form_key in request.form:
+                                        new_item[sub_field] = True
+                                        has_data = True
+                                    else:
+                                        new_item[sub_field] = False
+                                elif sub_type.field_type == "set":
+                                    values = request.form.getlist(form_key)
+                                    if values:
+                                        new_item[sub_field] = set(values)
+                                        has_data = True
+                                elif (
+                                    form_key in request.form and request.form[form_key]
+                                ):
+                                    new_item[sub_field] = request.form[form_key]
+                                    has_data = True
+                                elif sub_type.default is not None:
+                                    # Fill the default but don't let it alone
+                                    # materialise a row: has_data must come from a
+                                    # real submitted value in this row.
+                                    new_item[sub_field] = sub_type.default
+
+                            if has_data:
+                                new_items.append(new_item)
+
+                        if new_items:
+                            if "list_items" not in data:
+                                data["list_items"] = {}
+                            if field not in data["list_items"]:
+                                data["list_items"][field] = {}
+                            data["list_items"][field]["new"] = new_items
+            errors = validate_form_data(ds, form_fields, data, row=FormData(data))
+            if errors:
+                return render_template(
+                    self._form_template("create.html", self.create_template),
+                    construct=self.construct,
+                    view=self,
+                    data=FormData(data),
+                    ds=ds,
+                    errors=errors,
+                    fields=self.get_form_fields(ds),
+                    primary_key=ds._primary_key,
+                    form_scripts=self.form_scripts(ds, FormData(data)),
+                ), 400
+
+            rec = None
+            try:
+                rec = ds.create(data)
+                flash("crud-item-created", "success")
+            except Exception:
+                if current_app.debug:
+                    raise
+                flash("crud-error-creating-item", "danger")
+            return redirect(self.get_success_url("create", rec))
+
+        return render_template(
+            self._form_template("create.html", self.create_template),
+            construct=self.construct,
+            view=self,
+            data={},
+            ds=ds,
+            fields=self.get_form_fields(ds),
+            primary_key=ds._primary_key,
+            form_scripts=self.form_scripts(ds, None),
+        )
+
+    @expose("/<int:id>", methods=["POST"])
+    def patch(self, id):
+        ds = self.dataclass()
+        rec = ds.read(id)
+        raw_data = request.form.to_dict()
+        form_fields = {k: v for k, v in self.get_form_fields(ds, rec)}
+        data = {}
+        # Only take fields that are in the form_fields and are not readonly/hidden
+        for field, type_info in form_fields.items():
+            if type_info.readonly or not type_info.visible_form:
+                continue
+            if field in raw_data:
+                data[field] = raw_data[field]
+
+        for field, type_info in ds._schema.items():
+            if (
+                field not in form_fields
+                or type_info.readonly
+                or not type_info.visible_form
+            ):
+                continue
+
+            if type_info.secret:
+                change_flag = f"{field}-change"
+                if change_flag not in request.form:
+                    if field in data:
+                        del data[field]
+            if hasattr(type_info, "field_type"):
+                if type_info.field_type == "bool":
+                    if field in raw_data:
+                        data[field] = True
+                    else:
+                        data[field] = False
+                elif type_info.field_type == "set":
+                    data[field] = set(request.form.getlist(field))
+                elif isinstance(type_info, schema.ManyRelated):
+                    pks, staged = _parse_many_related_field(
+                        field, type_info, request.form
+                    )
+                    data[field] = pks
+                    if staged:
+                        data.setdefault("many_related_new", {})[field] = staged
+                elif isinstance(type_info, schema.List):
+                    if "list_items" not in data:
+                        data["list_items"] = {}
+                    if field not in data["list_items"]:
+                        data["list_items"][field] = {}
+
+                    # Deletes
+                    delete_ids = request.form.getlist(f"{field}-delete")
+                    if delete_ids:
+                        data["list_items"][field]["delete"] = delete_ids
+
+                    # Updates
+                    update_items = []
+                    item_ids = request.form.getlist(f"{field}-id")
+                    list_cls_schema = type_info.list_class._schema
+
+                    for item_id in item_ids:
+                        if item_id in delete_ids:
+                            continue
+
+                        item_data = {"id": item_id}
+                        prefix = f"{field}-{item_id}-"
+                        for sub_field, sub_type in list_cls_schema.items():
+                            if (
+                                sub_type.field_type == "pk"
+                                or sub_type.readonly
+                                or not sub_type.visible_form
+                            ):
+                                continue
+
+                            form_key = prefix + sub_field
+                            if sub_type.field_type == "bool":
+                                item_data[sub_field] = form_key in request.form
+                            elif sub_type.field_type == "set":
+                                item_data[sub_field] = set(
+                                    request.form.getlist(form_key)
+                                )
+                            elif form_key in request.form:
+                                item_data[sub_field] = request.form[form_key]
+                        update_items.append(item_data)
+
+                    if update_items:
+                        data["list_items"][field]["update"] = update_items
+
+                    # New items
+                    indices = set()
+                    prefix = f"{field}-new-"
+                    for key in request.form:
+                        if key.startswith(prefix):
+                            try:
+                                index_str = key[len(prefix) :].split("-", 1)[0]
+                                indices.add(int(index_str))
+                            except (ValueError, IndexError):
+                                continue
+
+                    new_items = []
+                    for i in sorted(list(indices)):
+                        item_prefix = f"{prefix}{i}-"
+                        new_item = {}
+                        has_data = False
+                        for sub_field, sub_type in list_cls_schema.items():
+                            if (
+                                sub_type.field_type == "pk"
+                                or sub_type.readonly
+                                or not sub_type.visible_form
+                            ):
+                                continue
+
+                            form_key = item_prefix + sub_field
+                            if sub_type.field_type == "bool":
+                                if form_key in request.form:
+                                    new_item[sub_field] = True
+                                    has_data = True
+                                else:
+                                    new_item[sub_field] = False
+                            elif sub_type.field_type == "set":
+                                values = request.form.getlist(form_key)
+                                if values:
+                                    new_item[sub_field] = set(values)
+                                    has_data = True
+                            elif form_key in request.form and request.form[form_key]:
+                                new_item[sub_field] = request.form[form_key]
+                                has_data = True
+
+                        if has_data:
+                            new_items.append(new_item)
+
+                    if new_items:
+                        if "new" not in data["list_items"][field]:
+                            data["list_items"][field]["new"] = []
+                        data["list_items"][field]["new"].extend(new_items)
+
+        errors = validate_form_data(
+            ds, form_fields, data, row=FormData(data, rec), partial=True
+        )
+        if errors:
+            return render_template(
+                self._form_template("edit.html", self.edit_template),
+                construct=self.construct,
+                view=self,
+                data=FormData(data, rec),
+                ds=ds,
+                errors=errors,
+                fields=self.get_form_fields(ds, rec),
+                primary_key=ds._primary_key,
+                tab_actions=self.tab_actions,
+                edit_actions=self.edit_actions,
+                form_scripts=self.form_scripts(ds, FormData(data, rec)),
+            ), 400
+
+        try:
+            ds.update(id, data)
+            flash("crud-item-updated", "success")
+        except Exception:
+            if current_app.debug:
+                raise
+            flash("crud-error-updating-item", "danger")
+        return redirect(self.get_success_url("update", rec))
+
+    @expose("/<int:id>/delete", methods=["POST"])
+    def delete(self, id):
+        ds = self.dataclass()
+        try:
+            ds.delete(id)
+            flash("crud-item-deleted", "success")
+        except Exception:
+            if current_app.debug:
+                raise
+            flash("crud-error-deleting-item", "danger")
+        return redirect(self.get_success_url("delete"))