rename client, update docs/skills

packages/app/src/policy.ts

@@ -0,0 +1,145 @@
+import type {Unsubscriber} from "svelte/store"
+import {on, noop, always, call} from "@welshman/lib"
+import {WRAP, isDVMKind, isEphemeralKind, verifyEvent} from "@welshman/util"
+import type {TrustedEvent} from "@welshman/util"
+import {SocketEvent, isRelayEvent, makeSocketPolicyAuth} from "@welshman/net"
+import type {RelayMessage, Socket} from "@welshman/net"
+import type {IApp} from "./app.js"
+import {RelayStats} from "./plugins/relayStats.js"
+import {Wraps} from "./plugins/wraps.js"
+import {BlockedRelayLists} from "./plugins/blockedRelayLists.js"
+import {LoggingSigner} from "./logging.js"
+import type {LogMessage} from "./logging.js"
+
+/**
+ * An app policy is a side effect applied once per app at construction,
+ * returning a cleanup function — directly analogous to a socket policy. Policies
+ * own everything that subscribes or links components together (event ingestion,
+ * stats collection, gift-wrap unwrapping), so the data classes themselves stay
+ * pure and free of subscriptions, and teardown is centralized in `cleanup()`.
+ */
+export type AppPolicy = (app: IApp) => Unsubscriber
+
+/**
+ * Builds an app policy that authenticates the app's sockets (NIP-42) with
+ * the user's signer. It appends an auth socket policy to the pool's
+ * `socketPolicies`, so every socket the pool creates answers AUTH challenges
+ * according to `shouldAuth`; the policy is spliced back out on cleanup. No-op
+ * when the app has no user.
+ *
+ * Use the `appPolicyAuthAlways` / `appPolicyAuthNever` presets below, or
+ * call this with a custom predicate.
+ */
+export const makeAppPolicyAuth =
+  (shouldAuth: (socket: Socket, app: IApp) => boolean): AppPolicy =>
+  app => {
+    if (!app.user) {
+      return noop
+    }
+
+    const policy = makeSocketPolicyAuth({
+      sign: app.user.signer.sign,
+      shouldAuth: socket => shouldAuth(socket, app),
+    })
+
+    app.pool.socketPolicies.push(policy)
+
+    return () => {
+      const index = app.pool.socketPolicies.indexOf(policy)
+
+      if (index !== -1) {
+        app.pool.socketPolicies.splice(index, 1)
+      }
+    }
+  }
+
+export const appPolicyAuthNever = makeAppPolicyAuth(always(false))
+
+export const appPolicyAuthAlways = makeAppPolicyAuth(always(true))
+
+export const appPolicyAuthUnlessBlocked = makeAppPolicyAuth((socket, app) => {
+  if (!app.user) {
+    return false
+  }
+
+  return !app
+    .use(BlockedRelayLists)
+    .urls(app.user.pubkey)
+    .get()
+    .includes(socket.url)
+})
+
+/**
+ * Ingests every event received on any socket into the app's repository. The
+ * net layer doesn't do this for us, and it's how all the repository-backed
+ * collections (and gift-wrap unwrapping) get populated.
+ */
+export const appPolicyIngest: AppPolicy = app =>
+  app.pool.subscribe(socket => {
+    const onReceive = (message: RelayMessage) => {
+      if (!isRelayEvent(message)) return
+
+      const event = message[2]
+
+      if (isDVMKind(event.kind) || isEphemeralKind(event.kind)) return
+      if (!verifyEvent(event)) return
+
+      app.tracker.track(event.id, socket.url)
+      app.repository.publish(event)
+    }
+
+    socket.on(SocketEvent.Receive, onReceive)
+
+    return () => socket.off(SocketEvent.Receive, onReceive)
+  })
+
+/**
+ * Listens to socket activity on the app's pool into the RelayStats store.
+ */
+export const appPolicyRelayStats: AppPolicy = app => {
+  return app.pool.subscribe(app.use(RelayStats).monitorSocket)
+}
+
+/**
+ * Watches the app's repository for gift wraps (existing and incoming) and
+ * feeds them to the unwrap queue.
+ */
+export const appPolicyWraps: AppPolicy = app => {
+  const wraps = app.use(Wraps)
+
+  for (const wrap of app.repository.query([{kinds: [WRAP]}])) {
+    wraps.enqueue(wrap)
+  }
+
+  return on(app.repository, "update", ({added}: {added: TrustedEvent[]}) => {
+    for (const event of added) {
+      if (event.kind === WRAP) {
+        wraps.enqueue(event)
+      }
+    }
+  })
+}
+
+/**
+ * Forwards "message" events from the user's signer to `onMessage`. Opt-in —
+ * add `makeAppPolicyLogger(handler)` to an app's `policies`.
+ */
+export const makeAppPolicyLogger =
+  (onMessage: (message: LogMessage) => void): AppPolicy =>
+  app => {
+    const unsubscribers: Unsubscriber[] = []
+    const signer = app.user?.signer
+
+    if (signer instanceof LoggingSigner) {
+      unsubscribers.push(on(signer, "message", onMessage))
+    }
+
+    return () => unsubscribers.forEach(call)
+  }
+
+export const defaultAppPolicies: AppPolicy[] = [
+  appPolicyIngest,
+  appPolicyRelayStats,
+  appPolicyWraps,
+  appPolicyAuthUnlessBlocked,
+]