:recycle: trimming p2p responses

plugins/cia-endpoints/includes/class.make-endpoint.php

                 parse_blocks($item->post_content)
             );
             $filtered[attached] = get_images_from_content($item->post_content);
-            $filtered[relatedto] = p2p_related_to( $item->ID );
+            $filtered[relatedto] = p2p_related_to( $item->ID, false );
             array_push($collection, $filtered);
         }
         wp_reset_postdata();

plugins/cia-endpoints/includes/class.make-sortby.php

         }
         
         if($params['episode']) {
-            $args['p2p'] = $params['episode'];
+            $args['p2p_query'] = $params['episode'];
+            $args['tax_query'] = [];
         }
 
         return $args;
 
     public function by_episode( $request ) {
         $q = new WP_Query($this->make_args($request, null));
-        $found_posts = $q->get_posts();
+        $episode_name = $q->query->p2p_query;
+        $items = $this->prepare_items_for_reponse($q->get_posts());
         wp_reset_postdata();
 
-        return new WP_REST_Response([$q], 200 );
+        return new WP_REST_Response( $items, 200 );
     }
 
     public function prepare_items_for_reponse( $items ) {
         forEach( $items as $item ) {
             $formatted = default_post_format( $item, false );
             $formatted[hero] = get_post_meta( $item->ID, 'hero_header', true );
+            $formatted[relatedto] = p2p_related_to( $item->ID, false );
             array_push($collection, $formatted);
         }
 

plugins/cia-endpoints/includes/formats.php

     return $filtered;
 }
 
+function minimal_post_format( $item ) {
+    $filtered = [];
+    $filtered[id] = $item->ID;
+    $filtered[slug] = $item->post_name;
+    $filtered[type] = $item->post_type;
+    $filtered[title] = $item->post_title;
+    $filtered[date] = $item->post_date;
+    
+    $filtered[thumb] = get_the_post_thumbnail_url($item, 'medium');
+    if(!$filtered[thumb]) {
+        $thumbnailId = get_post_meta( $item->ID, '_thumbnail_id', true );
+        $filtered[thumb] = get_post($thumbnailId)->guid;
+    }
+
+    $posts_with_date = ['exhbition', 'event'];
+    if( in_array($item->post_type, $posts_with_date) ) {
+        $filtered[start] = get_post_meta($item->ID, $item->post_type . '-start-time', true);
+        $filtered[end] = get_post_meta($item->ID, $item->post_type . '-end-time', true);
+        $filtered[current] = time() <= (int)$filtered[end] && time() >= (int)$filtered[start];
+    }
+
+    // Post categories and tags (store just the slugs)
+    if($item->post_type === 'post') {
+        $filtered[categories] = make_taxonomy_endpoint_for(get_the_terms( $item, 'category' ));
+        $filtered[tags] = make_taxonomy_endpoint_for(get_the_terms( $item, 'post_tag' ));
+    }
+
+    return $filtered;
+}
+
 ?>

plugins/cia-endpoints/includes/related-items.php

     return array_diff( $deduped, array($id_to_remove) );
 }
 
-function prepare_related_items($post_ids) {
+function prepare_related_items($post_ids, $include_post) {
     // Rearrange what fields get shown
     $collection = array();
 
     
     $related_items = get_posts($args);
     forEach( $related_items as $item ) {
-        $collection[$item->ID] = default_post_format($item, false);
+        if($include_post) {
+            $collection[$item->ID] = default_post_format($item, false);
+        } else {
+            $collection[$item->ID] = minimal_post_format($item);
+        }
     }
     return $collection;
 }
 
-function p2p_related_to($id, $type) {
+function p2p_related_to($id, $include_post) {
     global $wpdb;
     $sql = $wpdb->prepare(
         "SELECT * FROM wp_p2p
     $res = $wpdb->get_results($sql);
     
     $related_posts_ids = grab_ids_related_to_and_from($id, $res);
-    $related_posts = prepare_related_items($related_posts_ids);
+    
+    $related_posts = prepare_related_items($related_posts_ids, $include_post);
     
     if(empty($related_posts_ids)) {
         return [];

vue-theme/src/pages/single.vue

             )
         },
         p2pPostsByType() {
-            return this.singlePost
+            return this.singlePost && this.singlePost.relatedto
                 ? Object.values(this.singlePost.relatedto).reduce(
                       (byType, relatedPost) => {
                           if (!byType[relatedPost.type])