commit de5e096297caebbc837b6b4bbcdab41c13c2efd4 · ptr.pet/at-fronter

+5 -1

src/entrypoints/background.ts

···

       60
       60
        
             const results = [];

     

       61
       61
        
             for (const result of items) {

     

       62
       62
        
               const resp = await putFronter(

     

       63
       63
       -
                 { name: fronter ?? "", subject: result.uri, member: spFronters },

     

       63
       63
       +
                 {

     

       64
       64
       +
                   names: fronter?.split(",").map((name) => name.trim()) ?? [],

     

       65
       65
       +
                   subject: result.uri,

     

       66
       66
       +
                   members: spFronters,

     

       67
       67
       +
                 },

     

       64
       68
        
                 authToken,

     

       65
       69
        
               );

     

       66
       70
        
               if (resp.ok) {

+16 -15

src/lib/utils.ts

···

       47
       47
        
         v.string(),

     

       48
       48
        
         v.object({

     

       49
       49
        
           $type: v.literal("systems.gaze.atfronter.fronter"),

     

       50
       50
       -
           name: v.string(),

     

       51
       50
        
           subject: v.resourceUriString(),

     

       52
       52
       -
           member: v.array(v.genericUriString()), // identifier(s) for pk or sp or etc. (maybe member record in the future?)

     

       51
       51
       +
           names: v.array(v.string()),

     

       52
       52
       +
           members: v.array(v.genericUriString()), // identifier(s) for pk or sp or etc. (maybe member record in the future?)

     

       53
       53
        
         }),

     

       54
       54
        
       );

     

       55
       55
        
       

     
···

       119
       119
        
       };

     

       120
       120
        
       

     

       121
       121
        
       export const getFronterNames = async (

     

       122
       122
       -
         name: string,

     

       122
       122
       +
         name: string[],

     

       123
       123
        
         memberUris: MemberUri[],

     

       124
       124
        
       ) => {

     

       125
       125
       -
         let fronterNames = [name];

     

       125
       125
       +
         let fronterNames = name;

     

       126
       126
        
         if (memberUris.length > 0) {

     

       127
       127
        
           fronterNames = (

     

       128
       128
        
             await Promise.allSettled(memberUris.map((m) => fetchMember(m)))

     
···

       199
       199
        
       

     

       200
       200
        
         let memberUris, fronterNames;

     

       201
       201
        
         try {

     

       202
       202
       -
           memberUris = maybeTyped.value.member.map((m) => parseMemberId(m));

     

       203
       203
       -
           fronterNames = await getFronterNames(maybeTyped.value.name, memberUris);

     

       202
       202
       +
           memberUris = maybeTyped.value.members.map((m) => parseMemberId(m));

     

       203
       203
       +
           // fronterNames = await getFronterNames(maybeTyped.value.names, memberUris);

     

       204
       204
       +
           fronterNames = maybeTyped.value.names;

     

       204
       205
        
         } catch (error) {

     

       205
       206
        
           return err(`error fetching fronter names: ${error}`);

     

       206
       207
        
         }

     
···

       227
       228
        
         // make client

     

       228
       229
        
         const atpClient = await getAtpClient(did);

     

       229
       230
        
       

     

       231
       231
       +
         let memberUris, fronterNames;

     

       232
       232
       +
         try {

     

       233
       233
       +
           memberUris = record.members.map((m) => parseMemberId(m));

     

       234
       234
       +
           fronterNames = await getFronterNames(record.names, memberUris);

     

       235
       235
       +
         } catch (error) {

     

       236
       236
       +
           return err(`error fetching fronter names: ${error}`);

     

       237
       237
       +
         }

     

       238
       238
       +
       

     

       230
       239
        
         // put

     

       231
       240
        
         let maybeRecord = await atpClient.post("com.atproto.repo.putRecord", {

     

       232
       241
        
           input: {

     

       233
       242
        
             repo: did,

     

       234
       243
        
             collection: fronterSchema.object.shape.$type.expected,

     

       235
       244
        
             rkey: `${collection}_${rkey}`,

     

       236
       236
       -
             record,

     

       245
       245
       +
             record: { ...record, names: fronterNames },

     

       237
       246
        
             validate: false,

     

       238
       247
        
           },

     

       239
       248
        
           headers: { authorization: `Bearer ${authToken}` },

     

       240
       249
        
         });

     

       241
       250
        
         if (!maybeRecord.ok)

     

       242
       251
        
           return err(maybeRecord.data.message ?? maybeRecord.data.error);

     

       243
       243
       -
       

     

       244
       244
       -
         let memberUris, fronterNames;

     

       245
       245
       -
         try {

     

       246
       246
       -
           memberUris = record.member.map((m) => parseMemberId(m));

     

       247
       247
       -
           fronterNames = await getFronterNames(record.name, memberUris);

     

       248
       248
       -
         } catch (error) {

     

       249
       249
       -
           return err(`error fetching fronter names: ${error}`);

     

       250
       250
       -
         }

     

       251
       252
        
       

     

       252
       253
        
         return ok({

     

       253
       254
        
           did,