Bump version

* Support pytest for running tests

* Support extracting description from meta og:description property

* Revert changes to TOC

* Add test

---------

Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@gmail.com>

.dockerignore

@@ -1,34 +1,22 @@
-# Remove project files, data, tmp files, build files
-/.env
-/.idea
-/data
-/node_modules
-/tmp
-/docs
-/static
-/scripts
-/build
-/out
-/.git
-/.devcontainer
+# Ignore everything
+*
 
-/.dockerignore
-/.gitignore
-/.gitattributes
-/Dockerfile
-/docker-compose.yml
-/*.sh
-/*.iml
-/*.patch
-/*.md
-/*.js
-/*.log
-/*.pid
+# Include files required for build or at runtime
+!/bookmarks
+!/siteroot
 
-# Whitelist files needed in build or prod image
-!/rollup.config.js
-!/bootstrap.sh
 !/background-tasks-wrapper.sh
+!/bootstrap.sh
+!/LICENSE.txt
+!/manage.py
+!/package.json
+!/package-lock.json
+!/requirements.prod.txt
+!/requirements.txt
+!/rollup.config.js
+!/supervisord.conf
+!/uwsgi.ini
+!/version.txt
 
-# Remove development settings
+ # Remove dev settings
 /siteroot/settings/dev.py

CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+## v1.23.0 (24/11/2023)
+
+### What's Changed
+* Add Alpine based Docker image (experimental) by @sissbruecker in https://github.com/sissbruecker/linkding/pull/570
+* Add backup CLI command by @sissbruecker in https://github.com/sissbruecker/linkding/pull/571
+* Update browser extension links by @OPerepadia in https://github.com/sissbruecker/linkding/pull/574
+* Include archived bookmarks in export by @sissbruecker in https://github.com/sissbruecker/linkding/pull/579
+
+### New Contributors
+* @OPerepadia made their first contribution in https://github.com/sissbruecker/linkding/pull/574
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.3...v1.23.0
+
+---
+
+## v1.22.3 (04/11/2023)
+
+### What's Changed
+* Fix RSS feed not handling None values  by @vitormarcal in https://github.com/sissbruecker/linkding/pull/569
+* Bump django from 4.1.10 to 4.1.13 by @dependabot in https://github.com/sissbruecker/linkding/pull/567
+
+### New Contributors
+* @vitormarcal made their first contribution in https://github.com/sissbruecker/linkding/pull/569
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.2...v1.22.3
+
+---
+
+## v1.22.2 (27/10/2023)
+
+### What's Changed
+* Fix search options not opening on iOS by @sissbruecker in https://github.com/sissbruecker/linkding/pull/549
+* Bump urllib3 from 1.26.11 to 1.26.17 by @dependabot in https://github.com/sissbruecker/linkding/pull/542
+* Add iOS shortcut to community section by @andrewdolphin in https://github.com/sissbruecker/linkding/pull/550
+* Disable editing of search preferences in user admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/555
+* Add feed2linkding to community section by @Strubbl in https://github.com/sissbruecker/linkding/pull/544
+* Sanitize RSS feed to remove control characters by @sissbruecker in https://github.com/sissbruecker/linkding/pull/565
+* Bump urllib3 from 1.26.17 to 1.26.18 by @dependabot in https://github.com/sissbruecker/linkding/pull/560
+
+### New Contributors
+* @andrewdolphin made their first contribution in https://github.com/sissbruecker/linkding/pull/550
+* @Strubbl made their first contribution in https://github.com/sissbruecker/linkding/pull/544
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.1...v1.22.2
+
+---
+
+## v1.22.1 (06/10/2023)
+
+### What's Changed
+* Fix memory leak with SQLite by @sissbruecker in https://github.com/sissbruecker/linkding/pull/548
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.0...v1.22.1
+
+---
+
 ## v1.22.0 (01/10/2023)
 
 ### What's Changed

README.md

@@ -9,11 +9,11 @@
 ## Overview
 - [Introduction](#introduction)
 - [Installation](#installation)
-    - [Using Docker](#using-docker)
-    - [Using Docker Compose](#using-docker-compose)
-    - [User Setup](#user-setup)
-    - [Reverse Proxy Setup](#reverse-proxy-setup)
-    - [Managed Hosting Options](#managed-hosting-options)
+  - [Using Docker](#using-docker)
+  - [Using Docker Compose](#using-docker-compose)
+  - [User Setup](#user-setup)
+  - [Reverse Proxy Setup](#reverse-proxy-setup)
+  - [Managed Hosting Options](#managed-hosting-options)
 - [Documentation](#documentation)
 - [Browser Extension](#browser-extension)
 - [Community](#community)
@@ -40,7 +40,7 @@ The name comes from:
 - Automatically provides titles, descriptions and icons of bookmarked websites
 - Automatically creates snapshots of bookmarked websites on [the Internet Archive Wayback Machine](https://archive.org/web/)
 - Import and export bookmarks in Netscape HTML format
-- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
+- Extensions for [Firefox](https://addons.mozilla.org/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
 - Light and dark themes
 - REST API for developing 3rd party apps
 - Admin panel for user self-service and raw data access
@@ -58,9 +58,27 @@ The name comes from:
 linkding is designed to be run with container solutions like [Docker](https://docs.docker.com/get-started/).
 The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.
 
-By default, linkding uses SQLite as a database.
+linkding uses an SQLite database by default.
 Alternatively linkding supports PostgreSQL, see the [database options](docs/Options.md#LD_DB_ENGINE) for more information.
 
+<details>
+
+<summary>🧪 Alpine-based image</summary>
+
+The default Docker image (`latest` tag) is based on a slim variant of Debian Linux.
+Alternatively, there is an image based on Alpine Linux (`latest-alpine` tag) which has a smaller size, resulting in a smaller download and less disk space required.
+The Alpine image is currently about 45 MB in compressed size, compared to about 130 MB for the Debian image.
+
+To use it, replace the `latest` tag with `latest-alpine`, either in the CLI command below when using Docker, or in the `docker-compose.yml` file when using docker-compose.
+
+> [!WARNING]
+> The image is currently considered experimental in order to gather feedback and iron out any issues.
+> Only use it if you are comfortable running experimental software or want to help out with testing.
+> While there should be no issues with creating new installations, there might be issues when migrating existing installations.
+> If you plan to migrate your existing installation, make sure to create proper [backups](https://github.com/sissbruecker/linkding/blob/master/docs/backup.md) first.
+
+</details>
+
 ###  Using Docker
 
 To install linkding using Docker you can just run the [latest image](https://hub.docker.com/repository/docker/sissbruecker/linkding) from Docker Hub:
@@ -85,7 +103,7 @@ docker-compose up -d
 
 To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.
 
-### User setup
+### User Setup
 
 For security reasons, the linkding Docker image does not provide an initial user, so you have to create one after setting up an installation. To do so, replace the credentials in the following command and run it:
 
@@ -101,7 +119,7 @@ docker-compose exec linkding python manage.py createsuperuser --username=joe --e
 
 The command will prompt you for a secure password. After the command has completed you can start using the application by logging into the UI with your credentials.
 
-Alternatively you can automatically create an initial superuser on startup using the [`LD_SUPERUSER_NAME` option](docs/Options.md#LD_SUPERUSER_NAME). 
+Alternatively you can automatically create an initial superuser on startup using the [`LD_SUPERUSER_NAME` option](docs/Options.md#LD_SUPERUSER_NAME).
 
 ### Reverse Proxy Setup
 
@@ -164,6 +182,7 @@ Self-hosting web applications still requires a lot of technical know-how and com
 
 - [linkding on fly.io](https://github.com/fspoettel/linkding-on-fly) - Guide for hosting a linkding installation on [fly.io](https://fly.io). By [fspoettel](https://github.com/fspoettel)
 - [PikaPods.com](https://www.pikapods.com/) - Managed hosting for linkding, EU and US regions available. [1-click setup link](https://www.pikapods.com/pods?run=linkding) ([Disclosure](#pikapods))
+- [CapRover](https://caprover.com/) - Linkding is included as a default one-click app
 
 ## Documentation
 
@@ -180,7 +199,7 @@ Self-hosting web applications still requires a lot of technical know-how and com
 ## Browser Extension
 
 linkding comes with an official browser extension that allows to quickly add bookmarks, and search bookmarks through the browser's address bar. You can get the extension here:
-- [Mozilla Addon Store](https://addons.mozilla.org/de/firefox/addon/linkding-extension/)
+- [Mozilla Addon Store](https://addons.mozilla.org/firefox/addon/linkding-extension/)
 - [Chrome Web Store](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe)
 
 The extension is open-source as well, and can be found [here](https://github.com/sissbruecker/linkding-extension).
@@ -192,7 +211,7 @@ This section lists community projects around using linkding, in alphabetical ord
 - [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
 - [feed2linkding](https://codeberg.org/strubbl/feed2linkding) A commandline utility to add all web feed item links to linkding via API call. By [Strubbl](https://github.com/Strubbl)
 - [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) Helm Chart for deploying linkding inside a Kubernetes cluster. By [pascaliske](https://github.com/pascaliske)
-- [iOS Shortcut using API and Tagging](https://gist.github.com/andrewdolphin/a7dff49505e588d940bec55132fab8ad) An iOS shortcut using the Linkding API (no extra logins required) that pulls previously used tags and allows tagging at the time of link creation. 
+- [iOS Shortcut using API and Tagging](https://gist.github.com/andrewdolphin/a7dff49505e588d940bec55132fab8ad) An iOS shortcut using the Linkding API (no extra logins required) that pulls previously used tags and allows tagging at the time of link creation.
 - [Linka!](https://github.com/cmsax/linka) Web app (also a PWA) for quickly searching & opening bookmarks in linkding, support multi keywords, exclude mode and other advance options. By [cmsax](https://github.com/cmsax)
 - [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
 - [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)
@@ -205,7 +224,7 @@ This section lists community projects around using linkding, in alphabetical ord
 
 ### PikaPods
 
-[PikaPods](https://www.pikapods.com/) has a revenue sharing agreement with this project, sharing some of their revenue from hosting linkding instances. I do not intend to profit from this project financially, so I am in turn donating that revenue. Big thanks to PikaPods for making this possible. 
+[PikaPods](https://www.pikapods.com/) has a revenue sharing agreement with this project, sharing some of their revenue from hosting linkding instances. I do not intend to profit from this project financially, so I am in turn donating that revenue. Big thanks to PikaPods for making this possible.
 
 See the table below for a list of donations.
 
@@ -281,3 +300,8 @@ Start the Django development server with:
 python3 manage.py runserver
 ```
 The frontend is now available under http://localhost:8000
+
+Run all tests with pytest
+```
+pytest
+```

bookmarks/feeds.py

@@ -16,6 +16,8 @@ class FeedContext:
 
 
 def sanitize(text: str):
+    if not text:
+        return ''
     # remove control characters
     valid_chars = ['\n', '\r', '\t']
     return ''.join(ch for ch in text if ch in valid_chars or unicodedata.category(ch)[0] != 'C')

bookmarks/frontend/behaviors/bookmark-page.js

@@ -59,10 +59,18 @@ class BookmarkItem {
   constructor(element) {
     this.element = element;
 
+    // Toggle notes
     const notesToggle = element.querySelector(".toggle-notes");
     if (notesToggle) {
       notesToggle.addEventListener("click", this.onToggleNotes.bind(this));
     }
+
+    // Add tooltip to title if it is truncated
+    const titleAnchor = element.querySelector(".title > a");
+    const titleSpan = titleAnchor.querySelector("span");
+    if (titleSpan.offsetWidth > titleAnchor.offsetWidth) {
+      titleAnchor.dataset.tooltip = titleSpan.textContent;
+    }
   }
 
   onToggleNotes(event) {

bookmarks/frontend/components/TagAutocomplete.svelte

@@ -22,7 +22,7 @@
   async function init() {
     // For now we cache all tags on load as the template did before
     try {
-      tags = await apiClient.getTags({limit: 1000, offset: 0});
+      tags = await apiClient.getTags({limit: 5000, offset: 0});
       tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
     } catch (e) {
       console.warn('TagAutocomplete: Error loading tag list');

bookmarks/management/commands/backup.py

@@ -0,0 +1,26 @@
+import sqlite3
+import os
+
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Creates a backup of the linkding database"
+
+    def add_arguments(self, parser):
+        parser.add_argument('destination', type=str, help='Backup file destination')
+
+    def handle(self, *args, **options):
+        destination = options['destination']
+
+        def progress(status, remaining, total):
+            self.stdout.write(f'Copied {total-remaining} of {total} pages...')
+
+        source_db = sqlite3.connect(os.path.join('data', 'db.sqlite3'))
+        backup_db = sqlite3.connect(destination)
+        with backup_db:
+            source_db.backup(backup_db, pages=50, progress=progress)
+        backup_db.close()
+        source_db.close()
+
+        self.stdout.write(self.style.SUCCESS(f'Backup created at {destination}'))

bookmarks/services/bookmarks.py

@@ -67,9 +67,9 @@ def archive_bookmark(bookmark: Bookmark):
 
 def archive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
 
-    bookmarks.update(is_archived=True, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(is_archived=True,
+                                                                                      date_modified=timezone.now())
 
 
 def unarchive_bookmark(bookmark: Bookmark):
@@ -81,70 +81,76 @@ def unarchive_bookmark(bookmark: Bookmark):
 
 def unarchive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
 
-    bookmarks.update(is_archived=False, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(is_archived=False,
+                                                                                      date_modified=timezone.now())
 
 
 def delete_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
 
-    bookmarks.delete()
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).delete()
 
 
 def tag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+    owned_bookmark_ids = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).values_list('id',
+                                                                                                                flat=True)
     tag_names = parse_tag_string(tag_string)
     tags = get_or_create_tags(tag_names, current_user)
 
-    for bookmark in bookmarks:
-        bookmark.tags.add(*tags)
-        bookmark.date_modified = timezone.now()
+    BookmarkToTagRelationShip = Bookmark.tags.through
+    relationships = []
+    for tag in tags:
+        for bookmark_id in owned_bookmark_ids:
+            relationships.append(BookmarkToTagRelationShip(bookmark_id=bookmark_id, tag=tag))
 
-    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
+    # Insert all bookmark -> tag associations at once, should ignore errors if association already exists
+    BookmarkToTagRelationShip.objects.bulk_create(relationships, ignore_conflicts=True)
+    Bookmark.objects.filter(id__in=owned_bookmark_ids).update(date_modified=timezone.now())
 
 
 def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+    owned_bookmark_ids = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).values_list('id',
+                                                                                                                flat=True)
     tag_names = parse_tag_string(tag_string)
     tags = get_or_create_tags(tag_names, current_user)
 
-    for bookmark in bookmarks:
-        bookmark.tags.remove(*tags)
-        bookmark.date_modified = timezone.now()
+    BookmarkToTagRelationShip = Bookmark.tags.through
+    for tag in tags:
+        # Remove all bookmark -> tag associations for the owned bookmarks and the current tag
+        BookmarkToTagRelationShip.objects.filter(bookmark_id__in=owned_bookmark_ids, tag=tag).delete()
 
-    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
+    Bookmark.objects.filter(id__in=owned_bookmark_ids).update(date_modified=timezone.now())
 
 
 def mark_bookmarks_as_read(bookmark_ids: [Union[int, str]], current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
 
-    bookmarks.update(unread=False, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(unread=False,
+                                                                                      date_modified=timezone.now())
 
 
 def mark_bookmarks_as_unread(bookmark_ids: [Union[int, str]], current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
 
-    bookmarks.update(unread=True, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(unread=True,
+                                                                                      date_modified=timezone.now())
 
 
 def share_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
 
-    bookmarks.update(shared=True, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(shared=True,
+                                                                                      date_modified=timezone.now())
 
 
 def unshare_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
     sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
 
-    bookmarks.update(shared=False, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(shared=False,
+                                                                                      date_modified=timezone.now())
 
 
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):

bookmarks/services/exporter.py

@@ -33,7 +33,10 @@ def append_bookmark(doc: BookmarkDocument, bookmark: Bookmark):
     desc = html.escape(bookmark.resolved_description or '')
     if bookmark.notes:
         desc += f'[linkding-notes]{html.escape(bookmark.notes)}[/linkding-notes]'
-    tags = ','.join(bookmark.tag_names)
+    tag_names = bookmark.tag_names
+    if bookmark.is_archived:
+        tag_names.append('linkding:archived')
+    tags = ','.join(tag_names)
     toread = '1' if bookmark.unread else '0'
     private = '0' if bookmark.shared else '1'
     added = int(bookmark.date_added.timestamp())

bookmarks/services/importer.py

@@ -5,7 +5,7 @@ from typing import List
 from django.contrib.auth.models import User
 from django.utils import timezone
 
-from bookmarks.models import Bookmark, Tag, parse_tag_string
+from bookmarks.models import Bookmark, Tag
 from bookmarks.services import tasks
 from bookmarks.services.parser import parse, NetscapeBookmark
 from bookmarks.utils import parse_timestamp
@@ -93,8 +93,7 @@ def _create_missing_tags(netscape_bookmarks: List[NetscapeBookmark], user: User)
     tags_to_create = []
 
     for netscape_bookmark in netscape_bookmarks:
-        tag_names = parse_tag_string(netscape_bookmark.tag_string)
-        for tag_name in tag_names:
+        for tag_name in netscape_bookmark.tag_names:
             tag = tag_cache.get(tag_name)
             if not tag:
                 tag = Tag(name=tag_name, owner=user)
@@ -194,8 +193,7 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark],
             continue
 
         # Get tag models by string, schedule inserts for bookmark -> tag associations
-        tag_names = parse_tag_string(netscape_bookmark.tag_string)
-        tags = tag_cache.get_all(tag_names)
+        tags = tag_cache.get_all(netscape_bookmark.tag_names)
         for tag in tags:
             relationships.append(BookmarkToTagRelationShip(bookmark=bookmark, tag=tag))
 
@@ -219,3 +217,5 @@ def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark,
         bookmark.notes = netscape_bookmark.notes
     if options.map_private_flag and not netscape_bookmark.private:
         bookmark.shared = True
+    if netscape_bookmark.archived:
+        bookmark.is_archived = True

bookmarks/services/parser.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 from html.parser import HTMLParser
 from typing import Dict, List
 
+from bookmarks.models import parse_tag_string
+
 
 @dataclass
 class NetscapeBookmark:
@@ -10,9 +12,10 @@ class NetscapeBookmark:
     description: str
     notes: str
     date_added: str
-    tag_string: str
+    tag_names: List[str]
     to_read: bool
     private: bool
+    archived: bool
 
 
 class BookmarkParser(HTMLParser):
@@ -56,16 +59,24 @@ class BookmarkParser(HTMLParser):
 
     def handle_start_a(self, attrs: Dict[str, str]):
         vars(self).update(attrs)
+        tag_names = parse_tag_string(self.tags)
+        archived = 'linkding:archived' in self.tags
+        try:
+            tag_names.remove('linkding:archived')
+        except ValueError:
+            pass
+
         self.bookmark = NetscapeBookmark(
             href=self.href,
             title='',
             description='',
             notes='',
             date_added=self.add_date,
-            tag_string=self.tags,
+            tag_names=tag_names,
             to_read=self.toread == '1',
             # Mark as private by default, also when attribute is not specified
             private=self.private != '0',
+            archived=archived,
         )
 
     def handle_a_data(self, data):

bookmarks/services/website_loader.py

@@ -41,8 +41,13 @@ def load_website_metadata(url: str):
 
         title = soup.title.string.strip() if soup.title is not None else None
         description_tag = soup.find('meta', attrs={'name': 'description'})
-        description = description = description_tag['content'].strip() if description_tag and description_tag[
+        description = description_tag['content'].strip() if description_tag and description_tag[
             'content'] else None
+
+        if not description:
+            description_tag = soup.find('meta', attrs={'property': 'og:description'})
+            description = description_tag['content'].strip() if description_tag and description_tag['content'] else None
+
         end = timezone.now()
         logger.debug(f'Parsing duration: {end - start}')
     finally:

bookmarks/styles/bookmark-page.scss

@@ -107,6 +107,18 @@ ul.bookmark-list {
   padding: 0;
 }
 
+@keyframes appear {
+  0% {
+    opacity: 0;
+  }
+  90% {
+    opacity: 0;
+  }
+  100% {
+    opacity: 1;
+  }
+}
+
 /* Bookmarks */
 li[ld-bookmark-item] {
   position: relative;
@@ -122,6 +134,27 @@ li[ld-bookmark-item] {
     white-space: nowrap;
     overflow: hidden;
     text-overflow: ellipsis;
+
+    &[data-tooltip]:hover::after, &[data-tooltip]:focus::after {
+      content: attr(data-tooltip);
+      position: absolute;
+      z-index: 10;
+      top: 20px;
+      left: 50%;
+      transform: translateX(-50%);
+      width: max-content;
+      max-width: 100%;
+      height: fit-content;
+      background-color: #292f62;
+      color: #fff;
+      padding: $unit-1;
+      border-radius: $border-radius;
+      border: 1px solid #424a8c;
+      font-size: $font-size-sm;
+      font-style: normal;
+      white-space: normal;
+      animation: 0.3s ease 0s appear;
+    }
   }
 
   &.unread .title a {

bookmarks/templates/bookmarks/bookmark_list.html

@@ -14,11 +14,11 @@
           <i class="form-icon"></i>
         </label>
         <div class="title">
-          <a href="{{ bookmark_item.url }}" target="{{ bookmark_list.link_target }}" rel="noopener">
+          <a href="{{ bookmark_item.url }}" target="{{ bookmark_list.link_target }}" rel="noopener" >
             {% if bookmark_item.favicon_file and bookmark_list.show_favicons %}
               <img src="{% static bookmark_item.favicon_file %}" alt="">
             {% endif %}
-            {{ bookmark_item.title }}
+              <span>{{ bookmark_item.title }}</span>
           </a>
         </div>
         {% if bookmark_list.show_url %}

bookmarks/templates/bookmarks/search.html

@@ -95,7 +95,7 @@
       props: {
         name: 'q',
         placeholder: 'Search for words or #tags',
-        value: '{{ search.q|safe }}',
+        value: input.value,
         tags: uniqueTags,
         mode: '{{ mode }}',
         linkTarget: '{{ request.user_profile.bookmark_link_target }}',

bookmarks/templates/settings/general.html

@@ -99,7 +99,7 @@
             Machine</a>.
             This allows to preserve, and later access the website as it was at the point in time it was bookmarked, in
             case it goes offline or its content is modified.
-            Please consider donating to the <a href="https://archive.org/donate/index.php" target="_blank"
+            Please consider donating to the <a href="https://archive.org/donate" target="_blank"
                                                rel="noopener">Internet Archive</a> if you make use of this feature.
           </div>
         </div>

bookmarks/templates/settings/integrations.html

@@ -9,7 +9,7 @@
             <h2>Browser Extension</h2>
             <p>The browser extension allows you to quickly add new bookmarks without leaving the page that you are on. The extension is available in the official extension stores for:</p>
             <ul>
-                <li><a href="https://addons.mozilla.org/de/firefox/addon/linkding-extension/" target="_blank">Firefox</a></li>
+                <li><a href="https://addons.mozilla.org/firefox/addon/linkding-extension/" target="_blank">Firefox</a></li>
                 <li><a href="https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe" target="_blank">Chrome</a></li>
             </ul>
             <p>The extension is <a href="https://github.com/sissbruecker/linkding-extension" target="_blank">open source</a> as well, which enables you to build and manually load it into any browser that supports Chrome extensions.</p>

bookmarks/tests/test_bookmark_archived_view.py

@@ -422,3 +422,31 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin
 
         self.assertEqual(actions_form.attrs['action'],
                          '/bookmarks/archived/action?q=%23foo&return_url=%2Fbookmarks%2Farchived%3Fq%3D%2523foo')
+
+    def test_encode_search_params(self):
+        bookmark = self.setup_bookmark(description='alert(\'xss\')', is_archived=True)
+
+        url = reverse('bookmarks:archived') + '?q=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertContains(response, bookmark.url)
+
+        url = reverse('bookmarks:archived') + '?sort=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:archived') + '?unread=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:archived') + '?shared=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:archived') + '?user=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:archived') + '?page=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')

bookmarks/tests/test_bookmark_index_view.py

@@ -418,3 +418,31 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
         self.assertEqual(actions_form.attrs['action'],
                          '/bookmarks/action?q=%23foo&return_url=%2Fbookmarks%3Fq%3D%2523foo')
+
+    def test_encode_search_params(self):
+        bookmark = self.setup_bookmark(description='alert(\'xss\')')
+
+        url = reverse('bookmarks:index') + '?q=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertContains(response, bookmark.url)
+
+        url = reverse('bookmarks:index') + '?sort=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:index') + '?unread=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:index') + '?shared=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:index') + '?user=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:index') + '?page=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')

bookmarks/tests/test_bookmark_new_view.py

@@ -183,9 +183,8 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
           </div>
         ''', html)
 
+    def test_should_hide_notes_if_there_are_no_notes(self):
+        bookmark = self.setup_bookmark()
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
 
-def test_should_hide_notes_if_there_are_no_notes(self):
-    bookmark = self.setup_bookmark()
-    response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
-
-    self.assertContains(response, '<details class="notes">', count=1)
+        self.assertContains(response, '<details class="notes">', count=1)

bookmarks/tests/test_bookmark_shared_view.py

@@ -500,3 +500,35 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
         self.assertEqual(actions_form.attrs['action'],
                          '/bookmarks/shared/action?q=%23foo&return_url=%2Fbookmarks%2Fshared%3Fq%3D%2523foo')
+
+    def test_encode_search_params(self):
+        self.authenticate()
+        user = self.get_or_create_test_user()
+        user.profile.enable_sharing = True
+        user.profile.save()
+        bookmark = self.setup_bookmark(description='alert(\'xss\')', shared=True)
+
+        url = reverse('bookmarks:shared') + '?q=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertContains(response, bookmark.url)
+
+        url = reverse('bookmarks:shared') + '?sort=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:shared') + '?unread=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:shared') + '?shared=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:shared') + '?user=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')
+
+        url = reverse('bookmarks:shared') + '?page=alert(%27xss%27)'
+        response = self.client.get(url)
+        self.assertNotContains(response, 'alert(\'xss\')')

bookmarks/tests/test_bookmarks_list_template.py

@@ -24,7 +24,7 @@ class BookmarkListTemplateTest(TestCase, BookmarkFactoryMixin):
                 target="{link_target}" 
                 rel="noopener">
                 {favicon_img}
-                {bookmark.resolved_title}
+                <span>{bookmark.resolved_title}</span>
             </a>
             ''',
             html

bookmarks/tests/test_bookmarks_service.py

@@ -336,6 +336,28 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
         self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
         self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
 
+    def test_tag_bookmarks_should_handle_existing_relationships(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark1 = self.setup_bookmark(tags=[tag1])
+        bookmark2 = self.setup_bookmark(tags=[tag1])
+        bookmark3 = self.setup_bookmark(tags=[tag1])
+
+        BookmarkToTagRelationShip = Bookmark.tags.through
+        self.assertEqual(3, BookmarkToTagRelationShip.objects.count())
+
+        tag_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], f'{tag1.name},{tag2.name}',
+                      self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
+        self.assertEqual(6, BookmarkToTagRelationShip.objects.count())
+
     def test_tag_bookmarks_should_only_tag_specified_bookmarks(self):
         bookmark1 = self.setup_bookmark()
         bookmark2 = self.setup_bookmark()

bookmarks/tests/test_exporter.py

@@ -22,6 +22,9 @@ class ExporterTestCase(TestCase, BookmarkFactoryMixin):
                                 description='Example description', notes='Example notes'),
             self.setup_bookmark(url='https://example.com/6', title='Title 6', added=added, shared=True,
                                 notes='Example notes'),
+            self.setup_bookmark(url='https://example.com/7', title='Title 7', added=added, is_archived=True),
+            self.setup_bookmark(url='https://example.com/8', title='Title 8', added=added,
+                                tags=[self.setup_tag(name='tag4'), self.setup_tag(name='tag5')], is_archived=True),
         ]
         html = exporter.export_netscape_html(bookmarks)
 
@@ -35,6 +38,8 @@ class ExporterTestCase(TestCase, BookmarkFactoryMixin):
             '<DD>Example description[linkding-notes]Example notes[/linkding-notes]',
             f'<DT><A HREF="https://example.com/6" ADD_DATE="{timestamp}" PRIVATE="0" TOREAD="0" TAGS="">Title 6</A>',
             '<DD>[linkding-notes]Example notes[/linkding-notes]',
+            f'<DT><A HREF="https://example.com/7" ADD_DATE="{timestamp}" PRIVATE="1" TOREAD="0" TAGS="linkding:archived">Title 7</A>',
+            f'<DT><A HREF="https://example.com/8" ADD_DATE="{timestamp}" PRIVATE="1" TOREAD="0" TAGS="tag4,tag5,linkding:archived">Title 8</A>',
         ]
         self.assertIn('\n\r'.join(lines), html)
 

bookmarks/tests/test_feeds.py

@@ -7,6 +7,8 @@ from django.urls import reverse
 
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 from bookmarks.models import FeedToken, User
+from bookmarks.feeds import sanitize
+
 
 
 def rfc2822_date(date):
@@ -112,6 +114,9 @@ class FeedsTestCase(TestCase, BookmarkFactoryMixin):
         self.assertContains(response, f'<title>test\n\r\ttitle</title>', count=1)
         self.assertContains(response, f'<description>test\n\r\tdescription</description>', count=1)
 
+    def test_sanitize_with_none_text(self):
+        self.assertEqual('', sanitize(None))
+
     def test_unread_returns_404_for_unknown_feed_token(self):
         response = self.client.get(reverse('bookmarks:feeds.unread', args=['foo']))
 

bookmarks/tests/test_importer.py

@@ -295,6 +295,27 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
         self.assertEqual(bookmark2.shared, False)
         self.assertEqual(bookmark3.shared, True)
 
+    def test_archived_state(self):
+        test_html = self.render_html(tags_html='''
+        <DT><A HREF="https://example.com/1" ADD_DATE="1" TAGS="tag1,tag2,linkding:archived">Example title 1</A>
+        <DD>Example description 1</DD>
+        <DT><A HREF="https://example.com/2" ADD_DATE="1" PRIVATE="1" TAGS="tag1,tag2">Example title 2</A>
+        <DD>Example description 2</DD>
+        <DT><A HREF="https://example.com/3" ADD_DATE="1" PRIVATE="0">Example title 3</A>
+        <DD>Example description 3</DD>
+        ''')
+        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions())
+
+        self.assertEqual(Bookmark.objects.count(), 3)
+        self.assertEqual(Bookmark.objects.all()[0].is_archived, True)
+        self.assertEqual(Bookmark.objects.all()[1].is_archived, False)
+        self.assertEqual(Bookmark.objects.all()[2].is_archived, False)
+
+        tags = Tag.objects.all()
+        self.assertEqual(len(tags), 2)
+        self.assertEqual(tags[0].name, 'tag1')
+        self.assertEqual(tags[1].name, 'tag2')
+
     def test_notes(self):
         # initial notes
         test_html = self.render_html(tags_html='''

bookmarks/tests/test_parser.py

@@ -2,6 +2,7 @@ from typing import List
 
 from django.test import TestCase
 
+from bookmarks.models import parse_tag_string
 from bookmarks.services.parser import NetscapeBookmark
 from bookmarks.services.parser import parse
 from bookmarks.tests.helpers import ImportTestMixin, BookmarkHtmlTag
@@ -16,7 +17,7 @@ class ParserTestCase(TestCase, ImportTestMixin):
             self.assertEqual(bookmark.title, html_tag.title)
             self.assertEqual(bookmark.date_added, html_tag.add_date)
             self.assertEqual(bookmark.description, html_tag.description)
-            self.assertEqual(bookmark.tag_string, html_tag.tags)
+            self.assertEqual(bookmark.tag_names, parse_tag_string(html_tag.tags))
             self.assertEqual(bookmark.to_read, html_tag.to_read)
             self.assertEqual(bookmark.private, html_tag.private)
 

bookmarks/tests/test_settings_export_view.py

@@ -3,6 +3,7 @@ from unittest.mock import patch
 from django.test import TestCase
 from django.urls import reverse
 
+from bookmarks.models import Bookmark
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 
 
@@ -20,6 +21,9 @@ class SettingsExportViewTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(tags=[self.setup_tag()])
         self.setup_bookmark(tags=[self.setup_tag()])
         self.setup_bookmark(tags=[self.setup_tag()])
+        self.setup_bookmark(tags=[self.setup_tag()], is_archived=True)
+        self.setup_bookmark(tags=[self.setup_tag()], is_archived=True)
+        self.setup_bookmark(tags=[self.setup_tag()], is_archived=True)
 
         response = self.client.get(
             reverse('bookmarks:settings.export'),
@@ -30,6 +34,35 @@ class SettingsExportViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(response['content-type'], 'text/plain; charset=UTF-8')
         self.assertEqual(response['Content-Disposition'], 'attachment; filename="bookmarks.html"')
 
+        for bookmark in Bookmark.objects.all():
+            self.assertContains(response, bookmark.url)
+
+    def test_should_only_export_user_bookmarks(self):
+        other_user = self.setup_user()
+        owned_bookmarks = [
+            self.setup_bookmark(tags=[self.setup_tag()]),
+            self.setup_bookmark(tags=[self.setup_tag()]),
+            self.setup_bookmark(tags=[self.setup_tag()]),
+        ]
+        non_owned_bookmarks = [
+            self.setup_bookmark(tags=[self.setup_tag()], user=other_user),
+            self.setup_bookmark(tags=[self.setup_tag()], user=other_user),
+            self.setup_bookmark(tags=[self.setup_tag()], user=other_user),
+        ]
+
+        response = self.client.get(
+            reverse('bookmarks:settings.export'),
+            follow=True
+        )
+
+        text = response.content.decode('utf-8')
+
+        for bookmark in owned_bookmarks:
+            self.assertIn(bookmark.url, text)
+
+        for bookmark in non_owned_bookmarks:
+            self.assertNotIn(bookmark.url, text)
+
     def test_should_check_authentication(self):
         self.client.logout()
         response = self.client.get(reverse('bookmarks:settings.export'), follow=True)

bookmarks/tests/test_website_loader.py

@@ -29,14 +29,17 @@ class WebsiteLoaderTestCase(TestCase):
         # clear cached metadata before test run
         website_loader.load_website_metadata.cache_clear()
 
-    def render_html_document(self, title, description):
+    def render_html_document(self, title, description='', og_description=''):
+        meta_description = f'<meta name="description" content="{description}">' if description else ''
+        meta_og_description = f'<meta property="og:description" content="{og_description}">' if og_description else ''
         return f'''
         <!DOCTYPE html>
         <html lang="en">
         <head>
             <meta charset="UTF-8">
             <title>{title}</title>
-            <meta name="description" content="{description}">
+            {meta_description}
+            {meta_og_description}
         </head>
         <body></body>
         </html>
@@ -94,3 +97,19 @@ class WebsiteLoaderTestCase(TestCase):
             metadata = website_loader.load_website_metadata('https://example.com')
             self.assertEqual('test title', metadata.title)
             self.assertEqual('test description', metadata.description)
+
+    def test_load_website_metadata_using_og_description(self):
+        with mock.patch('bookmarks.services.website_loader.load_page') as mock_load_page:
+            mock_load_page.return_value = self.render_html_document('test title', '',
+                                                                    og_description='test og description')
+            metadata = website_loader.load_website_metadata('https://example.com')
+            self.assertEqual('test title', metadata.title)
+            self.assertEqual('test og description', metadata.description)
+
+    def test_load_website_metadata_prefers_description_over_og_description(self):
+        with mock.patch('bookmarks.services.website_loader.load_page') as mock_load_page:
+            mock_load_page.return_value = self.render_html_document('test title', 'test description',
+                                                                    og_description='test og description')
+            metadata = website_loader.load_website_metadata('https://example.com')
+            self.assertEqual('test title', metadata.title)
+            self.assertEqual('test description', metadata.description)

bookmarks/views/settings.py

@@ -12,8 +12,7 @@ from django.shortcuts import render
 from django.urls import reverse
 from rest_framework.authtoken.models import Token
 
-from bookmarks.models import BookmarkSearch, UserProfileForm, FeedToken
-from bookmarks.queries import query_bookmarks
+from bookmarks.models import Bookmark, BookmarkSearch, UserProfileForm, FeedToken
 from bookmarks.services import exporter, tasks
 from bookmarks.services import importer
 from bookmarks.utils import app_version
@@ -136,7 +135,7 @@ def bookmark_import(request):
 def bookmark_export(request):
     # noinspection PyBroadException
     try:
-        bookmarks = list(query_bookmarks(request.user, request.user_profile, BookmarkSearch()))
+        bookmarks = Bookmark.objects.filter(owner=request.user)
         # Prefetch tags to prevent n+1 queries
         prefetch_related_objects(bookmarks, 'tags')
         file_content = exporter.export_netscape_html(bookmarks)

docker/alpine.Dockerfile

@@ -0,0 +1,89 @@
+FROM node:18.18.0-alpine AS node-build
+WORKDIR /etc/linkding
+# install build dependencies
+COPY rollup.config.js package.json package-lock.json ./
+RUN npm install
+# copy files needed for JS build
+COPY bookmarks/frontend ./bookmarks/frontend
+# run build
+RUN npm run build
+
+
+FROM python:3.10.13-alpine3.18 AS python-base
+RUN apk update && apk add alpine-sdk linux-headers libpq-dev pkgconfig icu-dev sqlite-dev
+WORKDIR /etc/linkding
+
+
+FROM python-base AS python-build
+# install build dependencies
+COPY requirements.txt requirements.txt
+# remove playwright from requirements as there is not always a distro and it's not needed for the build
+RUN sed -i '/playwright/d' requirements.txt
+RUN pip install -U pip && pip install -Ur requirements.txt
+# copy files needed for Django build
+COPY . .
+COPY --from=node-build /etc/linkding .
+# run Django part of the build
+RUN python manage.py compilescss && \
+    python manage.py collectstatic --ignore=*.scss && \
+    python manage.py compilescss --delete-files
+
+
+FROM python-base AS prod-deps
+COPY requirements.prod.txt ./requirements.txt
+RUN mkdir /opt/venv && \
+    python -m venv --upgrade-deps --copies /opt/venv && \
+    /opt/venv/bin/pip install --upgrade pip wheel && \
+    /opt/venv/bin/pip install -Ur requirements.txt
+
+
+FROM python-base AS compile-icu
+# Defines SQLite version
+# Since this is only needed for downloading the header files this probably
+# doesn't need to be up-to-date, assuming the SQLite APIs used by the ICU
+# extension do not change
+ARG SQLITE_RELEASE_YEAR=2023
+ARG SQLITE_RELEASE=3430000
+
+# Compile the ICU extension needed for case-insensitive search and ordering
+# with SQLite. This does:
+# - Download SQLite amalgamation for header files
+# - Download ICU extension source file
+# - Compile ICU extension
+RUN wget https://www.sqlite.org/${SQLITE_RELEASE_YEAR}/sqlite-amalgamation-${SQLITE_RELEASE}.zip && \
+    unzip sqlite-amalgamation-${SQLITE_RELEASE}.zip && \
+    cp sqlite-amalgamation-${SQLITE_RELEASE}/sqlite3.h ./sqlite3.h && \
+    cp sqlite-amalgamation-${SQLITE_RELEASE}/sqlite3ext.h ./sqlite3ext.h && \
+    wget https://www.sqlite.org/src/raw/ext/icu/icu.c?name=91c021c7e3e8bbba286960810fa303295c622e323567b2e6def4ce58e4466e60 -O icu.c && \
+    gcc -fPIC -shared icu.c `pkg-config --libs --cflags icu-uc icu-io` -o libicu.so
+
+
+FROM python:3.10.13-alpine3.18 AS final
+# install runtime dependencies
+RUN apk update && apk add bash curl icu libpq mailcap
+# create www-data user and group
+RUN set -x ; \
+  addgroup -g 82 -S www-data ; \
+  adduser -u 82 -D -S -G www-data www-data && exit 0 ; exit 1
+WORKDIR /etc/linkding
+# copy prod dependencies
+COPY --from=prod-deps /opt/venv /opt/venv
+# copy output from build stage
+COPY --from=python-build /etc/linkding/static static/
+# copy compiled icu extension
+COPY --from=compile-icu /etc/linkding/libicu.so libicu.so
+# copy application code
+COPY . .
+# Expose uwsgi server at port 9090
+EXPOSE 9090
+# Activate virtual env
+ENV VIRTUAL_ENV /opt/venv
+ENV PATH /opt/venv/bin:$PATH
+# Allow running containers as an an arbitrary user in the root group, to support deployment scenarios like OpenShift, Podman
+RUN chmod g+w . && \
+    chmod +x ./bootstrap.sh
+
+HEALTHCHECK --interval=30s --retries=3 --timeout=1s \
+CMD curl -f http://localhost:${LD_SERVER_PORT:-9090}/${LD_CONTEXT_PATH}health || exit 1
+
+CMD ["./bootstrap.sh"]

docker/default.Dockerfile

@@ -1,11 +1,11 @@
 FROM node:18.18.0-alpine AS node-build
 WORKDIR /etc/linkding
 # install build dependencies
-COPY package.json package-lock.json ./
-RUN npm install -g npm && \
-    npm install
-# compile JS components
-COPY . .
+COPY rollup.config.js package.json package-lock.json ./
+RUN npm install
+# copy files needed for JS build
+COPY bookmarks/frontend ./bookmarks/frontend
+# run build
 RUN npm run build
 
 
@@ -17,9 +17,13 @@ WORKDIR /etc/linkding
 FROM python-base AS python-build
 # install build dependencies
 COPY requirements.txt requirements.txt
+# remove playwright from requirements as there is not always a distro and it's not needed for the build
+RUN sed -i '/playwright/d' requirements.txt
 RUN pip install -U pip && pip install -Ur requirements.txt
-# run Django part of the build
+# copy files needed for Django build
+COPY . .
 COPY --from=node-build /etc/linkding .
+# run Django part of the build
 RUN python manage.py compilescss && \
     python manage.py collectstatic --ignore=*.scss && \
     python manage.py compilescss --delete-files

docs/backup.md

@@ -1,52 +1,82 @@
 # Backups
 
-This page describes some options on how to create backups.
+Linkding stores all data in the application's data folder.
+The full path to that folder in the Docker container is `/etc/linkding/data`.
+As described in the installation docs, you should mount the `/etc/linkding/data` folder to a folder on your host system.
 
-## What to backup
+The data folder contains the following contents:
+- `db.sqlite3` - the SQLite database
+- `favicons` - folder that contains downloaded favicons
 
-Linkding stores all data in a SQLite database, so all you need to backup are the contents of that database.
+The following sections explain how to back up the individual contents.
 
-The location of the database file is `data/db.sqlite3` in the application folder. 
-If you are using Docker then the full path in the Docker container is `/etc/linkding/data/db.sqlite`. 
-As described in the installation docs, you should mount the `/etc/linkding/data` folder to a folder on your host system, from which you then can execute the backup.
+## Database
 
-Below, we describe several methods to create a backup of the database:
+This section describes several methods on how to back up the contents of the SQLite database.
 
-- Manual backup using the export function from the UI
-- Create a copy of the SQLite database with the SQLite backup function
-- Create a plain textfile with the contents of the SQLite database with the SQLite dump function
+> [!WARNING]
+> While the SQLite database is just a single file, it is not recommended to just copy that file.
+> This method is not transaction safe and may result in a [corrupted database](https://www.sqlite.org/howtocorrupt.html).
+> Use one of the backup methods described below.
 
-Choose the method that fits you best.
+### Using the backup command
 
-## Exporting from the UI
+linkding includes a CLI command for creating a backup copy of the database.
 
-The least technical option is to use the bookmark export in the UI.
-Go to the settings page and open the *Data* tab. 
-Then click on the *Download* button to download an HTML file containing all your bookmarks.
-You can backup this file on a drive, or an online file host.
-
-## Using the SQLite backup function
-
-Requires [SQLite](https://www.sqlite.org/index.html) to be installed on your host system.
-
-With this method you create a new SQLite database, which is a copy of your linkding database.
-This method uses the backup command in the [Command Line Shell For SQLite](https://sqlite.org/cli.html).
+To create a backup, execute the following command:
 ```shell
-sqlite3 db.sqlite3 ".backup 'backup.sqlite3'"
+docker exec -it linkding python manage.py backup backup.sqlite3
 ```
-After you have created the backup database `backup.sqlite` you have to move it to another system, for example with rsync.
+This creates a `backup.sqlite3` file in the Docker container.
 
-## Using the SQLite dump function
+To copy the backup file to your host system, execute the following command:
+```shell
+docker cp linkding:/etc/linkding/backup.sqlite3 backup.sqlite3
+```
+This copies the backup file from the Docker container to the current folder on your host system.
+Now you can move that file to your backup location.
+
+To restore the backup, just copy the backup file to the data folder of your new installation and rename it to `db.sqlite3`. Then start the Docker container.
+
+### Using the SQLite dump function
 
 Requires [SQLite](https://www.sqlite.org/index.html) to be installed on your host system.
 
 With this method you create a plain text file with the SQL statements to recreate the SQLite database.
-
+To create a backup, execute the following command in the data folder:
 ```shell
 sqlite3 db.sqlite3 .dump > backup.sql
 ```
+This creates a `backup.sql` which you can copy to your backup location.
+As this is a plain text file you can also commit it to any revision management system, like git.
+Using git, you can commit the changes, followed by a git push to a remote repository.
 
-As this is a plain text file you can commit it to any revision management system, like git.
-Using git you can commit the changes, followed by a git push to a remote repository.
+### Exporting bookmarks from the UI
 
+This is the least technical option to back up bookmarks, but has several limitations:
+- It does not export user profiles.
+- It only exports your own bookmarks, not those of other users.
+- It does not export archived bookmarks.
+- It does not export URLs of snapshots on the Internet Archive Wayback machine.
+- It does not export favicons.
 
+Only use this method if you are fine with the above limitations.
+
+To export bookmarks from the UI, open the general settings.
+In the Export section, click on the *Download* button to download an HTML file containing all your bookmarks.
+Then move that file to your backup location.
+
+To restore bookmarks, open the general settings on your new installation.
+In the Import section, click on the *Choose file* button to select the HTML file you downloaded before.
+Then click on the *Import* button to import the bookmarks.
+
+## Favicons
+
+Doing a backup of the icons is optional, as they can be downloaded again.
+
+If you choose not to back up the icons, you can just restore the database and then click the _Refresh Favicons_ button in the general settings.
+This will download all missing icons again.
+
+If you want to back up the icons, then you have to copy the `favicons` folder to your backup location.
+
+To restore the icons, copy the `favicons` folder back to the data folder of your new installation.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkding",
-  "version": "1.22.2",
+  "version": "1.24.0",
   "description": "",
   "main": "index.js",
   "scripts": {

pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+DJANGO_SETTINGS_MODULE = siteroot.settings.dev
+# -- recommended but optional:
+python_files = tests.py test_*.py *_tests.py

requirements.prod.txt

@@ -6,7 +6,7 @@ certifi==2023.7.22
 charset-normalizer==2.1.1
 click==8.1.3
 confusable-homoglyphs==3.2.0
-Django==4.1.10
+Django==4.1.13
 django-generate-secret-key==1.0.2
 django-registration==3.3
 django-sass-processor==1.2.1

requirements.txt

@@ -1,13 +1,12 @@
 asgiref==3.5.2
 beautifulsoup4==4.11.1
-bleach==6.0.0
 bleach-allowlist==1.0.3
+bleach==6.0.0
 certifi==2023.7.22
 charset-normalizer==2.1.1
 click==8.1.3
 confusable-homoglyphs==3.2.0
 coverage==5.5
-Django==4.1.10
 django-appconf==1.0.5
 django-compressor==4.1
 django-debug-toolbar==3.6.0
@@ -15,15 +14,18 @@ django-generate-secret-key==1.0.2
 django-registration==3.3
 django-sass-processor==1.2.1
 django-widget-tweaks==1.4.12
+Django==4.1.13
 django4-background-tasks==1.2.7
 djangorestframework==3.13.1
-greenlet==2.0.1
+greenlet==3.0.1
 idna==3.3
 libsass==0.21.0
 Markdown==3.4.3
-playwright==1.29.1
+playwright==1.40.0
 psycopg2-binary==2.9.5
-pyee==9.0.4
+pyee==11.0.1
+pytest-django==4.7.0
+pytest==7.4.4
 python-dateutil==2.8.2
 pytz==2022.2.1
 rcssmin==1.1.0

scripts/build-docker.sh

@@ -3,6 +3,13 @@
 version=$(<version.txt)
 
 docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 \
+  -f docker/default.Dockerfile \
   -t sissbruecker/linkding:latest \
   -t sissbruecker/linkding:$version \
   --push .
+
+docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 \
+  -f docker/alpine.Dockerfile \
+  -t sissbruecker/linkding:latest-alpine \
+  -t sissbruecker/linkding:$version-alpine \
+  --push .

scripts/run-docker.sh

@@ -1,6 +1,8 @@
 #!/usr/bin/env bash
 
-docker build -t sissbruecker/linkding:local .
+variant="${1:-default}"
+
+docker build -f "docker/$variant.Dockerfile" -t sissbruecker/linkding:local .
 
 docker rm -f linkding-local || true
 

version.txt

@@ -1 +1 @@
-1.22.2
+1.24.0