feat: 히스토리 api ts rest 적용

backend/src/app.ts

@@ -81,6 +81,7 @@ app.use('/api', router);
 createExpressEndpoints(contract, routerV2, app, {
   logInitialization: true,
   responseValidation: true,
+  jsonQuery: true,
 });
 
 // 에러 핸들러

backend/src/entity/entities/VHistories.ts

@@ -28,7 +28,7 @@ import { DataSource, ViewColumn, ViewEntity } from 'typeorm';
 })
 export class VHistories {
   @ViewColumn()
-    id: string;
+    id: number;
 
   @ViewColumn()
     lendingCondition: string;

backend/src/v2/histories/controller/controller.ts

@@ -0,0 +1,50 @@
+import { contract } from '@jiphyeonjeon-42/contracts';
+import { P, match } from 'ts-pattern';
+import {
+  UnauthorizedError,
+  HandlerFor,
+  unauthorized,
+} from '../../shared';
+import { HistoriesService } from '../service';
+
+// mkGetMyHistories
+type GetMyDeps = Pick<HistoriesService, 'searchMyHistories'>;
+type MkGetMy = (services: GetMyDeps) => HandlerFor<typeof contract.histories.getMyHistories>;
+export const mkGetMyHistories: MkGetMy = ({ searchMyHistories }) =>
+  async ({
+    query: {
+      query, page, limit, type,
+    },
+  }) => {
+    contract.histories.getMyHistories.query.safeParse({
+      query, page, limit, type,
+    });
+    const result = await searchMyHistories({
+      query, page, limit, type,
+    });
+
+    return match(result)
+      .with(P.instanceOf(UnauthorizedError), () => unauthorized)
+      .otherwise(() => ({
+        status: 200,
+        body: result,
+      } as const));
+  };
+
+// mkGetAllHistories
+type GetAllDeps = Pick<HistoriesService, 'searchAllHistories'>;
+type MkGetAll = (services: GetAllDeps) => HandlerFor<typeof contract.histories.getAllHistories>;
+export const mkGetAllHistories: MkGetAll = ({ searchAllHistories }) => async ({
+  query: { query, page, limit, type },
+}) => {
+  const parsedQuery = contract.histories.getMyHistories.query.parse({
+    query, page, limit, type,
+  });
+  const result = await searchAllHistories(parsedQuery);
+  return match(result)
+    .with(P.instanceOf(UnauthorizedError), () => unauthorized)
+    .otherwise(() => ({
+      status: 200,
+      body: result,
+    } as const));
+};

backend/src/v2/histories/controller/impl.ts

@@ -0,0 +1,9 @@
+import { mkGetMyHistories, mkGetAllHistories } from './controller';
+import {
+  HistoriesService,
+} from '../service';
+
+export const implHistoriesController = (service: HistoriesService) => ({
+  getMyHistories: mkGetMyHistories(service),
+  getAllHistories: mkGetAllHistories(service),
+});

backend/src/v2/histories/controller/index.ts

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

backend/src/v2/histories/impl.ts

@@ -0,0 +1,26 @@
+import { contract } from '@jiphyeonjeon-42/contracts';
+import { initServer } from '@ts-rest/express';
+import jipDataSource from '~/app-data-source';
+import { roleSet } from '~/v1/auth/auth.type';
+import authValidate from '~/v1/auth/auth.validate';
+import { VHistories } from '~/entity/entities/VHistories';
+import { implHistoriesService } from '~/v2/histories/service/impl';
+import { implHistoriesController } from '~/v2/histories/controller/impl';
+
+const service = implHistoriesService({
+  historiesRepo: jipDataSource.getRepository(VHistories),
+});
+
+const handler = implHistoriesController(service);
+
+const s = initServer();
+export const histories = s.router(contract.histories, {
+  getMyHistories: {
+    middleware: [authValidate(roleSet.all)],
+    handler: handler.getMyHistories,
+  },
+  getAllHistories: {
+    middleware: [authValidate(roleSet.librarian)],
+    handler: handler.getAllHistories,
+  },
+});

backend/src/v2/histories/service/impl.ts

@@ -0,0 +1,13 @@
+import { Repository } from 'typeorm';
+import { VHistories } from '~/entity/entities/VHistories';
+
+import {
+  mkSearchHistories,
+} from './service';
+
+export const implHistoriesService = (repos: {
+  historiesRepo: Repository<VHistories>;
+}) => ({
+  searchMyHistories: mkSearchHistories(repos),
+  searchAllHistories: mkSearchHistories(repos),
+});

backend/src/v2/histories/service/index.ts

@@ -0,0 +1,20 @@
+import { VHistories } from '~/entity/entities/VHistories';
+import { Meta, UnauthorizedError } from '~/v2/shared';
+
+type Args = {
+  query?: string | undefined;
+  page: number;
+  limit: number;
+  type?: 'title' | 'user' | 'callsign' | undefined;
+};
+
+export type HistoriesService = {
+  searchMyHistories: (
+    args: Args,
+    ) => Promise<UnauthorizedError | { items: VHistories[], meta: Meta }>;
+  searchAllHistories: (
+    args: Args,
+    ) => Promise<UnauthorizedError | { items: VHistories[], meta: Meta }>;
+  }
+
+export * from './service';

backend/src/v2/histories/service/service.ts

@@ -0,0 +1,68 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { match } from 'ts-pattern';
+
+import { FindOperator, Like, type Repository } from 'typeorm';
+import { VHistories } from '~/entity/entities/VHistories';
+
+import { Meta } from '~/v2/shared';
+import type { HistoriesService } from '.';
+
+// HistoriesService
+
+type Repos = { historiesRepo: Repository<VHistories> };
+
+type MkSearchHistories = (
+  repos: Repos
+) => HistoriesService['searchAllHistories'];
+
+type whereCondition = {
+  login: FindOperator<string>,
+  title: FindOperator<string>,
+  callSign: FindOperator<string>,
+} | [
+  { login: FindOperator<string> },
+  { title: FindOperator<string> },
+  { callSign: FindOperator<string> },
+];
+
+export const mkSearchHistories: MkSearchHistories = ({ historiesRepo }) => async ({
+  query, type, page, limit,
+}): Promise<{ items: VHistories[], meta: Meta }> => {
+  let filterQuery: whereCondition = {
+    login: Like('%%'),
+    title: Like('%%'),
+    callSign: Like('%%'),
+  };
+  if (query !== undefined) {
+    if (type === 'user') {
+      filterQuery.login = Like(`%${query}%`);
+    } else if (type === 'title') {
+      filterQuery.title = Like(`%${query}%`);
+    } else if (type === 'callsign') {
+      filterQuery.callSign = Like(`%${query}%`);
+    } else {
+      filterQuery = [
+        { login: Like(`%${query}%`) },
+        { title: Like(`%${query}%`) },
+        { callSign: Like(`%${query}%`) },
+      ];
+    }
+  }
+  const [items, count] = await historiesRepo.findAndCount({
+    where: filterQuery,
+    take: limit,
+    skip: limit * page,
+  });
+  const meta: Meta = {
+    totalItems: count,
+    itemCount: items.length,
+    itemsPerPage: limit,
+    totalPages: Math.ceil(count / limit),
+    currentPage: page + 1,
+  };
+  const returnObject = {
+    items,
+    meta,
+  };
+  return returnObject;
+};

backend/src/v2/histories/type.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { positiveInt } from '~/v1/reviews/controller/reviews.type';
+
+export type ParsedHistoriesSearchCondition = z.infer<typeof getHistoriesSearchCondition>;
+export const getHistoriesSearchCondition = z.object({
+  query: z.string().optional(),
+  type: z.enum(['user', 'title', 'callsign']).optional(),
+  page: z.number().nonnegative().default(0),
+  limit: z.number().nonnegative().default(10),
+});
+
+export type ParsedHistoriesUserInfo = z.infer<typeof getHistoriesUserInfo>;
+export const getHistoriesUserInfo = z.object({
+  userId: positiveInt,
+  userRole: positiveInt.max(3),
+});

backend/src/v2/routes.ts

@@ -3,8 +3,10 @@ import { contract } from '@jiphyeonjeon-42/contracts';
 import { initServer } from '@ts-rest/express';
 
 import { reviews } from './reviews/impl';
+import { histories } from './histories/impl';
 
 const s = initServer();
 export default s.router(contract, {
   reviews,
+  histories,
 });

backend/src/v2/shared/errors.ts

@@ -5,3 +5,11 @@ export class BookInfoNotFoundError extends Error {
     super(`개별 도서 정보 (id: ${bookInfoId})를 찾을 수 없습니다`);
   }
 }
+
+export class UnauthorizedError extends Error {
+  declare readonly _tag: 'UnauthorizedError';
+
+  constructor() {
+    super('권한이 없습니다');
+  }
+}

backend/src/v2/shared/responses.ts

@@ -1,4 +1,4 @@
-import { bookInfoNotFoundSchema, reviewNotFoundSchema } from '@jiphyeonjeon-42/contracts';
+import { bookInfoNotFoundSchema, reviewNotFoundSchema, unauthorizedSchema } from '@jiphyeonjeon-42/contracts';
 import { z } from 'zod';
 
 export const reviewNotFound = {
@@ -16,3 +16,11 @@ export const bookInfoNotFound = {
     description: '검색한 책이 존재하지 않습니다.',
   } as z.infer<typeof bookInfoNotFoundSchema>,
 } as const;
+
+export const unauthorized = {
+  status: 401,
+  body: {
+    code: 'UNAUTHORIZED',
+    description: '권한이 없습니다.',
+  } as z.infer<typeof unauthorizedSchema>,
+} as const;

backend/src/v2/shared/types.ts

@@ -1,4 +1,14 @@
 import { AppRoute } from '@ts-rest/core';
 import { AppRouteOptions } from '@ts-rest/express';
+import { z } from 'zod';
 
 export type HandlerFor<T extends AppRoute> = AppRouteOptions<T>['handler'];
+
+export type Meta = z.infer<typeof meta>;
+export const meta = z.object({
+  totalItems: z.number().nonnegative(),
+  itemCount: z.number().nonnegative(),
+  itemsPerPage: z.number().nonnegative(),
+  totalPages: z.number().nonnegative(),
+  currentPage: z.number().nonnegative(),
+});

contracts/src/histories/index.ts

@@ -0,0 +1,37 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  historiesGetQuerySchema, historiesGetResponseSchema,
+} from './schema';
+import { unauthorizedSchema } from '../shared';
+
+export * from './schema';
+
+//  contract 를 생성할 때, router 함수를 사용하여 api 를 생성
+const c = initContract();
+
+export const historiesContract = c.router(
+  {
+    getMyHistories: {
+      method: 'GET',
+      path: '/mypage/histories',
+      description: '마이페이지에서 본인의 대출 기록을 가져온다.',
+      query: historiesGetQuerySchema,
+      responses: {
+        200: historiesGetResponseSchema,
+        401: unauthorizedSchema,
+      },
+    },
+    getAllHistories: {
+      method: 'GET',
+      path: '/histories',
+      description: '사서가 전체 대출 기록을 가져온다.',
+      query: historiesGetQuerySchema,
+      responses: {
+        200: historiesGetResponseSchema,
+        401: unauthorizedSchema,
+      },
+    },
+
+  },
+);

contracts/src/histories/schema.ts

@@ -0,0 +1,32 @@
+import { metaSchema, positiveInt } from '../shared';
+import { z } from '../zodWithOpenapi';
+
+export const historiesGetQuerySchema = z.object({
+  query: z.string().optional(),
+  type: z.enum(['user', 'title', 'callsign']).optional(),
+  page: z.number().int().nonnegative().default(0),
+  limit: z.number().int().nonnegative().default(10),
+});
+
+export const historiesGetResponseSchema = z.object({
+  items: z.array(
+    z.object({
+      id: positiveInt,
+      lendingCondition: z.string(),
+      login: z.string(),
+      returningCondition: z.string(),
+      penaltyDays: z.number().int().nonnegative(),
+      callSign: z.string(),
+      title: z.string(),
+      bookInfoId: positiveInt,
+      image: z.string(),
+      createdAt: z.string(),
+      returnedAt: z.string(),
+      updatedAt: z.date(),
+      dueDate: z.string(),
+      lendingLibrarianNickName: z.string(),
+      returningLibrarianNickname: z.string(),
+    }),
+  ),
+  meta: metaSchema,
+});

contracts/src/index.ts

@@ -1,5 +1,6 @@
 import { initContract } from '@ts-rest/core';
 import { reviewsContract } from './reviews';
+import { historiesContract } from './histories';
 import { likesContract } from './likes';
 
 export * from './reviews';
@@ -12,6 +13,8 @@ export const contract = c.router(
   {
     // likes: likesContract,
     reviews: reviewsContract,
+    histories: historiesContract,
+
   },
   {
     pathPrefix: '/api/v2',

contracts/src/shared.ts

@@ -24,3 +24,15 @@ export const mkErrorMessageSchema = <const T extends string>(code: T) =>
 
 export const bookInfoNotFoundSchema =
   mkErrorMessageSchema('BOOK_INFO_NOT_FOUND').describe('해당 도서 연관 정보가 존재하지 않습니다');
+
+export const unauthorizedSchema = mkErrorMessageSchema('UNAUTHORIZED').describe(
+  '권한이 없습니다.',
+);
+
+export const metaSchema = z.object({
+  totalItems: positiveInt,
+  itemCount: positiveInt,
+  itemsPerPage: positiveInt,
+  totalPages: positiveInt,
+  currentPage: positiveInt,
+});