#lang racket/base

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PostgreSQL-backed page, history, search, bookmark and upload storage.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(require db
         json
         racket/file
         racket/list
         racket/path
         racket/string
         "attachment-references.rkt"
         "config.rkt"
         "database.rkt"
         "todo.rkt")

(provide ensure-wiki-data!
         valid-slug?
         valid-page-reference?
         page-reference
         split-page-reference
         title->slug
         list-pages
         read-page
         create-page!
         update-page!
         archive-page!
         page-history
         read-version
         search-pages
         list-todos
         list-recent-pages
         list-bookmarks
         set-bookmark!
         delete-bookmark!
         list-orphaned-uploads
         delete-orphaned-upload!
         save-upload!
         uploaded-file)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Ensure writable installation directories exist.
; pre    : config is a wiki-config value and its data directory is writable.
; post   : The data directory and writable static directory exist.
; result : void.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Supporting functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define (ensure-wiki-data! config)
  (for ((directory (in-list (list (wiki-config-data-dir config)
                                  (data-static-directory config)))))
    (make-directory* directory)))

(define (slug-alphanumeric? char)
  (or (char-alphabetic? char)
      (char-numeric? char)))

(define (combining-mark? char)
  (if (member (char-general-category char) '(mn mc me))
      #t
      #f))

(define (valid-slug-character? char)
  (or (slug-alphanumeric? char)
      (char=? char #\.)
      (char=? char #\_)
      (char=? char #\-)))

(define (valid-slug? slug)
  (and (> (string-length slug) 0)
       (<= (string-length slug) 120)
       (slug-alphanumeric? (string-ref slug 0))
       (for/and ((char (in-string slug)))
         (valid-slug-character? char))
       (not (member slug '("." "..")))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Build the external wiki reference for a namespace and slug.
; pre    : namespace and slug are strings; slug is a valid page slug.
; post   : No state is changed.
; result : slug for the root namespace, otherwise namespace:slug.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (page-reference namespace slug)
  (if (string=? (string-trim namespace) "")
      slug
      (string-append (string-trim namespace) ":" slug)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Split an external page reference into namespace and slug.
; pre    : reference is a string.
; post   : No state is changed.
; result : Two values: namespace and slug. The namespace is empty for root pages.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (split-page-reference reference)
  (define match (regexp-match #px"^([^:]+):(.*)$" reference))
  (if match
      (values (list-ref match 1) (list-ref match 2))
      (values "" reference)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Check whether a namespace-qualified page reference is valid.
; pre    : reference is a string.
; post   : No state is changed.
; result : #t for root slugs or namespace:slug references with letter/number namespaces.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (valid-page-reference? reference)
  (define-values (namespace slug) (split-page-reference reference))
  (and (valid-slug? slug)
       (or (string=? namespace "")
           (and (valid-slug? namespace)
                (<= (string-length namespace) 80)))))

(define (title->slug title)
  (define normalized
    (string-downcase
     (string-normalize-nfkd (string-trim title))))
  (define out (open-output-string))
  (define separator-needed? #f)
  (define wrote-character? #f)
  (for ((char (in-string normalized)))
    (cond
      ((slug-alphanumeric? char)
       (when (and separator-needed? wrote-character?)
         (write-char #\- out))
       (write-char char out)
       (set! separator-needed? #f)
       (set! wrote-character? #t))
      ((combining-mark? char)
       (void))
      (else
       (set! separator-needed? #t))))
  (define slug (get-output-string out))
  (define limited
    (if (> (string-length slug) 120)
        (substring slug 0 120)
        slug))
  (regexp-replace #px"-+$" limited ""))

(define (tags->text tags)
  (jsexpr->string tags))

(define (text->tags text)
  (with-handlers ((exn:fail? (λ (_e) '())))
    (define value (string->jsexpr text))
    (if (list? value) value '())))

(define (row->page row [include-markdown? #t])
  (define namespace (vector-ref row 9))
  (define slug (vector-ref row 0))
  (define result
    (hash 'slug (page-reference namespace slug)
          'pageSlug slug
          'namespace namespace
          'title (vector-ref row 1)
          'createdAt (vector-ref row 3)
          'updatedAt (vector-ref row 4)
          'createdBy (vector-ref row 5)
          'updatedBy (vector-ref row 6)
          'tags (text->tags (vector-ref row 7))
          'currentVersion (vector-ref row 8)))
  (if include-markdown?
      (hash-set result 'markdown (vector-ref row 2))
      result))

(define page-columns
  "slug, title, markdown, created_at, updated_at, created_by, updated_by, tags, current_version, namespace")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : List current wiki page metadata.
; pre    : The PostgreSQL schema is initialized.
; post   : The pages table has only been read.
; result : A title-sorted list of page metadata hashes.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (list-pages config)
  (call-with-wiki-database
   config
   (λ (db)
     (for/list ((row (in-list
                      (query-rows db
                                  (string-append "SELECT " page-columns
                                                 " FROM pages WHERE archived = FALSE ORDER BY lower(namespace), namespace, lower(title), title")))))
       (row->page row #f)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Read the current form of one wiki page.
; pre    : slug is a valid page slug.
; post   : The pages table has only been read.
; result : Page metadata with Markdown, or #f when the page does not exist.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (read-page config reference)
  (if (not (valid-page-reference? reference))
      #f
      (let-values (((namespace slug) (split-page-reference reference)))
        (call-with-wiki-database
         config
         (λ (db)
           (define row
             (query-maybe-row db
                              (string-append "SELECT " page-columns
                                             " FROM pages WHERE namespace = $1 AND slug = $2 AND archived = FALSE")
                              namespace slug))
           (if row (row->page row) #f))))))


(define (replace-todos! db page-id markdown)
  (query-exec db "DELETE FROM todo_items WHERE page_id = $1" page-id)
  (for ((item (in-list (extract-todos markdown))))
    (query-exec db
                "INSERT INTO todo_items(page_id, item_number, line_number, text) VALUES ($1, $2, $3, $4)"
                page-id
                (hash-ref item 'number)
                (hash-ref item 'line)
                (hash-ref item 'text))))

(define (insert-version! db page-id version title markdown author action summary now tags)
  (query-value db
               #<<SQL
INSERT INTO page_versions(page_id, version, title, markdown, tags, author, action, summary, created_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING id
SQL
               page-id version title markdown (tags->text tags) author action summary now))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Create a wiki page and its first version.
; pre    : slug is valid and unused.
; post   : Current page state and version 1 are committed atomically.
; result : The new page metadata with Markdown.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (create-page! config reference title markdown author [summary "Created page"] [tags '()])
  (define-values (namespace slug) (split-page-reference reference))
  (call-with-wiki-database
   config
   (λ (db)
     (call-with-transaction
      db
      (λ ()
        (define now (current-seconds))
        (define page-id
          (query-value db
                       #<<SQL
INSERT INTO pages(namespace, slug, title, markdown, tags, current_version,
                  created_at, updated_at, created_by, updated_by, search_document)
VALUES ($1, $2, $3, $4, $5, 1, $6, $6, $7, $7,
        setweight(to_tsvector('simple', coalesce($3, '')), 'A') ||
        setweight(to_tsvector('simple', coalesce($4, '')), 'B'))
RETURNING id
SQL
                       namespace slug title markdown (tags->text tags) now author))
        (define page-version-id
          (insert-version! db page-id 1 title markdown author "create" summary now tags))
        (replace-todos! db page-id markdown)
        (replace-current-attachment-references! db page-id markdown now)
        (record-version-attachment-references! db page-id page-version-id markdown now)))))
  (read-page config reference))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Save a new version of an existing wiki page.
; pre    : The page exists and base-version equals its current version.
; post   : Current page and version history are committed atomically.
; result : The updated page metadata with Markdown.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (update-page! config reference title markdown author base-version [summary "Edited page"] [tags #f] [new-namespace #f])
  (define-values (namespace slug) (split-page-reference reference))
  (call-with-wiki-database
   config
   (λ (db)
     (call-with-transaction
      db
      (λ ()
        (define row
          (query-maybe-row db
                           "SELECT id, current_version, tags, namespace FROM pages WHERE namespace = $1 AND slug = $2 AND archived = FALSE FOR UPDATE"
                           namespace slug))
        (unless row
          (error 'update-page! "unknown page: ~a" slug))
        (define current-version (vector-ref row 1))
        (define supplied-version
          (if (number? base-version)
              base-version
              (string->number (format "~a" base-version))))
        (unless (and supplied-version (= current-version supplied-version))
          (error 'update-page! "version-conflict"))
        (define page-tags
          (if tags tags (text->tags (vector-ref row 2))))
        (define target-namespace
          (if (eq? new-namespace #f)
              (vector-ref row 3)
              (string-trim new-namespace)))
        (unless (or (string=? target-namespace "")
                    (and (valid-slug? target-namespace)
                         (<= (string-length target-namespace) 80)))
          (error 'update-page! "invalid namespace: ~a" target-namespace))
        (define next-version (+ current-version 1))
        (define now (current-seconds))
        (query-exec db
                    #<<SQL
UPDATE pages
SET title = $1, markdown = $2, tags = $3, current_version = $4,
    updated_at = $5, updated_by = $6, namespace = $7,
    search_document = setweight(to_tsvector('simple', coalesce($1, '')), 'A') ||
                      setweight(to_tsvector('simple', coalesce($2, '')), 'B')
WHERE id = $8
SQL
                    title markdown (tags->text page-tags) next-version now author target-namespace (vector-ref row 0))
        (define page-id (vector-ref row 0))
        (define page-version-id
          (insert-version! db page-id next-version title markdown author "edit" summary now page-tags))
        (replace-todos! db page-id markdown)
        (replace-current-attachment-references! db page-id markdown now)
        (record-version-attachment-references! db page-id page-version-id markdown now)))))
  (read-page config (page-reference (if (eq? new-namespace #f) namespace (string-trim new-namespace)) slug)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Archive an existing wiki page.
; pre    : The page exists.
; post   : The page is marked archived while its versions and attachments remain stored.
; result : void.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (archive-page! config reference author)
  (define-values (namespace slug) (split-page-reference reference))
  (call-with-wiki-database
   config
   (λ (db)
     (define id
       (query-maybe-value db
                          #<<SQL
UPDATE pages
SET archived = TRUE, archived_at = $1, archived_by = $2
WHERE namespace = $3 AND slug = $4 AND archived = FALSE
RETURNING id
SQL
                          (current-seconds) author namespace slug))
     (unless id
       (error 'archive-page! "unknown page: ~a" slug))
     (query-exec db
                 "DELETE FROM attachment_references WHERE page_id = $1 AND current_reference = TRUE"
                 id)))
  (void))

(define (page-id config reference)
  (define-values (namespace slug) (split-page-reference reference))
  (call-with-wiki-database
   config
   (λ (db)
     (query-maybe-value db
                        "SELECT id FROM pages WHERE namespace = $1 AND slug = $2 AND archived = FALSE"
                        namespace slug))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Read the version history for a wiki page.
; pre    : The page exists.
; post   : Page version rows have only been read.
; result : A newest-first list of version metadata hashes.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (page-history config reference)
  (define-values (namespace slug) (split-page-reference reference))
  (call-with-wiki-database
   config
   (λ (db)
     (define id
       (query-maybe-value db "SELECT id FROM pages WHERE namespace = $1 AND slug = $2 AND archived = FALSE" namespace slug))
     (unless id
       (error 'page-history "unknown page: ~a" slug))
     (for/list ((row (in-list
                      (query-rows db
                                  #<<SQL
SELECT version, title, author, action, summary, tags, created_at
FROM page_versions
WHERE page_id = $1
ORDER BY version DESC
SQL
                                  id))))
       (hash 'version (vector-ref row 0)
             'title (vector-ref row 1)
             'author (vector-ref row 2)
             'action (vector-ref row 3)
             'summary (vector-ref row 4)
             'tags (text->tags (vector-ref row 5))
             'createdAt (vector-ref row 6))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Read one stored page version.
; pre    : slug and version identify a possible stored version.
; post   : Version rows have only been read.
; result : Version metadata with Markdown, or #f when the version is absent.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (read-version config reference version)
  (define-values (namespace slug) (split-page-reference reference))
  (define version-number
    (if (number? version) version (string->number version)))
  (and version-number
       (call-with-wiki-database
        config
        (λ (db)
          (define row
            (query-maybe-row db
                             #<<SQL
SELECT v.version, v.title, v.markdown, v.author, v.action, v.summary, v.tags, v.created_at
FROM page_versions v
JOIN pages p ON p.id = v.page_id
WHERE p.namespace = $1 AND p.slug = $2 AND p.archived = FALSE AND v.version = $3
SQL
                             namespace slug version-number))
          (and row
               (hash 'version (vector-ref row 0)
                     'title (vector-ref row 1)
                     'markdown (vector-ref row 2)
                     'author (vector-ref row 3)
                     'action (vector-ref row 4)
                     'summary (vector-ref row 5)
                     'tags (text->tags (vector-ref row 6))
                     'createdAt (vector-ref row 7)))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Search current wiki pages using PostgreSQL full-text search.
; pre    : query-text is a string and the database schema is initialized.
; post   : Page content has only been read.
; result : Up to 50 relevance-sorted search result hashes.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (search-pages config query-text)
  (if (string=? (string-trim query-text) "")
      '()
      (call-with-wiki-database
       config
       (λ (db)
         (for/list ((row (in-list
                          (query-rows db
                                      #<<SQL
WITH q AS (SELECT websearch_to_tsquery('simple', $1) AS query)
SELECT p.slug,
       p.title,
       ts_rank(p.search_document, q.query) AS rank,
       ts_headline('simple', p.markdown, q.query,
                   'StartSel=[[[, StopSel=]]], MaxWords=28, MinWords=8, ShortWord=2') AS snippet,
       p.namespace
FROM pages p, q
WHERE p.archived = FALSE
  AND p.search_document @@ q.query
ORDER BY rank DESC, lower(p.title), p.title
LIMIT 50
SQL
                                      query-text))))
           (hash 'slug (page-reference (vector-ref row 4) (vector-ref row 0))
                 'namespace (vector-ref row 4)
                 'title (vector-ref row 1)
                 'rank (vector-ref row 2)
                 'snippet (vector-ref row 3)))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : List unresolved todo(...) markers from all current wiki pages.
; pre    : PostgreSQL schema 3 or newer is initialized.
; post   : Todo and page rows have only been read.
; result : A page/title sorted list of todo item hashes.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (list-todos config)
  (call-with-wiki-database
   config
   (λ (db)
     (for/list ((row (in-list
                      (query-rows db
                                  #<<SQL
SELECT p.slug, p.title, t.item_number, t.line_number, t.text, p.namespace
FROM todo_items t
JOIN pages p ON p.id = t.page_id
WHERE p.archived = FALSE
ORDER BY lower(p.namespace), p.namespace, lower(p.title), p.title, t.item_number
SQL
                                  ))))
       (hash 'slug (page-reference (vector-ref row 5) (vector-ref row 0))
             'namespace (vector-ref row 5)
             'title (vector-ref row 1)
             'number (vector-ref row 2)
             'line (vector-ref row 3)
             'text (vector-ref row 4))))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : List recently edited current wiki pages.
; pre    : PostgreSQL schema 1 or newer is initialized.
; post   : Page rows have only been read.
; result : At most limit page metadata hashes, newest first.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (list-recent-pages config [limit 50])
  (call-with-wiki-database
   config
   (λ (db)
     (for/list ((row (in-list
                      (query-rows db
                                  (string-append "SELECT " page-columns
                                                 " FROM pages WHERE archived = FALSE"
                                                 " ORDER BY updated_at DESC, lower(title), title"
                                                 " LIMIT $1")
                                  limit))))
       (row->page row #f)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : List bookmarks for one wiki user.
; pre    : PostgreSQL schema 4 or newer is initialized and user-id identifies a user.
; post   : Bookmark and page rows have only been read.
; result : Bookmarks ordered by section and position.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (list-bookmarks config user-id)
  (call-with-wiki-database
   config
   (λ (db)
     (for/list ((row (in-list
                      (query-rows db
                                  #<<SQL
SELECT p.slug, p.title, b.section, b.position, b.created_at, p.updated_at, p.namespace
FROM bookmarks b
JOIN pages p ON p.id = b.page_id
WHERE b.user_id = $1
  AND p.archived = FALSE
ORDER BY lower(p.namespace), p.namespace, lower(b.section), b.section, b.position, b.created_at, lower(p.title), p.title
SQL
                                  user-id))))
       (hash 'slug (page-reference (vector-ref row 6) (vector-ref row 0))
             'namespace (vector-ref row 6)
             'title (vector-ref row 1)
             'section (vector-ref row 2)
             'position (vector-ref row 3)
             'createdAt (vector-ref row 4)
             'updatedAt (vector-ref row 5))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Add a page to a user's bookmarks or move it to another section.
; pre    : PostgreSQL schema 4 or newer is initialized and slug identifies a current page.
; post   : Exactly one bookmark exists for user-id and the page.
; result : void.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (set-bookmark! config user-id reference section)
  (define-values (namespace slug) (split-page-reference reference))
  (call-with-wiki-database
   config
   (λ (db)
     (call-with-transaction
      db
      (λ ()
        (define page-id
          (query-maybe-value db
                             "SELECT id FROM pages WHERE namespace = $1 AND slug = $2 AND archived = FALSE"
                             namespace slug))
        (unless page-id
          (error 'set-bookmark! "unknown page: ~a" slug))
        (define clean-section (string-trim section))
        (define position
          (query-value db
                       #<<SQL
SELECT COALESCE(MAX(position), -1) + 1
FROM bookmarks
WHERE user_id = $1 AND section = $2
SQL
                       user-id
                       clean-section))
        (query-exec db
                    #<<SQL
INSERT INTO bookmarks(user_id, page_id, section, position, created_at)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (user_id, page_id)
DO UPDATE SET section = EXCLUDED.section, position = EXCLUDED.position
SQL
                    user-id page-id clean-section position (current-seconds))))))
  (void))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Remove one page from a user's bookmarks.
; pre    : PostgreSQL schema 4 or newer is initialized.
; post   : The bookmark no longer exists; other bookmarks are unchanged.
; result : void.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (delete-bookmark! config user-id reference)
  (define-values (namespace slug) (split-page-reference reference))
  (call-with-wiki-database
   config
   (λ (db)
     (query-exec db
                 #<<SQL
DELETE FROM bookmarks
WHERE user_id = $1
  AND page_id = (SELECT id FROM pages WHERE namespace = $2 AND slug = $3)
SQL
                 user-id namespace slug)))
  (void))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : List uploads that no current page references.
; pre    : PostgreSQL schema 6 or newer is initialized.
; post   : Attachment and reference rows have only been read.
; result : A newest-first list with owner and last historical use metadata.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (list-orphaned-uploads config)
  (call-with-wiki-database
   config
   (λ (db)
     (for/list ((row (in-list
                      (query-rows db
                                  #<<SQL
SELECT a.id,
       a.original_name,
       a.stored_name,
       a.mime_type,
       a.size,
       a.uploaded_at,
       a.uploaded_by,
       owner.slug,
       owner.title,
       owner.namespace
FROM attachments a
JOIN pages owner ON owner.id = a.page_id
WHERE NOT EXISTS (
  SELECT 1
  FROM attachment_references current_ref
  WHERE current_ref.attachment_id = a.id
    AND current_ref.current_reference = TRUE
)
ORDER BY a.uploaded_at DESC, a.id DESC
SQL
                                  ))))
       (define attachment-id (vector-ref row 0))
       (define last-uses
         (for/list ((use-row (in-list
                              (query-rows db
                                          #<<SQL
SELECT p.slug, p.title, pv.version, ar.referenced_at, p.namespace
FROM attachment_references ar
JOIN pages p ON p.id = ar.page_id
LEFT JOIN page_versions pv ON pv.id = ar.page_version_id
WHERE ar.attachment_id = $1
  AND ar.current_reference = FALSE
ORDER BY ar.referenced_at DESC, ar.id DESC
LIMIT 5
SQL
                                          attachment-id))))
           (hash 'slug (page-reference (vector-ref use-row 4) (vector-ref use-row 0))
                 'namespace (vector-ref use-row 4)
                 'title (vector-ref use-row 1)
                 'version (if (sql-null? (vector-ref use-row 2)) #f (vector-ref use-row 2))
                 'referencedAt (vector-ref use-row 3))))
       (hash 'id attachment-id
             'originalName (vector-ref row 1)
             'storedName (vector-ref row 2)
             'mimeType (vector-ref row 3)
             'size (vector-ref row 4)
             'uploadedAt (vector-ref row 5)
             'uploadedBy (vector-ref row 6)
             'ownerSlug (page-reference (vector-ref row 9) (vector-ref row 7))
             'ownerNamespace (vector-ref row 9)
             'ownerTitle (vector-ref row 8)
             'lastUses last-uses)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Delete an upload only when no current page references it.
; pre    : attachment-id identifies a possible attachment.
; post   : The attachment and its reference rows are deleted, or an error is raised.
; result : void.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (delete-orphaned-upload! config attachment-id)
  (call-with-wiki-database
   config
   (λ (db)
     (call-with-transaction
      db
      (λ ()
        (define current-count
          (query-value db
                       "SELECT COUNT(*) FROM attachment_references WHERE attachment_id = $1 AND current_reference = TRUE"
                       attachment-id))
        (when (> current-count 0)
          (error 'delete-orphaned-upload! "attachment is still referenced by a current page"))
        (define deleted-id
          (query-maybe-value db
                             "DELETE FROM attachments WHERE id = $1 RETURNING id"
                             attachment-id))
        (unless deleted-id
          (error 'delete-orphaned-upload! "unknown attachment: ~a" attachment-id))))))
  (void))

(define (safe-file-name name)
  (define clean
    (regexp-replace* #px"[^A-Za-z0-9._ -]" name "_"))
  (if (or (string=? clean "")
          (string=? clean ".")
          (string=? clean ".."))
      "upload.bin"
      clean))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Store an uploaded file in PostgreSQL.
; pre    : The page exists and content is a byte string.
; post   : Attachment metadata and bytes are stored in one PostgreSQL row.
; result : A hash containing original name, stored name and page-local URL.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (save-upload! config reference original-name content author)
  (define id (page-id config reference))
  (unless id
    (error 'save-upload! "unknown page: ~a" reference))
  (define stored-name
    (format "~a-~a-~a" (current-seconds) (random 1000000) (safe-file-name original-name)))
  (define mime-type
    (cond
      ((regexp-match? #px"(?i:[.]png)$" stored-name) "image/png")
      ((regexp-match? #px"(?i:[.](jpg|jpeg))$" stored-name) "image/jpeg")
      ((regexp-match? #px"(?i:[.]gif)$" stored-name) "image/gif")
      ((regexp-match? #px"(?i:[.]webp)$" stored-name) "image/webp")
      ((regexp-match? #px"(?i:[.]pdf)$" stored-name) "application/pdf")
      ((regexp-match? #px"(?i:[.]txt)$" stored-name) "text/plain; charset=utf-8")
      (else "application/octet-stream")))
  (call-with-wiki-database
   config
   (λ (db)
     (query-exec db
                 #<<SQL
INSERT INTO attachments(page_id, original_name, stored_name, mime_type, content,
                        size, uploaded_at, uploaded_by)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
SQL
                 id
                 original-name
                 stored-name
                 mime-type
                 content
                 (bytes-length content)
                 (current-seconds)
                 author)))
  (hash 'name original-name
        'storedName stored-name
        'url (format "/uploads/~a/~a" reference stored-name)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; goal   : Read one stored attachment from PostgreSQL.
; pre    : slug and stored-name come from an upload request path.
; post   : PostgreSQL has only been read.
; result : A hash containing bytes, MIME type and names, or #f when absent.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (uploaded-file config reference stored-name)
  (define-values (namespace slug) (split-page-reference reference))
  (and (valid-page-reference? reference)
       (not (regexp-match? #px"[/\\\\]" stored-name))
       (call-with-wiki-database
        config
        (λ (db)
          (define row
            (query-maybe-row db
                             #<<SQL
SELECT a.original_name, a.stored_name, a.mime_type, a.content, a.size
FROM attachments a
JOIN pages p ON p.id = a.page_id
WHERE p.slug = $1 AND p.archived = FALSE AND a.stored_name = $2
ORDER BY CASE WHEN p.namespace = $3 THEN 0 ELSE 1 END, a.id
LIMIT 1
SQL
                             slug stored-name namespace))
          (if row
              (hash 'originalName (vector-ref row 0)
                    'storedName (vector-ref row 1)
                    'mimeType (vector-ref row 2)
                    'content (vector-ref row 3)
                    'size (vector-ref row 4))
              #f)))))