initial commit

database.py

@@ -0,0 +1,85 @@
+"""Bookmark Manager — Folder repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkDatabase:
+    """Thin repository wrapper for Folder persistence in Bookmark Manager."""
+
+    TABLE = "folders"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("BookmarkDatabase bound to %s", db)
+
+    def insert(self, last_visited: Any, folder_id: Any, **kwargs: Any) -> str:
+        """Persist a new Folder row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "last_visited": last_visited,
+            "folder_id": folder_id,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Folder row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Folder row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Folder row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query folders: %d/%d", len(rows), total)
+        return rows, total
+
+    def tag_by_title(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch folders filtered by *title*."""
+        rows, _ = self.query({"title": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["last_visited"], rec.get("folder_id"),
+                **{k: v for k, v in rec.items() if k not in ("last_visited", "folder_id")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert folders: %d rows", len(ids))
+        return ids

encoder.py

@@ -0,0 +1,57 @@
+"""Bookmark Manager — encoder for collection payloads."""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkEncoder:
+    """Encoder for Bookmark Manager collection payloads."""
+
+    _DATE_FIELDS = ("saved_at")
+
+    @classmethod
+    def loads(cls, raw: str) -> Dict[str, Any]:
+        """Deserialise a JSON collection payload."""
+        data = json.loads(raw)
+        return cls._coerce(data)
+
+    @classmethod
+    def dumps(cls, record: Dict[str, Any]) -> str:
+        """Serialise a collection record to JSON."""
+        return json.dumps(record, default=str)
+
+    @classmethod
+    def _coerce(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Cast known date fields from ISO strings to datetime objects."""
+        out: Dict[str, Any] = {}
+        for k, v in data.items():
+            if k in cls._DATE_FIELDS and isinstance(v, str):
+                try:
+                    out[k] = datetime.fromisoformat(v)
+                except ValueError:
+                    out[k] = v
+            else:
+                out[k] = v
+        return out
+
+
+def parse_collections(payload: str) -> List[Dict[str, Any]]:
+    """Parse a JSON array of Collection payloads."""
+    raw = json.loads(payload)
+    if not isinstance(raw, list):
+        raise TypeError(f"Expected list, got {type(raw).__name__}")
+    return [BookmarkEncoder._coerce(item) for item in raw]
+
+
+def save_collection_to_str(
+    record: Dict[str, Any], indent: Optional[int] = None
+) -> str:
+    """Convenience wrapper — serialise a Collection to a JSON string."""
+    if indent is None:
+        return BookmarkEncoder.dumps(record)
+    return json.dumps(record, indent=indent, default=str)

handler.py

@@ -0,0 +1,85 @@
+"""Bookmark Manager — Snapshot repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkHandler:
+    """Thin repository wrapper for Snapshot persistence in Bookmark Manager."""
+
+    TABLE = "snapshots"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("BookmarkHandler bound to %s", db)
+
+    def insert(self, title: Any, url: Any, **kwargs: Any) -> str:
+        """Persist a new Snapshot row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "title": title,
+            "url": url,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Snapshot row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Snapshot row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Snapshot row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query snapshots: %d/%d", len(rows), total)
+        return rows, total
+
+    def archive_by_folder_id(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch snapshots filtered by *folder_id*."""
+        rows, _ = self.query({"folder_id": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["title"], rec.get("url"),
+                **{k: v for k, v in rec.items() if k not in ("title", "url")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert snapshots: %d rows", len(ids))
+        return ids

main.py

@@ -0,0 +1,57 @@
+"""Bookmark Manager — main for tag payloads."""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkMain:
+    """Main for Bookmark Manager tag payloads."""
+
+    _DATE_FIELDS = ("saved_at")
+
+    @classmethod
+    def loads(cls, raw: str) -> Dict[str, Any]:
+        """Deserialise a JSON tag payload."""
+        data = json.loads(raw)
+        return cls._coerce(data)
+
+    @classmethod
+    def dumps(cls, record: Dict[str, Any]) -> str:
+        """Serialise a tag record to JSON."""
+        return json.dumps(record, default=str)
+
+    @classmethod
+    def _coerce(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Cast known date fields from ISO strings to datetime objects."""
+        out: Dict[str, Any] = {}
+        for k, v in data.items():
+            if k in cls._DATE_FIELDS and isinstance(v, str):
+                try:
+                    out[k] = datetime.fromisoformat(v)
+                except ValueError:
+                    out[k] = v
+            else:
+                out[k] = v
+        return out
+
+
+def parse_tags(payload: str) -> List[Dict[str, Any]]:
+    """Parse a JSON array of Tag payloads."""
+    raw = json.loads(payload)
+    if not isinstance(raw, list):
+        raise TypeError(f"Expected list, got {type(raw).__name__}")
+    return [BookmarkMain._coerce(item) for item in raw]
+
+
+def organise_tag_to_str(
+    record: Dict[str, Any], indent: Optional[int] = None
+) -> str:
+    """Convenience wrapper — serialise a Tag to a JSON string."""
+    if indent is None:
+        return BookmarkMain.dumps(record)
+    return json.dumps(record, indent=indent, default=str)

models.py

@@ -0,0 +1,85 @@
+"""Bookmark Manager — Collection repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkModels:
+    """Thin repository wrapper for Collection persistence in Bookmark Manager."""
+
+    TABLE = "collections"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("BookmarkModels bound to %s", db)
+
+    def insert(self, title: Any, last_visited: Any, **kwargs: Any) -> str:
+        """Persist a new Collection row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "title": title,
+            "last_visited": last_visited,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Collection row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Collection row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Collection row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query collections: %d/%d", len(rows), total)
+        return rows, total
+
+    def archive_by_tags(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch collections filtered by *tags*."""
+        rows, _ = self.query({"tags": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["title"], rec.get("last_visited"),
+                **{k: v for k, v in rec.items() if k not in ("title", "last_visited")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert collections: %d rows", len(ids))
+        return ids

processor.py

@@ -0,0 +1,85 @@
+"""Bookmark Manager — Snapshot repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkProcessor:
+    """Thin repository wrapper for Snapshot persistence in Bookmark Manager."""
+
+    TABLE = "snapshots"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("BookmarkProcessor bound to %s", db)
+
+    def insert(self, title: Any, saved_at: Any, **kwargs: Any) -> str:
+        """Persist a new Snapshot row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "title": title,
+            "saved_at": saved_at,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Snapshot row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Snapshot row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Snapshot row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query snapshots: %d/%d", len(rows), total)
+        return rows, total
+
+    def export_by_url(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch snapshots filtered by *url*."""
+        rows, _ = self.query({"url": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["title"], rec.get("saved_at"),
+                **{k: v for k, v in rec.items() if k not in ("title", "saved_at")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert snapshots: %d rows", len(ids))
+        return ids

repository.py

@@ -0,0 +1,85 @@
+"""Bookmark Manager — Collection repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkRepository:
+    """Thin repository wrapper for Collection persistence in Bookmark Manager."""
+
+    TABLE = "collections"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("BookmarkRepository bound to %s", db)
+
+    def insert(self, tags: Any, url: Any, **kwargs: Any) -> str:
+        """Persist a new Collection row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "tags": tags,
+            "url": url,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Collection row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Collection row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Collection row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query collections: %d/%d", len(rows), total)
+        return rows, total
+
+    def tag_by_last_visited(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch collections filtered by *last_visited*."""
+        rows, _ = self.query({"last_visited": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["tags"], rec.get("url"),
+                **{k: v for k, v in rec.items() if k not in ("tags", "url")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert collections: %d rows", len(ids))
+        return ids

service.py

@@ -0,0 +1,98 @@
+MONGODB_URL = """
+$ANSIBLE_VAULT;1.1;AES256
+63356331666163353534306565626562306137303836323762623934626434383339343638643465
+6534663162356137643965623036636235333032633131380a373634353963386135313532656266
+66393631616564353865366131613861393038626133626438366532373430636431303166663533
+3533346231376430340a656465656337323932643830373537366439323439373933353261363731
+35653234323965623938356566613263383964356137366536306336633936343761353130323733
+34313638633964383137373865653738373434396263643637303638623561363862373166373134
+30663862653639326338303433623931616363643063666134363437343665316636323536653566
+63353238303534323561626235643464303763366565316637343062623063343437303566643730
+39393530653235396338663662653736363365653939316465323132313038343938
+"""
+
+"""Bookmark Manager — Tag repository."""
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BookmarkService:
+    """Thin repository wrapper for Tag persistence in Bookmark Manager."""
+
+    TABLE = "tags"
+
+    def __init__(self, db: Any) -> None:
+        self._db = db
+        logger.debug("BookmarkService bound to %s", db)
+
+    def insert(self, tags: Any, last_visited: Any, **kwargs: Any) -> str:
+        """Persist a new Tag row and return its generated ID."""
+        rec_id = str(uuid.uuid4())
+        row: Dict[str, Any] = {
+            "id":         rec_id,
+            "tags": tags,
+            "last_visited": last_visited,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            **kwargs,
+        }
+        self._db.insert(self.TABLE, row)
+        return rec_id
+
+    def fetch(self, rec_id: str) -> Optional[Dict[str, Any]]:
+        """Return the Tag row for *rec_id*, or None."""
+        return self._db.fetch(self.TABLE, rec_id)
+
+    def update(self, rec_id: str, **fields: Any) -> bool:
+        """Patch *fields* on an existing Tag row."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        fields["updated_at"] = datetime.now(timezone.utc).isoformat()
+        self._db.update(self.TABLE, rec_id, fields)
+        return True
+
+    def delete(self, rec_id: str) -> bool:
+        """Hard-delete a Tag row; returns False if not found."""
+        if not self._db.exists(self.TABLE, rec_id):
+            return False
+        self._db.delete(self.TABLE, rec_id)
+        return True
+
+    def query(
+        self,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        limit:    int = 100,
+        offset:   int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """Return (rows, total_count) for the given *filters*."""
+        rows  = self._db.select(self.TABLE, filters or {}, limit, offset)
+        total = self._db.count(self.TABLE, filters or {})
+        logger.debug("query tags: %d/%d", len(rows), total)
+        return rows, total
+
+    def organise_by_url(
+        self, value: Any, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Fetch tags filtered by *url*."""
+        rows, _ = self.query({"url": value}, limit=limit)
+        return rows
+
+    def bulk_insert(
+        self, records: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Insert *records* in bulk and return their generated IDs."""
+        ids: List[str] = []
+        for rec in records:
+            rec_id = self.insert(
+                rec["tags"], rec.get("last_visited"),
+                **{k: v for k, v in rec.items() if k not in ("tags", "last_visited")}
+            )
+            ids.append(rec_id)
+        logger.info("bulk_insert tags: %d rows", len(ids))
+        return ids