8823766018

Committed 24 Apr 2024 09:50PM UTC coverage: 32.019% (-0.03%) from 32.044%

Build # 8823766018

Build Type

Pull #9160

github

Committed by

darkruby501

Commit Message

manually stickied posts for recommendations tab

Pull Request Pull Request #9160: Continue Reading accepts limit and shuffle params + recommendationsTab stickied posts

Run Details

4689 of 38078 branches covered (12.31%)

Branch coverage included in aggregate %.

3 of 16 new or added lines in 3 files covered. (18.75%)

2 existing lines in 1 file now uncovered.

27195 of 61500 relevant lines covered (44.22%)

181.81 hits per line

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

8.44

/packages/lesswrong/server/recombee/client.ts

import { ApiClient, RecommendationResponse, requests } from 'recombee-api-client';
import { HybridRecombeeConfiguration, RecombeeConfiguration, RecombeeRecommendationArgs } from '../../lib/collections/users/recommendationSettings';
import { loadByIds } from '../../lib/loaders';
import { filterNonnull } from '../../lib/utils/typeGuardUtils';
import { htmlToTextDefault } from '../../lib/htmlToText';
import { truncate } from '../../lib/editor/ellipsize';
import findByIds from '../vulcan-lib/findbyids';
import { accessFilterMultiple } from '../../lib/utils/schemaUtils';
import { recombeeDatabaseIdSetting, recombeePrivateApiTokenSetting } from '../../lib/instanceSettings';
import { viewTermsToQuery } from '../../lib/utils/viewUtils';
import { stickiedPostTerms } from '../../components/posts/RecombeePostsList';
import groupBy from 'lodash/groupBy';
import { recommendationsTabManuallyStickiedPostIdsSetting } from '../../lib/publicSettings';

export const getRecombeeClientOrThrow = (() => {
  let client: ApiClient;

  return () => {
    if (!client) {
      const databaseId = recombeeDatabaseIdSetting.get();
      const apiToken = recombeePrivateApiTokenSetting.get();

      if (!databaseId || !apiToken) {
        throw new Error('Missing either databaseId or api token when initializing Recombee client!');
      }
      
      // TODO - pull out client options like region to db settings?
      client = new ApiClient(databaseId, apiToken, { region: 'us-west' });
    }

    return client;
  };
})();

const voteTypeRatingsMap: Partial<Record<string, number>> = {
  bigDownvote: -1,
  smallDownvote: -0.5,
  smallUpvote: 0.5,
  bigUpvote: 1,
};

const HYBRID_SCENARIO_MAP = {
  configurable: 'recombee-personal-latest',
  fixed: 'recombee-personal'
};

interface OnsitePostRecommendationsInfo {
  curatedPostIds: string[],
  stickiedPostIds: string[],
  excludedPostFilter?: string,
}

export interface RecombeeRecommendedPost {
  post: Partial<DbPost>,
  recommId: string,
  curated?: never,
  stickied?: never,
}

export type RecommendedPost = RecombeeRecommendedPost | {
  post: Partial<DbPost>,
  recommId?: never,
  curated: boolean,
  stickied: boolean,
};

const recombeeRequestHelpers = {
  createRecommendationsForUserRequest(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs) {
    const { userId: overrideUserId, rotationTime, lwRationalityOnly, onlyUnread, loadMore, ...settings } = lwAlgoSettings;

    if (loadMore) {
      return new requests.RecommendNextItems(loadMore.prevRecommId, count);
    }

    const servedUserId = overrideUserId ?? userId;
    const rotationTimeSeconds = typeof rotationTime === 'number' ? rotationTime * 3600 : undefined;

    // TODO: pass in scenario, exclude unread, etc, in options?
    const lwRationalityFilter = lwRationalityOnly ? ` and ("Rationality" in 'core_tags' or "World Modeling" in 'core_tags')` : '';

    return new requests.RecommendItemsToUser(servedUserId, count, {
      ...settings,
      // Explicitly coalesce empty strings to undefined, since empty strings aren't valid booster expressions
      booster: settings.booster || undefined,
      rotationTime: rotationTimeSeconds
    });
  },

  async createUpsertPostRequest(post: DbPost, context: ResolverContext, tags?: { name: string, core: boolean }[]) {
    const { Tags } = context;

    const tagIds = Object.entries(post.tagRelevance ?? {}).filter(([_, relevance]: [string, number]) => relevance > 0).map(([tagId]) => tagId)
    tags ??= filterNonnull(await findByIds(Tags, tagIds))
    const tagNames = tags.map(tag => tag.name)
    const coreTagNames = tags.filter(tag => tag.core).map(tag => tag.name)

    const postText = htmlToTextDefault(truncate(post.contents?.html, 2000, 'words'))

    return new requests.SetItemValues(post._id, {
      title: post.title,
      author: post.author,
      authorId: post.userId,
      karma: post.baseScore,
      body: postText,
      postedAt: post.postedAt,
      tags: tagNames,
      coreTags: coreTagNames,
      curated: !!post.curatedDate,
      frontpage: !!post.frontpageDate,
      draft: !!post.draft,
      lastCommentedAt: post.lastCommentedAt,
    }, { cascadeCreate: true });
  },

  createReadStatusRequest(readStatus: DbReadStatus) {
    if (!readStatus.postId) {
      // eslint-disable-next-line no-console
      console.error(`Missing postId for read status ${readStatus._id} when trying to add detail view to recombee`);
      return;
    }

    return new requests.AddDetailView(readStatus.userId, readStatus.postId, {
      timestamp: readStatus.lastUpdated.toISOString(),
      cascadeCreate: false
    });
  },

  createVoteRequest(vote: DbVote) {
    const rating = voteTypeRatingsMap[vote.voteType];
    if (typeof rating !== 'number') {
      // eslint-disable-next-line no-console
      console.log(`Attempted to create a recombee rating request for a non-karma vote with id ${vote._id}`);
      return;
    }

    return new requests.AddRating(vote.userId, vote.documentId, rating, {
      timestamp: vote.votedAt.toISOString(),
      cascadeCreate: false
    });
  },

  createUpsertUserDetailsRequest(user: DbUser) {
    const { displayName, karma, createdAt } = user;
    return new requests.SetUserValues(user._id, { displayName, karma, createdAt }, { cascadeCreate: true });
  },

  getBatchRequest(requestBatch: requests.Request[]) {
    return new requests.Batch(requestBatch);
  },

  async getOnsitePostInfo(lwAlgoSettings: HybridRecombeeConfiguration | RecombeeConfiguration, context: ResolverContext): Promise<OnsitePostRecommendationsInfo> {
    if (lwAlgoSettings.loadMore) {
      return {
        curatedPostIds: [],
        stickiedPostIds: [],
        excludedPostFilter: undefined,
      };
    }

    const postPromises =  [curatedPostTerms, stickiedPostTerms]
      .map(terms => viewTermsToQuery("Posts", terms, undefined, context))
      .map(postsQuery => context.Posts.find(postsQuery.selector, postsQuery.options, { _id: 1 }).fetch());

    const [curatedPosts, stickiedPosts] = await Promise.all(postPromises);

    const curatedPostIds = curatedPosts.map(post => post._id);
    const stickiedPostIds = stickiedPosts.map(post => post._id);
    const excludedPostIds = [...curatedPostIds, ...stickiedPostIds];
    const excludedPostFilter = `'itemId' not in {${excludedPostIds.map(id => `"${id}"`).join(', ')}}`;

    return {
      curatedPostIds,
      stickiedPostIds,
      excludedPostFilter,
    };
  },

  convertHybridToRecombeeArgs(hybridArgs: HybridRecombeeConfiguration, hybridArm: keyof typeof HYBRID_SCENARIO_MAP, filter?: string) {
    const { loadMore, userId, ...rest } = hybridArgs;

    const scenario = HYBRID_SCENARIO_MAP[hybridArm];
    const isConfigurable = hybridArm === 'configurable';
    const clientConfig: Partial<Omit<HybridRecombeeConfiguration,"loadMore"|"userId">> = isConfigurable ? rest : {rotationRate: 0.1, rotationTime: 144};
    const prevRecommIdIndex = isConfigurable ? 0 : 1;
    const loadMoreConfig = loadMore
      ? { loadMore: { prevRecommId: loadMore.prevRecommIds[prevRecommIdIndex] } }
      : {};

    return {
      userId,
      ...clientConfig,
      filter,
      scenario,
      ...loadMoreConfig
    };
  },

  interleaveHybridRecommendedPosts(recommendedPosts: RecombeeRecommendedPost[]) {
    const recommendationGroupedPosts = groupBy(recommendedPosts, (result) => result.recommId);
    let weights = Object.entries(recommendationGroupedPosts).map(([recommId, posts]) => [recommId, posts.length / recommendedPosts.length] as const);

    const interleavedPosts: RecombeeRecommendedPost[] = [];

    while (interleavedPosts.length < recommendedPosts.length) {
      // Calculate current total weight (since it changes when we remove a recommId group for running out of posts)
      const totalWeight = weights.reduce((sum, [_, weight]) => sum + weight, 0);

      // Weighted random selection of next recommId to pick a post from
      let randomWeight = Math.random() * totalWeight;
      let selectedRecommId: string | undefined;
      for (const [recommId, recommIdWeight] of weights) {
        randomWeight -= recommIdWeight;
        if (randomWeight <= 0) {
          selectedRecommId = recommId;
          break;
        }
      }

      // Safety check, though selectedGroup should always be defined here
      if (!selectedRecommId) continue;

      // Add next post from the selected group to the interleaved array
      const postsWithRecommId = recommendationGroupedPosts[selectedRecommId];
      const nextPost = postsWithRecommId.shift();
      if (!nextPost) {
        // We shouldn't ever get here, but just in case
        continue;
      } else {
        interleavedPosts.push(nextPost);

        // Update the group's state: remove it if it's out of posts
        if (postsWithRecommId.length === 0) {
          weights = weights.filter(([recommId]) => recommId !== selectedRecommId);
        }  
      }
    }

    return interleavedPosts;
  }
};

const curatedPostTerms: PostsViewTerms = {
  view: 'curated',
  limit: 3,
};

const recombeeApi = {
  async getRecommendationsForUser(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs, context: ResolverContext) {
    const client = getRecombeeClientOrThrow();

    const {
      curatedPostIds,
      stickiedPostIds,
      excludedPostFilter
    } = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);

    const curatedPostReadStatuses = await (
      lwAlgoSettings.loadMore
        ? Promise.resolve([])
        : context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
    );

    const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));
    const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length;

    const modifiedCount = count - curatedAndStickiedPostCount;
    const recommendationsRequestBody = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, modifiedCount, { ...lwAlgoSettings, filter: excludedPostFilter });

    // We need the type cast here because recombee's type definitions can't handle inferring response types for union request types, even if they have the same response type
    const recombeeResponse = await client.send(recommendationsRequestBody) as RecommendationResponse;
    const { recomms, recommId } = recombeeResponse;

    const recommendationIdPairs = recomms.map(rec => [rec.id, recommId] as const);
    const recommendedPostIds = recomms.map(({ id }) => id);
    const postIds = [...includedCuratedPostIds, ...stickiedPostIds, ...recommendedPostIds];

    const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));
    const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, posts, context)

    const mappedPosts = filteredPosts.map(post => {
      // _id isn't going to be filtered out by `accessFilterMultiple`
      const postId = post._id!;
      const recommId = recommendationIdPairs.find(([id]) => id === postId)?.[1];
      if (recommId) {
        return { post, recommId };
      } else {
        return {
          post,
          curated: curatedPostIds.includes(postId),
          stickied: stickiedPostIds.includes(postId)  
        };
      }
    });

    return mappedPosts;
  },


  async getHybridRecommendationsForUser(userId: string, count: number, lwAlgoSettings: HybridRecombeeConfiguration, context: ResolverContext) {
    const client = getRecombeeClientOrThrow();

    const {
      curatedPostIds,
      stickiedPostIds,
      excludedPostFilter
    } = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);

    const manuallyStickiedPostIds = recommendationsTabManuallyStickiedPostIdsSetting.get()

    const curatedPostReadStatuses = await (
      lwAlgoSettings.loadMore
        ? Promise.resolve([])
        : context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
    );

    const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));
    const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length + manuallyStickiedPostIds.length;

    const modifiedCount = count - curatedAndStickiedPostCount;
    const split = 0.5;
    const firstCount = Math.floor(modifiedCount * split);
    const secondCount = modifiedCount - firstCount;

    const firstRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'configurable', excludedPostFilter);
    const secondRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'fixed', excludedPostFilter);

    const firstRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, firstCount, firstRequestSettings);
    const secondRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, secondCount, secondRequestSettings);
    const batchRequest = recombeeRequestHelpers.getBatchRequest([firstRequest, secondRequest]);

    const batchResponse = await client.send(batchRequest);
    // We need the type cast here because recombee's type definitions don't provide response types for batch requests
    const recombeeResponses = batchResponse.map(({json}) => json as RecommendationResponse);

    // We explicitly avoid deduplicating postIds because we want to see how often the same post is recommended by both arms of the hybrid recommender
    const recommendationIdPairs = recombeeResponses.flatMap(response => response.recomms.map(rec => [rec.id, response.recommId] as const));
    const recommendedPostIds = recommendationIdPairs.map(([id]) => id);
    const postIds = [...includedCuratedPostIds, ...manuallyStickiedPostIds, ...stickiedPostIds, ...recommendedPostIds];
    
    const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));
    const orderedPosts = filterNonnull(postIds.map(id => posts.find(post => post._id === id)));
    const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, orderedPosts, context);

    const mappedPosts = filteredPosts.map(post => {
      // _id isn't going to be filtered out by `accessFilterMultiple`
      const postId = post._id!;
      const recommId = recommendationIdPairs.find(([id]) => id === postId)?.[1];
      if (recommId) {
        return { post, recommId };
      } else {
        const stickied = stickiedPostIds.includes(postId) || manuallyStickiedPostIds.includes(postId);
        if ( stickied ) {
          post.sticky = true;
        }

        return {
          post,
          curated: curatedPostIds.includes(postId),
          stickied  
        };
      }
    });

    const curatedOrStickiedPosts = mappedPosts.filter((result): result is Exclude<RecommendedPost, RecombeeRecommendedPost> => !result.recommId);
    const recommendedPosts = mappedPosts.filter((result): result is RecombeeRecommendedPost => !!result.recommId);

    const interleavedRecommendedPosts = recombeeRequestHelpers.interleaveHybridRecommendedPosts(recommendedPosts);

    return [...curatedOrStickiedPosts, ...interleavedRecommendedPosts];
  },


  async upsertPost(post: DbPost, context: ResolverContext) {
    const client = getRecombeeClientOrThrow();
    const request = await recombeeRequestHelpers.createUpsertPostRequest(post, context);

    await client.send(request);
  },

  async createReadStatus(readStatus: DbReadStatus) {
    const client = getRecombeeClientOrThrow();
    const request = recombeeRequestHelpers.createReadStatusRequest(readStatus);
    if (!request) {
      return;
    }

    await client.send(request);
  },

  async createVote(vote: DbVote) {
    const client = getRecombeeClientOrThrow();
    const request = recombeeRequestHelpers.createVoteRequest(vote);
    if (!request) {
      return;
    }

    await client.send(request);
  },

  async createUser(user: DbUser) {
    const client = getRecombeeClientOrThrow();
    const request = recombeeRequestHelpers.createUpsertUserDetailsRequest(user);
    await client.send(request);
  }
};

export { recombeeRequestHelpers, recombeeApi };

1	import { ApiClient, RecommendationResponse, requests } from 'recombee-api-client';	54✔
2	import { HybridRecombeeConfiguration, RecombeeConfiguration, RecombeeRecommendationArgs } from '../../lib/collections/users/recommendationSettings';
3	import { loadByIds } from '../../lib/loaders';	18✔
4	import { filterNonnull } from '../../lib/utils/typeGuardUtils';	18✔
5	import { htmlToTextDefault } from '../../lib/htmlToText';	18✔
6	import { truncate } from '../../lib/editor/ellipsize';	18✔
7	import findByIds from '../vulcan-lib/findbyids';	18✔
8	import { accessFilterMultiple } from '../../lib/utils/schemaUtils';	18✔
9	import { recombeeDatabaseIdSetting, recombeePrivateApiTokenSetting } from '../../lib/instanceSettings';	18✔
10	import { viewTermsToQuery } from '../../lib/utils/viewUtils';	18✔
11	import { stickiedPostTerms } from '../../components/posts/RecombeePostsList';	18✔
12	import groupBy from 'lodash/groupBy';	18✔
13	import { recommendationsTabManuallyStickiedPostIdsSetting } from '../../lib/publicSettings';	18✔
14
15	export const getRecombeeClientOrThrow = (() => {	18✔
16	let client: ApiClient;
17
18	return () => {	18✔
19	if (!client) {	×
20	const databaseId = recombeeDatabaseIdSetting.get();	×
21	const apiToken = recombeePrivateApiTokenSetting.get();	×
22
23	if (!databaseId \|\| !apiToken) {	×
24	throw new Error('Missing either databaseId or api token when initializing Recombee client!');	×
25	}
26
27	// TODO - pull out client options like region to db settings?
28	client = new ApiClient(databaseId, apiToken, { region: 'us-west' });	×
29	}
30
31	return client;	×
32	};
33	})();
34
35	const voteTypeRatingsMap: Partial<Record<string, number>> = {	18✔
36	bigDownvote: -1,
37	smallDownvote: -0.5,
38	smallUpvote: 0.5,
39	bigUpvote: 1,
40	};
41
42	const HYBRID_SCENARIO_MAP = {	18✔
43	configurable: 'recombee-personal-latest',
44	fixed: 'recombee-personal'
45	};
46
47	interface OnsitePostRecommendationsInfo {
48	curatedPostIds: string[],
49	stickiedPostIds: string[],
50	excludedPostFilter?: string,
51	}
52
53	export interface RecombeeRecommendedPost {
54	post: Partial<DbPost>,
55	recommId: string,
56	curated?: never,
57	stickied?: never,
58	}
59
60	export type RecommendedPost = RecombeeRecommendedPost \| {
61	post: Partial<DbPost>,
62	recommId?: never,
63	curated: boolean,
64	stickied: boolean,
65	};
66
67	const recombeeRequestHelpers = {	18✔
68	createRecommendationsForUserRequest(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs) {
69	const { userId: overrideUserId, rotationTime, lwRationalityOnly, onlyUnread, loadMore, ...settings } = lwAlgoSettings;	×
70
71	if (loadMore) {	×
72	return new requests.RecommendNextItems(loadMore.prevRecommId, count);	×
73	}
74
75	const servedUserId = overrideUserId ?? userId;	×
76	const rotationTimeSeconds = typeof rotationTime === 'number' ? rotationTime * 3600 : undefined;	×
77
78	// TODO: pass in scenario, exclude unread, etc, in options?
79	const lwRationalityFilter = lwRationalityOnly ? ` and ("Rationality" in 'core_tags' or "World Modeling" in 'core_tags')` : '';	×
80
81	return new requests.RecommendItemsToUser(servedUserId, count, {	×
82	...settings,
83	// Explicitly coalesce empty strings to undefined, since empty strings aren't valid booster expressions
84	booster: settings.booster \|\| undefined,	×
85	rotationTime: rotationTimeSeconds
86	});
87	},
88
89	async createUpsertPostRequest(post: DbPost, context: ResolverContext, tags?: { name: string, core: boolean }[]) {
90	const { Tags } = context;	×
91
92	const tagIds = Object.entries(post.tagRelevance ?? {}).filter(([_, relevance]: [string, number]) => relevance > 0).map(([tagId]) => tagId)	×
93	tags ??= filterNonnull(await findByIds(Tags, tagIds))	×
94	const tagNames = tags.map(tag => tag.name)	×
95	const coreTagNames = tags.filter(tag => tag.core).map(tag => tag.name)	×
96
97	const postText = htmlToTextDefault(truncate(post.contents?.html, 2000, 'words'))	×
98
99	return new requests.SetItemValues(post._id, {	×
100	title: post.title,
101	author: post.author,
102	authorId: post.userId,
103	karma: post.baseScore,
104	body: postText,
105	postedAt: post.postedAt,
106	tags: tagNames,
107	coreTags: coreTagNames,
108	curated: !!post.curatedDate,
109	frontpage: !!post.frontpageDate,
110	draft: !!post.draft,
111	lastCommentedAt: post.lastCommentedAt,
112	}, { cascadeCreate: true });
113	},
114
115	createReadStatusRequest(readStatus: DbReadStatus) {
116	if (!readStatus.postId) {	×
117	// eslint-disable-next-line no-console
118	console.error(`Missing postId for read status ${readStatus._id} when trying to add detail view to recombee`);	×
119	return;	×
120	}
121
122	return new requests.AddDetailView(readStatus.userId, readStatus.postId, {	×
123	timestamp: readStatus.lastUpdated.toISOString(),
124	cascadeCreate: false
125	});
126	},
127
128	createVoteRequest(vote: DbVote) {
129	const rating = voteTypeRatingsMap[vote.voteType];	×
130	if (typeof rating !== 'number') {	×
131	// eslint-disable-next-line no-console
132	console.log(`Attempted to create a recombee rating request for a non-karma vote with id ${vote._id}`);	×
133	return;	×
134	}
135
136	return new requests.AddRating(vote.userId, vote.documentId, rating, {	×
137	timestamp: vote.votedAt.toISOString(),
138	cascadeCreate: false
139	});
140	},
141
142	createUpsertUserDetailsRequest(user: DbUser) {
143	const { displayName, karma, createdAt } = user;	×
144	return new requests.SetUserValues(user._id, { displayName, karma, createdAt }, { cascadeCreate: true });	×
145	},
146
147	getBatchRequest(requestBatch: requests.Request[]) {
148	return new requests.Batch(requestBatch);	×
149	},
150
151	async getOnsitePostInfo(lwAlgoSettings: HybridRecombeeConfiguration \| RecombeeConfiguration, context: ResolverContext): Promise<OnsitePostRecommendationsInfo> {
152	if (lwAlgoSettings.loadMore) {	×
153	return {	×
154	curatedPostIds: [],
155	stickiedPostIds: [],
156	excludedPostFilter: undefined,
157	};
158	}
159
160	const postPromises = [curatedPostTerms, stickiedPostTerms]	×
161	.map(terms => viewTermsToQuery("Posts", terms, undefined, context))	×
162	.map(postsQuery => context.Posts.find(postsQuery.selector, postsQuery.options, { _id: 1 }).fetch());	×
163
164	const [curatedPosts, stickiedPosts] = await Promise.all(postPromises);	×
165
166	const curatedPostIds = curatedPosts.map(post => post._id);	×
167	const stickiedPostIds = stickiedPosts.map(post => post._id);	×
168	const excludedPostIds = [...curatedPostIds, ...stickiedPostIds];	×
169	const excludedPostFilter = `'itemId' not in {${excludedPostIds.map(id => `"${id}"`).join(', ')}}`;	×
170
171	return {	×
172	curatedPostIds,
173	stickiedPostIds,
174	excludedPostFilter,
175	};
176	},
177
178	convertHybridToRecombeeArgs(hybridArgs: HybridRecombeeConfiguration, hybridArm: keyof typeof HYBRID_SCENARIO_MAP, filter?: string) {
179	const { loadMore, userId, ...rest } = hybridArgs;	×
180
181	const scenario = HYBRID_SCENARIO_MAP[hybridArm];	×
182	const isConfigurable = hybridArm === 'configurable';	×
183	const clientConfig: Partial<Omit<HybridRecombeeConfiguration,"loadMore"\|"userId">> = isConfigurable ? rest : {rotationRate: 0.1, rotationTime: 144};	×
184	const prevRecommIdIndex = isConfigurable ? 0 : 1;	×
185	const loadMoreConfig = loadMore	×
186	? { loadMore: { prevRecommId: loadMore.prevRecommIds[prevRecommIdIndex] } }	×
187	: {};
188
189	return {	×
190	userId,
191	...clientConfig,
192	filter,
193	scenario,
194	...loadMoreConfig
195	};
196	},
197
198	interleaveHybridRecommendedPosts(recommendedPosts: RecombeeRecommendedPost[]) {
199	const recommendationGroupedPosts = groupBy(recommendedPosts, (result) => result.recommId);	×
200	let weights = Object.entries(recommendationGroupedPosts).map(([recommId, posts]) => [recommId, posts.length / recommendedPosts.length] as const);	×
201
202	const interleavedPosts: RecombeeRecommendedPost[] = [];	×
203
204	while (interleavedPosts.length < recommendedPosts.length) {	×
205	// Calculate current total weight (since it changes when we remove a recommId group for running out of posts)
206	const totalWeight = weights.reduce((sum, [_, weight]) => sum + weight, 0);	×
207
208	// Weighted random selection of next recommId to pick a post from
209	let randomWeight = Math.random() * totalWeight;	×
210	let selectedRecommId: string \| undefined;
211	for (const [recommId, recommIdWeight] of weights) {	×
212	randomWeight -= recommIdWeight;	×
213	if (randomWeight <= 0) {	×
214	selectedRecommId = recommId;	×
215	break;	×
216	}
217	}
218
219	// Safety check, though selectedGroup should always be defined here
220	if (!selectedRecommId) continue;	×
221
222	// Add next post from the selected group to the interleaved array
223	const postsWithRecommId = recommendationGroupedPosts[selectedRecommId];	×
224	const nextPost = postsWithRecommId.shift();	×
225	if (!nextPost) {	×
226	// We shouldn't ever get here, but just in case
227	continue;	×
228	} else {
229	interleavedPosts.push(nextPost);	×
230
231	// Update the group's state: remove it if it's out of posts
232	if (postsWithRecommId.length === 0) {	×
233	weights = weights.filter(([recommId]) => recommId !== selectedRecommId);	×
234	}
235	}
236	}
237
238	return interleavedPosts;	×
239	}
240	};
241
242	const curatedPostTerms: PostsViewTerms = {	18✔
243	view: 'curated',
244	limit: 3,
245	};
246
247	const recombeeApi = {	18✔
248	async getRecommendationsForUser(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs, context: ResolverContext) {
249	const client = getRecombeeClientOrThrow();	×
250
251	const {
252	curatedPostIds,
253	stickiedPostIds,
254	excludedPostFilter
255	} = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);	×
256
257	const curatedPostReadStatuses = await (	×
258	lwAlgoSettings.loadMore
259	? Promise.resolve([])	×
260	: context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
261	);
262
263	const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));	×
264	const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length;	×
265
266	const modifiedCount = count - curatedAndStickiedPostCount;	×
267	const recommendationsRequestBody = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, modifiedCount, { ...lwAlgoSettings, filter: excludedPostFilter });	×
268
269	// We need the type cast here because recombee's type definitions can't handle inferring response types for union request types, even if they have the same response type
270	const recombeeResponse = await client.send(recommendationsRequestBody) as RecommendationResponse;	×
271	const { recomms, recommId } = recombeeResponse;	×
272
273	const recommendationIdPairs = recomms.map(rec => [rec.id, recommId] as const);	×
274	const recommendedPostIds = recomms.map(({ id }) => id);	×
275	const postIds = [...includedCuratedPostIds, ...stickiedPostIds, ...recommendedPostIds];	×
276
277	const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));	×
278	const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, posts, context)	×
279
280	const mappedPosts = filteredPosts.map(post => {	×
281	// _id isn't going to be filtered out by `accessFilterMultiple`
282	const postId = post._id!;	×
283	const recommId = recommendationIdPairs.find(([id]) => id === postId)?.[1];	×
284	if (recommId) {	×
285	return { post, recommId };	×
286	} else {
287	return {	×
288	post,
289	curated: curatedPostIds.includes(postId),
290	stickied: stickiedPostIds.includes(postId)
291	};
292	}
293	});
294
295	return mappedPosts;	×
296	},
297
298
299	async getHybridRecommendationsForUser(userId: string, count: number, lwAlgoSettings: HybridRecombeeConfiguration, context: ResolverContext) {
300	const client = getRecombeeClientOrThrow();	×
301
302	const {
303	curatedPostIds,
304	stickiedPostIds,
305	excludedPostFilter
306	} = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);	×
307
NEW 308	const manuallyStickiedPostIds = recommendationsTabManuallyStickiedPostIdsSetting.get()	×
309
UNCOV 310	const curatedPostReadStatuses = await (	×
311	lwAlgoSettings.loadMore
312	? Promise.resolve([])	×
313	: context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
314	);
315
316	const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));	×
NEW 317	const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length + manuallyStickiedPostIds.length;	×
318
319	const modifiedCount = count - curatedAndStickiedPostCount;	×
320	const split = 0.5;	×
321	const firstCount = Math.floor(modifiedCount * split);	×
322	const secondCount = modifiedCount - firstCount;	×
323
324	const firstRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'configurable', excludedPostFilter);	×
325	const secondRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'fixed', excludedPostFilter);	×
326
327	const firstRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, firstCount, firstRequestSettings);	×
328	const secondRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, secondCount, secondRequestSettings);	×
329	const batchRequest = recombeeRequestHelpers.getBatchRequest([firstRequest, secondRequest]);	×
330
331	const batchResponse = await client.send(batchRequest);	×
332	// We need the type cast here because recombee's type definitions don't provide response types for batch requests
333	const recombeeResponses = batchResponse.map(({json}) => json as RecommendationResponse);	×
334
335	// We explicitly avoid deduplicating postIds because we want to see how often the same post is recommended by both arms of the hybrid recommender
336	const recommendationIdPairs = recombeeResponses.flatMap(response => response.recomms.map(rec => [rec.id, response.recommId] as const));	×
337	const recommendedPostIds = recommendationIdPairs.map(([id]) => id);	×
NEW 338	const postIds = [...includedCuratedPostIds, ...manuallyStickiedPostIds, ...stickiedPostIds, ...recommendedPostIds];	×
339
340	const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));	×
341	const orderedPosts = filterNonnull(postIds.map(id => posts.find(post => post._id === id)));	×
342	const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, orderedPosts, context);	×
343
344	const mappedPosts = filteredPosts.map(post => {	×
345	// _id isn't going to be filtered out by `accessFilterMultiple`
346	const postId = post._id!;	×
347	const recommId = recommendationIdPairs.find(([id]) => id === postId)?.[1];	×
348	if (recommId) {	×
349	return { post, recommId };	×
350	} else {
NEW 351	const stickied = stickiedPostIds.includes(postId) \|\| manuallyStickiedPostIds.includes(postId);	×
NEW 352	if ( stickied ) {	×
NEW 353	post.sticky = true;	×
354	}
355
UNCOV 356	return {	×
357	post,
358	curated: curatedPostIds.includes(postId),
359	stickied
360	};
361	}
362	});
363
364	const curatedOrStickiedPosts = mappedPosts.filter((result): result is Exclude<RecommendedPost, RecombeeRecommendedPost> => !result.recommId);	×
365	const recommendedPosts = mappedPosts.filter((result): result is RecombeeRecommendedPost => !!result.recommId);	×
366
367	const interleavedRecommendedPosts = recombeeRequestHelpers.interleaveHybridRecommendedPosts(recommendedPosts);	×
368
369	return [...curatedOrStickiedPosts, ...interleavedRecommendedPosts];	×
370	},
371
372
373	async upsertPost(post: DbPost, context: ResolverContext) {
374	const client = getRecombeeClientOrThrow();	×
375	const request = await recombeeRequestHelpers.createUpsertPostRequest(post, context);	×
376
377	await client.send(request);	×
378	},
379
380	async createReadStatus(readStatus: DbReadStatus) {
381	const client = getRecombeeClientOrThrow();	×
382	const request = recombeeRequestHelpers.createReadStatusRequest(readStatus);	×
383	if (!request) {	×
384	return;	×
385	}
386
387	await client.send(request);	×
388	},
389
390	async createVote(vote: DbVote) {
391	const client = getRecombeeClientOrThrow();	×
392	const request = recombeeRequestHelpers.createVoteRequest(vote);	×
393	if (!request) {	×
394	return;	×
395	}
396
397	await client.send(request);	×
398	},
399
400	async createUser(user: DbUser) {
401	const client = getRecombeeClientOrThrow();	×
402	const request = recombeeRequestHelpers.createUpsertUserDetailsRequest(user);	×
403	await client.send(request);	×
404	}
405	};
406
407	export { recombeeRequestHelpers, recombeeApi };

ForumMagnum / ForumMagnum / 8823766018

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