8825582470

Committed 25 Apr 2024 01:23AM UTC coverage: 31.988% (-0.06%) from 32.048%

Build # 8825582470

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9171 from ForumMagnum/track-each-half-recombee-hybrid

Recombee Hybrid: tracking each half

Run Details

4699 of 38163 branches covered (12.31%)

Branch coverage included in aggregate %.

0 of 9 new or added lines in 2 files covered. (0.0%)

2 existing lines in 2 files now uncovered.

27204 of 61571 relevant lines covered (44.18%)

181.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

18.99

/packages/lesswrong/components/posts/RecombeePostsList.tsx

import React from 'react';
import { Components, fragmentTextForQuery, registerComponent } from '../../lib/vulcan-lib';
import { NetworkStatus, gql, useQuery } from '@apollo/client';
import { HybridRecombeeConfiguration, RecombeeConfiguration } from '../../lib/collections/users/recommendationSettings';
import { useOnMountTracking } from '../../lib/analyticsEvents';
import uniq from 'lodash/uniq';
import { filterNonnull } from '../../lib/utils/typeGuardUtils';
import { isServer } from '../../lib/executionEnvironment';

// Would be nice not to duplicate in postResolvers.ts but unfortunately the post types are different
interface RecombeeRecommendedPost {
  post: PostsListWithVotes,
  scenario: string,
  recommId: string,
  curated?: never,
  stickied?: never,
}

type RecommendedPost = RecombeeRecommendedPost | {
  post: PostsListWithVotes,
  scenario?: never,
  recommId?: never,
  curated: boolean,
  stickied: boolean,
};

const styles = (theme: ThemeType) => ({
  root: {

  }
});

const DEFAULT_RESOLVER_NAME = 'RecombeeLatestPosts';
const HYBRID_RESOLVER_NAME = 'RecombeeHybridPosts';

type RecombeeResolver = typeof DEFAULT_RESOLVER_NAME | typeof HYBRID_RESOLVER_NAME;

const getRecombeePostsQuery = (resolverName: RecombeeResolver) => gql`
  query get${resolverName}($limit: Int, $settings: JSON) {
    ${resolverName}(limit: $limit, settings: $settings) {
      results {
        post {
          ...PostsListWithVotes
        }
        scenario
        recommId
        curated
        stickied
      }
    }
  }
  ${fragmentTextForQuery('PostsListWithVotes')}
`;

const getLoadMoreSettings = (resolverName: RecombeeResolver, results: RecommendedPost[]): (RecombeeConfiguration | HybridRecombeeConfiguration)['loadMore'] => {
  switch (resolverName) {
    case DEFAULT_RESOLVER_NAME:
      const prevRecommId = results.find(result => result.recommId)?.recommId;
      if (!prevRecommId) {
        return undefined;
      }
      return { prevRecommId };  
    case HYBRID_RESOLVER_NAME:
      const [firstRecommId, secondRecommId] = filterNonnull(uniq(results.map(({ recommId }) => recommId)));
      return { prevRecommIds: [firstRecommId, secondRecommId] };
  }
}

export const stickiedPostTerms: PostsViewTerms = {
  view: 'stickied',
  limit: 4, // seriously, shouldn't have more than 4 stickied posts
  forum: true
};

export const RecombeePostsList = ({ algorithm, settings, limit = 15, classes }: {
  algorithm: string,
  settings: RecombeeConfiguration,
  limit?: number,
  classes: ClassesType<typeof styles>,
}) => {
  const { LoadMore, PostsItem, SectionFooter, PostsLoading } = Components;

  const recombeeSettings = { ...settings, scenario: algorithm };

  const resolverName = algorithm === 'recombee-hybrid'
    ? HYBRID_RESOLVER_NAME
    : DEFAULT_RESOLVER_NAME;

  const query = getRecombeePostsQuery(resolverName);
  const { data, loading, fetchMore, networkStatus } = useQuery(query, {
    ssr: false || !isServer,
    notifyOnNetworkStatusChange: true,
    pollInterval: 0,
    variables: {
      limit,
      settings: recombeeSettings,
    },
  });

  const results: RecommendedPost[] | undefined = data?.[resolverName]?.results;
  const postIds = results?.map(({post}) => post._id) ?? [];
  const postIdsWithScenario = results?.map(({post, scenario}) => ({postId: post._id, scenario: scenario ?? 'none'})) ?? [];

  useOnMountTracking({
    eventType: "postList",
    // TODO: Remove postIds which is redundant once analytics dashboard written to use postIdsWithScenario
    eventProps: { postIds, postIdsWithScenario, algorithm },
    captureOnMount: (eventProps) => eventProps.postIds.length > 0,
    skip: !postIds.length || loading,
  });

  if (loading && !results) {
    return <PostsLoading placeholderCount={limit} />;
  }

  if (!results) {
    return null;
  }


  return <div>
    <div className={classes.root}>
      {results.map(({ post, recommId, curated, stickied }) => <PostsItem 
        key={post._id} 
        post={post} 
        recombeeRecommId={recommId} 
        curatedIconLeft={curated} 
        terms={stickied ? stickiedPostTerms : undefined}
      />)}
    </div>
    <SectionFooter>
      <LoadMore
        loading={loading || networkStatus === NetworkStatus.fetchMore}
        loadMore={() => {
          const loadMoreSettings = getLoadMoreSettings(resolverName, results);
          void fetchMore({
            variables: {
              settings: { ...recombeeSettings, loadMore: loadMoreSettings },
            },
            // Update the apollo cache with the combined results of previous loads and the items returned by the current loadMore
            updateQuery: (prev: AnyBecauseHard, { fetchMoreResult }: AnyBecauseHard) => {
              if (!fetchMoreResult) return prev;

              return {
                [resolverName]: {
                  __typename: fetchMoreResult[resolverName].__typename,
                  results: [...prev[resolverName].results, ...fetchMoreResult[resolverName].results]
                }
              };
            }
          });
        }}
        sectionFooterStyles
      />
    </SectionFooter>
  </div>;
}

const RecombeePostsListComponent = registerComponent('RecombeePostsList', RecombeePostsList, {styles});

declare global {
  interface ComponentTypes {
    RecombeePostsList: typeof RecombeePostsListComponent
  }
}

1	import React from 'react';	54✔
2	import { Components, fragmentTextForQuery, registerComponent } from '../../lib/vulcan-lib';	18✔
3	import { NetworkStatus, gql, useQuery } from '@apollo/client';	18✔
4	import { HybridRecombeeConfiguration, RecombeeConfiguration } from '../../lib/collections/users/recommendationSettings';
5	import { useOnMountTracking } from '../../lib/analyticsEvents';	18✔
6	import uniq from 'lodash/uniq';	18✔
7	import { filterNonnull } from '../../lib/utils/typeGuardUtils';	18✔
8	import { isServer } from '../../lib/executionEnvironment';	18✔
9
10	// Would be nice not to duplicate in postResolvers.ts but unfortunately the post types are different
11	interface RecombeeRecommendedPost {
12	post: PostsListWithVotes,
13	scenario: string,
14	recommId: string,
15	curated?: never,
16	stickied?: never,
17	}
18
19	type RecommendedPost = RecombeeRecommendedPost \| {
20	post: PostsListWithVotes,
21	scenario?: never,
22	recommId?: never,
23	curated: boolean,
24	stickied: boolean,
25	};
26
27	const styles = (theme: ThemeType) => ({	18✔
28	root: {
29
30	}
31	});
32
33	const DEFAULT_RESOLVER_NAME = 'RecombeeLatestPosts';	18✔
34	const HYBRID_RESOLVER_NAME = 'RecombeeHybridPosts';	18✔
35
36	type RecombeeResolver = typeof DEFAULT_RESOLVER_NAME \| typeof HYBRID_RESOLVER_NAME;
37
38	const getRecombeePostsQuery = (resolverName: RecombeeResolver) => gql`	18✔
39	query get${resolverName}($limit: Int, $settings: JSON) {
40	${resolverName}(limit: $limit, settings: $settings) {
41	results {
42	post {
43	...PostsListWithVotes
44	}
45	scenario
46	recommId
47	curated
48	stickied
49	}
50	}
51	}
52	${fragmentTextForQuery('PostsListWithVotes')}
53	`;
54
55	const getLoadMoreSettings = (resolverName: RecombeeResolver, results: RecommendedPost[]): (RecombeeConfiguration \| HybridRecombeeConfiguration)['loadMore'] => {	18✔
56	switch (resolverName) {	×
57	case DEFAULT_RESOLVER_NAME:
58	const prevRecommId = results.find(result => result.recommId)?.recommId;	×
59	if (!prevRecommId) {	×
60	return undefined;	×
61	}
62	return { prevRecommId };	×
63	case HYBRID_RESOLVER_NAME:
64	const [firstRecommId, secondRecommId] = filterNonnull(uniq(results.map(({ recommId }) => recommId)));	×
65	return { prevRecommIds: [firstRecommId, secondRecommId] };	×
66	}
67	}
68
69	export const stickiedPostTerms: PostsViewTerms = {	18✔
70	view: 'stickied',
71	limit: 4, // seriously, shouldn't have more than 4 stickied posts
72	forum: true
73	};
74
75	export const RecombeePostsList = ({ algorithm, settings, limit = 15, classes }: {	18!
76	algorithm: string,
77	settings: RecombeeConfiguration,
78	limit?: number,
79	classes: ClassesType<typeof styles>,
80	}) => {
NEW 81	const { LoadMore, PostsItem, SectionFooter, PostsLoading } = Components;	×
82
83	const recombeeSettings = { ...settings, scenario: algorithm };	×
84
85	const resolverName = algorithm === 'recombee-hybrid'	×
86	? HYBRID_RESOLVER_NAME	×
87	: DEFAULT_RESOLVER_NAME;
88
89	const query = getRecombeePostsQuery(resolverName);	×
90	const { data, loading, fetchMore, networkStatus } = useQuery(query, {	×
91	ssr: false \|\| !isServer,
92	notifyOnNetworkStatusChange: true,
93	pollInterval: 0,
94	variables: {
95	limit,
96	settings: recombeeSettings,
97	},
98	});
99
100	const results: RecommendedPost[] \| undefined = data?.[resolverName]?.results;	×
101	const postIds = results?.map(({post}) => post._id) ?? [];	×
NEW 102	const postIdsWithScenario = results?.map(({post, scenario}) => ({postId: post._id, scenario: scenario ?? 'none'})) ?? [];	×
103
104	useOnMountTracking({	×
105	eventType: "postList",
106	// TODO: Remove postIds which is redundant once analytics dashboard written to use postIdsWithScenario
107	eventProps: { postIds, postIdsWithScenario, algorithm },
UNCOV 108	captureOnMount: (eventProps) => eventProps.postIds.length > 0,	×
109	skip: !postIds.length \|\| loading,	×
110	});
111
112	if (loading && !results) {	×
113	return <PostsLoading placeholderCount={limit} />;	×
114	}
115
116	if (!results) {	×
117	return null;	×
118	}
119
120
121	return <div>	×
122	<div className={classes.root}>
123	{results.map(({ post, recommId, curated, stickied }) => <PostsItem	×
124	key={post._id}
125	post={post}
126	recombeeRecommId={recommId}
127	curatedIconLeft={curated}
128	terms={stickied ? stickiedPostTerms : undefined}	×
129	/>)}
130	</div>
131	<SectionFooter>
132	<LoadMore
133	loading={loading \|\| networkStatus === NetworkStatus.fetchMore}	×
134	loadMore={() => {
135	const loadMoreSettings = getLoadMoreSettings(resolverName, results);	×
136	void fetchMore({	×
137	variables: {
138	settings: { ...recombeeSettings, loadMore: loadMoreSettings },
139	},
140	// Update the apollo cache with the combined results of previous loads and the items returned by the current loadMore
141	updateQuery: (prev: AnyBecauseHard, { fetchMoreResult }: AnyBecauseHard) => {
142	if (!fetchMoreResult) return prev;	×
143
144	return {	×
145	[resolverName]: {
146	__typename: fetchMoreResult[resolverName].__typename,
147	results: [...prev[resolverName].results, ...fetchMoreResult[resolverName].results]
148	}
149	};
150	}
151	});
152	}}
153	sectionFooterStyles
154	/>
155	</SectionFooter>
156	</div>;
157	}
158
159	const RecombeePostsListComponent = registerComponent('RecombeePostsList', RecombeePostsList, {styles});	18✔
160
161	declare global {
162	interface ComponentTypes {
163	RecombeePostsList: typeof RecombeePostsListComponent
164	}
165	}

ForumMagnum / ForumMagnum / 8825582470

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous