commit 72b423c587639aa10aa51b21543628ec71e3a800 · gmstn.systems/lattice

+38
src/index.ts
···

       1
       1
        
       import { OWNER_DID, SERVER_PORT, SERVICE_DID } from "@/lib/env";

     

       2
       2
        
       import { setRegistrationState } from "@/lib/state";

     

       3
       3
        
       import type { AtUri, Did } from "@/lib/types/atproto";

     

       4
       4
       +
       import type { SessionInfo } from "@/lib/types/handshake";

     

       4
       5
        
       import { systemsGmstnDevelopmentChannelRecordSchema } from "@/lib/types/lexicon/systems.gmstn.development.channel";

     

       5
       6
        
       import { getRecordFromAtUri, stringToAtUri } from "@/lib/utils/atproto";

     

       6
       7
        
       import { getConstellationBacklink } from "@/lib/utils/constellation";

     

       8
       8
       +
       import { isDomain } from "@/lib/utils/domains";

     

       9
       9
       +
       import { initiateHandshakeTo } from "@/lib/utils/handshake";

     

       7
       10
        
       import { newErrorResponse } from "@/lib/utils/http/responses";

     

       8
       11
        
       import { connectToPrism } from "@/lib/utils/prism";

     

       9
       12
        
       import {

     
···

       112
       115
        
                   channelsByShard.set(storeAtAtUri, [...prevUris, currentChannelUri]);

     

       113
       116
        
               }

     

       114
       117
        
           });

     

       118
       118
       +
       

     

       119
       119
       +
           const channelSessions = new Map<AtUri, SessionInfo>();

     

       120
       120
       +
       

     

       121
       121
       +
           const channelsByShardEntries = channelsByShard.entries();

     

       122
       122
       +
       

     

       123
       123
       +
           for (const entry of channelsByShardEntries) {

     

       124
       124
       +
               const shardAtUri = entry[0];

     

       125
       125
       +
       

     

       126
       126
       +
               let shardDid: Did | undefined;

     

       127
       127
       +
               // TODO: if the rkey of the shard URI is not a valid domain, then it must be a did:plc

     

       128
       128
       +
               // we need to find a better way to enforce this. we really should explore just resolving the

     

       129
       129
       +
               // record and then checking the record value for the actual domain instead.

     

       130
       130
       +
               // did resolution hard;;

     

       131
       131
       +
               if (

     

       132
       132
       +
                   isDomain(shardAtUri.rKey ?? "") ||

     

       133
       133
       +
                   shardAtUri.rKey?.startsWith("localhost:")

     

       134
       134
       +
               ) {

     

       135
       135
       +
                   // from the isDomain check, if we pass, we can conclude that

     

       136
       136
       +
                   shardDid = `did:web:${encodeURIComponent(shardAtUri.rKey ?? "")}`;

     

       137
       137
       +
               } else {

     

       138
       138
       +
                   shardDid = `did:plc:${encodeURIComponent(shardAtUri.rKey ?? "")}`;

     

       139
       139
       +
               }

     

       140
       140
       +
       

     

       141
       141
       +
               const channelAtUris = entry[1];

     

       142
       142
       +
       

     

       143
       143
       +
               const handshakeResult = await initiateHandshakeTo({

     

       144
       144
       +
                   did: shardDid,

     

       145
       145
       +
                   channels: channelAtUris,

     

       146
       146
       +
               });

     

       147
       147
       +
               if (!handshakeResult.ok) return;

     

       148
       148
       +
               const sessionInfo = handshakeResult.data;

     

       149
       149
       +
               console.log("Handshake to", shardAtUri.rKey, "complete!");

     

       150
       150
       +
               console.log("Session info:", sessionInfo);

     

       151
       151
       +
               channelSessions.set(shardAtUri, sessionInfo);

     

       152
       152
       +
           }

     

       115
       153
        
       

     

       116
       154
        
           const server = await setupServer();

     

       117
       155
        
           for (const [url, route] of Object.entries(routes)) {