···

       
60
       
 
       
      const results = [];

     

       
61
       
 
       
      for (const result of items) {

     

       
62
       
 
       
        const resp = await putFronter(

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
64
       
 
       
          authToken,

     

       
65
       
 
       
        );

     

       
66
       
 
       
        if (resp.ok) {

     

···

       
60
       
 
       
      const results = [];

     

       
61
       
 
       
      for (const result of items) {

     

       
62
       
 
       
        const resp = await putFronter(

     

       
63
       
+
       
          {

     

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

     

       
65
       
+
       
            subject: result.uri,

     

       
66
       
+
       
            members: spFronters,

     

       
67
       
+
       
          },

     

       
68
       
 
       
          authToken,

     

       
69
       
 
       
        );

     

       
70
       
 
       
        if (resp.ok) {

     

···

       
47
       
 
       
  v.string(),

     

       
48
       
 
       
  v.object({

     

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

     

       
50
       
-
       
    name: v.string(),

     

       
51
       
 
       
    subject: v.resourceUriString(),

     

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

     

       
0
       
 
       

     

       
53
       
 
       
  }),

     

       
54
       
 
       
);

     

       
55
       
 
       


     
···

       
119
       
 
       
};

     

       
120
       
 
       


     

       
121
       
 
       
export const getFronterNames = async (

     

       
122
       
-
       
  name: string,

     

       
123
       
 
       
  memberUris: MemberUri[],

     

       
124
       
 
       
) => {

     

       
125
       
-
       
  let fronterNames = [name];

     

       
126
       
 
       
  if (memberUris.length > 0) {

     

       
127
       
 
       
    fronterNames = (

     

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

     
···

       
199
       
 
       


     

       
200
       
 
       
  let memberUris, fronterNames;

     

       
201
       
 
       
  try {

     

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

     

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

     

       
0
       
 
       

     

       
204
       
 
       
  } catch (error) {

     

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

     

       
206
       
 
       
  }

     
···

       
227
       
 
       
  // make client

     

       
228
       
 
       
  const atpClient = await getAtpClient(did);

     

       
229
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
230
       
 
       
  // put

     

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

     

       
232
       
 
       
    input: {

     

       
233
       
 
       
      repo: did,

     

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

     

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

     

       
236
       
-
       
      record,

     

       
237
       
 
       
      validate: false,

     

       
238
       
 
       
    },

     

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

     

       
240
       
 
       
  });

     

       
241
       
 
       
  if (!maybeRecord.ok)

     

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

     

       
243
       
-
       


     

       
244
       
-
       
  let memberUris, fronterNames;

     

       
245
       
-
       
  try {

     

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

     

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

     

       
248
       
-
       
  } catch (error) {

     

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

     

       
250
       
-
       
  }

     

       
251
       
 
       


     

       
252
       
 
       
  return ok({

     

       
253
       
 
       
    did,

     

···

       
47
       
 
       
  v.string(),

     

       
48
       
 
       
  v.object({

     

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

     

       
0
       
 
       

     

       
50
       
 
       
    subject: v.resourceUriString(),

     

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

     

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

     

       
53
       
 
       
  }),

     

       
54
       
 
       
);

     

       
55
       
 
       


     
···

       
119
       
 
       
};

     

       
120
       
 
       


     

       
121
       
 
       
export const getFronterNames = async (

     

       
122
       
+
       
  name: string[],

     

       
123
       
 
       
  memberUris: MemberUri[],

     

       
124
       
 
       
) => {

     

       
125
       
+
       
  let fronterNames = name;

     

       
126
       
 
       
  if (memberUris.length > 0) {

     

       
127
       
 
       
    fronterNames = (

     

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

     
···

       
199
       
 
       


     

       
200
       
 
       
  let memberUris, fronterNames;

     

       
201
       
 
       
  try {

     

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

     

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

     

       
204
       
+
       
    fronterNames = maybeTyped.value.names;

     

       
205
       
 
       
  } catch (error) {

     

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

     

       
207
       
 
       
  }

     
···

       
228
       
 
       
  // make client

     

       
229
       
 
       
  const atpClient = await getAtpClient(did);

     

       
230
       
 
       


     

       
231
       
+
       
  let memberUris, fronterNames;

     

       
232
       
+
       
  try {

     

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

     

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

     

       
235
       
+
       
  } catch (error) {

     

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

     

       
237
       
+
       
  }

     

       
238
       
+
       


     

       
239
       
 
       
  // put

     

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

     

       
241
       
 
       
    input: {

     

       
242
       
 
       
      repo: did,

     

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

     

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

     

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

     

       
246
       
 
       
      validate: false,

     

       
247
       
 
       
    },

     

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

     

       
249
       
 
       
  });

     

       
250
       
 
       
  if (!maybeRecord.ok)

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
252
       
 
       


     

       
253
       
 
       
  return ok({

     

       
254
       
 
       
    did,