commit 520a6a95b5f123bc7a2fc4693467cdf5a76f9226 · gmstn.systems/shard

+62
src/lib/utils/atproto.ts
···

       1
       1
        
       import {

     

       2
       2
        
           atprotoHandleSchema,

     

       3
       3
       +
           atUriAuthoritySchema,

     

       4
       4
       +
           nsidSchema,

     

       3
       5
        
           type AtprotoHandle,

     

       4
       6
        
           type AtUri,

     

       5
       7
        
           type Did,

     
···

       16
       18
        
           WebDidDocumentResolver,

     

       17
       19
        
           WellKnownHandleResolver,

     

       18
       20
        
       } from "@atcute/identity-resolver";

     

       21
       21
       +
       import z from "zod";

     

       19
       22
        
       

     

       20
       23
        
       export const getRecordFromAtUri = async ({

     

       21
       24
        
           authority,

     
···

       113
       116
        
               return { ok: false, error: err };

     

       114
       117
        
           }

     

       115
       118
        
       };

     

       119
       119
       +
       

     

       120
       120
       +
       // thank u julie

     

       121
       121
       +
       export const atUriRegexp =

     

       122
       122
       +
           /^at:\/\/([a-zA-Z0-9._:%-]+)(?:\/([a-zA-Z0-9-.]+)(?:\/([a-zA-Z0-9._~:@!$&%')(*+,;=-]+))?)?(?:#(\/[a-zA-Z0-9._~:@!$&%')(*+,;=\-[\]/\\]*))?$/;

     

       123
       123
       +
       

     

       124
       124
       +
       export const stringToAtUri = (str: string): Result<AtUri, unknown> => {

     

       125
       125
       +
           const isValidAtUri = atUriRegexp.test(str);

     

       126
       126
       +
           if (!isValidAtUri)

     

       127
       127
       +
               return {

     

       128
       128
       +
                   ok: false,

     

       129
       129
       +
                   error: { message: "Input string was not a valid at:// URI" },

     

       130
       130
       +
               };

     

       131
       131
       +
       

     

       132
       132
       +
           const fragments = str.split("/");

     

       133
       133
       +
           if (fragments.length <= 2)

     

       134
       134
       +
               return {

     

       135
       135
       +
                   ok: false,

     

       136
       136
       +
                   error: { message: "Input string was not a valid at:// URI." },

     

       137
       137
       +
               };

     

       138
       138
       +
       

     

       139
       139
       +
           const {

     

       140
       140
       +
               success: authorityParseSuccess,

     

       141
       141
       +
               error: authorityParseError,

     

       142
       142
       +
               data: authorityParsed,

     

       143
       143
       +
           } = atUriAuthoritySchema.safeParse(fragments[1]);

     

       144
       144
       +
           if (!authorityParseSuccess)

     

       145
       145
       +
               return {

     

       146
       146
       +
                   ok: false,

     

       147
       147
       +
                   error: {

     

       148
       148
       +
                       message:

     

       149
       149
       +
                           "Input at:// URI was a valid shape, but somehow could not parse the first fragment as a valid authority.",

     

       150
       150
       +
                       details: z.treeifyError(authorityParseError),

     

       151
       151
       +
                   },

     

       152
       152
       +
               };

     

       153
       153
       +
       

     

       154
       154
       +
           const {

     

       155
       155
       +
               success: nsidParseSuccess,

     

       156
       156
       +
               error: nsidParseError,

     

       157
       157
       +
               data: nsidParsed,

     

       158
       158
       +
           } = nsidSchema.safeParse(fragments[2]);

     

       159
       159
       +
           if (fragments[2] && !nsidParseSuccess)

     

       160
       160
       +
               return {

     

       161
       161
       +
                   ok: false,

     

       162
       162
       +
                   error: {

     

       163
       163
       +
                       message:

     

       164
       164
       +
                           "Input at:// URI was a valid shape and had a second fragment, but was somehow not a valid NSID.",

     

       165
       165
       +
                       details: z.treeifyError(nsidParseError),

     

       166
       166
       +
                   },

     

       167
       167
       +
               };

     

       168
       168
       +
       

     

       169
       169
       +
           return {

     

       170
       170
       +
               ok: true,

     

       171
       171
       +
               data: {

     

       172
       172
       +
                   authority: authorityParsed,

     

       173
       173
       +
                   collection: nsidParsed,

     

       174
       174
       +
                   rKey: fragments[3],

     

       175
       175
       +
               },

     

       176
       176
       +
           };

     

       177
       177
       +
       };