9753778084

Committed 02 Jul 2024 02:00AM UTC coverage: 31.897%. Remained the same

Build # 9753778084

Build Type

Pull #9472

github

Committed by

web-flow

Commit Message

Merge 899448d38 into f30af452e

Pull Request Pull Request #9472: LW Deploy, 2024-07-07c

Run Details

4897 of 40120 branches covered (12.21%)

Branch coverage included in aggregate %.

22 of 45 new or added lines in 6 files covered. (48.89%)

3 existing lines in 3 files now uncovered.

28525 of 64660 relevant lines covered (44.12%)

180.44 hits per line

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

12.58

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

import React, { useState } 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 moment from 'moment';
import { useCurrentUser } from '../common/withUser';
import { aboutPostIdSetting } from '@/lib/instanceSettings';
import { IsRecommendationContext } from '../dropdowns/posts/PostActions';

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

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

type LoadMoreSettings = {
  loadMore: (RecombeeConfiguration | HybridRecombeeConfiguration)['loadMore'];
  excludedPostIds: string[];
} | {
  loadMore?: never;
  excludedPostIds: string[]
} | {
  loadMore: (RecombeeConfiguration | HybridRecombeeConfiguration)['loadMore'];
  excludedPostIds?: never
} | undefined;

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
        generatedAt
        curated
        stickied
      }
    }
  }
  ${fragmentTextForQuery('PostsListWithVotes')}
`;

const isWithinLoadMoreWindow = (recGeneratedAt: Date) => {
  // Use 29 minutes instead of 30 as the cutoff for considering recommendations stale, just to have a bit of buffer.
  const loadMoreTtlMs = 1000 * 60 * 29;
  const cutoff = moment().subtract(loadMoreTtlMs, 'ms');

  return moment(recGeneratedAt).isAfter(cutoff);
};

const getLoadMoreSettings = (resolverName: RecombeeResolver, results: RecommendedPost[], loadMoreCount: number): LoadMoreSettings => {
  const staleRecommIds = filterNonnull(uniq(
    results
      .filter(({ generatedAt }) => generatedAt && !isWithinLoadMoreWindow(generatedAt))
      .map(({ recommId }) => recommId)
  ));

  const staleRecomms = results.filter(({ recommId }) => recommId && staleRecommIds.includes(recommId));
  const freshRecomms = results.filter(({ recommId }) => recommId && !staleRecommIds.includes(recommId));

  const excludedPostIds = staleRecomms.map(({ post: { _id } }) => _id);
  const [firstRecommId, secondRecommId] = filterNonnull(uniq(freshRecomms.map(({ recommId }) => recommId)));

  switch (resolverName) {
    case DEFAULT_RESOLVER_NAME: {
      if (staleRecomms.length && !freshRecomms.length) {
        return { excludedPostIds };
      } else if (!staleRecomms.length && freshRecomms.length) {
        return { loadMore: { prevRecommId: firstRecommId } };
      } else {
        return { excludedPostIds, loadMore: { prevRecommId: firstRecommId } };
      }
    }
    case HYBRID_RESOLVER_NAME: {
      if (staleRecomms.length && !freshRecomms.length) {
        return { excludedPostIds, loadMore: { prevRecommIds: [undefined, undefined], loadMoreCount } };
      } else if (!staleRecomms.length && freshRecomms.length) {
        return { loadMore: { prevRecommIds: [firstRecommId, secondRecommId], loadMoreCount } };
      } else {
        return { excludedPostIds, loadMore: { prevRecommIds: [firstRecommId, secondRecommId], loadMoreCount } };
      }
    }
  }
}

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 [loadMoreCount, setLoadMoreCount] = useState(1);
  const currentUser = useCurrentUser();

  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, {
    notifyOnNetworkStatusChange: true,
    pollInterval: 0,
    variables: {
      limit,
      settings: recombeeSettings,
    },
  });

  const results: RecommendedPost[] | undefined = data?.[resolverName]?.results;

  const hiddenPostIds = currentUser?.hiddenPostsMetadata?.map(metadata => metadata.postId) ?? [];
  
  //exclude posts with hiddenPostIds
  const filteredResults = results?.filter(({ post }) => !hiddenPostIds.includes(post._id));

  const postIds = filteredResults?.map(({post}) => post._id) ?? [];
  const postIdsWithScenario = filteredResults?.map(({ post, scenario, curated, stickied, generatedAt }, idx) => {
    let loggedScenario = scenario;
    if (!loggedScenario) {
      if (post._id === aboutPostIdSetting.get() && idx === 0) {
        loggedScenario = 'welcome-post';
      } else if (curated) {
        loggedScenario = 'curated';
      } else if (stickied) {
        loggedScenario = 'stickied';
      } else {
        loggedScenario = 'hacker-news';
      }
    }

    const data = { postId: post._id, scenario: loggedScenario };

    if (generatedAt) {
      return {...data, generatedAt: new Date(generatedAt).toISOString()};
    }

    return data;
  }) ?? [];

  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 && !filteredResults) {
    return <PostsLoading placeholderCount={limit} />;
  }

  if (!filteredResults) {
    return null;
  }

  return <div>
    <div className={classes.root}>
      {filteredResults.map(({ post, recommId, curated, stickied }) => <IsRecommendationContext.Provider key={post._id} value={!!recommId}>
        <PostsItem 
          post={post} 
          recombeeRecommId={recommId} 
          curatedIconLeft={curated} 
          emphasizeIfNew={true}
          terms={stickied ? stickiedPostTerms : undefined}
        />
      </IsRecommendationContext.Provider>)}
    </div>
    <SectionFooter>
      <LoadMore
        loading={loading || networkStatus === NetworkStatus.fetchMore}
        loadMore={() => {
          const loadMoreSettings = getLoadMoreSettings(resolverName, filteredResults, loadMoreCount);
          void fetchMore({
            variables: {
              settings: { ...recombeeSettings, ...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) => {
              setLoadMoreCount(loadMoreCount + 1);

              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, { useState } 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 moment from 'moment';	18✔
9	import { useCurrentUser } from '../common/withUser';	18✔
10	import { aboutPostIdSetting } from '@/lib/instanceSettings';	18✔
11	import { IsRecommendationContext } from '../dropdowns/posts/PostActions';	18✔
12
13	// Would be nice not to duplicate in postResolvers.ts but unfortunately the post types are different
14	interface RecombeeRecommendedPost {
15	post: PostsListWithVotes,
16	scenario: string,
17	recommId: string,
18	generatedAt: Date,
19	curated?: never,
20	stickied?: never,
21	}
22
23	type RecommendedPost = RecombeeRecommendedPost \| {
24	post: PostsListWithVotes,
25	scenario?: never,
26	recommId?: never,
27	generatedAt?: never,
28	curated: boolean,
29	stickied: boolean,
30	};
31
32	type LoadMoreSettings = {
33	loadMore: (RecombeeConfiguration \| HybridRecombeeConfiguration)['loadMore'];
34	excludedPostIds: string[];
35	} \| {
36	loadMore?: never;
37	excludedPostIds: string[]
38	} \| {
39	loadMore: (RecombeeConfiguration \| HybridRecombeeConfiguration)['loadMore'];
40	excludedPostIds?: never
41	} \| undefined;
42
43	const styles = (theme: ThemeType) => ({	18✔
44	root: {
45
46	}
47	});
48
49	const DEFAULT_RESOLVER_NAME = 'RecombeeLatestPosts';	18✔
50	const HYBRID_RESOLVER_NAME = 'RecombeeHybridPosts';	18✔
51
52	type RecombeeResolver = typeof DEFAULT_RESOLVER_NAME \| typeof HYBRID_RESOLVER_NAME;
53
54	const getRecombeePostsQuery = (resolverName: RecombeeResolver) => gql`	18✔
55	query get${resolverName}($limit: Int, $settings: JSON) {
56	${resolverName}(limit: $limit, settings: $settings) {
57	results {
58	post {
59	...PostsListWithVotes
60	}
61	scenario
62	recommId
63	generatedAt
64	curated
65	stickied
66	}
67	}
68	}
69	${fragmentTextForQuery('PostsListWithVotes')}
70	`;
71
72	const isWithinLoadMoreWindow = (recGeneratedAt: Date) => {	18✔
73	// Use 29 minutes instead of 30 as the cutoff for considering recommendations stale, just to have a bit of buffer.
74	const loadMoreTtlMs = 1000 * 60 * 29;	×
75	const cutoff = moment().subtract(loadMoreTtlMs, 'ms');	×
76
77	return moment(recGeneratedAt).isAfter(cutoff);	×
78	};
79
80	const getLoadMoreSettings = (resolverName: RecombeeResolver, results: RecommendedPost[], loadMoreCount: number): LoadMoreSettings => {	18✔
81	const staleRecommIds = filterNonnull(uniq(	×
82	results
83	.filter(({ generatedAt }) => generatedAt && !isWithinLoadMoreWindow(generatedAt))	×
84	.map(({ recommId }) => recommId)	×
85	));
86
87	const staleRecomms = results.filter(({ recommId }) => recommId && staleRecommIds.includes(recommId));	×
88	const freshRecomms = results.filter(({ recommId }) => recommId && !staleRecommIds.includes(recommId));	×
89
90	const excludedPostIds = staleRecomms.map(({ post: { _id } }) => _id);	×
91	const [firstRecommId, secondRecommId] = filterNonnull(uniq(freshRecomms.map(({ recommId }) => recommId)));	×
92
93	switch (resolverName) {	×
94	case DEFAULT_RESOLVER_NAME: {
95	if (staleRecomms.length && !freshRecomms.length) {	×
96	return { excludedPostIds };	×
97	} else if (!staleRecomms.length && freshRecomms.length) {	×
98	return { loadMore: { prevRecommId: firstRecommId } };	×
99	} else {
100	return { excludedPostIds, loadMore: { prevRecommId: firstRecommId } };	×
101	}
102	}
103	case HYBRID_RESOLVER_NAME: {
104	if (staleRecomms.length && !freshRecomms.length) {	×
105	return { excludedPostIds, loadMore: { prevRecommIds: [undefined, undefined], loadMoreCount } };	×
106	} else if (!staleRecomms.length && freshRecomms.length) {	×
107	return { loadMore: { prevRecommIds: [firstRecommId, secondRecommId], loadMoreCount } };	×
108	} else {
109	return { excludedPostIds, loadMore: { prevRecommIds: [firstRecommId, secondRecommId], loadMoreCount } };	×
110	}
111	}
112	}
113	}
114
115	export const stickiedPostTerms: PostsViewTerms = {	18✔
116	view: 'stickied',
117	limit: 4, // seriously, shouldn't have more than 4 stickied posts
118	forum: true
119	};
120
121	export const RecombeePostsList = ({ algorithm, settings, limit = 15, classes }: {	18!
122	algorithm: string,
123	settings: RecombeeConfiguration,
124	limit?: number,
125	classes: ClassesType<typeof styles>,
126	}) => {
127	const { LoadMore, PostsItem, SectionFooter, PostsLoading } = Components;	×
128
129	const [loadMoreCount, setLoadMoreCount] = useState(1);	×
130	const currentUser = useCurrentUser();	×
131
132	const recombeeSettings = { ...settings, scenario: algorithm };	×
133
134	const resolverName = algorithm === 'recombee-hybrid'	×
135	? HYBRID_RESOLVER_NAME	×
136	: DEFAULT_RESOLVER_NAME;
137
138	const query = getRecombeePostsQuery(resolverName);	×
139	const { data, loading, fetchMore, networkStatus } = useQuery(query, {	×
140	notifyOnNetworkStatusChange: true,
141	pollInterval: 0,
142	variables: {
143	limit,
144	settings: recombeeSettings,
145	},
146	});
147
148	const results: RecommendedPost[] \| undefined = data?.[resolverName]?.results;	×
149
150	const hiddenPostIds = currentUser?.hiddenPostsMetadata?.map(metadata => metadata.postId) ?? [];	×
151
152	//exclude posts with hiddenPostIds
153	const filteredResults = results?.filter(({ post }) => !hiddenPostIds.includes(post._id));	×
154
155	const postIds = filteredResults?.map(({post}) => post._id) ?? [];	×
156	const postIdsWithScenario = filteredResults?.map(({ post, scenario, curated, stickied, generatedAt }, idx) => {	×
157	let loggedScenario = scenario;	×
158	if (!loggedScenario) {	×
159	if (post._id === aboutPostIdSetting.get() && idx === 0) {	×
160	loggedScenario = 'welcome-post';	×
161	} else if (curated) {	×
162	loggedScenario = 'curated';	×
163	} else if (stickied) {	×
164	loggedScenario = 'stickied';	×
165	} else {
166	loggedScenario = 'hacker-news';	×
167	}
168	}
169
170	const data = { postId: post._id, scenario: loggedScenario };	×
171
172	if (generatedAt) {	×
173	return {...data, generatedAt: new Date(generatedAt).toISOString()};	×
174	}
175
176	return data;	×
177	}) ?? [];
178
179	useOnMountTracking({	×
180	eventType: "postList",
181	// TODO: Remove postIds which is redundant once analytics dashboard written to use postIdsWithScenario
182	eventProps: { postIds, postIdsWithScenario, algorithm },
183	captureOnMount: (eventProps) => eventProps.postIds.length > 0,	×
184	skip: !postIds.length \|\| loading,	×
185	});
186
187	if (loading && !filteredResults) {	×
188	return <PostsLoading placeholderCount={limit} />;	×
189	}
190
191	if (!filteredResults) {	×
192	return null;	×
193	}
194
195	return <div>	×
196	<div className={classes.root}>
NEW 197	{filteredResults.map(({ post, recommId, curated, stickied }) => <IsRecommendationContext.Provider key={post._id} value={!!recommId}>	×
198	<PostsItem
199	post={post}
200	recombeeRecommId={recommId}
201	curatedIconLeft={curated}
202	emphasizeIfNew={true}
203	terms={stickied ? stickiedPostTerms : undefined}	×
204	/>
205	</IsRecommendationContext.Provider>)}
206	</div>
207	<SectionFooter>
208	<LoadMore
209	loading={loading \|\| networkStatus === NetworkStatus.fetchMore}	×
210	loadMore={() => {
211	const loadMoreSettings = getLoadMoreSettings(resolverName, filteredResults, loadMoreCount);	×
212	void fetchMore({	×
213	variables: {
214	settings: { ...recombeeSettings, ...loadMoreSettings },
215	},
216	// Update the apollo cache with the combined results of previous loads and the items returned by the current loadMore
217	updateQuery: (prev: AnyBecauseHard, { fetchMoreResult }: AnyBecauseHard) => {
218	setLoadMoreCount(loadMoreCount + 1);	×
219
220	if (!fetchMoreResult) return prev;	×
221
222	return {	×
223	[resolverName]: {
224	__typename: fetchMoreResult[resolverName].__typename,
225	results: [...prev[resolverName].results, ...fetchMoreResult[resolverName].results]
226	}
227	};
228	}
229	});
230	}}
231	sectionFooterStyles
232	/>
233	</SectionFooter>
234	</div>;
235	}
236
237	const RecombeePostsListComponent = registerComponent('RecombeePostsList', RecombeePostsList, {styles});	18✔
238
239	declare global {
240	interface ComponentTypes {
241	RecombeePostsList: typeof RecombeePostsListComponent
242	}
243	}

ForumMagnum / ForumMagnum / 9753778084

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