15639895198

Committed 13 Jun 2025 04:58PM UTC coverage: 39.67% (-0.3%) from 39.927%

Build # 15639895198

Build Type

Pull #11963

github

Committed by

web-flow

Commit Message

Merge 64f570ebd into f43680d6c

Pull Request Pull Request #11963: External API Quests

Run Details

1786 of 4904 branches covered (36.42%)

Branch coverage included in aggregate %.

8 of 61 new or added lines in 2 files covered. (13.11%)

50 existing lines in 3 files now uncovered.

3233 of 7748 relevant lines covered (41.73%)

36.56 hits per line

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

0.0

/libs/model/src/aggregates/thread/GetThreadById.query.ts

import { InvalidState, Query } from '@hicommonwealth/core';
import * as schemas from '@hicommonwealth/schemas';
import { QueryTypes } from 'sequelize';
import { z } from 'zod';
import { models, sequelize } from '../../database';
import { authOptionalForThread, UnauthorizedView } from '../../middleware';
import { filterGates, joinGates, withGates } from '../../utils/gating';

export function GetThreadById(): Query<typeof schemas.GetThreadById> {
  return {
    ...schemas.GetThreadById,
    auth: [authOptionalForThread],
    secure: true,
    body: async ({ actor, payload, context }) => {
      const { thread_id } = payload;
      const address_id = context?.address?.id;

      // find open gates in thread's community
      const [open_thread] = await sequelize.query<{
        id: number;
      }>(
        `
        ${withGates(address_id)}
        SELECT T.id
        FROM
          "Threads" T
          ${joinGates(address_id)}
        WHERE
          T.id = :thread_id
          ${filterGates(address_id)}
        `,
        {
          type: QueryTypes.SELECT,
          replacements: {
            address_id,
            community_id: context?.community_id,
            thread_id,
          },
        },
      );
      if (!open_thread) throw new UnauthorizedView(actor);

      // TODO: refactor using plain sql and add gating filters
      const thread = await models.Thread.findOne({
        where: { id: thread_id },
        include: [
          {
            model: models.Address,
            as: 'Address',
            include: [
              {
                model: models.User,
                as: 'User',
                required: true,
                attributes: ['id', 'profile', 'tier'],
              },
            ],
          },
          {
            model: models.Address,
            as: 'collaborators',
            include: [
              {
                model: models.User,
                as: 'User',
                required: true,
                attributes: ['id', 'profile', 'tier'],
              },
            ],
          },
          {
            model: models.Topic,
            as: 'topic',
            required: true,
          },
          {
            model: models.Reaction,
            as: 'reactions',
            include: [
              {
                model: models.Address,
                as: 'Address',
                required: true,
                include: [
                  {
                    model: models.User,
                    as: 'User',
                    required: true,
                    attributes: ['id', 'profile', 'tier'],
                  },
                ],
              },
            ],
          },
          {
            model: models.ContestAction,
            where: { action: 'upvoted' },
            required: false,
            attributes: ['content_id', 'thread_id'],
            include: [
              {
                model: models.Contest,
                on: {
                  contest_id: sequelize.where(
                    sequelize.col('"ContestActions".contest_id'),
                    '=',
                    sequelize.col('"ContestActions->Contest".contest_id'),
                  ),
                  contest_address: sequelize.where(
                    sequelize.col('"ContestActions".contest_address'),
                    '=',
                    sequelize.col('"ContestActions->Contest".contest_address'),
                  ),
                },
                attributes: [
                  'contest_id',
                  'contest_address',
                  'score',
                  'start_time',
                  'end_time',
                ],
                include: [
                  {
                    model: models.ContestManager,
                    attributes: ['name', 'cancelled', 'interval'],
                  },
                ],
              },
            ],
          },
          { model: models.ThreadVersionHistory },
        ],
      });

      if (!thread) {
        throw new InvalidState('Thread not found');
      }

      return thread!.toJSON() as z.infer<typeof schemas.ThreadView>;
    },
  };
}

1	import { InvalidState, Query } from '@hicommonwealth/core';
2	import * as schemas from '@hicommonwealth/schemas';
3	import { QueryTypes } from 'sequelize';
4	import { z } from 'zod';
5	import { models, sequelize } from '../../database';
6	import { authOptionalForThread, UnauthorizedView } from '../../middleware';
7	import { filterGates, joinGates, withGates } from '../../utils/gating';
8
9	export function GetThreadById(): Query<typeof schemas.GetThreadById> {
10	return {	×
11	...schemas.GetThreadById,
12	auth: [authOptionalForThread],
13	secure: true,
14	body: async ({ actor, payload, context }) => {
15	const { thread_id } = payload;	×
16	const address_id = context?.address?.id;	×
17
18	// find open gates in thread's community
19	const [open_thread] = await sequelize.query<{	×
20	id: number;
21	}>(
22	`
23	${withGates(address_id)}
24	SELECT T.id
25	FROM
26	"Threads" T
27	${joinGates(address_id)}
28	WHERE
29	T.id = :thread_id
30	${filterGates(address_id)}
31	`,
32	{
33	type: QueryTypes.SELECT,
34	replacements: {
35	address_id,
36	community_id: context?.community_id,
37	thread_id,
38	},
39	},
40	);
41	if (!open_thread) throw new UnauthorizedView(actor);	×
42
43	// TODO: refactor using plain sql and add gating filters
44	const thread = await models.Thread.findOne({	×
45	where: { id: thread_id },
46	include: [
47	{
48	model: models.Address,
49	as: 'Address',
50	include: [
51	{
52	model: models.User,
53	as: 'User',
54	required: true,
55	attributes: ['id', 'profile', 'tier'],
56	},
57	],
58	},
59	{
60	model: models.Address,
61	as: 'collaborators',
62	include: [
63	{
64	model: models.User,
65	as: 'User',
66	required: true,
67	attributes: ['id', 'profile', 'tier'],
68	},
69	],
70	},
71	{
72	model: models.Topic,
73	as: 'topic',
74	required: true,
75	},
76	{
77	model: models.Reaction,
78	as: 'reactions',
79	include: [
80	{
81	model: models.Address,
82	as: 'Address',
83	required: true,
84	include: [
85	{
86	model: models.User,
87	as: 'User',
88	required: true,
89	attributes: ['id', 'profile', 'tier'],
90	},
91	],
92	},
93	],
94	},
95	{
96	model: models.ContestAction,
97	where: { action: 'upvoted' },
98	required: false,
99	attributes: ['content_id', 'thread_id'],
100	include: [
101	{
102	model: models.Contest,
103	on: {
104	contest_id: sequelize.where(
105	sequelize.col('"ContestActions".contest_id'),
106	'=',
107	sequelize.col('"ContestActions->Contest".contest_id'),
108	),
109	contest_address: sequelize.where(
110	sequelize.col('"ContestActions".contest_address'),
111	'=',
112	sequelize.col('"ContestActions->Contest".contest_address'),
113	),
114	},
115	attributes: [
116	'contest_id',
117	'contest_address',
118	'score',
119	'start_time',
120	'end_time',
121	],
122	include: [
123	{
124	model: models.ContestManager,
125	attributes: ['name', 'cancelled', 'interval'],
126	},
127	],
128	},
129	],
130	},
131	{ model: models.ThreadVersionHistory },
132	],
133	});
134
135	if (!thread) {	×
UNCOV 136	throw new InvalidState('Thread not found');	×
137	}
138
UNCOV 139	return thread!.toJSON() as z.infer<typeof schemas.ThreadView>;	×
140	},
141	};
142	}

hicommonwealth / commonwealth / 15639895198

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