use strfry scan

2 files changed, 72 insertions, 119 deletions

diff --git a/routes/nostr.ts b/routes/nostr.ts
index b909f1ab..6c252927 100644
--- a/routes/nostr.ts
+++ b/routes/nostr.ts
@@ -9,7 +9,8 @@ import {
   send,
   serverPubkey,
 } from "$lib/nostr";
-import { bail, fail, getUser } from "$lib/utils";
+import { count, scan } from "$lib/strfry";
+import { bail, fail, getUser, publicFields } from "$lib/utils";
 import { decode } from "nostr-tools/nip19";
 import type { ProfilePointer } from "nostr-tools/nip19";
 
@@ -59,65 +60,41 @@ export default {
   async follows(req, res) {
     const {
       params: { pubkey },
-      query: { pubkeysOnly, nocache },
+      query: { limit = 20, offset = 0, pubkeysOnly },
     } = req;
     try {
-      let created_at;
-      let follows = [];
-
-      let pubkeys = await g(`${pubkey}:pubkeys`);
-      if (!pubkeys || !pubkeysOnly || nocache) {
-        let filter = { kinds: [3], authors: [pubkey] };
-        let ev = await pool.get([config.nostr], filter, opts);
-
-        if (!ev) {
-          let { relays } = config;
-          ({ write: relays } = await getRelays(pubkey));
-
-          filter = { kinds: [3], authors: [pubkey] };
-          ev = await pool.get(relays, filter, opts);
-          send(ev);
-        }
+      const events = await scan({ authors: [pubkey], kinds: [3] });
+      if (!events.length) return res.send([]);
 
-        let tags = [];
+      const event = events[0];
+      const pubkeys = event.tags
+        .filter((tag) => tag[0] === "p")
+        .map((tag) => tag[1])
+        .slice(offset, limit);
 
-        if (ev) ({ created_at, tags } = ev);
-        pubkeys = tags
-          .map((t) => t[0] === "p" && t[1])
-          .filter((p) => p && p.length === 64);
-
-        await s(`${pubkey}:pubkeys`, pubkeys);
-      }
-      if (!pubkeys.length || pubkeysOnly) return res.send(pubkeys);
-
-      const cache = await g(`${pubkey}:follows`);
-      if (cache && cache.t >= created_at) ({ follows } = cache);
+      let follows = [];
+      if (pubkeysOnly) follows = pubkeys;
       else {
-        const filter: any = { cache: ["user_infos", { pubkeys }] };
-        const infos = await pool.querySync([config.cache], filter, opts);
-        const profiles = infos.filter((e) => e.kind === 0);
-
-        const f = infos.find((e) => e.kind === 10000133);
-        let counts = {};
-        if (f) counts = JSON.parse(f.content);
-
+        const profiles = await scan({ authors: pubkeys, kinds: [0] });
         for (const p of profiles) {
           const { content, pubkey } = p;
-          const user = JSON.parse(content);
-          user.count = counts[pubkey];
+          let user = await getUser(pubkey, publicFields);
+          user = { ...user, ...JSON.parse(content) };
           user.pubkey = pubkey;
           follows.push(user);
         }
 
-        const followKeys = follows.map((f) => f.pubkey);
-        const missing = pubkeys
-          .filter((p) => !followKeys.includes(p))
-          .map((pubkey) => anon(pubkey));
+        const keys = follows.map((f) => f.pubkey);
+        const missing = await Promise.all(
+          pubkeys
+            .filter((p) => !keys.includes(p))
+            .map(
+              async (pubkey) =>
+                (await getUser(pubkey, publicFields)) || anon(pubkey),
+            ),
+        );
 
-        follows.sort((a: any, b: any) => b.count - a.count);
         follows.push(...missing);
-
-        s(`${pubkey}:follows`, { follows, t: created_at });
       }
 
       res.send(follows);
@@ -130,38 +107,36 @@ export default {
   async followers(req, res) {
     const {
       params: { pubkey },
+      query: { limit = 20, offset = 0 },
     } = req;
     try {
-      let filter: any = { kinds: [3], "#p": [pubkey] };
-      const ev = await pool.get([config.nostr], filter, opts);
-      let created_at;
-      if (ev) ({ created_at } = ev);
+      const filter = { kinds: [3], "#p": [pubkey] };
+      const events = await scan({ ...filter, limit });
+      if (!events.length) return res.send([]);
 
-      let followers = [];
-      const cache = await g(`${pubkey}:followers`);
-      if (cache && cache.t >= created_at) ({ followers } = cache);
-      else {
-        filter = { cache: ["user_followers", { pubkey }] };
-        const data = await pool.querySync([config.cache], filter, opts);
-        for (const ev of data.filter((f) => f.kind === 0)) {
-          const { content, pubkey } = ev;
-          const user = JSON.parse(content);
-          user.pubkey = pubkey;
-          followers.push(user);
-        }
+      const pubkeys = events.map((e) => e.pubkey).slice(offset, limit);
 
-        const pubkeys = followers.map((f) => f.pubkey);
-        filter = { cache: ["user_infos", { pubkeys }] };
-        const infos = await pool.querySync([config.cache], filter, opts);
+      const followers = [];
+      const profiles = await scan({ authors: pubkeys, kinds: [0] });
+      for (const p of profiles) {
+        const { content, pubkey } = p;
+        let user = await getUser(pubkey, publicFields);
+        user = { ...user, ...JSON.parse(content) };
+        user.pubkey = pubkey;
+        followers.push(user);
+      }
 
-        let counts = {};
-        const f = infos.find((e) => e.kind === 10000133);
-        if (f) counts = JSON.parse(f.content);
-        followers.map((f) => (f.count = counts[f.pubkey]));
-        followers.sort((a: any, b: any) => b.count - a.count);
+      const keys = followers.map((f) => f.pubkey);
+      const missing = await Promise.all(
+        pubkeys
+          .filter((p) => !keys.includes(p))
+          .map(
+            async (pubkey) =>
+              (await getUser(pubkey, publicFields)) || anon(pubkey),
+          ),
+      );
 
-        await s(`${pubkey}:followers`, { followers, t: created_at });
-      }
+      followers.push(...missing);
 
       res.send(followers);
     } catch (e) {
diff --git a/routes/users.ts b/routes/users.ts
index af5794d5..dc3636e8 100644
--- a/routes/users.ts
+++ b/routes/users.ts
@@ -10,7 +10,7 @@ import { reconcile, types } from "$lib/payments";
 import register from "$lib/register";
 import { emit } from "$lib/sockets";
 import upload from "$lib/upload";
-import { bail, fail, getUser, pick } from "$lib/utils";
+import { bail, fail, publicFields, getUser, pick } from "$lib/utils";
 import whitelist from "$lib/whitelist";
 import rpc from "@coinos/rpc";
 import { bytesToHex, randomBytes } from "@noble/hashes/utils";
@@ -114,29 +114,10 @@ export default {
 
       if (!user) return res.code(500).send("User not found");
 
-      const whitelist = [
-        "about",
-        "anon",
-        "banner",
-        "banner",
-        "currency",
-        "display",
-        "id",
-        "hidepay",
-        "lud16",
-        "memoPrompt",
-        "npub",
-        "picture",
-        "prompt",
-        "pubkey",
-        "username",
-        "website",
-      ];
-
       if (user.pubkey) user.npub = nip19.npubEncode(user.pubkey);
       user.prompt = !!user.prompt;
 
-      res.send(pick(user, whitelist));
+      res.send(pick(user, publicFields));
     } catch (e) {
       err("problem getting user", e.message);
       res.code(500).send(e.message);
@@ -213,9 +194,17 @@ export default {
       l("updating user", user.username);
 
       const { confirm, password, pin, newpin, username } = body;
+      let exists;
 
       let { pubkey } = body;
       if (pubkey) {
+        exists = await getUser(pubkey);
+        if (exists && ![username].includes(exists.username)) {
+          warn("key in use", pubkey, exists.username);
+          if (exists.anon) await db.del(`user:${pubkey}`);
+          else fail("Key in use by another account");
+        }
+
         const { challenge } = body;
         const event = JSON.parse(body.event);
         const c = await g(`challenge:${challenge}`);
@@ -241,32 +230,21 @@ export default {
         user.pin = newpin;
       if (user.pin === "delete") user.pin = undefined;
 
-      let exists;
-      if (username) exists = await getUser(username);
-
-      let token;
-      let oldname;
-      if (
-        username &&
-        user.username.toLowerCase() !== username.toLowerCase() &&
-        exists
-      ) {
-        err("username taken", username, user.username, exists.username);
-        fail("Username taken");
-      } else if (username) {
-        if (user.username.toLowerCase() !== username.toLowerCase())
-          l("changing username", user.username, username);
+      if (username) {
+        let oldname;
+        exists = await getUser(username);
 
-        await db.del(`user:${user.username}`);
-        oldname = user.username;
-        user.username = username;
-      }
+        if (user.username.toLowerCase() !== username.toLowerCase() && exists) {
+          err("username taken", username, user.username, exists.username);
+          fail("Username taken");
+        } else if (username) {
+          if (user.username.toLowerCase() !== username.toLowerCase())
+            l("changing username", user.username, username);
 
-      if (pubkey) exists = await getUser(pubkey);
-      if (exists && ![oldname, username].includes(exists.username)) {
-        warn("key in use", pubkey, exists.username);
-        if (exists.anon) await db.del(`user:${pubkey}`);
-        else fail("Key in use by another account");
+          await db.del(`user:${user.username}`);
+          oldname = user.username;
+          user.username = username;
+        }
       }
 
       const attributes = [
@@ -319,7 +297,7 @@ export default {
       if (user.nip5) await db.sAdd("nip5", `${user.username}:${user.pubkey}`);
 
       emit(user.id, "user", user);
-      res.send({ user, token });
+      res.send({ user });
     } catch (e) {
       warn("failed to update", user.username, e.message);
       bail(res, e.message);