typescript-express-starter 10.2.1 → 11.0.0

package/devtools/jest/src/test/unit/services/users.service.spec.ts

@@ -0,0 +1,109 @@
+import { User, type UserCreateData } from '@entities/user.entity';
+import { UsersRepository } from '@repositories/users.repository';
+import { UsersService } from '@services/users.service';
+
+describe('UsersService (with UsersRepository)', () => {
+  let usersService: UsersService;
+  let userRepo: UsersRepository;
+
+  beforeEach(async () => {
+    userRepo = new UsersRepository();
+    userRepo.reset();
+
+    // Create test users using Entity
+    const user1 = await User.create({
+      email: 'one@example.com',
+      password: 'password1',
+    });
+    const user2 = await User.create({
+      email: 'two@example.com',
+      password: 'password2',
+    });
+
+    await userRepo.save(user1);
+    await userRepo.save(user2);
+    usersService = new UsersService(userRepo);
+  });
+
+  it('getAllUsers: should return all users', async () => {
+    const users = await usersService.getAllUsers();
+    expect(users.length).toBe(2);
+    expect(users.map((u) => u.email)).toContain('one@example.com');
+    expect(users.map((u) => u.email)).toContain('two@example.com');
+  });
+
+  it('getUserById: should return user by ID', async () => {
+    const users = await usersService.getAllUsers();
+    const targetUser = users.find((u) => u.email === 'two@example.com');
+    expect(targetUser).toBeDefined();
+
+    const user = await usersService.getUserById(targetUser!.id);
+    expect(user.email).toBe('two@example.com');
+  });
+
+  it('getUserById: should throw if ID does not exist', async () => {
+    await expect(usersService.getUserById('999')).rejects.toThrow(/not found/);
+  });
+
+  it('createUser: should add a new user', async () => {
+    const userData: UserCreateData = {
+      email: 'new@example.com',
+      password: 'newpass3',
+    };
+
+    const created = await usersService.createUser(userData);
+    expect(created.email).toBe('new@example.com');
+    const all = await usersService.getAllUsers();
+    expect(all.length).toBe(3);
+  });
+
+  it('createUser: should throw if email already exists', async () => {
+    const userData: UserCreateData = {
+      email: 'one@example.com', // already exists
+      password: 'password9',
+    };
+
+    await expect(usersService.createUser(userData)).rejects.toThrow(/exists/);
+  });
+
+  it('updateUser: should update user password', async () => {
+    const users = await usersService.getAllUsers();
+    const targetUser = users.find((u) => u.email === 'two@example.com');
+    expect(targetUser).toBeDefined();
+
+    const updateData = {
+      email: 'updated@example.com',
+      password: 'newpass1',
+    };
+
+    const updated = await usersService.updateUser(targetUser!.id, updateData);
+    expect(updated).toBeDefined();
+    expect(updated.email).toBe('updated@example.com');
+  });
+
+  it('updateUser: should throw if ID does not exist', async () => {
+    const updateData = {
+      email: 'no@no.com',
+      password: 'nopass12',
+    };
+
+    await expect(usersService.updateUser('nonexistent-id', updateData)).rejects.toThrow(
+      /not found/,
+    );
+  });
+
+  it('deleteUser: should delete user successfully', async () => {
+    const users = await usersService.getAllUsers();
+    const userToDelete = users.find((u) => u.email === 'one@example.com');
+    expect(userToDelete).toBeDefined();
+
+    await usersService.deleteUser(userToDelete!.id);
+    const remaining = await usersService.getAllUsers();
+    expect(remaining.length).toBe(1);
+    expect(remaining.find((u) => u.id === userToDelete!.id)).toBeUndefined();
+  });
+
+  it('deleteUser: should throw if ID does not exist', async () => {
+    await expect(usersService.deleteUser('nonexistent-id')).rejects.toThrow(/not found/);
+  });
+});

package/devtools/oxlint/.oxlintrc.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "ignorePatterns": [
+    "node_modules/**",
+    "dist/**",
+    "build/**",
+    "coverage/**",
+    "logs/**",
+    "*.config.js",
+    "*.config.ts",
+    ".env",
+    ".env.*",
+    "!.eslintrc.js"
+  ],
+  "env": {
+    "node": true,
+    "es2022": true
+  },
+  "plugins": [
+    "typescript",
+    "unicorn",
+    "oxc",
+    "import",
+    "node",
+    "promise"
+  ],
+  "categories": {
+    "correctness": "error",
+    "suspicious": "warn",
+    "style": "off"
+  },
+  "rules": {
+    "eqeqeq": "warn"
+  },
+  "overrides": [
+    {
+      "files": [
+        "**/*.ts",
+        "**/*.tsx"
+      ],
+      "rules": {
+        "typescript/no-explicit-any": "off",
+        "typescript/explicit-module-boundary-types": "off",
+        "typescript/ban-types": "off",
+        "typescript/no-var-requires": "off"
+      }
+    },
+    {
+      "files": [
+        "**/*.{spec,test}.ts"
+      ],
+      "rules": {
+        "no-console": "off"
+      }
+    }
+  ]
+}

package/devtools/pm2/ecosystem.config.js

@@ -0,0 +1,59 @@
+module.exports = {
+  apps: [
+    // --- PRODUCTION ---
+    {
+      name: 'prod',
+      script: 'dist/server.js',
+      exec_mode: 'cluster',
+      instances: 'max',
+      autorestart: true,
+      watch: false,
+      max_memory_restart: '1G',
+      output: './logs/access.log',
+      error: './logs/error.log',
+      merge_logs: true,
+      time: true, // 로그에 타임스탬프
+      log_date_format: 'YYYY-MM-DD HH:mm:ss.SSS',
+      node_args: '--enable-source-maps', // 소스맵 스택트레이스
+      env: {
+        PORT: 3000,
+        NODE_ENV: 'production',
+      },
+      // env_production: { ... } // 필요 시 분리도 가능
+    },
+
+    // --- DEVELOPMENT ---
+    {
+      name: 'dev',
+      script: 'src/server.ts',
+      interpreter: 'node',
+      node_args: '-r ts-node/register -r tsconfig-paths/register --enable-source-maps',
+      exec_mode: 'fork',
+      instances: 1,
+      autorestart: true,
+      watch: ['src'],
+      watch_delay: 300, // 저장 폭주 시 완충
+      ignore_watch: ['node_modules', 'logs', 'dist'],
+      max_memory_restart: '1G',
+      output: './logs/access.log',
+      error: './logs/error.log',
+      merge_logs: true,
+      time: true,
+      env: {
+        PORT: 3000,
+        NODE_ENV: 'development',
+      },
+    },
+  ],
+
+  deploy: {
+    production: {
+      user: 'user',
+      host: '0.0.0.0',
+      ref: 'origin/master',
+      repo: 'git@github.com:repo.git',
+      path: '/home/user/app',
+      'post-deploy': 'npm install && npm run build && pm2 reload ecosystem.config.js --env production',
+    },
+  },
+};

package/devtools/swagger/swagger.yaml

@@ -0,0 +1,124 @@
+openapi: 3.0.0
+info:
+  title: Express Typescript API
+  description: User API Docs
+  version: "1.0.0"
+schemes:
+  - https
+  - http
+tags:
+  - name: users
+    description: users API
+paths:
+  /users:
+    get:
+      tags: [users]
+      summary: Find All Users
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/User'
+        500:
+          description: Server Error
+    post:
+      tags: [users]
+      summary: Add User
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/User'
+      responses:
+        201:
+          description: Created
+        400:
+          description: Bad Request
+        409:
+          description: Conflict
+        500:
+          description: Server Error
+  /users/{id}:
+    get:
+      tags: [users]
+      summary: Find User By Id
+      parameters:
+        - name: id
+          in: path
+          description: User Id
+          required: true
+          schema:
+            type: string
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+        404:
+          description: Not Found
+        500:
+          description: Server Error
+    put:
+      tags: [users]
+      summary: Update User By Id
+      parameters:
+        - name: id
+          in: path
+          description: user Id
+          required: true
+          schema:
+            type: string
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/User'
+      responses:
+        200:
+          description: OK
+        400:
+          description: Bad Request
+        409:
+          description: Conflict
+        500:
+          description: Server Error
+    delete:
+      tags: [users]
+      summary: Delete User By Id
+      parameters:
+        - name: id
+          in: path
+          description: user Id
+          required: true
+          schema:
+            type: string
+      responses:
+        204:
+          description: No Content
+        404:
+          description: Not Found
+        500:
+          description: Server Error
+
+components:
+  schemas:
+    User:
+      type: object
+      required:
+        - email
+        - password
+      properties:
+        id:
+          type: string
+        email:
+          type: string
+        password:
+          type: string

package/{lib/prisma → devtools/swc}/.swcrc

@@ -21,12 +21,13 @@
     "baseUrl": "src",
     "paths": {
       "@/*": ["*"],
-      "@config": ["config"],
+      "@config/*": ["config/*"],
       "@controllers/*": ["controllers/*"],
       "@dtos/*": ["dtos/*"],
       "@exceptions/*": ["exceptions/*"],
       "@interfaces/*": ["interfaces/*"],
       "@middlewares/*": ["middlewares/*"],
+      "@repositories/*": ["repositories/*"],
       "@routes/*": ["routes/*"],
       "@services/*": ["services/*"],
       "@utils/*": ["utils/*"]

package/devtools/tsup/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/server.ts'], // CLI 등 추가시 여러 entry도 가능
+  outDir: 'dist', // 출력 디렉토리
+  format: ['cjs'], // 필요시 'esm'도 ['cjs', 'esm']
+  dts: true, // 타입 선언 파일(.d.ts) 생성
+  sourcemap: true, // 소스맵 생성
+  clean: true, // 빌드 전 dist 폴더 정리
+  target: 'es2020', // 트랜스파일 대상
+  minify: false, // JS 파일을 압축(minify) 해서 더 작게 만듭니다.
+  treeshake: true, //사용하지 않는 코드를 제거합니다. 기본은 true지만 명시
+  // alias, swc 옵션은 tsconfig.json 기준으로 자동 적용
+  // external: [], // node_modules 제외하고 싶을 때
+});

package/devtools/vitest/src/test/e2e/auth.e2e.spec.ts

@@ -0,0 +1,41 @@
+import request from 'supertest';
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { createTestApp, resetUserDB } from '@/test/setup';
+
+describe('Auth API', () => {
+  let server: any;
+  const prefix = '/api/v1';
+
+  beforeAll(() => {
+    server = createTestApp(); // Use shared repository for testing
+  });
+
+  beforeEach(() => {
+    resetUserDB(); // Reset repository before each test
+  });
+
+  const user = { email: 'authuser@example.com', password: 'authpassword123' };
+
+  it('should successfully register a new user', async () => {
+    const res = await request(server).post(`${prefix}/auth/signup`).send(user);
+    expect(res.statusCode).toBe(201);
+    expect(res.body.data.email).toBe(user.email);
+  });
+
+  it('should login a user and set a cookie', async () => {
+    await request(server).post(`${prefix}/auth/signup`).send(user);
+    const res = await request(server).post(`${prefix}/auth/login`).send(user);
+    expect(res.statusCode).toBe(200);
+    expect(res.body.data.email).toBe(user.email);
+    expect(res.header['set-cookie']).toBeDefined();
+  });
+
+  it('should logout a user', async () => {
+    await request(server).post(`${prefix}/auth/signup`).send(user);
+    const loginRes = await request(server).post(`${prefix}/auth/login`).send(user);
+    const cookie = loginRes.headers['set-cookie'];
+    const logoutRes = await request(server).post(`${prefix}/auth/logout`).set('Cookie', cookie[0]);
+    expect(logoutRes.statusCode).toBe(200);
+    expect(logoutRes.body.message).toBe('logout');
+  });
+});

package/devtools/vitest/src/test/e2e/users.e2e.spec.ts

@@ -0,0 +1,64 @@
+import request from 'supertest';
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { createTestApp, resetUserDB } from '@/test/setup';
+
+describe('Users API', () => {
+  let server: any;
+  const prefix = '/api/v1';
+
+  beforeAll(() => {
+    server = createTestApp(); // Initialize server with shared repository
+  });
+
+  beforeEach(() => {
+    resetUserDB(); // Reset repository before each test
+  });
+
+  const user = { email: 'user1@example.com', password: 'password123' };
+
+  it('should create a new user', async () => {
+    const res = await request(server).post(`${prefix}/users`).send(user);
+    expect(res.statusCode).toBe(201);
+    expect(res.body.data.email).toBe(user.email);
+  });
+
+  it('should retrieve all users', async () => {
+    await request(server).post(`${prefix}/users`).send(user);
+    const res = await request(server).get(`${prefix}/users`);
+    expect(res.statusCode).toBe(200);
+    expect(Array.isArray(res.body.data)).toBe(true);
+    expect(res.body.data[0].email).toBe(user.email);
+  });
+
+  it('should retrieve a user by id', async () => {
+    const createRes = await request(server).post(`${prefix}/users`).send(user);
+    const id = createRes.body.data.id;
+
+    const res = await request(server).get(`${prefix}/users/${id}`);
+    expect(res.statusCode).toBe(200);
+    expect(res.body.data.email).toBe(user.email);
+  });
+
+  it('should update user information', async () => {
+    const createRes = await request(server).post(`${prefix}/users`).send(user);
+    const id = createRes.body.data.id;
+
+    const newPassword = 'newpassword123';
+    const res = await request(server).put(`${prefix}/users/${id}`).send({ password: newPassword });
+    expect(res.statusCode).toBe(200);
+    expect(res.body.data.id).toBe(id);
+  });
+
+  it('should delete a user', async () => {
+    const createRes = await request(server).post(`${prefix}/users`).send(user);
+    const id = createRes.body.data.id;
+
+    const res = await request(server).delete(`${prefix}/users/${id}`);
+    expect(res.statusCode).toBe(204);
+  });
+
+  it('should return 404 if user does not exist', async () => {
+    const res = await request(server).get(`${prefix}/users/invalid-id`);
+    expect(res.statusCode).toBe(404);
+  });
+});

package/devtools/vitest/src/test/setup.ts

@@ -0,0 +1,31 @@
+import 'reflect-metadata';
+import { container } from 'tsyringe';
+import App from '@/app';
+import { AuthRoute } from '@routes/auth.route';
+import { UsersRoute } from '@routes/users.route';
+import { UsersRepository, IUsersRepository } from '@repositories/users.repository';
+
+let sharedRepo: UsersRepository;
+
+export function createTestApp({ mockRepo }: { mockRepo?: IUsersRepository } = {}) {
+  // 항상 새로운 인스턴스를 주입하고 싶으면 reset logic 추가 필요
+  if (!sharedRepo) {
+    sharedRepo = new UsersRepository();
+    container.registerInstance(UsersRepository, sharedRepo);
+  }
+  // mockRepo가 있으면 주입
+  if (mockRepo) {
+    container.registerInstance(UsersRepository, mockRepo as UsersRepository);
+  }
+
+  // 클래스 타입을 직접 주입
+  const routes = [container.resolve(UsersRoute), container.resolve(AuthRoute)];
+  const appInstance = new App(routes);
+  return appInstance.getServer();
+}
+
+export function resetUserDB() {
+  if (sharedRepo) {
+    sharedRepo.reset();
+  }
+}

package/devtools/vitest/src/test/unit/services/auth.service.spec.ts

@@ -0,0 +1,70 @@
+import { compare, hash } from 'bcryptjs';
+import { describe, it, expect, beforeEach } from 'vitest';
+import { CreateUserDto } from '@dtos/users.dto';
+import { User } from '@interfaces/users.interface';
+import { UsersRepository } from '@repositories/users.repository';
+import { AuthService } from '@services/auth.service';
+
+describe('AuthService (with UserMemoryRepository)', () => {
+  let authService: AuthService;
+  let userRepo: UsersRepository;
+  const testUser: User = {
+    id: '1',
+    email: 'authuser@example.com',
+    password: '', // will be replaced with actual hash
+  };
+
+  beforeEach(async () => {
+    userRepo = new UsersRepository();
+    testUser.password = await hash('plainpw', 10);
+    // Add initial user
+    await userRepo.save({ ...testUser });
+    authService = new AuthService(userRepo); // inject repo
+  });
+
+  it('should sign up a new user', async () => {
+    const dto: CreateUserDto = {
+      email: 'newuser@example.com',
+      password: 'newpassword123',
+    };
+    const created = await authService.signup(dto);
+    expect(created.email).toBe(dto.email);
+
+    const found = await userRepo.findByEmail(dto.email);
+    expect(found).toBeDefined();
+    expect(await compare(dto.password, found!.password)).toBe(true);
+  });
+
+  it('should throw an error if email is already in use', async () => {
+    const dto: CreateUserDto = {
+      email: testUser.email,
+      password: 'anypw',
+    };
+    await expect(authService.signup(dto)).rejects.toThrow(/already in use/);
+  });
+
+  it('should return user and cookie on successful login', async () => {
+    // Create user with hashed password
+    const plainPassword = 'mySecret123';
+    const email = 'loginuser@example.com';
+    const hashed = await hash(plainPassword, 10);
+    await userRepo.save({ id: '2', email, password: hashed });
+
+    const result = await authService.login({ email, password: plainPassword });
+    expect(result.user.email).toBe(email);
+    expect(result.cookie).toContain('Authorization=');
+  });
+
+  it('should throw an error if email or password is incorrect', async () => {
+    // Non-existing email
+    await expect(authService.login({ email: 'nobody@example.com', password: 'xxx' })).rejects.toThrow(/Invalid email or password/i);
+
+    // Incorrect password
+    const email = testUser.email;
+    await expect(authService.login({ email, password: 'wrongpw' })).rejects.toThrow(/password/i);
+  });
+
+  it('should successfully logout without errors', async () => {
+    await expect(authService.logout(testUser)).resolves.toBeUndefined();
+  });
+});

package/devtools/vitest/src/test/unit/services/users.service.spec.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { User } from '@interfaces/users.interface';
+import { UsersRepository } from '@repositories/users.repository';
+import { UsersService } from '@services/users.service';
+
+describe('UsersService (with UsersRepository)', () => {
+  let usersService: UsersService;
+  let userRepo: UsersRepository;
+
+  // Sample user data
+  const user1: User & { id: string } = { id: '1', email: 'one@example.com', password: 'pw1' };
+  const user2: User & { id: string } = { id: '2', email: 'two@example.com', password: 'pw2' };
+
+  beforeEach(async () => {
+    userRepo = new UsersRepository();
+    userRepo.reset();
+    // Directly save users (save is async but await is optional for init)
+    await userRepo.save({ ...user1 });
+    await userRepo.save({ ...user2 });
+    usersService = new UsersService(userRepo);
+  });
+
+  it('getAllUsers: should return all users', async () => {
+    const users = await usersService.getAllUsers();
+    expect(users.length).toBe(2);
+    expect(users[0].email).toBe(user1.email);
+  });
+
+  it('getUserById: should return user by ID', async () => {
+    const user = await usersService.getUserById('2');
+    expect(user.email).toBe(user2.email);
+  });
+
+  it('getUserById: should throw if ID does not exist', async () => {
+    await expect(usersService.getUserById('999')).rejects.toThrow(/not found/);
+  });
+
+  it('createUser: should add a new user', async () => {
+    const created = await usersService.createUser({
+      id: '', // ignored
+      email: 'new@example.com',
+      password: 'pw3',
+    });
+    expect(created.email).toBe('new@example.com');
+    const all = await usersService.getAllUsers();
+    expect(all.length).toBe(3);
+  });
+
+  it('createUser: should throw if email already exists', async () => {
+    await expect(
+      usersService.createUser({
+        id: '',
+        email: user1.email,
+        password: 'pwX',
+      }),
+    ).rejects.toThrow(/exists/);
+  });
+
+  it('updateUser: should update user password', async () => {
+    const newPassword = 'newpw';
+    const updated = await usersService.updateUser(user2.id as string, {
+      id: user2.id as string,
+      email: user2.email,
+      password: newPassword,
+    });
+    expect(updated).toBeDefined();
+    expect(updated!.password).not.toBe(user2.password); // changed to hashed value
+  });
+
+  it('updateUser: should throw if ID does not exist', async () => {
+    await expect(
+      usersService.updateUser('999', {
+        id: '999',
+        email: 'no@no.com',
+        password: 'no',
+      }),
+    ).rejects.toThrow(/not found/);
+  });
+
+  it('deleteUser: should delete user successfully', async () => {
+    await usersService.deleteUser(user1.id as string);
+    const users = await usersService.getAllUsers();
+    expect(users.length).toBe(1);
+    expect(users[0].id).toBe(user2.id);
+  });
+
+  it('deleteUser: should throw if ID does not exist', async () => {
+    await expect(usersService.deleteUser('999')).rejects.toThrow(/not found/);
+  });
+});