toggle self-notification

secret dev setting

atproto-notifications/src/components/setup/Chrome.tsx

···
+import { useCallback, useEffect, useState } from 'react';
 import { Link } from 'react-router';
 import { Handle } from '../User';
+import { GetJson, postJson } from '../Fetch';
 import './Chrome.css';
 
+function Header({ user, onLogout }) {
+  return (
+    <header id="app-header">
+      <h1>
+        <Link to="/" className="inherit-font">
+          spacedust notifications&nbsp;<span className="demo">demo!</span>
+        </Link>
+      </h1>
+      {user && (
+        <div className="current-user">
+          <p>
+            <span className="handle">
+              <Handle did={user.did} />
+              {user.role !== 'public' && (
+                <span className="chrome-role-tag">
+                  {user.role === 'admin' ? (
+                    <Link to="/admin" className="inherit-font">{user.role}</Link>
+                  ) : user.role === 'early' ? (
+                    <Link to="/early" className="inherit-font">{user.role}</Link>
+                  ) : (
+                    <>{user.role}</>
+                  )}
+                </span>
+              )}
+            </span>
+            <button className="subtle bad" onClick={onLogout}>&times;</button>
+          </p>
+        </div>
+      )}
+    </header>
+  );
+}
+
 export function Chrome({ user, onLogout, children }) {
-  const content = children;
-  const logout = () => null;
+  const [secretDevCounter, setSecretDevCounter] = useState(0);
+  const [secretDevStatus, setSecretDevStatus] = useState(null);
+
+  // ~~is this the best way~~ does it work? yeh
+  const setSelfNotify = useCallback(async enabled => {
+    setSecretDevStatus('pending');
+    const host = import.meta.env.VITE_NOTIFICATIONS_HOST;
+    const url = new URL('/global-notify', host);
+    try {
+      await postJson(url, JSON.stringify({ notify_self: enabled }), true)
+      setSecretDevStatus(null);
+    } catch (err) {
+      console.error('failed to set self-notify setting', err);
+      setSecretDevStatus('failed');
+    }
+    setSecretDevCounter(n => n + 1);
+  });
+
   return (
     <>
-      <header id="app-header">
-        <h1>
-          <Link to="/" className="inherit-font">
-            spacedust notifications&nbsp;<span className="demo">demo!</span>
-          </Link>
-        </h1>
-        {user && (
-          <div className="current-user">
-            <p>
-              <span className="handle">
-                <Handle did={user.did} />
-                {user.role !== 'public' && (
-                  <span className="chrome-role-tag">
-                    {user.role === 'admin' ? (
-                      <Link to="/admin" className="inherit-font">{user.role}</Link>
-                    ) : user.role === 'early' ? (
-                      <Link to="/early" className="inherit-font">{user.role}</Link>
-                    ) : (
-                      <>{user.role}</>
-                    )}
-                  </span>
-                )}
-              </span>
-              <button className="subtle bad" onClick={onLogout}>&times;</button>
-            </p>
-          </div>
-        )}
-      </header>
+      <Header user={user} onLogout={onLogout} />
 
       <div id="app-content">
-        {content}
+        {children}
       </div>
 
       <div className="footer">
···
         <p className="secret-dev">
           secret dev setting:
           {' '}
-          <label>
-            <input
-              type="checkbox"
-              onChange={e => setDev(e.target.checked)}
-              checked={true /*isDev(ufosHost)*/}
-            />
-            localhost
-          </label>
+          <GetJson
+            key={secretDevCounter}
+            endpoint="/global-notify"
+            credentials
+            loading={() => <>&hellip;</>}
+            ok={({ notify_self }) => (
+              <label>
+                <input
+                  type="checkbox"
+                  onChange={e => setSelfNotify(e.target.checked)}
+                  checked={notify_self ^ (secretDevStatus === 'pending')}
+                  disabled={secretDevStatus === 'pending'}
+                />
+                self-notify
+              </label>
+            )}
+          />
         </p>
       </div>
     </>

server/api.js

···
 };
 
 const handleTopSecret = async (db, user, req, res) => {
-  console.log('ts');
   // TODO: succeed early if they're already in?
   const body = await getRequesBody(req);
   const { secret_password } = JSON.parse(body);
···
     return forbidden(res);
   }
 };
+
+const handleGetGlobalNotifySettings = async (db, user, res) => {
+  const settings = db.getNotifyAccountGlobals(user.did);
+  return ok(res, settings);
+};
+
+const handleSetGlobalNotifySettings = async (db, user, req, res) => {
+  const body = await getRequesBody(req);
+  const { notify_enabled, notify_self } = JSON.parse(body);
+  db.setNotifyAccountGlobals(user.did, { notify_enabled, notify_self });
+  return gotIt(res);
+};
+
+/// admin stuff
 
 const handleListSecrets = async (db, res) => {
   const secrets = db.getSecrets();
···
     if (method === 'POST' && pathname === '/super-top-secret-access') {
       if (!user) return unauthorized(res);
       return handleTopSecret(db, user, req, res);
+    }
+    if (method === 'GET' && pathname === '/global-notify') {
+      if (!user) return unauthorized(res);
+      return handleGetGlobalNotifySettings(db, user, res);
+    }
+    if (method === 'POST' && pathname === '/global-notify') {
+      if (!user) return unauthorized(res);
+      return handleSetGlobalNotifySettings(db, user, req, res);
     }
 
     // non-public access required

server/db.js

···
   #stmt_delete_push_sub;
   #stmt_get_push_info;
   #stmt_set_role;
+  #stmt_get_notify_account_globals;
+  #stmt_set_notify_account_globals;
+
   #stmt_admin_add_secret;
   #stmt_admin_expire_secret;
   #stmt_admin_get_secrets;
···
         where did = :did
           and :secret_password in (select password
                                      from top_secret_passwords)`);
+
+    this.#stmt_get_notify_account_globals = db.prepare(
+      `select notify_enabled,
+              notify_self
+         from accounts
+        where did = :did`);
+
+    this.#stmt_set_notify_account_globals = db.prepare(
+      `update accounts
+          set notify_enabled = :notify_enabled,
+              notify_self = :notify_self
+        where did = :did`);
+
 
     this.#stmt_admin_add_secret = db.prepare(
       `insert into top_secret_passwords (password)
···
     let res = this.#stmt_set_role.run(params);
     return res.changes > 0;
   }
+
+  getNotifyAccountGlobals(did) {
+    return this.#stmt_get_notify_account_globals.get({ did });
+  }
+
+  setNotifyAccountGlobals(did, globals) {
+    this.#transactionally(() => {
+      const update = this.getNotifyAccountGlobals(did);
+      if (globals.notify_enabled !== undefined) update.notify_enabled = +globals.notify_enabled;
+      if (globals.notify_self !== undefined) update.notify_self = +globals.notify_self;
+      update.did = did;
+      this.#stmt_set_notify_account_globals.run(update);
+    });
+  }
+
 
   addTopSecret(secretPassword) {
     this.#stmt_admin_add_secret.run(secretPassword);

server/notifications.js

···
   }
 };
 
+const extractUriDid = at_uri => {
+  if (!at_uri.startsWith('at://')) {
+    console.warn(`ignoring non-at-uri: ${at_uri}`);
+    return null;
+  }
+  const [id, ..._] = at_uri.slice('at://'.length).split('/');
+  if (!id) {
+    console.warn(`ignoring at-uri with missing id segment: ${at_uri}`);
+    return null;
+  }
+  if (id.startsWith('@')) {
+    console.warn(`ignoring @handle at-uri: ${at_uri}`);
+    return null;
+  }
+  if (!id.startsWith('did:')) {
+    console.warn(`ignoring non-did at-uri: ${at_uri}`);
+    return null;
+  }
+  return id;
+};
+
 const handleDust = db => async event => {
   console.log('got', event.data);
   let data;
···
   }
   const timestamp = +new Date();
 
-  let did;
-  if (subject.startsWith('did:')) did = subject;
-  else if (subject.startsWith('at://')) {
-    const [id, ..._] = subject.slice('at://'.length).split('/');
-    if (id.startsWith('did:')) did = id;
-  }
+  const did = subject.startsWith('did:') ? subject : extractUriDid(subject);
   if (!did) {
     console.warn(`ignoring link with non-DID subject: ${subject}`)
     return;
+  }
+
+  // this works for now since only the account owner is assumed to be a notification target
+  // but for "replies on post" etc that won't hold
+  const { notify_enabled, notify_self } = db.getNotifyAccountGlobals(did);
+  if (!notify_enabled) console.warn('would drop this since notifies are not enabled (ui todo)');
+  if (!notify_self) {
+    const source_did = extractUriDid(source_record);
+    if (!source_did) {
+      console.warn(`ignoring link with non-DID source_record: ${source_record}`)
+      return;
+    }
+    if (source_did === did) {
+      console.warn(`ignoring self-notification`);
+      return;
+    }
   }
 
   const subs = db.getSubsByDid(did);

server/schema.sql

···
   first_seen      text not null default CURRENT_TIMESTAMP,
   role            text null,
   secret_password text null,
+  notify_enabled  integer not null default false,
+  notify_self     integer not null default false,
 
   check(did like 'did:%')
 ) strict;