[feature] Push notifications (#3587)

* Update push subscription API model to be Mastodon 4.0 compatible

* Add webpush-go dependency

# Conflicts:
#	go.sum

* Single-row table for storing instance's VAPID key pair

* Generate VAPID key pair during startup

* Add VAPID public key to instance info API

* Return VAPID public key when registering an app

* Store Web Push subscriptions in DB

* Add Web Push sender (similar to email sender)

* Add no-op push senders to most processor tests

* Test Web Push notifications from workers

* Delete Web Push subscriptions when account is deleted

* Implement push subscription API

* Linter fixes

* Update Swagger

* Fix enum to int migration

* Fix GetVAPIDKeyPair

* Create web push subscriptions table with indexes

* Log Web Push server error messages

* Send instance URL as Web Push JWT subject

* Accept any 2xx code as a success

* Fix malformed VAPID sub claim

* Use packed notification flags

* Remove unused date columns

* Add notification type for update notifications

Not used yet

* Make GetVAPIDKeyPair idempotent

and remove PutVAPIDKeyPair

* Post-rebase fixes

* go mod tidy

* Special-case 400 errors other than 408/429

Most client errors should remove the subscription.

* Improve titles, trim body to reasonable length

* Disallow cleartext HTTP for Web Push servers

* Fix lint

* Remove redundant index on unique column

Also removes redundant unique and notnull tags on ID column since these are implied by pk

* Make realsender.go more readable

* Use Tobi's style for wrapping errors

* Restore treating all 5xx codes as temporary problems

* Always load target account settings

* Stub `policy` and `standard`

* webpush.Sender: take type converter as ctor param

* Move webpush.MockSender and noopSender into testrig

vendor/github.com/rivo/uniseg/wordrules.go

@@ -0,0 +1,282 @@
+package uniseg
+
+import "unicode/utf8"
+
+// The states of the word break parser.
+const (
+	wbAny = iota
+	wbCR
+	wbLF
+	wbNewline
+	wbWSegSpace
+	wbHebrewLetter
+	wbALetter
+	wbWB7
+	wbWB7c
+	wbNumeric
+	wbWB11
+	wbKatakana
+	wbExtendNumLet
+	wbOddRI
+	wbEvenRI
+	wbZWJBit = 16 // This bit is set for any states followed by at least one zero-width joiner (see WB4 and WB3c).
+)
+
+// wbTransitions implements the word break parser's state transitions. It's
+// anologous to [grTransitions], see comments there for details.
+//
+// Unicode version 15.0.0.
+func wbTransitions(state, prop int) (newState int, wordBreak bool, rule int) {
+	switch uint64(state) | uint64(prop)<<32 {
+	// WB3b.
+	case wbAny | prNewline<<32:
+		return wbNewline, true, 32
+	case wbAny | prCR<<32:
+		return wbCR, true, 32
+	case wbAny | prLF<<32:
+		return wbLF, true, 32
+
+	// WB3a.
+	case wbNewline | prAny<<32:
+		return wbAny, true, 31
+	case wbCR | prAny<<32:
+		return wbAny, true, 31
+	case wbLF | prAny<<32:
+		return wbAny, true, 31
+
+	// WB3.
+	case wbCR | prLF<<32:
+		return wbLF, false, 30
+
+	// WB3d.
+	case wbAny | prWSegSpace<<32:
+		return wbWSegSpace, true, 9990
+	case wbWSegSpace | prWSegSpace<<32:
+		return wbWSegSpace, false, 34
+
+	// WB5.
+	case wbAny | prALetter<<32:
+		return wbALetter, true, 9990
+	case wbAny | prHebrewLetter<<32:
+		return wbHebrewLetter, true, 9990
+	case wbALetter | prALetter<<32:
+		return wbALetter, false, 50
+	case wbALetter | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 50
+	case wbHebrewLetter | prALetter<<32:
+		return wbALetter, false, 50
+	case wbHebrewLetter | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 50
+
+	// WB7. Transitions to wbWB7 handled by transitionWordBreakState().
+	case wbWB7 | prALetter<<32:
+		return wbALetter, false, 70
+	case wbWB7 | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 70
+
+	// WB7a.
+	case wbHebrewLetter | prSingleQuote<<32:
+		return wbAny, false, 71
+
+	// WB7c. Transitions to wbWB7c handled by transitionWordBreakState().
+	case wbWB7c | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 73
+
+	// WB8.
+	case wbAny | prNumeric<<32:
+		return wbNumeric, true, 9990
+	case wbNumeric | prNumeric<<32:
+		return wbNumeric, false, 80
+
+	// WB9.
+	case wbALetter | prNumeric<<32:
+		return wbNumeric, false, 90
+	case wbHebrewLetter | prNumeric<<32:
+		return wbNumeric, false, 90
+
+	// WB10.
+	case wbNumeric | prALetter<<32:
+		return wbALetter, false, 100
+	case wbNumeric | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 100
+
+	// WB11. Transitions to wbWB11 handled by transitionWordBreakState().
+	case wbWB11 | prNumeric<<32:
+		return wbNumeric, false, 110
+
+	// WB13.
+	case wbAny | prKatakana<<32:
+		return wbKatakana, true, 9990
+	case wbKatakana | prKatakana<<32:
+		return wbKatakana, false, 130
+
+	// WB13a.
+	case wbAny | prExtendNumLet<<32:
+		return wbExtendNumLet, true, 9990
+	case wbALetter | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbHebrewLetter | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbNumeric | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbKatakana | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbExtendNumLet | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+
+	// WB13b.
+	case wbExtendNumLet | prALetter<<32:
+		return wbALetter, false, 132
+	case wbExtendNumLet | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 132
+	case wbExtendNumLet | prNumeric<<32:
+		return wbNumeric, false, 132
+	case wbExtendNumLet | prKatakana<<32:
+		return wbKatakana, false, 132
+
+	default:
+		return -1, false, -1
+	}
+}
+
+// transitionWordBreakState determines the new state of the word break parser
+// given the current state and the next code point. It also returns whether a
+// word boundary was detected. If more than one code point is needed to
+// determine the new state, the byte slice or the string starting after rune "r"
+// can be used (whichever is not nil or empty) for further lookups.
+func transitionWordBreakState(state int, r rune, b []byte, str string) (newState int, wordBreak bool) {
+	// Determine the property of the next character.
+	nextProperty := property(workBreakCodePoints, r)
+
+	// "Replacing Ignore Rules".
+	if nextProperty == prZWJ {
+		// WB4 (for zero-width joiners).
+		if state == wbNewline || state == wbCR || state == wbLF {
+			return wbAny | wbZWJBit, true // Make sure we don't apply WB4 to WB3a.
+		}
+		if state < 0 {
+			return wbAny | wbZWJBit, false
+		}
+		return state | wbZWJBit, false
+	} else if nextProperty == prExtend || nextProperty == prFormat {
+		// WB4 (for Extend and Format).
+		if state == wbNewline || state == wbCR || state == wbLF {
+			return wbAny, true // Make sure we don't apply WB4 to WB3a.
+		}
+		if state == wbWSegSpace || state == wbAny|wbZWJBit {
+			return wbAny, false // We don't break but this is also not WB3d or WB3c.
+		}
+		if state < 0 {
+			return wbAny, false
+		}
+		return state, false
+	} else if nextProperty == prExtendedPictographic && state >= 0 && state&wbZWJBit != 0 {
+		// WB3c.
+		return wbAny, false
+	}
+	if state >= 0 {
+		state = state &^ wbZWJBit
+	}
+
+	// Find the applicable transition in the table.
+	var rule int
+	newState, wordBreak, rule = wbTransitions(state, nextProperty)
+	if newState < 0 {
+		// No specific transition found. Try the less specific ones.
+		anyPropState, anyPropWordBreak, anyPropRule := wbTransitions(state, prAny)
+		anyStateState, anyStateWordBreak, anyStateRule := wbTransitions(wbAny, nextProperty)
+		if anyPropState >= 0 && anyStateState >= 0 {
+			// Both apply. We'll use a mix (see comments for grTransitions).
+			newState, wordBreak, rule = anyStateState, anyStateWordBreak, anyStateRule
+			if anyPropRule < anyStateRule {
+				wordBreak, rule = anyPropWordBreak, anyPropRule
+			}
+		} else if anyPropState >= 0 {
+			// We only have a specific state.
+			newState, wordBreak, rule = anyPropState, anyPropWordBreak, anyPropRule
+			// This branch will probably never be reached because okAnyState will
+			// always be true given the current transition map. But we keep it here
+			// for future modifications to the transition map where this may not be
+			// true anymore.
+		} else if anyStateState >= 0 {
+			// We only have a specific property.
+			newState, wordBreak, rule = anyStateState, anyStateWordBreak, anyStateRule
+		} else {
+			// No known transition. WB999: Any ÷ Any.
+			newState, wordBreak, rule = wbAny, true, 9990
+		}
+	}
+
+	// For those rules that need to look up runes further in the string, we
+	// determine the property after nextProperty, skipping over Format, Extend,
+	// and ZWJ (according to WB4). It's -1 if not needed, if such a rune cannot
+	// be determined (because the text ends or the rune is faulty).
+	farProperty := -1
+	if rule > 60 &&
+		(state == wbALetter || state == wbHebrewLetter || state == wbNumeric) &&
+		(nextProperty == prMidLetter || nextProperty == prMidNumLet || nextProperty == prSingleQuote || // WB6.
+			nextProperty == prDoubleQuote || // WB7b.
+			nextProperty == prMidNum) { // WB12.
+		for {
+			var (
+				r      rune
+				length int
+			)
+			if b != nil { // Byte slice version.
+				r, length = utf8.DecodeRune(b)
+				b = b[length:]
+			} else { // String version.
+				r, length = utf8.DecodeRuneInString(str)
+				str = str[length:]
+			}
+			if r == utf8.RuneError {
+				break
+			}
+			prop := property(workBreakCodePoints, r)
+			if prop == prExtend || prop == prFormat || prop == prZWJ {
+				continue
+			}
+			farProperty = prop
+			break
+		}
+	}
+
+	// WB6.
+	if rule > 60 &&
+		(state == wbALetter || state == wbHebrewLetter) &&
+		(nextProperty == prMidLetter || nextProperty == prMidNumLet || nextProperty == prSingleQuote) &&
+		(farProperty == prALetter || farProperty == prHebrewLetter) {
+		return wbWB7, false
+	}
+
+	// WB7b.
+	if rule > 72 &&
+		state == wbHebrewLetter &&
+		nextProperty == prDoubleQuote &&
+		farProperty == prHebrewLetter {
+		return wbWB7c, false
+	}
+
+	// WB12.
+	if rule > 120 &&
+		state == wbNumeric &&
+		(nextProperty == prMidNum || nextProperty == prMidNumLet || nextProperty == prSingleQuote) &&
+		farProperty == prNumeric {
+		return wbWB11, false
+	}
+
+	// WB15 and WB16.
+	if newState == wbAny && nextProperty == prRegionalIndicator {
+		if state != wbOddRI && state != wbEvenRI { // Includes state == -1.
+			// Transition into the first RI.
+			return wbOddRI, true
+		}
+		if state == wbOddRI {
+			// Don't break pairs of Regional Indicators.
+			return wbEvenRI, false
+		}
+		return wbOddRI, true // We can break after a pair.
+	}
+
+	return
+}