External API GET threads and topics

libs/adapters/src/trpc/handlers.ts

@@ -55,6 +55,7 @@ export enum Tag {
   User = 'User',
   Community = 'Community',
   Thread = 'Thread',
+  Topic = 'Topic',
   Comment = 'Comment',
   Reaction = 'Reaction',
   Integration = 'Integration',

libs/model/src/index.ts

@@ -9,6 +9,7 @@ export * as LoadTest from './load-testing';
 export * as Reaction from './reaction';
 export * as Subscription from './subscription';
 export * as Thread from './thread';
+export * as Topic from './topic';
 export * as User from './user';
 export * as Wallet from './wallet';
 export * as Webhook from './webhook';

libs/model/src/thread/GetThreads.query.ts

@@ -0,0 +1,94 @@
+import { type Query } from '@hicommonwealth/core';
+import * as schemas from '@hicommonwealth/schemas';
+import { Comment } from '@hicommonwealth/schemas';
+import { FindAndCountOptions } from 'sequelize';
+import { models } from '../database';
+import { ThreadAttributes } from '../models';
+import { removeUndefined } from '../utils';
+import { formatSequelizePagination } from '../utils/paginationUtils';
+
+export function GetThreads(): Query<typeof schemas.GetThreads> {
+  return {
+    input: schemas.GetThreads.input,
+    output: schemas.GetThreads.output.extend({ Comment: Comment.nullish() }),
+    auth: [],
+    secure: false,
+    body: async ({ payload }) => {
+      const {
+        community_id,
+        topic_id,
+        thread_id,
+        include_comments,
+        include_user,
+        include_reactions,
+      } = payload;
+
+      const includeArray = [];
+      if (include_comments) {
+        includeArray.push({
+          model: models.Comment,
+          as: 'Comments',
+          include: [
+            {
+              model: models.Address,
+              as: 'Address',
+              attributes: ['id', 'address', 'last_active'],
+              include: [
+                {
+                  model: models.User,
+                  as: 'User',
+                  required: true,
+                  attributes: ['id', 'profile'],
+                },
+              ],
+            },
+          ],
+        });
+      }
+      if (include_user) {
+        includeArray.push({
+          model: models.Address,
+          as: 'Address',
+          include: [
+            {
+              model: models.User,
+              as: 'User',
+              required: true,
+              attributes: ['id', 'profile'],
+            },
+          ],
+        });
+      }
+
+      if (include_reactions) {
+        includeArray.push({
+          model: models.Reaction,
+          as: 'reactions',
+          include: [
+            {
+              model: models.Address,
+              as: 'Address',
+              required: true,
+              attributes: ['id', 'address', 'last_active'],
+              include: [
+                {
+                  model: models.User,
+                  attributes: ['id', 'profile'],
+                },
+              ],
+            },
+          ],
+        });
+      }
+
+      const { count, rows: threads } = await models.Thread.findAndCountAll({
+        where: removeUndefined({ community_id, topic_id, id: thread_id }),
+        include: includeArray,
+        ...formatSequelizePagination(payload),
+        paranoid: false,
+      } as unknown as FindAndCountOptions<ThreadAttributes>);
+
+      return schemas.buildPaginatedResponse(threads, count as number, payload);
+    },
+  };
+}

libs/model/src/thread/index.ts

@@ -1,3 +1,3 @@
 export * from './CreateThread.command';
 export * from './GetBulkThread.query';
-export * from './GetThread.query';
+export * from './GetThreads.query';

libs/model/src/topic/GetTopics.query.ts

@@ -0,0 +1,40 @@
+import { type Query } from '@hicommonwealth/core';
+import * as schemas from '@hicommonwealth/schemas';
+import { FindAndCountOptions } from 'sequelize';
+import { models } from '../database';
+import { TopicAttributes } from '../models/index';
+import { removeUndefined } from '../utils';
+import { formatSequelizePagination } from '../utils/paginationUtils';
+
+export function GetTopics(): Query<typeof schemas.GetTopics> {
+  return {
+    ...schemas.GetTopics,
+    auth: [],
+    secure: false,
+    body: async ({ payload }) => {
+      const { community_id, topic_id, include_threads } = payload;
+
+      const includeArray = [];
+      if (include_threads) {
+        includeArray.push({
+          model: models.Thread,
+          as: 'threads',
+        });
+      }
+
+      const { count, rows: topics } = await models.Topic.findAndCountAll({
+        where: removeUndefined({ community_id, id: topic_id }),
+        include: includeArray,
+        ...formatSequelizePagination(payload),
+        paranoid: false,
+      } as unknown as FindAndCountOptions<TopicAttributes>);
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return schemas.buildPaginatedResponse(
+        topics,
+        count as number,
+        payload,
+      ) as any;
+    },
+  };
+}

libs/model/src/topic/index.ts

@@ -0,0 +1 @@
+export * from './GetTopics.query';

libs/schemas/src/entities/thread.schemas.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { DiscordMetaSchema, linksSchema, PG_INT } from '../utils';
+import { Reaction } from './reaction.schemas';
 import { Topic } from './topic.schemas';
 import { Address } from './user.schemas';
 
@@ -51,6 +52,7 @@ export const Thread = z.object({
 
   // associations
   Address: Address.nullish(),
+  Reaction: Reaction.nullish(),
   topic: Topic.nullish(),
 });
 

libs/schemas/src/queries/index.ts

@@ -5,4 +5,5 @@ export * from './feed.schemas';
 export * from './pagination';
 export * from './subscription.schemas';
 export * from './thread.schemas';
+export * from './topic.schemas';
 export * from './user.schemas';

libs/schemas/src/queries/thread.schemas.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
+import { Thread } from '../entities';
 import {
   DiscordMetaSchema,
   linksSchema,
   paginationSchema,
   PG_INT,
 } from '../utils';
+import { PaginatedResultSchema, PaginationParamsSchema } from './pagination';
 
 export const OrderByQueriesKeys = z.enum([
   'createdAt:asc',
@@ -91,3 +93,42 @@ export const GetBulkThreads = {
     threads: z.array(BulkThread),
   }),
 };
+
+export const GetThreads = {
+  input: PaginationParamsSchema.extend({
+    community_id: z.string(),
+    topic_id: PG_INT.optional(),
+    thread_id: PG_INT.optional(),
+    include_comments: z.coerce.boolean(),
+    include_user: z.coerce.boolean(),
+    include_reactions: z.coerce.boolean(),
+  }),
+  output: PaginatedResultSchema.extend({
+    results: Thread.array(),
+  }),
+};
+
+export const DEPRECATED_GetThreads = z.object({
+  community_id: z.string(),
+  bulk: z.coerce.boolean().default(false),
+  thread_ids: z.coerce.number().int().array().optional(),
+  active: z.string().optional(),
+  search: z.string().optional(),
+  count: z.coerce.boolean().optional().default(false),
+  include_count: z.coerce.boolean().default(false),
+});
+
+export const DEPRECATED_GetBulkThreads = z.object({
+  topic_id: z.coerce.number().int().optional(),
+  includePinnedThreads: z.coerce.boolean().optional(),
+  limit: z.coerce.number().int().optional(),
+  page: z.coerce.number().int().optional(),
+  archived: z.coerce.boolean().optional(),
+  stage: z.string().optional(),
+  orderBy: z.string().optional(),
+  from_date: z.string().optional(),
+  to_date: z.string().optional(),
+  contestAddress: z.string().optional(),
+  status: z.string().optional(),
+  withXRecentComments: z.coerce.number().optional(),
+});

libs/schemas/src/queries/topic.schemas.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { Topic } from '../entities';
+import { PG_INT } from '../utils';
+import { PaginatedResultSchema, PaginationParamsSchema } from './pagination';
+
+export const GetTopics = {
+  input: PaginationParamsSchema.extend({
+    community_id: z.string(),
+    topic_id: PG_INT.optional(),
+    include_threads: z.coerce.boolean(),
+  }),
+  output: PaginatedResultSchema.extend({
+    results: Topic.array(),
+  }),
+};

packages/commonwealth/server/api/external-router.ts

@@ -5,12 +5,15 @@ import passport from 'passport';
 import { config } from '../config';
 import * as comment from './comment';
 import * as community from './community';
-import * as thread from './threads';
+import * as thread from './thread';
+import * as topic from './topic';
 
 const { createCommunity, getCommunities, getCommunity, getMembers } =
   community.trpcRouter;
 const { createThread } = thread.trpcRouter;
 const { getComments } = comment.trpcRouter;
+const { getThreads } = thread.trpcRouter;
+const { getTopics } = topic.trpcRouter;
 //const { getBulkThreads } = thread.trpcRouter;
 
 const api = {
@@ -20,6 +23,8 @@ const api = {
   getMembers,
   getComments,
   createThread,
+  getThreads,
+  getTopics,
   //getBulkThreads,
 };
 

packages/commonwealth/server/api/internal-router.ts

@@ -9,7 +9,7 @@ import * as feed from './feed';
 import * as integrations from './integrations';
 import * as loadTest from './load-test';
 import * as subscription from './subscription';
-import * as thread from './threads';
+import * as thread from './thread';
 import * as user from './user';
 import * as wallet from './wallet';
 import * as webhook from './webhook';

packages/commonwealth/server/api/threads.ts → packages/commonwealth/server/api/thread.ts

@@ -12,4 +12,5 @@ export const trpcRouter = trpc.router({
     ),
   ),
   getBulkThreads: trpc.query(Thread.GetBulkThreads, trpc.Tag.Thread),
+  getThreads: trpc.query(Thread.GetThreads, trpc.Tag.Thread),
 });

packages/commonwealth/server/api/topic.ts

@@ -0,0 +1,6 @@
+import { trpc } from '@hicommonwealth/adapters';
+import { Topic } from '@hicommonwealth/model';
+
+export const trpcRouter = trpc.router({
+  getTopics: trpc.query(Topic.GetTopics, trpc.Tag.Topic),
+});

packages/commonwealth/server/routes/feed.ts

@@ -1,5 +1,6 @@
 import { AppError } from '@hicommonwealth/core';
-import { Thread, ThreadAttributes, type DB } from '@hicommonwealth/model';
+import { ThreadAttributes, type DB } from '@hicommonwealth/model';
+import * as schemas from '@hicommonwealth/schemas';
 import { slugify } from '@hicommonwealth/shared';
 import { Feed } from 'feed';
 import { GetBulkThreadsResult } from '../controllers/server_threads_methods/get_bulk_threads';
@@ -47,7 +48,7 @@ export const getFeedHandler = async (
   >,
   res: TypedResponse<GetThreadsResponse>,
 ) => {
-  const queryValidationResult = Thread.GetThreadsParamsSchema.safeParse(
+  const queryValidationResult = schemas.DEPRECATED_GetBulkThreads.safeParse(
     req.query,
   );
 
@@ -65,7 +66,7 @@ export const getFeedHandler = async (
   // get bulk threads
   if (bulk) {
     const bulkQueryValidationResult =
-      Thread.GetBulkThreadsParamsSchema.safeParse(req.query);
+      schemas.DEPRECATED_GetBulkThreads.safeParse(req.query);
 
     if (bulkQueryValidationResult.success === false) {
       throw new AppError(formatErrorPretty(bulkQueryValidationResult));

packages/commonwealth/server/routes/threads/get_threads_handler.ts

@@ -1,5 +1,5 @@
 import { AppError } from '@hicommonwealth/core';
-import { Thread } from '@hicommonwealth/model';
+import * as schemas from '@hicommonwealth/schemas';
 import { ALL_COMMUNITIES } from '../../middleware/databaseValidationService';
 import { ServerControllers } from '../../routing/router';
 import {
@@ -66,7 +66,7 @@ export const getThreadsHandler = async (
   >,
   res: TypedResponse<GetThreadsResponse>,
 ) => {
-  const queryValidationResult = Thread.GetThreadsParamsSchema.safeParse(
+  const queryValidationResult = schemas.DEPRECATED_GetThreads.safeParse(
     req.query,
   );
 
@@ -95,7 +95,7 @@ export const getThreadsHandler = async (
   // get bulk threads
   if (bulk) {
     const bulkQueryValidationResult =
-      Thread.GetBulkThreadsParamsSchema.safeParse(req.query);
+      schemas.DEPRECATED_GetBulkThreads.safeParse(req.query);
 
     if (bulkQueryValidationResult.success === false) {
       throw new AppError(formatErrorPretty(bulkQueryValidationResult));