Support HEAD in the API, and include the last-modified header

[xxxserxxx]

Before submitting this feature request I have
COMPLETE AND FILL THESE OUT

• Reviewed the documentation and verified that my feature request isn't already a feature.
• Reviewed the existing feature requests and my feature has not been requested.
• Checked the tasks taged issues and verified my feature is not covered

Please Describe The Problem To Be Solved
Clients would be improved by adding an efficient way of checking the server for changes.

Currently, the only way to test for changes is to download whatever data set (in my case, shopping-lists) and comparing the data. A common API mechanism is for API servers to support the HTTP HEAD request and include a last-modified timestamp in the header. The last-modified header is independent of HEAD, but together they provide an efficient way for clients to test whether the data has changed since the last time they looked.

(Optional): Suggest A Solution
The difficulty in implementing is dominated by whether or not Mealie timestamps changes to (e.g.) shopping-lists, either at the top (list-of-lists) level, or at the list level. Either would be an improvement over having to re-fetch all of the data to test for changes.

Additional Information
Again, I have no experience with Python.

[michael-genson]

While not exactly what you're asking for, I submitted a PR to extend the Apprise functionality to support programmatic use, particularly for shopping lists but for other object types as well.

Based on your request it sounds like you're trying to sync the Mealie shopping list with an external shopping list, which this should enable.

[xxxserxxx]

Thanks for the heads-up. Work to improve programmatic interaction with Mealie are great.

In my particular use case, I'm syncing with a mobile app; there's no server (except for the Mealie server), so call-backs aren't an option. My app design is to sync when the user performs some action on the app, and then resolve conflicts. Currently (without a timestamp header), this means pulling the entire contents of the lists, so I'll continue to look out for proper modification timestamps.

I could use your patch if I had a server component, and hooked through Google and Apple's push notification system; a plug-in or extension to Mealie would be the way to go for that, and I may do that eventually.

In any case, thanks again for the heads up; this may be useful to me in the future.

[michael-genson]

I looked into this a bit more and it looks like Mealie isn't storing timestamps for shopping lists, so we would need to extend the DB to store those.

Relevant code snippit:

class ShoppingList(SqlAlchemyBase, BaseMixins):
    __tablename__ = "shopping_lists"
    id = Column(GUID, primary_key=True, default=GUID.generate)

    group_id = Column(GUID, ForeignKey("groups.id"), nullable=False, index=True)
    group = orm.relationship("Group", back_populates="shopping_lists")

    name = Column(String)
    list_items = orm.relationship(
        ShoppingListItem,
        cascade="all, delete, delete-orphan",
        order_by="ShoppingListItem.position",
        collection_class=ordering_list("position"),
    )

    recipe_references = orm.relationship(ShoppingListRecipeReference, cascade="all, delete, delete-orphan")

    class Config:
        exclude = {"id", "list_items"}

    @auto_init()
    def __init__(self, **_) -> None:
        pass

Implementing the HEAD route is pretty straightforward, but without the last-modified timestamp it probably wouldn't be of much use. The only object type I see with a timestamp is recipes.

[xxxserxxx]

Off, yes; that seems like a bit of work, although maybe hooking it into the ORM would simplify the implementation. In any case, thanks for looking into that.

[hay-kot]

@michael-genson FYI All models derive from the base model, so they should all have a created_at and updated_at field, they may not be exposed schema side, but the should be there and the update_at should be automatically set.

# mealie/db/models/_model_base.py
from datetime import datetime

from sqlalchemy import Column, DateTime, Integer
from sqlalchemy.ext.declarative import as_declarative
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm.session import Session


@as_declarative()
class Base:
    id = Column(Integer, primary_key=True)
    created_at = Column(DateTime, default=datetime.now)
    update_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)


class BaseMixins:
    """
    `self.update` method which directly passing arugments to the `__init__`
    `cls.get_ref` method which will return the object from the database or none. Useful for many-to-many relationships.
    """

    def update(self, *args, **kwarg):
        self.__init__(*args, **kwarg)

    @classmethod
    def get_ref(cls, match_value: str, match_attr: str = None, session: Session = None):
        match_attr = match_attr or cls.Config.get_attr  # type: ignore

        if match_value is None or session is None:
            return None

        eff_ref = getattr(cls, match_attr)

        return session.query(cls).filter(eff_ref == match_value).one_or_none()


SqlAlchemyBase = declarative_base(cls=Base, constructor=None)

[michael-genson]

Oh duh, makes sense. I can work with that!

[michael-genson]

I submitted PR #1379 to implement this. There are still some limitations, but hopefully this can give you something to work with.