8804553182

Committed 23 Apr 2024 05:18PM UTC coverage: 32.039% (-0.005%) from 32.044%

Build # 8804553182

Build Type

Pull #9156

github

Committed by

Will-Howard

Commit Message

cleanup

Pull Request Pull Request #9156: Fix all time view of author analytics for old users

Run Details

4689 of 38077 branches covered (12.31%)

Branch coverage included in aggregate %.

0 of 9 new or added lines in 1 file covered. (0.0%)

9 existing lines in 2 files now uncovered.

27197 of 61446 relevant lines covered (44.26%)

181.97 hits per line

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

8.66

/packages/lesswrong/server/resolvers/analyticsResolvers.ts

import { PostAnalyticsResult } from "../../components/hooks/usePostAnalytics";
import { isEAForum } from "../../lib/instanceSettings";
import { getAnalyticsConnection, getAnalyticsConnectionOrThrow } from "../analytics/postgresConnection";
import { addGraphQLQuery, addGraphQLResolvers, addGraphQLSchema } from "../vulcan-lib";
import  camelCase  from "lodash/camelCase";
import { canUserEditPostMetadata } from "../../lib/collections/posts/helpers";
import { AnalyticsSeriesValue, MultiPostAnalyticsResult, PostAnalytics2Result } from "../../components/hooks/useAnalytics";
import Posts from "../../lib/collections/posts/collection";
import { userIsAdminOrMod } from "../../lib/vulcan-users";
import moment from "moment";
import groupBy from "lodash/groupBy";
import { generateDateSeries } from "../../lib/helpers";

/**
 * Based on an analytics query, returns a function that runs that query
 */
function makePgAnalyticsQueryScalar({query, resultColumns}: {query: string, resultColumns: string[]}) {
  return async (post: DbPost) => {
    const postgres = getAnalyticsConnection();
    if (!postgres) throw new Error("Unable to connect to analytics database - no database configured");

    const queryVars = [post._id];

    const pgResult = await postgres.query(query, queryVars);

    if (!pgResult.length) {
      throw new Error(`No data found for post ${post.title}`);
    }
    if (pgResult.length > 1) {
      throw new Error(`Multiple rows found for post ${post.title}`);
    }

    const result = Object.fromEntries(resultColumns.map(resultColumn => [camelCase(resultColumn), pgResult[0][resultColumn]]))
    return result
  };
}

function makePgAnalyticsQuerySeries({query, resultColumnRenaming, resultKey}: {query: string, resultColumnRenaming: {[column: string]: string}, resultKey: keyof PostAnalyticsResult}) {
  return async (post: DbPost) => {
    const postgres = getAnalyticsConnection();
    if (!postgres) throw new Error("Unable to connect to analytics database - no database configured");

    const queryVars = [post._id];

    const pgResult = await postgres.query(query, queryVars);
    if (!pgResult.length) {
      // eslint-disable-next-line no-console
      console.warn(`No data found for post ${post.title}`);
      // Should be prepared to return an empty array here
    }

    const result = {[resultKey]: pgResult.map((row: any) => Object.fromEntries(
      Object.entries(row).map(
        ([column, values]) => [resultColumnRenaming[column], values]
      )
    ))}
    return result
  }
}

type QueryFunc = (post: DbPost) => Promise<Partial<PostAnalyticsResult>>;

const queries: QueryFunc[] = [
  makePgAnalyticsQueryScalar({
    query: `
      SELECT COUNT(*) AS all_views
      FROM page_view
      WHERE post_id = $1
    `,
    resultColumns: ["all_views"]
  }),
  makePgAnalyticsQueryScalar({
    query: `
      SELECT COUNT(DISTINCT client_id) AS unique_client_views
      FROM page_view
      WHERE post_id = $1
        AND client_id IS NOT NULL
    `,
    resultColumns: ["unique_client_views"]
  }),
  // TODO: implement median function and change avg call to use it
  makePgAnalyticsQueryScalar({
    query: `
      SELECT
        COUNT(*) AS unique_client_views_10_sec,
        PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY total_reading_time) AS median_reading_time,
        COUNT(*) FILTER (WHERE total_reading_time > 5*60) AS unique_client_views_5_min
      FROM (
        SELECT
          client_id,
          sum(increment) AS total_reading_time
        FROM event_timer_event
        WHERE post_id = $1
          AND client_id IS NOT NULL
        GROUP BY client_id
      ) a
    `,
    resultColumns: [
      "unique_client_views_10_sec",
      "median_reading_time",
      "unique_client_views_5_min"
    ]
  }),
  makePgAnalyticsQuerySeries({
    // a masterpiece
    query: `
      WITH unique_client_views AS (
        SELECT
          COUNT(DISTINCT client_id) AS unique_client_views,
          timestamp::DATE AS date
        FROM page_view
        WHERE post_id = $1
        GROUP BY timestamp::DATE
      ),
      min_date AS (
        SELECT MIN(date) AS min_date
        FROM unique_client_views
        WHERE unique_client_views.unique_client_views > 0
      ),
      eligible_dates AS (
        SELECT (generate_series(min_date, NOW()::DATE, '1 day'::INTERVAL))::DATE AS date FROM min_date
      )
      SELECT
        coalesce(unique_client_views.unique_client_views, 0) AS unique_client_views,
        eligible_dates.date
      FROM unique_client_views
      RIGHT JOIN eligible_dates ON eligible_dates.date = unique_client_views.date
      ORDER BY date;
    `,
     resultColumnRenaming: {date: 'date', unique_client_views: 'uniqueClientViews'},
     resultKey: 'uniqueClientViewsSeries'
  })
];

addGraphQLResolvers({
  Query: {
    async PostAnalytics(
      root: void,
      { postId }: { postId: string },
      context: ResolverContext
    ): Promise<PostAnalyticsResult> {
      const { currentUser } = context;
      if (!currentUser) throw new Error(`No user`);
      const post = await context.loaders.Posts.load(postId);
      // check that the current user has permission to view post metrics
      // LW doesn't want to show this to authors, but we'll let admins see it
      if (!isEAForum && !currentUser.isAdmin) {
        throw new Error("Permission denied");
      }
      // Maybe check for karma level here?
      if (
        !canUserEditPostMetadata(currentUser, post) &&
        !currentUser.groups?.includes("sunshineRegiment")
      ) {
        throw new Error("Permission denied");
      }

      // I really wanted to do this as a map, but I want to do this in serial,
      // and couldn't get it to work the way I wanted
      let postAnalytics: Partial<PostAnalyticsResult> = {};
      for (const queryFunc of queries) {
        const queryResult = await queryFunc(post);
        postAnalytics = {...postAnalytics, ...queryResult}
      }
      
      // There's no good way to tell TS that because we've iterated over all the
      // keys, the partial is no longer partial
      return postAnalytics as PostAnalyticsResult;
    },
    async MultiPostAnalytics(
      root: void,
      {
        userId,
        postIds: postIdsInput,
        sortBy,
        desc,
        limit,
      }: { userId: string; postIds: string[] | null; sortBy: string | null; desc: boolean | null; limit: number | null },
      context: ResolverContext
    ): Promise<MultiPostAnalyticsResult> {
      // These are null (not undefined) if not provided, so we have to explicitly set them to the default
      sortBy = sortBy ?? "postedAt";
      desc = desc ?? true;
      limit = limit ?? 10;

      // Directly sortable fields can be sorted and filtered on before querying the analytics database,
      // so we can avoid querying for most of the post ids. Indirectly sortable fields are calculated
      // rely on the results from the analytics database, so we have to query for all the post ids and then
      // sort and filter afterwards.
      const DIRECTLY_SORTABLE_FIELDS = ["postedAt", "baseScore", "commentCount"];
      const INDIRECTLY_SORTABLE_FIELDS = ["views", "reads"];

      const { currentUser } = context;

      const directlySortable = DIRECTLY_SORTABLE_FIELDS.includes(sortBy);

      const postSelector = {
        ...(userId && {$or: [{ userId: userId }, { "coauthorStatuses.userId": userId }]}),
        ...(postIdsInput && { _id: { $in: postIdsInput } }),
        rejected: { $ne: true },
        draft: false,
        isEvent: false,
      };
      const postCountPromise = Posts.find(postSelector).count();
      const rawPosts = await Posts.find(postSelector, {
        ...(directlySortable && { sort: { [sortBy]: desc ? -1 : 1 } }),
        ...(directlySortable && { limit }),
      }).fetch();

      const filteredPosts = rawPosts.filter((post) =>
        userIsAdminOrMod(currentUser) || canUserEditPostMetadata(currentUser, post)
      );

      const postsById = Object.fromEntries(filteredPosts.map((post) => [post._id, post]));
      const postIds = filteredPosts.map((post) => post._id);

      if (!postIds.length) {
        return {
          posts: [],
          totalCount: 0,
        };
      }

      const [viewsResults, readsResults] = await Promise.all([
        context.repos.postViews.viewsByPost({postIds}),
        context.repos.postViewTimes.readsByPost({postIds}),
      ]);

      // Flatten the results
      const viewsById = Object.fromEntries(viewsResults.map((row) => [row.postId, row.totalViews]));
      const uniqueViewsById = Object.fromEntries(viewsResults.map((row) => [row.postId, row.totalUniqueViews]));
      const readsById = Object.fromEntries(readsResults.map((row) => [row.postId, row.totalReads]));
      const meanReadingTimeById = Object.fromEntries(readsResults.map((row) => [row.postId, row.meanReadTime]));

      let sortedAndLimitedPostIds: string[] = postIds;
      if (INDIRECTLY_SORTABLE_FIELDS.includes(sortBy)) {
        const sortMap = sortBy === "views" ? viewsById : readsById;
        sortedAndLimitedPostIds = postIds.sort((a, b) => {
          const aVal = sortMap[a] ?? 0;
          const bVal = sortMap[b] ?? 0;
          return desc ? bVal - aVal : aVal - bVal;
        });
      }
      sortedAndLimitedPostIds = sortedAndLimitedPostIds.slice(0, limit);

      const posts: PostAnalytics2Result[] = sortedAndLimitedPostIds.map((_id, idx) => {
        return {
          _id,
          title: postsById[_id].title,
          slug: postsById[_id].slug,
          postedAt: postsById[_id].postedAt,
          views: viewsById[_id] ?? 0,
          uniqueViews: uniqueViewsById[_id] ?? 0,
          reads: readsById[_id] ?? 0,
          meanReadingTime: meanReadingTimeById[_id] ?? 0,
          karma: postsById[_id].baseScore,
          comments: postsById[_id].commentCount ?? 0,
        };
      });

      return {
        posts: posts,
        totalCount: await postCountPromise,
      };
    },
    async AnalyticsSeries(
      root: void,
      {
        userId,
        postIds,
        startDate,
        endDate,
      }: {
        userId: string | null;
        postIds: string[] | null;
        startDate: Date | null;
        endDate: Date | null;
      },
      context: ResolverContext
    ): Promise<AnalyticsSeriesValue[]> {
      const { currentUser } = context;

      if (!userId && (!postIds || !postIds.length)) {
        throw new Error("Must provide either userId or postIds");
      }
      if (!endDate) {
        throw new Error("Must provide endDate");
      }
    
      // Round start date down to nearest day in UTC
      const adjustedStartDate = startDate ? moment(new Date(startDate)).utc().startOf("day") : undefined;
      const adjustedEndDate = moment(new Date(endDate)).utc().add(1, "days").startOf("day");

      const postSelector = {
        ...(userId && {$or: [{ userId: userId }, { "coauthorStatuses.userId": userId }]}),
        ...(postIds && { _id: { $in: postIds } }),
        rejected: { $ne: true },
        draft: false,
        isEvent: false,
      }
      const rawPosts = await Posts.find(postSelector).fetch();
      const filteredPosts = rawPosts.filter(
        (post) => userIsAdminOrMod(currentUser) || canUserEditPostMetadata(currentUser, post)
      );
      const queryPostIds = filteredPosts.map((post) => post._id);

      if (!queryPostIds.length) {
        return [];
      }

      const [viewRes, readRes, karmaRes, commentRes] = await Promise.all([
        context.repos.postViews.viewsByDate({
          postIds: queryPostIds,
          startDate: adjustedStartDate?.toDate(),
          endDate: adjustedEndDate.toDate(),
        }),
        context.repos.postViewTimes.readsByDate({
          postIds: queryPostIds,
          startDate: adjustedStartDate?.toDate(),
          endDate: adjustedEndDate.toDate(),
        }),
        context.repos.votes.getDocumentKarmaChangePerDay({
          documentIds: queryPostIds,
          startDate: adjustedStartDate?.toDate(),
          endDate: adjustedEndDate.toDate(),
        }),
        context.repos.comments.getCommentsPerDay({
          postIds: queryPostIds,
          startDate: adjustedStartDate?.toDate(),
          endDate: adjustedEndDate.toDate(),
        }),
      ]);

      const viewsByDate = groupBy(viewRes, "date");
      const readsByDate = groupBy(readRes, "date");
      const commentsByDate = groupBy(commentRes, "window_start_key");
      const karmaByDate = groupBy(karmaRes, "window_start_key");

      const lowestStartDate =
        adjustedStartDate ??
        moment.min(
          moment.min(Object.keys(viewsByDate).map((date) => moment(date))),
          moment.min(Object.keys(readsByDate).map((date) => moment(date))),
          moment.min(Object.keys(commentsByDate).map((date) => moment(date))),
          moment.min(Object.keys(karmaByDate).map((date) => moment(date)))
        );

      const result = generateDateSeries(lowestStartDate, adjustedEndDate).map((date) => ({
        date: new Date(date),
        views: viewsByDate[date]?.reduce((acc, curr) => acc + (curr.totalViews ?? 0), 0) ?? 0,
        reads: readsByDate[date]?.reduce((acc, curr) => acc + (curr.totalReads ?? 0), 0) ?? 0,
        karma: karmaByDate[date]?.reduce((acc, curr) => acc + parseInt(curr.karma_change ?? 0), 0) ?? 0,
        comments: commentsByDate[date]?.reduce((acc, curr) => acc + parseInt(curr.comment_count ?? 0), 0) ?? 0
      }));
      // Remove leading values where all fields are 0
      const truncatedResult = result.slice(result.findIndex((value) => (
        value.views !== 0 || value.reads !== 0 || value.karma !== 0 || value.comments !== 0
      )));
      return truncatedResult;
    },
  },
});

addGraphQLSchema(`
  type UniqueClientViewsSeries {
    uniqueClientViews: Int
    date: Date
  }

  type PostAnalyticsResult {
    allViews: Int
    uniqueClientViews: Int
    uniqueClientViews10Sec: Int
    medianReadingTime: Int
    uniqueClientViews5Min: Int
    uniqueClientViewsSeries: [UniqueClientViewsSeries]
  }
`);

addGraphQLSchema(`
  type PostAnalytics2Result {
    _id: String
    title: String
    slug: String
    postedAt: Date
    views: Int
    uniqueViews: Int
    reads: Int
    meanReadingTime: Float
    karma: Int
    comments: Int
  }

  type MultiPostAnalyticsResult {
    posts: [PostAnalytics2Result]
    totalCount: Int!
  }
`);

addGraphQLSchema(`
  type AnalyticsSeriesValue {
    date: Date
    views: Int
    reads: Int
    karma: Int
    comments: Int
  }
`);

addGraphQLQuery("PostAnalytics(postId: String!): PostAnalyticsResult!");
addGraphQLQuery("MultiPostAnalytics(userId: String, postIds: [String], sortBy: String, desc: Boolean, limit: Int): MultiPostAnalyticsResult!");
addGraphQLQuery("AnalyticsSeries(userId: String, postIds: [String], startDate: Date, endDate: Date): [AnalyticsSeriesValue]");

1	import { PostAnalyticsResult } from "../../components/hooks/usePostAnalytics";
2	import { isEAForum } from "../../lib/instanceSettings";	18✔
3	import { getAnalyticsConnection, getAnalyticsConnectionOrThrow } from "../analytics/postgresConnection";	18✔
4	import { addGraphQLQuery, addGraphQLResolvers, addGraphQLSchema } from "../vulcan-lib";	18✔
5	import camelCase from "lodash/camelCase";	18✔
6	import { canUserEditPostMetadata } from "../../lib/collections/posts/helpers";	18✔
7	import { AnalyticsSeriesValue, MultiPostAnalyticsResult, PostAnalytics2Result } from "../../components/hooks/useAnalytics";
8	import Posts from "../../lib/collections/posts/collection";	18✔
9	import { userIsAdminOrMod } from "../../lib/vulcan-users";	18✔
10	import moment from "moment";	18✔
11	import groupBy from "lodash/groupBy";	18✔
12	import { generateDateSeries } from "../../lib/helpers";	18✔
13
14	/**
15	* Based on an analytics query, returns a function that runs that query
16	*/
17	function makePgAnalyticsQueryScalar({query, resultColumns}: {query: string, resultColumns: string[]}) {
18	return async (post: DbPost) => {	54✔
19	const postgres = getAnalyticsConnection();	×
20	if (!postgres) throw new Error("Unable to connect to analytics database - no database configured");	×
21
22	const queryVars = [post._id];	×
23
24	const pgResult = await postgres.query(query, queryVars);	×
25
26	if (!pgResult.length) {	×
27	throw new Error(`No data found for post ${post.title}`);	×
28	}
29	if (pgResult.length > 1) {	×
30	throw new Error(`Multiple rows found for post ${post.title}`);	×
31	}
32
33	const result = Object.fromEntries(resultColumns.map(resultColumn => [camelCase(resultColumn), pgResult[0][resultColumn]]))	×
34	return result	×
35	};
36	}
37
38	function makePgAnalyticsQuerySeries({query, resultColumnRenaming, resultKey}: {query: string, resultColumnRenaming: {[column: string]: string}, resultKey: keyof PostAnalyticsResult}) {
39	return async (post: DbPost) => {	18✔
40	const postgres = getAnalyticsConnection();	×
41	if (!postgres) throw new Error("Unable to connect to analytics database - no database configured");	×
42
43	const queryVars = [post._id];	×
44
45	const pgResult = await postgres.query(query, queryVars);	×
46	if (!pgResult.length) {	×
47	// eslint-disable-next-line no-console
48	console.warn(`No data found for post ${post.title}`);	×
49	// Should be prepared to return an empty array here
50	}
51
52	const result = {[resultKey]: pgResult.map((row: any) => Object.fromEntries(	×
53	Object.entries(row).map(
54	([column, values]) => [resultColumnRenaming[column], values]	×
55	)
56	))}
57	return result	×
58	}
59	}
60
61	type QueryFunc = (post: DbPost) => Promise<Partial<PostAnalyticsResult>>;
62
63	const queries: QueryFunc[] = [	18✔
64	makePgAnalyticsQueryScalar({
65	query: `
66	SELECT COUNT(*) AS all_views
67	FROM page_view
68	WHERE post_id = $1
69	`,
70	resultColumns: ["all_views"]
71	}),
72	makePgAnalyticsQueryScalar({
73	query: `
74	SELECT COUNT(DISTINCT client_id) AS unique_client_views
75	FROM page_view
76	WHERE post_id = $1
77	AND client_id IS NOT NULL
78	`,
79	resultColumns: ["unique_client_views"]
80	}),
81	// TODO: implement median function and change avg call to use it
82	makePgAnalyticsQueryScalar({
83	query: `
84	SELECT
85	COUNT(*) AS unique_client_views_10_sec,
86	PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY total_reading_time) AS median_reading_time,
87	COUNT() FILTER (WHERE total_reading_time > 560) AS unique_client_views_5_min
88	FROM (
89	SELECT
90	client_id,
91	sum(increment) AS total_reading_time
92	FROM event_timer_event
93	WHERE post_id = $1
94	AND client_id IS NOT NULL
95	GROUP BY client_id
96	) a
97	`,
98	resultColumns: [
99	"unique_client_views_10_sec",
100	"median_reading_time",
101	"unique_client_views_5_min"
102	]
103	}),
104	makePgAnalyticsQuerySeries({
105	// a masterpiece
106	query: `
107	WITH unique_client_views AS (
108	SELECT
109	COUNT(DISTINCT client_id) AS unique_client_views,
110	timestamp::DATE AS date
111	FROM page_view
112	WHERE post_id = $1
113	GROUP BY timestamp::DATE
114	),
115	min_date AS (
116	SELECT MIN(date) AS min_date
117	FROM unique_client_views
118	WHERE unique_client_views.unique_client_views > 0
119	),
120	eligible_dates AS (
121	SELECT (generate_series(min_date, NOW()::DATE, '1 day'::INTERVAL))::DATE AS date FROM min_date
122	)
123	SELECT
124	coalesce(unique_client_views.unique_client_views, 0) AS unique_client_views,
125	eligible_dates.date
126	FROM unique_client_views
127	RIGHT JOIN eligible_dates ON eligible_dates.date = unique_client_views.date
128	ORDER BY date;
129	`,
130	resultColumnRenaming: {date: 'date', unique_client_views: 'uniqueClientViews'},
131	resultKey: 'uniqueClientViewsSeries'
132	})
133	];	18✔
134
135	addGraphQLResolvers({
136	Query: {
137	async PostAnalytics(
138	root: void,
139	{ postId }: { postId: string },
140	context: ResolverContext
141	): Promise<PostAnalyticsResult> {
142	const { currentUser } = context;	×
143	if (!currentUser) throw new Error(`No user`);	×
144	const post = await context.loaders.Posts.load(postId);	×
145	// check that the current user has permission to view post metrics
146	// LW doesn't want to show this to authors, but we'll let admins see it
147	if (!isEAForum && !currentUser.isAdmin) {	×
148	throw new Error("Permission denied");	×
149	}
150	// Maybe check for karma level here?
151	if (	×
152	!canUserEditPostMetadata(currentUser, post) &&	×
153	!currentUser.groups?.includes("sunshineRegiment")	×
154	) {
155	throw new Error("Permission denied");	×
156	}
157
158	// I really wanted to do this as a map, but I want to do this in serial,
159	// and couldn't get it to work the way I wanted
160	let postAnalytics: Partial<PostAnalyticsResult> = {};	×
161	for (const queryFunc of queries) {	×
162	const queryResult = await queryFunc(post);	×
163	postAnalytics = {...postAnalytics, ...queryResult}	×
164	}
165
166	// There's no good way to tell TS that because we've iterated over all the
167	// keys, the partial is no longer partial
168	return postAnalytics as PostAnalyticsResult;	×
169	},
170	async MultiPostAnalytics(
171	root: void,
172	{
173	userId,
174	postIds: postIdsInput,
175	sortBy,
176	desc,
177	limit,
178	}: { userId: string; postIds: string[] \| null; sortBy: string \| null; desc: boolean \| null; limit: number \| null },
179	context: ResolverContext
180	): Promise<MultiPostAnalyticsResult> {
181	// These are null (not undefined) if not provided, so we have to explicitly set them to the default
182	sortBy = sortBy ?? "postedAt";	×
183	desc = desc ?? true;	×
184	limit = limit ?? 10;	×
185
186	// Directly sortable fields can be sorted and filtered on before querying the analytics database,
187	// so we can avoid querying for most of the post ids. Indirectly sortable fields are calculated
188	// rely on the results from the analytics database, so we have to query for all the post ids and then
189	// sort and filter afterwards.
190	const DIRECTLY_SORTABLE_FIELDS = ["postedAt", "baseScore", "commentCount"];	×
191	const INDIRECTLY_SORTABLE_FIELDS = ["views", "reads"];	×
192
193	const { currentUser } = context;	×
194
UNCOV 195	const directlySortable = DIRECTLY_SORTABLE_FIELDS.includes(sortBy);	×
196
197	const postSelector = {	×
198	...(userId && {$or: [{ userId: userId }, { "coauthorStatuses.userId": userId }]}),	×
199	...(postIdsInput && { _id: { $in: postIdsInput } }),	×
200	rejected: { $ne: true },
201	draft: false,
202	isEvent: false,
203	};
204	const postCountPromise = Posts.find(postSelector).count();	×
205	const rawPosts = await Posts.find(postSelector, {	×
206	...(directlySortable && { sort: { [sortBy]: desc ? -1 : 1 } }),	×
207	...(directlySortable && { limit }),	×
208	}).fetch();
209
210	const filteredPosts = rawPosts.filter((post) =>	×
211	userIsAdminOrMod(currentUser) \|\| canUserEditPostMetadata(currentUser, post)
212	);
213
214	const postsById = Object.fromEntries(filteredPosts.map((post) => [post._id, post]));	×
215	const postIds = filteredPosts.map((post) => post._id);	×
216
217	if (!postIds.length) {	×
218	return {	×
219	posts: [],
220	totalCount: 0,
221	};
222	}
223
224	const [viewsResults, readsResults] = await Promise.all([	×
225	context.repos.postViews.viewsByPost({postIds}),
226	context.repos.postViewTimes.readsByPost({postIds}),
227	]);
228
229	// Flatten the results
230	const viewsById = Object.fromEntries(viewsResults.map((row) => [row.postId, row.totalViews]));	×
231	const uniqueViewsById = Object.fromEntries(viewsResults.map((row) => [row.postId, row.totalUniqueViews]));	×
232	const readsById = Object.fromEntries(readsResults.map((row) => [row.postId, row.totalReads]));	×
233	const meanReadingTimeById = Object.fromEntries(readsResults.map((row) => [row.postId, row.meanReadTime]));	×
234
235	let sortedAndLimitedPostIds: string[] = postIds;	×
236	if (INDIRECTLY_SORTABLE_FIELDS.includes(sortBy)) {	×
237	const sortMap = sortBy === "views" ? viewsById : readsById;	×
238	sortedAndLimitedPostIds = postIds.sort((a, b) => {	×
239	const aVal = sortMap[a] ?? 0;	×
240	const bVal = sortMap[b] ?? 0;	×
241	return desc ? bVal - aVal : aVal - bVal;	×
242	});
243	}
244	sortedAndLimitedPostIds = sortedAndLimitedPostIds.slice(0, limit);	×
245
246	const posts: PostAnalytics2Result[] = sortedAndLimitedPostIds.map((_id, idx) => {	×
247	return {	×
248	_id,
249	title: postsById[_id].title,
250	slug: postsById[_id].slug,
251	postedAt: postsById[_id].postedAt,
252	views: viewsById[_id] ?? 0,	×
253	uniqueViews: uniqueViewsById[_id] ?? 0,	×
254	reads: readsById[_id] ?? 0,	×
255	meanReadingTime: meanReadingTimeById[_id] ?? 0,	×
256	karma: postsById[_id].baseScore,
257	comments: postsById[_id].commentCount ?? 0,	×
258	};
259	});
260
261	return {	×
262	posts: posts,
263	totalCount: await postCountPromise,
264	};
265	},
266	async AnalyticsSeries(
267	root: void,
268	{
269	userId,
270	postIds,
271	startDate,
272	endDate,
273	}: {
274	userId: string \| null;
275	postIds: string[] \| null;
276	startDate: Date \| null;
277	endDate: Date \| null;
278	},
279	context: ResolverContext
280	): Promise<AnalyticsSeriesValue[]> {
281	const { currentUser } = context;	×
282
UNCOV 283	if (!userId && (!postIds \|\| !postIds.length)) {	×
284	throw new Error("Must provide either userId or postIds");	×
285	}
286	if (!endDate) {	×
287	throw new Error("Must provide endDate");	×
288	}
289
290	// Round start date down to nearest day in UTC
291	const adjustedStartDate = startDate ? moment(new Date(startDate)).utc().startOf("day") : undefined;	×
292	const adjustedEndDate = moment(new Date(endDate)).utc().add(1, "days").startOf("day");	×
293
294	const postSelector = {	×
295	...(userId && {$or: [{ userId: userId }, { "coauthorStatuses.userId": userId }]}),	×
296	...(postIds && { _id: { $in: postIds } }),	×
297	rejected: { $ne: true },
298	draft: false,
299	isEvent: false,
300	}
301	const rawPosts = await Posts.find(postSelector).fetch();	×
302	const filteredPosts = rawPosts.filter(	×
303	(post) => userIsAdminOrMod(currentUser) \|\| canUserEditPostMetadata(currentUser, post)	×
304	);
305	const queryPostIds = filteredPosts.map((post) => post._id);	×
306
307	if (!queryPostIds.length) {	×
308	return [];	×
309	}
310
311	const [viewRes, readRes, karmaRes, commentRes] = await Promise.all([	×
312	context.repos.postViews.viewsByDate({
313	postIds: queryPostIds,
314	startDate: adjustedStartDate?.toDate(),	×
315	endDate: adjustedEndDate.toDate(),
316	}),
317	context.repos.postViewTimes.readsByDate({
318	postIds: queryPostIds,
319	startDate: adjustedStartDate?.toDate(),	×
320	endDate: adjustedEndDate.toDate(),
321	}),
322	context.repos.votes.getDocumentKarmaChangePerDay({
323	documentIds: queryPostIds,
324	startDate: adjustedStartDate?.toDate(),	×
325	endDate: adjustedEndDate.toDate(),
326	}),
327	context.repos.comments.getCommentsPerDay({
328	postIds: queryPostIds,
329	startDate: adjustedStartDate?.toDate(),	×
330	endDate: adjustedEndDate.toDate(),
331	}),
332	]);
333
334	const viewsByDate = groupBy(viewRes, "date");	×
335	const readsByDate = groupBy(readRes, "date");	×
336	const commentsByDate = groupBy(commentRes, "window_start_key");	×
337	const karmaByDate = groupBy(karmaRes, "window_start_key");	×
338
339	const lowestStartDate =
340	adjustedStartDate ??	×
341	moment.min(
342	moment.min(Object.keys(viewsByDate).map((date) => moment(date))),	×
343	moment.min(Object.keys(readsByDate).map((date) => moment(date))),	×
344	moment.min(Object.keys(commentsByDate).map((date) => moment(date))),	×
345	moment.min(Object.keys(karmaByDate).map((date) => moment(date)))	×
346	);
347
348	const result = generateDateSeries(lowestStartDate, adjustedEndDate).map((date) => ({	×
349	date: new Date(date),
350	views: viewsByDate[date]?.reduce((acc, curr) => acc + (curr.totalViews ?? 0), 0) ?? 0,	×
351	reads: readsByDate[date]?.reduce((acc, curr) => acc + (curr.totalReads ?? 0), 0) ?? 0,	×
352	karma: karmaByDate[date]?.reduce((acc, curr) => acc + parseInt(curr.karma_change ?? 0), 0) ?? 0,	×
353	comments: commentsByDate[date]?.reduce((acc, curr) => acc + parseInt(curr.comment_count ?? 0), 0) ?? 0	×
354	}));
355	// Remove leading values where all fields are 0
356	const truncatedResult = result.slice(result.findIndex((value) => (	×
357	value.views !== 0 \|\| value.reads !== 0 \|\| value.karma !== 0 \|\| value.comments !== 0	×
358	)));
359	return truncatedResult;	×
360	},
361	},
362	});	18✔
363
364	addGraphQLSchema(`
365	type UniqueClientViewsSeries {
366	uniqueClientViews: Int
367	date: Date
368	}
369
370	type PostAnalyticsResult {
371	allViews: Int
372	uniqueClientViews: Int
373	uniqueClientViews10Sec: Int
374	medianReadingTime: Int
375	uniqueClientViews5Min: Int
376	uniqueClientViewsSeries: [UniqueClientViewsSeries]
377	}
378	`);	18✔
379
380	addGraphQLSchema(`
381	type PostAnalytics2Result {
382	_id: String
383	title: String
384	slug: String
385	postedAt: Date
386	views: Int
387	uniqueViews: Int
388	reads: Int
389	meanReadingTime: Float
390	karma: Int
391	comments: Int
392	}
393
394	type MultiPostAnalyticsResult {
395	posts: [PostAnalytics2Result]
396	totalCount: Int!
397	}
398	`);	18✔
399
400	addGraphQLSchema(`
401	type AnalyticsSeriesValue {
402	date: Date
403	views: Int
404	reads: Int
405	karma: Int
406	comments: Int
407	}
408	`);	18✔
409
410	addGraphQLQuery("PostAnalytics(postId: String!): PostAnalyticsResult!");	18✔
411	addGraphQLQuery("MultiPostAnalytics(userId: String, postIds: [String], sortBy: String, desc: Boolean, limit: Int): MultiPostAnalyticsResult!");	18✔
412	addGraphQLQuery("AnalyticsSeries(userId: String, postIds: [String], startDate: Date, endDate: Date): [AnalyticsSeriesValue]");

ForumMagnum / ForumMagnum / 8804553182

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