Merge pull request #13 from StackExchange/PS-328-search-api

Search API + new pagination logic + dynamic filters

Author: EstoesMoises

plugins/stack-overflow-teams-backend/src/api/createStackOverflowApi.ts

@@ -7,6 +7,7 @@ export const createStackOverflowApi = (baseUrl: string) => {
     body?: any,
     searchQuery?: string,
     pageSize?: number,
+    page?: number,
     additionalParams?: Record<string, string>
   ): Promise<T> => {
     let url = teamName
@@ -23,6 +24,10 @@ export const createStackOverflowApi = (baseUrl: string) => {
       queryParams.append('pageSize', pageSize.toString());
     }
 
+    if (page) {
+      queryParams.append('page', page.toString());
+    }
+
     if (additionalParams) {
       Object.entries(additionalParams).forEach(([key, value]) => {
         queryParams.append(key, value);
@@ -57,12 +62,12 @@ export const createStackOverflowApi = (baseUrl: string) => {
 
   return {
     GET: <T>(endpoint: string, authToken: string, teamName?: string, additionalParams?: Record<string, string>) =>
-      request<T>(endpoint, 'GET', authToken, teamName, undefined, undefined, undefined, additionalParams),
+      request<T>(endpoint, 'GET', authToken, teamName, undefined, undefined, undefined, undefined, additionalParams),
 
     POST: <T>(endpoint: string, body: any, authToken: string, teamName?: string) =>
       request<T>(endpoint, 'POST', authToken, teamName, body),
 
-    SEARCH: <T>(endpoint: string, searchQuery: string, authToken: string, teamName?: string) =>
-      request<T>(endpoint, 'GET', authToken, teamName, undefined, searchQuery, 30),
+    SEARCH: <T>(endpoint: string, searchQuery: string, authToken: string, teamName?: string, page?: number) =>
+      request<T>(endpoint, 'GET', authToken, teamName, undefined, searchQuery, 30, page),
   };
-};
+};

plugins/stack-overflow-teams-backend/src/router.ts

@@ -4,6 +4,7 @@ import Router from 'express-promise-router';
 import {
   StackOverflowAPI,
   StackOverflowConfig,
+  QuestionFilters, 
 } from './services/StackOverflowService/types';
 import { createStackOverflowAuth } from './api';
 
@@ -51,6 +52,45 @@ export async function createRouter({
     }
   }
 
+  // Helper function to build question filters from query parameters
+  function buildQuestionFilters(query: any): QuestionFilters | undefined {
+    const filters: QuestionFilters = {};
+    let hasFilters = false;
+
+    if (query.sort && ['activity', 'creation', 'score'].includes(query.sort)) {
+      filters.sort = query.sort;
+      hasFilters = true;
+    }
+
+    if (query.order && ['asc', 'desc'].includes(query.order)) {
+      filters.order = query.order;
+      hasFilters = true;
+    }
+
+    if (query.isAnswered !== undefined) {
+      filters.isAnswered = query.isAnswered === 'true';
+      hasFilters = true;
+    }
+
+    if (query.page !== undefined) {
+      const page = parseInt(query.page, 10);
+      if (!isNaN(page) && page > 0) {
+        filters.page = page;
+        hasFilters = true;
+      }
+    }
+
+    if (query.pageSize !== undefined) {
+      const pageSize = parseInt(query.pageSize, 10);
+      if (!isNaN(pageSize) && pageSize > 0) {
+        filters.pageSize = pageSize;
+        hasFilters = true;
+      }
+    }
+
+    return hasFilters ? filters : undefined;
+  }
+
   // OAuth Authentication routes
 
   router.get('/auth/start', async (_req: Request, res: Response) => {
@@ -256,6 +296,7 @@ export async function createRouter({
     }
   });
 
+  // Updated questions route with filtering support
   router.get('/questions', async (req: Request, res: Response) => {
     try {
       const authToken = getValidAuthToken(req, res);
@@ -264,17 +305,99 @@ export async function createRouter({
           .status(401)
           .json({ error: 'Missing Stack Overflow Teams Access Token' });
       }
-      const questions = await stackOverflowService.getQuestions(authToken);
+      
+      const filters = buildQuestionFilters(req.query);
+      const questions = await stackOverflowService.getQuestions(authToken, filters);
       return res.send(questions);
     } catch (error: any) {
-      // Fix type issue when including the error for some reason
       logger.error('Error fetching questions', { error });
       return res.status(500).send({
         error: `Failed to fetch questions from the Stack Overflow instance`,
       });
     }
   });
 
+  // Convenience routes for common question filtering scenarios
+  router.get('/questions/active', async (req: Request, res: Response) => {
+    try {
+      const authToken = getValidAuthToken(req, res);
+      if (!authToken) {
+        return res
+          .status(401)
+          .json({ error: 'Missing Stack Overflow Teams Access Token' });
+      }
+      
+      const page = req.query.page ? parseInt(req.query.page as string, 10) : undefined;
+      const questions = await stackOverflowService.getActiveQuestions(authToken, page);
+      return res.send(questions);
+    } catch (error: any) {
+      logger.error('Error fetching active questions', { error });
+      return res.status(500).send({
+        error: `Failed to fetch active questions from the Stack Overflow instance`,
+      });
+    }
+  });
+
+  router.get('/questions/newest', async (req: Request, res: Response) => {
+    try {
+      const authToken = getValidAuthToken(req, res);
+      if (!authToken) {
+        return res
+          .status(401)
+          .json({ error: 'Missing Stack Overflow Teams Access Token' });
+      }
+      
+      const page = req.query.page ? parseInt(req.query.page as string, 10) : undefined;
+      const questions = await stackOverflowService.getNewestQuestions(authToken, page);
+      return res.send(questions);
+    } catch (error: any) {
+      logger.error('Error fetching newest questions', { error });
+      return res.status(500).send({
+        error: `Failed to fetch newest questions from the Stack Overflow instance`,
+      });
+    }
+  });
+
+  router.get('/questions/top-scored', async (req: Request, res: Response) => {
+    try {
+      const authToken = getValidAuthToken(req, res);
+      if (!authToken) {
+        return res
+          .status(401)
+          .json({ error: 'Missing Stack Overflow Teams Access Token' });
+      }
+      
+      const page = req.query.page ? parseInt(req.query.page as string, 10) : undefined;
+      const questions = await stackOverflowService.getTopScoredQuestions(authToken, page);
+      return res.send(questions);
+    } catch (error: any) {
+      logger.error('Error fetching top scored questions', { error });
+      return res.status(500).send({
+        error: `Failed to fetch top scored questions from the Stack Overflow instance`,
+      });
+    }
+  });
+
+  router.get('/questions/unanswered', async (req: Request, res: Response) => {
+    try {
+      const authToken = getValidAuthToken(req, res);
+      if (!authToken) {
+        return res
+          .status(401)
+          .json({ error: 'Missing Stack Overflow Teams Access Token' });
+      }
+      
+      const page = req.query.page ? parseInt(req.query.page as string, 10) : undefined;
+      const questions = await stackOverflowService.getUnansweredQuestions(authToken, page);
+      return res.send(questions);
+    } catch (error: any) {
+      logger.error('Error fetching unanswered questions', { error });
+      return res.status(500).send({
+        error: `Failed to fetch unanswered questions from the Stack Overflow instance`,
+      });
+    }
+  });
+
   router.get('/tags', async (req: Request, res: Response) => {
     try {
       const authToken = getValidAuthToken(req, res);
@@ -315,7 +438,7 @@ export async function createRouter({
   router.post('/search', async (req: Request, res: Response) => {
     try {
       const authToken = getValidAuthToken(req, res);
-      const { query } = req.body;
+      const { query, page } = req.body;
 
       if (!authToken) {
         return res
@@ -325,6 +448,7 @@ export async function createRouter({
       const searchResults = await stackOverflowService.getSearch(
         query,
         authToken,
+        page
       );
       return res.status(201).json(searchResults);
     } catch (error: any) {
@@ -367,4 +491,4 @@ export async function createRouter({
   });
 
   return router;
-}
+}

plugins/stack-overflow-teams-backend/src/services/StackOverflowService/createStackOverflowService.ts

@@ -5,6 +5,7 @@ import {
   SearchItem,
   StackOverflowAPI,
   StackOverflowConfig,
+  QuestionFilters,
   Tag,
   User,
 } from './types';
@@ -18,7 +19,6 @@ export async function createStackOverflowService({
   logger: LoggerService;
 }): Promise<StackOverflowAPI> {
   // LOGGER
-
   logger.info('Initializing Stack Overflow Service');
 
   if (config.baseUrl && config.teamName) {
@@ -32,11 +32,32 @@ export async function createStackOverflowService({
     baseUrl || 'https://api.stackoverflowteams.com',
   );
 
+  // Helper function to build query parameters
+  const buildParams = (filters: Record<string, any>): Record<string, string> => {
+    const params: Record<string, string> = {};
+    
+    Object.entries(filters).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        params[key] = value.toString();
+      }
+    });
+    
+    return params;
+  };
+
   return {
-    // GET
-    getQuestions: authToken =>
-      api.GET<PaginatedResponse<Question>>('/questions', authToken, teamName, { sort: 'creation', order: 'desc' }),
-    getTags: (authToken, search?: string) => {
+    getQuestions: (authToken: string, filters?: QuestionFilters) => {
+      const params = buildParams({
+        sort: filters?.sort || 'creation',
+        order: filters?.order || 'desc',
+        isAnswered: filters?.isAnswered,
+        page: filters?.page,
+        pageSize: filters?.pageSize || 30,
+      });
+      
+      return api.GET<PaginatedResponse<Question>>('/questions', authToken, teamName, params);
+    },
+    getTags: (authToken: string, search?: string) => {
       const params: Record<string, string> = { sort: 'postCount', order: 'desc' };
       if (search) {
         params.partialName = search;
@@ -46,6 +67,24 @@ export async function createStackOverflowService({
     getUsers: authToken =>
       api.GET<PaginatedResponse<User>>('/users', authToken, teamName),
     getMe: authToken => api.GET<User>('/users/me', authToken, teamName),
+    
+    // Convenience methods for common filtering scenarios
+    getActiveQuestions: (authToken: string, page?: number) =>
+      api.GET<PaginatedResponse<Question>>('/questions', authToken, teamName, 
+        buildParams({ sort: 'activity', order: 'desc', page })),
+    
+    getNewestQuestions: (authToken: string, page?: number) =>
+      api.GET<PaginatedResponse<Question>>('/questions', authToken, teamName, 
+        buildParams({ sort: 'creation', order: 'desc', page })),
+    
+    getTopScoredQuestions: (authToken: string, page?: number) =>
+      api.GET<PaginatedResponse<Question>>('/questions', authToken, teamName, 
+        buildParams({ sort: 'score', order: 'desc', page })),
+    
+    getUnansweredQuestions: (authToken: string, page?: number) =>
+      api.GET<PaginatedResponse<Question>>('/questions', authToken, teamName, 
+        buildParams({ isAnswered: false, sort: 'creation', order: 'desc', page })),
+  
     // POST
     postQuestions: (
       title: string,
@@ -60,12 +99,13 @@ export async function createStackOverflowService({
         teamName,
       ),
     // SEARCH
-    getSearch: (query: string, authToken: string) =>
+    getSearch: (query: string, authToken: string, page?: number) =>
       api.SEARCH<PaginatedResponse<SearchItem>>(
         '/search',
         query,
         authToken,
         teamName,
+        page,
       ),
   };
 }

plugins/stack-overflow-teams-backend/src/services/StackOverflowService/types.ts

@@ -60,19 +60,32 @@ export type StackOverflowConfig = {
   authUrl?: string;
 };
 
-export interface StackOverflowAPI {
-  getQuestions(authToken: string): Promise<PaginatedResponse<Question>>;
-  getTags(authToken: string, search?: string): Promise<PaginatedResponse<Tag>>;
-  getUsers(authToken: string): Promise<PaginatedResponse<User>>;
-  getMe(authToken: string): Promise<User>;
-  postQuestions(
-    title: string,
-    body: string,
-    tags: string[],
-    authToken: string,
-  ): Promise<Question>;
-  getSearch(
-    query: string,
-    authToken: string,
-  ): Promise<PaginatedResponse<SearchItem>>;
+export interface QuestionFilters {
+  sort?: 'activity' | 'creation' | 'score';
+  order?: 'asc' | 'desc';
+  isAnswered?: boolean;
+  page?: number;
+  pageSize?: number;
 }
+
+export interface StackOverflowAPI {
+  // Enhanced questions method with filtering
+  getQuestions: (authToken: string, filters?: QuestionFilters) => Promise<PaginatedResponse<Question>>;
+  
+  // Keep original signatures for tags and users
+  getTags: (authToken: string, search?: string) => Promise<PaginatedResponse<Tag>>;
+  getUsers: (authToken: string) => Promise<PaginatedResponse<User>>;
+  getMe: (authToken: string) => Promise<User>;
+  
+  // Convenience methods for common question filtering scenarios
+  getActiveQuestions: (authToken: string, page?: number) => Promise<PaginatedResponse<Question>>;
+  getNewestQuestions: (authToken: string, page?: number) => Promise<PaginatedResponse<Question>>;
+  getTopScoredQuestions: (authToken: string, page?: number) => Promise<PaginatedResponse<Question>>;
+  getUnansweredQuestions: (authToken: string, page?: number) => Promise<PaginatedResponse<Question>>;
+  
+  // POST
+  postQuestions: (title: string, body: string, tags: string[], authToken: string) => Promise<Question>;
+  
+  // SEARCH
+  getSearch: (query: string, authToken: string, page?: number) => Promise<PaginatedResponse<SearchItem>>;
+}