link templating via data from record lookup

atproto-notifications/package-lock.json

···
       "name": "atproto-notifications",
       "version": "0.0.0",
       "dependencies": {
+        "@atcute/client": "^4.0.3",
         "@atcute/identity-resolver": "^1.1.3",
         "@uidotdev/usehooks": "^2.4.1",
         "lexicons": "file:../lexicons",
···
       }
     },
     "../lexicons": {
-      "version": "0.0.1"
+      "version": "0.0.1",
+      "dependencies": {
+        "psl": "^1.15.0"
+      }
     },
     "node_modules/@ampproject/remapping": {
       "version": "2.3.0",
···
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@atcute/client": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/@atcute/client/-/client-4.0.3.tgz",
+      "integrity": "sha512-RIOZWFVLca/HiPAAUDqQPOdOreCxTbL5cb+WUf5yqQOKIu5yEAP3eksinmlLmgIrlr5qVOE7brazUUzaskFCfw==",
+      "license": "MIT",
+      "dependencies": {
+        "@atcute/identity": "^1.0.2",
+        "@atcute/lexicons": "^1.0.3"
+      }
+    },
     "node_modules/@atcute/identity": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/@atcute/identity/-/identity-1.0.3.tgz",
       "integrity": "sha512-mNMxbKHFGys03A8JXKk0KfMBzdd0vrYMzZZWjpw1nYTs0+ea6bo5S1hwqVUZxHdo1gFHSe/t63jxQIF4yL9aKw==",
       "license": "0BSD",
-      "peer": true,
       "dependencies": {
         "@atcute/lexicons": "^1.0.4",
         "@badrap/valita": "^0.4.5"

atproto-notifications/package.json

···
     "preview": "vite preview"
   },
   "dependencies": {
+    "@atcute/client": "^4.0.3",
     "@atcute/identity-resolver": "^1.1.3",
     "@uidotdev/usehooks": "^2.4.1",
     "lexicons": "file:../lexicons",

atproto-notifications/src/components/Notification.tsx

···
+import { useState, useEffect } from 'react';
 import ReactTimeAgo from 'react-time-ago';
 import psl from 'psl';
-import lexicons from 'lexicons';
+import { default as lexicons, getLink } from 'lexicons';
 import { resolveDid } from '../atproto/resolve';
 import { Fetch } from './Fetch';
 
 import './Notification.css';
 
 export function Notification({ app, group, source, source_record, source_did, subject, timestamp }) {
+  const [resolvedLink, setResolvedLink] = useState(null);
+
+  useEffect(() => {
+    (async () => {
+      const link = await getLink(source, source_record, subject);
+      if (link) setResolvedLink(link);
+    })();
+  }, [source, source_record, subject]);
 
   // TODO: clean up / move this to lexicons package?
   let title = source;
···
 
     directLink = lex
       ?.clients[0]
-      ?.direct_links[`at_uri:${sourceRemainder}`]
+      ?.direct_links?.[`at_uri:${sourceRemainder}`]
       ?.replace('{subject.did}', did)
       ?.replace('{subject.collection}', collection)
       ?.replace('{subject.rkey}', rest.join('/') || null)
···
       ?.replace('{source_record.collection}', sCollection)
       ?.replace('{source_record.rkey}', sRest.join('/') || null);
   }
-  link = directLink ?? link;
+  link = resolvedLink ?? directLink ?? link;
 
   const contents = (
     <>

lexicons/atproto.js

···
+import { Client, CredentialManager, ok, simpleFetchHandler } from '@atcute/client';
+import { CompositeDidDocumentResolver, PlcDidDocumentResolver, WebDidDocumentResolver } from '@atcute/identity-resolver';
+
+// cleanup needed
+
+const docResolver = new CompositeDidDocumentResolver({
+  methods: {
+    plc: new PlcDidDocumentResolver(),
+    web: new WebDidDocumentResolver(),
+  },
+});
+
+async function resolve_did(did) {
+  return await docResolver.resolve(did);
+}
+
+function pds({ service }) {
+  if (!service) {
+    throw new Error('missing service from identity doc');
+  }
+  const { serviceEndpoint } = service[0];
+  if (!serviceEndpoint) {
+    throw new Error('missing serviceEndpoint from identity service array');
+  }
+  return serviceEndpoint;
+}
+
+
+async function get_pds_record(endpoint, did, collection, rkey) {
+  const handler = simpleFetchHandler({ service: endpoint });
+  const rpc = new Client({ handler });
+  const { ok, data } = await rpc.get('com.atproto.repo.getRecord', {
+    params: { repo: did, collection, rkey },
+  });
+  if (!ok) throw new Error('fetching pds record failed');
+  return data;
+}
+
+function parse_at_uri(uri) {
+  let collection, rkey;
+  if (!uri.startsWith('at://')) {
+    throw new Error('invalid at-uri: did not start with "at://"');
+  }
+  let remaining = uri.slice('at://'.length); // remove the at:// prefix
+  remaining = remaining.split('#')[0]; // hash is valid in at-uri but we don't handle them
+  remaining = remaining.split('?')[0]; // query is valid in at-uri but we don't handle it
+  const segments = remaining.split('/');
+  if (segments.length === 0) {
+    throw new Error('invalid at-uri: could not find did after "at://"');
+  }
+  const did = segments[0];
+  if (segments.length > 1) {
+    collection = segments[1];
+  }
+  if (segments.length > 2) {
+    rkey = segments.slice(2).join('/'); // hmm are slashes actually valid in rkey?
+  }
+  return { did, collection, rkey };
+}
+
+export async function getAtUri(atUri) {
+  const { did, collection, rkey } = parse_at_uri(atUri);
+  const doc = await resolve_did(did);
+  const endpoint = pds(doc);
+  const { value } = await get_pds_record(endpoint, did, collection, rkey);
+  return value;
+}

lexicons/bits.js

···
 import psl from 'psl';
+import { JSONPath } from 'jsonpath-plus';
 import defs from './defs.js';
+import { getAtUri } from './atproto.js';
 
 export function getBits(source) {
   const [nsid, ...rp] = source.split(':');
   const segments = nsid.split('.');
   const group = segments.slice(0, segments.length - 1).join('.') ?? null;
-  const unreversed = segments.toReversed().join('.');
-  const app = psl.parse(unreversed)?.domain ?? null;
+  segments.reverse();
+  const app = psl.parse(segments.join('.'))?.domain ?? null;
   return { app, group };
 }
+
+function getAppDefs(source) {
+  const { app } = getBits(source);
+  const appPrefix = source.slice(0, app.length);
+  const appSource = source.slice(app.length + 1);
+  return [appSource, defs[appPrefix]];
+}
+
+export async function getContext(source, source_record, subject) {
+}
+
+const uriBits = async uri => {
+  const bits = uri.slice('at://'.length).split('/');
+  // TODO: identifier might be a handle
+  // TODO: rest might contain stuff after the rkey
+  const [did, nsid, rkey] = [bits[0], bits[1], bits.slice(2)];
+  return [did, nsid, rkey.join('/') || null];
+};
+
+export async function getLink(source, source_record, subject) {
+  // TODO: pass in preferred client
+  const [appSource, appDefs] = getAppDefs(source);
+  const appLinks = appDefs?.clients?.[0]?.direct_links;
+  const linkType = subject.startsWith('did:') ? 'did' : 'at_uri';
+  const linkTemplate = appLinks?.[`${linkType}:${appSource}`];
+  if (!linkTemplate) return null;
+
+  let link = linkTemplate;
+
+  // 1. sync subs
+  const [sourceDid, sourceNsid, sourceRkey] = await uriBits(source_record);
+  link = link
+    .replaceAll('{source_record.did}', sourceDid)
+    .replaceAll('{source_record.collection}', sourceNsid)
+    .replaceAll('{source_record.rkey}', sourceRkey);
+  if (linkTemplate === 'did') {
+    link = link.replaceAll('{subject.did}', subject);
+  } else {
+    const [subjectDid, subjectNsid, subjectRkey] = await uriBits(subject);
+    link = link
+      .replaceAll('{subject.did}', subjectDid)
+      .replaceAll('{subject.collection}', subjectNsid)
+      .replaceAll('{subject.rkey}', subjectRkey);
+  }
+
+  // 2. async lookups
+
+  // do we need to fetch anything from the link subject record?
+  if (linkType === 'at_uri') {
+    const subjectMatches = [...link.matchAll(/(\{@subject:(?<path>[^\}]+)\})/g)];
+    if (subjectMatches.length > 0) {
+      const subjectRecord = await getAtUri(subject);
+
+      // do the actual replacements
+      for (const match of subjectMatches) {
+        // TODO: JSONPath won't actually cut it once we get $type in
+        const sub = JSONPath({
+          path: `$.${match.groups.path}`,
+          json: subjectRecord,
+        })[0];
+
+        link = link.replaceAll(match[0], sub);
+      }
+    }
+  }
+
+  // 2.b TODO: source record lookups if needed
+  return link;
+}

lexicons/defs.js

···
         canonical: true,
         icon: '/icons/sh.tangled.jpg',
         main: 'https://tangled.sh',
+        direct_links: {
+          'at_uri:feed.star:subject': 'https://tangled.sh/{subject.did}/{@subject:name}',
+        },
       }
     ],
     known_sources: {

lexicons/index.js

···
-export { getBits } from './bits.js';
+export { getBits, getLink, getContext } from './bits.js';
 export { default } from './defs.js';

lexicons/package-lock.json

···
       "name": "lexicons",
       "version": "0.0.1",
       "dependencies": {
+        "@atcute/client": "^4.0.3",
+        "@atcute/identity-resolver": "^1.1.3",
+        "jsonpath-plus": "^10.3.0",
         "psl": "^1.15.0"
+      }
+    },
+    "node_modules/@atcute/client": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/@atcute/client/-/client-4.0.3.tgz",
+      "integrity": "sha512-RIOZWFVLca/HiPAAUDqQPOdOreCxTbL5cb+WUf5yqQOKIu5yEAP3eksinmlLmgIrlr5qVOE7brazUUzaskFCfw==",
+      "license": "MIT",
+      "dependencies": {
+        "@atcute/identity": "^1.0.2",
+        "@atcute/lexicons": "^1.0.3"
+      }
+    },
+    "node_modules/@atcute/identity": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@atcute/identity/-/identity-1.0.3.tgz",
+      "integrity": "sha512-mNMxbKHFGys03A8JXKk0KfMBzdd0vrYMzZZWjpw1nYTs0+ea6bo5S1hwqVUZxHdo1gFHSe/t63jxQIF4yL9aKw==",
+      "license": "0BSD",
+      "dependencies": {
+        "@atcute/lexicons": "^1.0.4",
+        "@badrap/valita": "^0.4.5"
+      }
+    },
+    "node_modules/@atcute/identity-resolver": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@atcute/identity-resolver/-/identity-resolver-1.1.3.tgz",
+      "integrity": "sha512-KZgGgg99CWaV7Df3+h3X/WMrDzTPQVfsaoIVbTNLx2B56BvCL2EmaxPSVw/7BFUJMZHlVU4rtoEB4lyvNyMswA==",
+      "license": "MIT",
+      "dependencies": {
+        "@atcute/lexicons": "^1.0.4",
+        "@atcute/util-fetch": "^1.0.1",
+        "@badrap/valita": "^0.4.4"
+      },
+      "peerDependencies": {
+        "@atcute/identity": "^1.0.0"
+      }
+    },
+    "node_modules/@atcute/lexicons": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@atcute/lexicons/-/lexicons-1.1.0.tgz",
+      "integrity": "sha512-LFqwnria78xLYb62Ri/+WwQpUTgZp2DuyolNGIIOV1dpiKhFFFh//nscHMA6IExFLQRqWDs3tTjy7zv0h3sf1Q==",
+      "license": "0BSD",
+      "dependencies": {
+        "esm-env": "^1.2.2"
+      }
+    },
+    "node_modules/@atcute/util-fetch": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@atcute/util-fetch/-/util-fetch-1.0.1.tgz",
+      "integrity": "sha512-Clc0E/5ufyGBVfYBUwWNlHONlZCoblSr4Ho50l1LhmRPGB1Wu/AQ9Sz+rsBg7fdaW/auve8ulmwhRhnX2cGRow==",
+      "license": "MIT",
+      "dependencies": {
+        "@badrap/valita": "^0.4.2"
+      }
+    },
+    "node_modules/@badrap/valita": {
+      "version": "0.4.5",
+      "resolved": "https://registry.npmjs.org/@badrap/valita/-/valita-0.4.5.tgz",
+      "integrity": "sha512-4QwGbuhh/JesHRQj79mO/l37PvJj4l/tlAu7+S1n4h47qwaNpZ0WDvIwUGLYUsdi9uQ5UPpiG9wb1Wm3XUFBUQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@jsep-plugin/assignment": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@jsep-plugin/assignment/-/assignment-1.3.0.tgz",
+      "integrity": "sha512-VVgV+CXrhbMI3aSusQyclHkenWSAm95WaiKrMxRFam3JSUiIaQjoMIw2sEs/OX4XifnqeQUN4DYbJjlA8EfktQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.16.0"
+      },
+      "peerDependencies": {
+        "jsep": "^0.4.0||^1.0.0"
+      }
+    },
+    "node_modules/@jsep-plugin/regex": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@jsep-plugin/regex/-/regex-1.0.4.tgz",
+      "integrity": "sha512-q7qL4Mgjs1vByCaTnDFcBnV9HS7GVPJX5vyVoCgZHNSC9rjwIlmbXG5sUuorR5ndfHAIlJ8pVStxvjXHbNvtUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.16.0"
+      },
+      "peerDependencies": {
+        "jsep": "^0.4.0||^1.0.0"
+      }
+    },
+    "node_modules/esm-env": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
+      "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==",
+      "license": "MIT"
+    },
+    "node_modules/jsep": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/jsep/-/jsep-1.4.0.tgz",
+      "integrity": "sha512-B7qPcEVE3NVkmSJbaYxvv4cHkVW7DQsZz13pUMrfS8z8Q/BuShN+gcTXrUlPiGqM2/t/EEaI030bpxMqY8gMlw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.16.0"
+      }
+    },
+    "node_modules/jsonpath-plus": {
+      "version": "10.3.0",
+      "resolved": "https://registry.npmjs.org/jsonpath-plus/-/jsonpath-plus-10.3.0.tgz",
+      "integrity": "sha512-8TNmfeTCk2Le33A3vRRwtuworG/L5RrgMvdjhKZxvyShO+mBu2fP50OWUjRLNtvw344DdDarFh9buFAZs5ujeA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jsep-plugin/assignment": "^1.3.0",
+        "@jsep-plugin/regex": "^1.0.4",
+        "jsep": "^1.4.0"
+      },
+      "bin": {
+        "jsonpath": "bin/jsonpath-cli.js",
+        "jsonpath-plus": "bin/jsonpath-cli.js"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/psl": {

lexicons/package.json

···
   "author": "",
   "type": "module",
   "dependencies": {
+    "@atcute/client": "^4.0.3",
+    "@atcute/identity-resolver": "^1.1.3",
+    "jsonpath-plus": "^10.3.0",
     "psl": "^1.15.0"
   }
 }