9600607782

Committed 20 Jun 2024 03:56PM UTC coverage: 14.831% (-0.3%) from 15.137%

Build # 9600607782

Build Type

Pull #7910

github

Committed by

web-flow

Commit Message

Merge 46223b731 into 2c4ea3afa

Pull Request Pull Request #7910: Implements subscriptions and community alerts page.

Run Details

3698 of 25343 branches covered (14.59%)

Branch coverage included in aggregate %.

1 of 84 new or added lines in 10 files covered. (1.19%)

142 existing lines in 17 files now uncovered.

5142 of 34260 relevant lines covered (15.01%)

4.79 hits per line

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

51.25

/packages/commonwealth/server/util/parseUserMentions.ts

import { EventNames, events, ServerError } from '@hicommonwealth/core';
import { DB, emitEvent } from '@hicommonwealth/model';
import { Comment, Thread } from '@hicommonwealth/schemas';
import { NotificationCategories, ProposalType } from '@hicommonwealth/shared';
import { QueryTypes, Transaction } from 'sequelize';
import z from 'zod';
import { EmitOptions } from '../controllers/server_notifications_methods/emit';

export type UserMention = {
  profileId: string;
  profileName: string;
};

export type UserMentionQuery = {
  address_id: number;
  address: string;
  user_id: number;
  profile_id: number;
  profile_name: string;
}[];

const hash = (mention: UserMention) =>
  `name:${mention.profileName}id:${mention.profileId}`;

// Will return unique mentions of the diff between current and previous mentions
export const findMentionDiff = (
  previousMentions: UserMention[],
  currentMentions: UserMention[],
) => {
  const previousMentionHashes = new Set(previousMentions.map(hash));

  return currentMentions.filter((mention) => {
    const hashedMention = hash(mention);

    // If it exists in previous hash set, it is not a new mention
    if (previousMentionHashes.has(hashedMention)) {
      return false;
    }

    // otherwise add it to the previous hash set so that we don't re-include duplicates
    previousMentionHashes.add(hashedMention);

    return true;
  });
};

export const uniqueMentions = (mentions: UserMention[]) =>
  findMentionDiff([], mentions);

export const parseUserMentions = (text: string): UserMention[] => {
  // Extract links to Commonwealth profiles, so they can be processed by the server as mentions
  if (!text) return [];
  try {
    const parsedText = JSON.parse(text);
    return (parsedText.ops || [])
      .filter((op) => {
        return (
          op.attributes?.link?.length > 0 &&
          typeof op.insert === 'string' &&
          op.insert?.slice(0, 1) === '@'
        );
      })
      .map((op) => {
        const chunks = op.attributes.link.split('/');
        const refIdx = chunks.indexOf('account');
        return {
          profileName: chunks[refIdx - 1],
          profileId: chunks[refIdx + 1],
        };
      });
  } catch (e) {
    // matches profileName and number in [@${profileName}](/profile/id/${number})
    const regex = /\[@([^[]+)]\(\/profile\/id\/(\d+)\)/g;
    const matches = [...text.matchAll(regex)];
    return matches.map(([, profileName, profileId]) => {
      return { profileName, profileId };
    });
  }
};

export const queryMentionedUsers = async (
  mentions: UserMention[],
  models: DB,
): Promise<UserMentionQuery> => {
  if (mentions.length === 0) {
    return [];
  }

  try {
    // Create an array of tuples for the replacements
    const tuples = mentions.map(({ profileId, profileName }) => [
      profileId,
      profileName,
    ]);

    return await models.sequelize.query<{
      address_id: number;
      address: string;
      user_id: number;
      profile_id: number;
      profile_name: string;
    }>(
      `
          SELECT a.id as address_id, a.address, a.user_id, p.id as profile_id, p.profile_name
          FROM "Addresses" as a
                   INNER JOIN "Profiles" as p ON a.profile_id = p.id
          WHERE a.user_id IS NOT NULL
            AND (p.id, p.profile_name) IN (:tuples)
      `,
      {
        type: QueryTypes.SELECT,
        raw: true,
        replacements: { tuples },
      },
    );
  } catch (e) {
    throw new ServerError('Failed to query mentioned users', e);
  }
};

export const createCommentMentionNotifications = (
  mentions: UserMentionQuery,
  comment,
  address,
): EmitOptions[] => {
  return mentions.map(({ user_id }) => {
    return {
      notification: {
        categoryId: NotificationCategories.NewMention,
        data: {
          mentioned_user_id: user_id,
          created_at: new Date(),
          thread_id: +comment.thread_id,
          root_title: comment.root_title,
          root_type: ProposalType.Thread,
          comment_id: +comment.id,
          comment_text: comment.text,
          community_id: comment.community_id,
          author_address: address.address,
          author_community_id: address.community_id,
        },
      },
      excludeAddresses: [address.address],
    };
  }) as EmitOptions[];
};

export const createThreadMentionNotifications = (
  mentions: UserMentionQuery,
  finalThread,
): EmitOptions[] => {
  return mentions.map(({ user_id }) => {
    return {
      notification: {
        categoryId: NotificationCategories.NewMention,
        data: {
          mentioned_user_id: user_id,
          created_at: new Date(),
          thread_id: finalThread.id,
          root_type: ProposalType.Thread,
          root_title: finalThread.title,
          comment_text: finalThread.body,
          community_id: finalThread.community_id,
          author_address: finalThread.Address.address,
          author_community_id: finalThread.Address.community_id,
        },
      },
      excludeAddresses: [finalThread.Address.address],
    };
  }) as EmitOptions[];
};

type EmitMentionsData = {
  authorAddressId: number;
  authorUserId: number;
  authorAddress: string;
  authorProfileId: number;
  mentions: UserMentionQuery;
} & (
  | {
      thread: z.infer<typeof Thread>;
    }
  | {
      comment: z.infer<typeof Comment>;
    }
);

export const emitMentions = async (
  models: DB,
  transaction: Transaction,
  data: EmitMentionsData,
) => {
  if (data.mentions.length) {
    const values: {
      event_name: EventNames.UserMentioned;
      event_payload: z.infer<typeof events.UserMentioned>;
    }[] = data.mentions.map(({ user_id }) => ({
      event_name: EventNames.UserMentioned,
      event_payload: {
        authorAddressId: data.authorAddressId,
        authorUserId: data.authorUserId,
        authorAddress: data.authorAddress,
        authorProfileId: data.authorProfileId,
        mentionedUserId: user_id,
        communityId:
          'comment' in data
            ? data.comment.community_id
            : data.thread.community_id,
        comment: 'comment' in data ? data.comment : undefined,
        thread: 'thread' in data ? data.thread : undefined,
      },
    }));

    await emitEvent(models.Outbox, values, transaction);
  }
};

1	import { EventNames, events, ServerError } from '@hicommonwealth/core';
2	import { DB, emitEvent } from '@hicommonwealth/model';
3	import { Comment, Thread } from '@hicommonwealth/schemas';
4	import { NotificationCategories, ProposalType } from '@hicommonwealth/shared';
5	import { QueryTypes, Transaction } from 'sequelize';
6	import z from 'zod';
7	import { EmitOptions } from '../controllers/server_notifications_methods/emit';
8
9	export type UserMention = {
10	profileId: string;
11	profileName: string;
12	};
13
14	export type UserMentionQuery = {
15	address_id: number;
16	address: string;
17	user_id: number;
18	profile_id: number;
19	profile_name: string;
20	}[];
21
22	const hash = (mention: UserMention) =>	27✔
23	`name:${mention.profileName}id:${mention.profileId}`;	6✔
24
25	// Will return unique mentions of the diff between current and previous mentions
26	export const findMentionDiff = (	27✔
27	previousMentions: UserMention[],
28	currentMentions: UserMention[],
29	) => {
30	const previousMentionHashes = new Set(previousMentions.map(hash));	80✔
31
32	return currentMentions.filter((mention) => {	80✔
33	const hashedMention = hash(mention);	5✔
34
35	// If it exists in previous hash set, it is not a new mention
36	if (previousMentionHashes.has(hashedMention)) {	5✔
37	return false;	3✔
38	}
39
40	// otherwise add it to the previous hash set so that we don't re-include duplicates
41	previousMentionHashes.add(hashedMention);	2✔
42
43	return true;	2✔
44	});
45	};
46
47	export const uniqueMentions = (mentions: UserMention[]) =>	27✔
48	findMentionDiff([], mentions);	72✔
49
50	export const parseUserMentions = (text: string): UserMention[] => {	27✔
51	// Extract links to Commonwealth profiles, so they can be processed by the server as mentions
52	if (!text) return [];	93✔
53	try {	91✔
54	const parsedText = JSON.parse(text);	91✔
UNCOV 55	return (parsedText.ops \|\| [])	×
56	.filter((op) => {
UNCOV 57	return (	×
58	op.attributes?.link?.length > 0 &&	×
59	typeof op.insert === 'string' &&
60	op.insert?.slice(0, 1) === '@'
61	);
62	})
63	.map((op) => {
64	const chunks = op.attributes.link.split('/');	×
65	const refIdx = chunks.indexOf('account');	×
66	return {	×
67	profileName: chunks[refIdx - 1],
68	profileId: chunks[refIdx + 1],
69	};
70	});
71	} catch (e) {
72	// matches profileName and number in [@${profileName}](/profile/id/${number})
73	const regex = /\[@([^[]+)]\(\/profile\/id\/(\d+)\)/g;	91✔
74	const matches = [...text.matchAll(regex)];	91✔
75	return matches.map(([, profileName, profileId]) => {	91✔
76	return { profileName, profileId };	5✔
77	});
78	}
79	};
80
81	export const queryMentionedUsers = async (	27✔
82	mentions: UserMention[],
83	models: DB,
84	): Promise<UserMentionQuery> => {
85	if (mentions.length === 0) {	78!
86	return [];	78✔
87	}
88
89	try {	×
90	// Create an array of tuples for the replacements
91	const tuples = mentions.map(({ profileId, profileName }) => [	×
92	profileId,
93	profileName,
94	]);
95
96	return await models.sequelize.query<{	×
97	address_id: number;
98	address: string;
99	user_id: number;
100	profile_id: number;
101	profile_name: string;
102	}>(
103	`
104	SELECT a.id as address_id, a.address, a.user_id, p.id as profile_id, p.profile_name
105	FROM "Addresses" as a
106	INNER JOIN "Profiles" as p ON a.profile_id = p.id
107	WHERE a.user_id IS NOT NULL
108	AND (p.id, p.profile_name) IN (:tuples)
109	`,
110	{
111	type: QueryTypes.SELECT,
112	raw: true,
113	replacements: { tuples },
114	},
115	);
116	} catch (e) {
117	throw new ServerError('Failed to query mentioned users', e);	×
118	}
119	};
120
121	export const createCommentMentionNotifications = (	27✔
122	mentions: UserMentionQuery,
123	comment,
124	address,
125	): EmitOptions[] => {
126	return mentions.map(({ user_id }) => {	9✔
127	return {	×
128	notification: {
129	categoryId: NotificationCategories.NewMention,
130	data: {
131	mentioned_user_id: user_id,
132	created_at: new Date(),
133	thread_id: +comment.thread_id,
134	root_title: comment.root_title,
135	root_type: ProposalType.Thread,
136	comment_id: +comment.id,
137	comment_text: comment.text,
138	community_id: comment.community_id,
139	author_address: address.address,
140	author_community_id: address.community_id,
141	},
142	},
143	excludeAddresses: [address.address],
144	};
145	}) as EmitOptions[];
146	};
147
148	export const createThreadMentionNotifications = (	27✔
149	mentions: UserMentionQuery,
150	finalThread,
151	): EmitOptions[] => {
152	return mentions.map(({ user_id }) => {	67✔
153	return {	×
154	notification: {
155	categoryId: NotificationCategories.NewMention,
156	data: {
157	mentioned_user_id: user_id,
158	created_at: new Date(),
159	thread_id: finalThread.id,
160	root_type: ProposalType.Thread,
161	root_title: finalThread.title,
162	comment_text: finalThread.body,
163	community_id: finalThread.community_id,
164	author_address: finalThread.Address.address,
165	author_community_id: finalThread.Address.community_id,
166	},
167	},
168	excludeAddresses: [finalThread.Address.address],
169	};
170	}) as EmitOptions[];
171	};
172
173	type EmitMentionsData = {
174	authorAddressId: number;
175	authorUserId: number;
176	authorAddress: string;
177	authorProfileId: number;
178	mentions: UserMentionQuery;
179	} & (
180	\| {
181	thread: z.infer<typeof Thread>;
182	}
183	\| {
184	comment: z.infer<typeof Comment>;
185	}
186	);
187
188	export const emitMentions = async (	27✔
189	models: DB,
190	transaction: Transaction,
191	data: EmitMentionsData,
192	) => {
193	if (data.mentions.length) {	76!
194	const values: {
195	event_name: EventNames.UserMentioned;
196	event_payload: z.infer<typeof events.UserMentioned>;
197	}[] = data.mentions.map(({ user_id }) => ({	×
198	event_name: EventNames.UserMentioned,
199	event_payload: {
200	authorAddressId: data.authorAddressId,
201	authorUserId: data.authorUserId,
202	authorAddress: data.authorAddress,
203	authorProfileId: data.authorProfileId,
204	mentionedUserId: user_id,
205	communityId:
206	'comment' in data	×
207	? data.comment.community_id
208	: data.thread.community_id,
209	comment: 'comment' in data ? data.comment : undefined,	×
210	thread: 'thread' in data ? data.thread : undefined,	×
211	},
212	}));
213
214	await emitEvent(models.Outbox, values, transaction);	×
215	}
216	};

hicommonwealth / commonwealth / 9600607782

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