commit f107ba13c3824d18d425812e0b29b7dd5daede09 · gmstn.systems/gemstone-app

+1 -5

src/queries/get-channels-from-pds.ts

···

       92
       92
        
       

     

       93
       93
        
               if (!success) return { ok: false, error: z.treeifyError(error) };

     

       94
       94
        
       

     

       95
       95
       -
               allRecords.push(

     

       96
       96
       -
                   ...responses.map((data) => {

     

       97
       97
       -
                       return data;

     

       98
       98
       -
                   }),

     

       99
       99
       -
               );

     

       95
       95
       +
               allRecords.push(...responses);

     

       100
       96
        
       

     

       101
       97
        
               if (records.length < 100) continueLoop = false;

     

       102
       98
        
               cursor = nextCursor;

+4 -5

src/queries/get-invites-from-pds.ts

···

       15
       15
        
       }): Promise<

     

       16
       16
        
           Result<

     

       17
       17
        
               Array<{

     

       18
       18
       +
                   cid: string;

     

       18
       19
        
                   uri: string;

     

       19
       20
        
                   value: SystemsGmstnDevelopmentChannelInvite;

     

       20
       21
        
               }>,

     
···

       41
       42
        
       }): Promise<

     

       42
       43
        
           Result<

     

       43
       44
        
               Array<{

     

       45
       45
       +
                   cid: string;

     

       44
       46
        
                   uri: string;

     

       45
       47
        
                   value: SystemsGmstnDevelopmentChannelInvite;

     

       46
       48
        
               }>,

     
···

       48
       50
        
           >

     

       49
       51
        
       > => {

     

       50
       52
        
           const allRecords: Array<{

     

       53
       53
       +
               cid: string;

     

       51
       54
        
               uri: string;

     

       52
       55
        
               value: SystemsGmstnDevelopmentChannelInvite;

     

       53
       56
        
           }> = [];

     
···

       86
       89
        
                   .safeParse(records);

     

       87
       90
        
               if (!success) return { ok: false, error: z.treeifyError(error) };

     

       88
       91
        
       

     

       89
       89
       -
               allRecords.push(

     

       90
       90
       -
                   ...responses.map((data) => {

     

       91
       91
       -
                       return { uri: data.uri, value: data.value };

     

       92
       92
       -
                   }),

     

       93
       93
       -
               );

     

       92
       92
       +
               allRecords.push(...responses);

     

       94
       93
        
       

     

       95
       94
        
               if (records.length < 100) continueLoop = false;

     

       96
       95
        
               cursor = nextCursor;

+4 -5

src/queries/get-lattices-from-pds.ts

···

       15
       15
        
       }): Promise<

     

       16
       16
        
           Result<

     

       17
       17
        
               Array<{

     

       18
       18
       +
                   cid: string;

     

       18
       19
        
                   uri: string;

     

       19
       20
        
                   value: SystemsGmstnDevelopmentLattice;

     

       20
       21
        
               }>,

     
···

       41
       42
        
       }): Promise<

     

       42
       43
        
           Result<

     

       43
       44
        
               Array<{

     

       45
       45
       +
                   cid: string;

     

       44
       46
        
                   uri: string;

     

       45
       47
        
                   value: SystemsGmstnDevelopmentLattice;

     

       46
       48
        
               }>,

     
···

       48
       50
        
           >

     

       49
       51
        
       > => {

     

       50
       52
        
           const allRecords: Array<{

     

       53
       53
       +
               cid: string;

     

       51
       54
        
               uri: string;

     

       52
       55
        
               value: SystemsGmstnDevelopmentLattice;

     

       53
       56
        
           }> = [];

     
···

       87
       90
        
       

     

       88
       91
        
               if (!success) return { ok: false, error: z.treeifyError(error) };

     

       89
       92
        
       

     

       90
       90
       -
               allRecords.push(

     

       91
       91
       -
                   ...responses.map((data) => {

     

       92
       92
       -
                       return { uri: data.uri, value: data.value };

     

       93
       93
       -
                   }),

     

       94
       94
       -
               );

     

       93
       93
       +
               allRecords.push(...responses);

     

       95
       94
        
       

     

       96
       95
        
               if (records.length < 100) continueLoop = false;

     

       97
       96
        
               cursor = nextCursor;

+4 -5

src/queries/get-shards-from-pds.ts

···

       17
       17
        
       }): Promise<

     

       18
       18
        
           Result<

     

       19
       19
        
               Array<{

     

       20
       20
       +
                   cid: string;

     

       20
       21
        
                   uri: string;

     

       21
       22
        
                   value: SystemsGmstnDevelopmentShard;

     

       22
       23
        
               }>,

     
···

       43
       44
        
       }): Promise<

     

       44
       45
        
           Result<

     

       45
       46
        
               Array<{

     

       47
       47
       +
                   cid: string;

     

       46
       48
        
                   uri: string;

     

       47
       49
        
                   value: SystemsGmstnDevelopmentShard;

     

       48
       50
        
               }>,

     
···

       50
       52
        
           >

     

       51
       53
        
       > => {

     

       52
       54
        
           const allRecords: Array<{

     

       55
       55
       +
               cid: string;

     

       53
       56
        
               uri: string;

     

       54
       57
        
               value: SystemsGmstnDevelopmentShard;

     

       55
       58
        
           }> = [];

     
···

       89
       92
        
       

     

       90
       93
        
               if (!success) return { ok: false, error: z.treeifyError(error) };

     

       91
       94
        
       

     

       92
       92
       -
               allRecords.push(

     

       93
       93
       -
                   ...responses.map((data) => {

     

       94
       94
       -
                       return { uri: data.uri, value: data.value };

     

       95
       95
       -
                   }),

     

       96
       96
       -
               );

     

       95
       95
       +
               allRecords.push(...responses);

     

       97
       96
        
       

     

       98
       97
        
               if (records.length < 100) continueLoop = false;

     

       99
       98
        
               cursor = nextCursor;

+1 -1

src/queries/hooks/useLatticesQuery.ts

···

       55
       55
        
                       collection: convertResult.data.collection,

     

       56
       56
        
                       rKey: convertResult.data.rKey,

     

       57
       57
        
                   };

     

       58
       58
       -
                   return { uri, value: record.value };

     

       58
       58
       +
                   return { cid: record.cid, uri, value: record.value };

     

       59
       59
        
               })

     

       60
       60
        
               .filter((atUri) => atUri !== undefined);

     

       61
       61

+1 -1

src/queries/hooks/useShardsQuery.ts

···

       54
       54
        
                       collection: convertResult.data.collection,

     

       55
       55
        
                       rKey: convertResult.data.rKey,

     

       56
       56
        
                   };

     

       57
       57
       -
                   return { uri, value: record.value };

     

       57
       57
       +
                   return { cid: record.cid, uri, value: record.value };

     

       58
       58
        
               })

     

       59
       59
        
               .filter((atUri) => atUri !== undefined);

     

       60
       60