14198518114

Committed 01 Apr 2025 02:37PM UTC coverage: 45.602% (+0.3%) from 45.271%

Build # 14198518114

Build Type

Pull #11706

github

Committed by

web-flow

Commit Message

Merge 30952227e into d7ab14fcb

Pull Request Pull Request #11706: Cursor rules for FE

Run Details

1507 of 3693 branches covered (40.81%)

Branch coverage included in aggregate %.

2858 of 5879 relevant lines covered (48.61%)

39.34 hits per line

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

56.67

/libs/model/src/aggregates/thread/CreateThread.command.ts

import {
  Actor,
  AppError,
  InvalidInput,
  InvalidState,
  type Command,
} from '@hicommonwealth/core';
import * as schemas from '@hicommonwealth/schemas';
import { BalanceSourceType } from '@hicommonwealth/shared';
import { z } from 'zod';
import { config } from '../../config';
import { models } from '../../database';
import { authTopic, tiered } from '../../middleware';
import { verifyThreadSignature } from '../../middleware/canvas';
import { mustBeAuthorized, mustExist } from '../../middleware/guards';
import { getThreadSearchVector } from '../../models/thread';
import { tokenBalanceCache } from '../../services';
import {
  decodeContent,
  emitMentions,
  parseUserMentions,
  uniqueMentions,
  uploadIfLarge,
} from '../../utils';
import { GetActiveContestManagers } from '../contest';

export const CreateThreadErrors = {
  InsufficientTokenBalance: 'Insufficient token balance',
  BalanceCheckFailed: 'Could not verify user token balance',
  ParseMentionsFailed: 'Failed to parse mentions',
  LinkMissingTitleOrUrl: 'Links must include a title and URL',
  UnsupportedKind: 'Only discussion and link posts supported',
  FailedCreateThread: 'Failed to create thread',
  DiscussionMissingTitle: 'Discussion posts must include a title',
  NoBody: 'Thread body cannot be blank',
  PostLimitReached: 'Post limit reached',
  ArchivedTopic: 'Cannot post in archived topic',
};

const getActiveContestManagersQuery = GetActiveContestManagers();

/**
 * Ensure that user has non-dust ETH value
 */
async function checkAddressBalance(
  activeContestManagers: z.infer<typeof getActiveContestManagersQuery.output>,
  address: string,
) {
  const balances = await tokenBalanceCache.getBalances({
    balanceSourceType: BalanceSourceType.ETHNative,
    addresses: [address],
    sourceOptions: {
      evmChainId: activeContestManagers[0]!.eth_chain_id,
    },
    cacheRefresh: true,
  });
  const minUserEthBigInt = BigInt(config.CONTESTS.MIN_USER_ETH * 1e18);
  if (BigInt(balances[address]) < minUserEthBigInt)
    throw new AppError(
      `user ETH balance insufficient (${balances[address]} of ${minUserEthBigInt})`,
    );
}

/**
 * Ensure post limit not reached on active contests
 */
function checkContestLimits(
  activeContestManagers: z.infer<typeof getActiveContestManagersQuery.output>,
  address: string,
) {
  const validActiveContests = activeContestManagers.filter((c) => {
    const userPostsInContest = c.actions.filter(
      (action) => action.actor_address === address && action.action === 'added',
    );
    const quotaReached =
      userPostsInContest.length >= config.CONTESTS.MAX_USER_POSTS_PER_CONTEST;
    return !quotaReached;
  });
  if (validActiveContests.length === 0)
    throw new AppError(CreateThreadErrors.PostLimitReached);
}

export function CreateThread(): Command<typeof schemas.CreateThread> {
  return {
    ...schemas.CreateThread,
    auth: [
      authTopic({ action: schemas.PermissionEnum.CREATE_THREAD }),
      verifyThreadSignature,
      tiered({ creates: true }),
    ],
    body: async ({ actor, payload, context }) => {
      const { address } = mustBeAuthorized(actor, context);

      const { community_id, topic_id, kind, url, is_linking_token, ...rest } =
        payload;

      if (kind === 'link' && !url?.trim())
        throw new InvalidInput(CreateThreadErrors.LinkMissingTitleOrUrl);

      const community = await models.Community.findOne({
        where: { id: community_id },
        attributes: ['spam_tier_level'],
      });
      mustExist('Community', community);

      const user = await models.User.findOne({
        where: { id: actor.user.id },
        attributes: ['tier'],
      });
      mustExist('User', user);

      const topic = await models.Topic.findOne({ where: { id: topic_id } });
      if (topic?.archived_at)
        throw new InvalidState(CreateThreadErrors.ArchivedTopic);

      // check contest invariants
      const activeContestManagers = await getActiveContestManagersQuery.body({
        actor: {} as Actor,
        payload: {
          community_id,
          topic_id,
        },
      });
      if (activeContestManagers && activeContestManagers.length > 0) {
        await checkAddressBalance(activeContestManagers, actor.address!);
        checkContestLimits(activeContestManagers, actor.address!);
      }

      const body = decodeContent(payload.body);
      const mentions = uniqueMentions(parseUserMentions(body));

      const { contentUrl } = await uploadIfLarge('threads', body);

      // == mutation transaction boundary ==
      const new_thread_id = await models.sequelize.transaction(
        async (transaction) => {
          const thread = await models.Thread.create(
            {
              ...rest,
              community_id,
              address_id: address.id!,
              topic_id,
              kind,
              body,
              view_count: 0,
              comment_count: 0,
              reaction_count: 0,
              reaction_weights_sum: '0',
              search: getThreadSearchVector(rest.title, body),
              content_url: contentUrl,
              is_linking_token,
              marked_as_spam_at:
                user.tier <= community.spam_tier_level ? new Date() : null,
            },
            {
              transaction,
            },
          );

          await models.ThreadVersionHistory.create(
            {
              thread_id: thread.id!,
              body,
              address: address.address,
              timestamp: thread.created_at!,
              content_url: contentUrl,
            },
            {
              transaction,
            },
          );

          await models.ThreadSubscription.create(
            {
              user_id: actor.user.id!,
              thread_id: thread.id!,
            },
            { transaction },
          );

          mentions.length &&
            (await emitMentions(transaction, {
              authorAddressId: address.id!,
              authorUserId: actor.user.id!,
              authorAddress: address.address,
              mentions: mentions,
              thread,
              community_id: thread.community_id,
            }));

          return thread.id;
        },
      );
      // == end of transaction boundary ==

      const thread = await models.Thread.findOne({
        where: { id: new_thread_id },
        include: [{ model: models.Address, as: 'Address' }],
      });
      return {
        ...thread!.toJSON(),
        topic: topic!.toJSON(),
      };
    },
  };
}

1	import {
2	Actor,
3	AppError,
4	InvalidInput,
5	InvalidState,
6	type Command,
7	} from '@hicommonwealth/core';
8	import * as schemas from '@hicommonwealth/schemas';
9	import { BalanceSourceType } from '@hicommonwealth/shared';
10	import { z } from 'zod';
11	import { config } from '../../config';
12	import { models } from '../../database';
13	import { authTopic, tiered } from '../../middleware';
14	import { verifyThreadSignature } from '../../middleware/canvas';
15	import { mustBeAuthorized, mustExist } from '../../middleware/guards';
16	import { getThreadSearchVector } from '../../models/thread';
17	import { tokenBalanceCache } from '../../services';
18	import {
19	decodeContent,
20	emitMentions,
21	parseUserMentions,
22	uniqueMentions,
23	uploadIfLarge,
24	} from '../../utils';
25	import { GetActiveContestManagers } from '../contest';
26
27	export const CreateThreadErrors = {	32✔
28	InsufficientTokenBalance: 'Insufficient token balance',
29	BalanceCheckFailed: 'Could not verify user token balance',
30	ParseMentionsFailed: 'Failed to parse mentions',
31	LinkMissingTitleOrUrl: 'Links must include a title and URL',
32	UnsupportedKind: 'Only discussion and link posts supported',
33	FailedCreateThread: 'Failed to create thread',
34	DiscussionMissingTitle: 'Discussion posts must include a title',
35	NoBody: 'Thread body cannot be blank',
36	PostLimitReached: 'Post limit reached',
37	ArchivedTopic: 'Cannot post in archived topic',
38	};
39
40	const getActiveContestManagersQuery = GetActiveContestManagers();	32✔
41
42	/**
43	* Ensure that user has non-dust ETH value
44	*/
45	async function checkAddressBalance(
46	activeContestManagers: z.infer<typeof getActiveContestManagersQuery.output>,
47	address: string,
48	) {
49	const balances = await tokenBalanceCache.getBalances({	×
50	balanceSourceType: BalanceSourceType.ETHNative,
51	addresses: [address],
52	sourceOptions: {
53	evmChainId: activeContestManagers[0]!.eth_chain_id,
54	},
55	cacheRefresh: true,
56	});
57	const minUserEthBigInt = BigInt(config.CONTESTS.MIN_USER_ETH * 1e18);	×
58	if (BigInt(balances[address]) < minUserEthBigInt)	×
59	throw new AppError(	×
60	`user ETH balance insufficient (${balances[address]} of ${minUserEthBigInt})`,
61	);
62	}
63
64	/**
65	* Ensure post limit not reached on active contests
66	*/
67	function checkContestLimits(
68	activeContestManagers: z.infer<typeof getActiveContestManagersQuery.output>,
69	address: string,
70	) {
71	const validActiveContests = activeContestManagers.filter((c) => {	×
72	const userPostsInContest = c.actions.filter(	×
73	(action) => action.actor_address === address && action.action === 'added',	×
74	);
75	const quotaReached =
76	userPostsInContest.length >= config.CONTESTS.MAX_USER_POSTS_PER_CONTEST;	×
77	return !quotaReached;	×
78	});
79	if (validActiveContests.length === 0)	×
80	throw new AppError(CreateThreadErrors.PostLimitReached);	×
81	}
82
83	export function CreateThread(): Command<typeof schemas.CreateThread> {
84	return {	22✔
85	...schemas.CreateThread,
86	auth: [
87	authTopic({ action: schemas.PermissionEnum.CREATE_THREAD }),
88	verifyThreadSignature,
89	tiered({ creates: true }),
90	],
91	body: async ({ actor, payload, context }) => {
92	const { address } = mustBeAuthorized(actor, context);	15✔
93
94	const { community_id, topic_id, kind, url, is_linking_token, ...rest } =
95	payload;	15✔
96
97	if (kind === 'link' && !url?.trim())	15!
98	throw new InvalidInput(CreateThreadErrors.LinkMissingTitleOrUrl);	×
99
100	const community = await models.Community.findOne({	15✔
101	where: { id: community_id },
102	attributes: ['spam_tier_level'],
103	});
104	mustExist('Community', community);	15✔
105
106	const user = await models.User.findOne({	15✔
107	where: { id: actor.user.id },
108	attributes: ['tier'],
109	});
110	mustExist('User', user);	15✔
111
112	const topic = await models.Topic.findOne({ where: { id: topic_id } });	15✔
113	if (topic?.archived_at)	15!
114	throw new InvalidState(CreateThreadErrors.ArchivedTopic);	×
115
116	// check contest invariants
117	const activeContestManagers = await getActiveContestManagersQuery.body({	15✔
118	actor: {} as Actor,
119	payload: {
120	community_id,
121	topic_id,
122	},
123	});
124	if (activeContestManagers && activeContestManagers.length > 0) {	15!
125	await checkAddressBalance(activeContestManagers, actor.address!);	×
126	checkContestLimits(activeContestManagers, actor.address!);	×
127	}
128
129	const body = decodeContent(payload.body);	15✔
130	const mentions = uniqueMentions(parseUserMentions(body));	15✔
131
132	const { contentUrl } = await uploadIfLarge('threads', body);	15✔
133
134	// == mutation transaction boundary ==
135	const new_thread_id = await models.sequelize.transaction(	15✔
136	async (transaction) => {
137	const thread = await models.Thread.create(	15✔
138	{
139	...rest,
140	community_id,
141	address_id: address.id!,
142	topic_id,
143	kind,
144	body,
145	view_count: 0,
146	comment_count: 0,
147	reaction_count: 0,
148	reaction_weights_sum: '0',
149	search: getThreadSearchVector(rest.title, body),
150	content_url: contentUrl,
151	is_linking_token,
152	marked_as_spam_at:
153	user.tier <= community.spam_tier_level ? new Date() : null,	15✔
154	},
155	{
156	transaction,
157	},
158	);
159
160	await models.ThreadVersionHistory.create(	15✔
161	{
162	thread_id: thread.id!,
163	body,
164	address: address.address,
165	timestamp: thread.created_at!,
166	content_url: contentUrl,
167	},
168	{
169	transaction,
170	},
171	);
172
173	await models.ThreadSubscription.create(	15✔
174	{
175	user_id: actor.user.id!,
176	thread_id: thread.id!,
177	},
178	{ transaction },
179	);
180
181	mentions.length &&	15!
182	(await emitMentions(transaction, {
183	authorAddressId: address.id!,
184	authorUserId: actor.user.id!,
185	authorAddress: address.address,
186	mentions: mentions,
187	thread,
188	community_id: thread.community_id,
189	}));
190
191	return thread.id;	15✔
192	},
193	);
194	// == end of transaction boundary ==
195
196	const thread = await models.Thread.findOne({	15✔
197	where: { id: new_thread_id },
198	include: [{ model: models.Address, as: 'Address' }],
199	});
200	return {	15✔
201	...thread!.toJSON(),
202	topic: topic!.toJSON(),
203	};
204	},
205	};
206	}

hicommonwealth / commonwealth / 14198518114

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