ai-spec-dev 0.42.0 → 0.46.0

package/demo-backend/src/controllers/bookmark.controller.test.ts

@@ -1,255 +0,0 @@
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
-import { Request, Response, NextFunction } from 'express';
-import {
-  getBookmarks,
-  createBookmark,
-  updateBookmark,
-  deleteBookmark,
-} from '../bookmark.controller';
-import * as bookmarkService from '../../services/bookmark.service';
-import { AppError } from '../../middleware/error.middleware';
-
-vi.mock('../../services/bookmark.service');
-
-const mockedBookmarkService = vi.mocked(bookmarkService);
-
-describe('Bookmark Controller', () => {
-  let mockRequest: Partial<Request>;
-  let mockResponse: Partial<Response>;
-  let mockNext: NextFunction;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockResponse = {
-      status: vi.fn().mockReturnThis(),
-      json: vi.fn().mockReturnThis(),
-      send: vi.fn().mockReturnThis(),
-    };
-    mockNext = vi.fn();
-  });
-
-  describe('getBookmarks', () => {
-    it('should return 200 with paginated bookmarks', async () => {
-      const mockBookmarks = [
-        {
-          id: '1',
-          title: 'Test',
-          url: 'https://test.com',
-          tags: ['test'],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        },
-      ];
-      const mockTotal = 1;
-
-      mockRequest = {
-        query: { limit: '10', offset: '0' },
-      };
-
-      mockedBookmarkService.getBookmarks.mockResolvedValue({
-        bookmarks: mockBookmarks,
-        total: mockTotal,
-      });
-
-      await getBookmarks(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockedBookmarkService.getBookmarks).toHaveBeenCalledWith(10, 0);
-      expect(mockResponse.status).toHaveBeenCalledWith(200);
-      expect(mockResponse.json).toHaveBeenCalledWith({
-        code: 200,
-        message: 'success',
-        data: {
-          bookmarks: mockBookmarks,
-          total: mockTotal,
-        },
-      });
-    });
-
-    it('should call next with error when service throws', async () => {
-      const mockError = new AppError('Database error', 500, 'INTERNAL_ERROR');
-      mockRequest = {
-        query: {},
-      };
-
-      mockedBookmarkService.getBookmarks.mockRejectedValue(mockError);
-
-      await getBookmarks(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockNext).toHaveBeenCalledWith(mockError);
-    });
-  });
-
-  describe('createBookmark', () => {
-    it('should return 201 with created bookmark', async () => {
-      const mockBookmark = {
-        id: '1',
-        title: 'Test',
-        url: 'https://test.com',
-        tags: ['test'],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      mockRequest = {
-        body: {
-          title: 'Test',
-          url: 'https://test.com',
-          tags: ['test'],
-        },
-      };
-
-      mockedBookmarkService.createBookmark.mockResolvedValue(mockBookmark);
-
-      await createBookmark(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockedBookmarkService.createBookmark).toHaveBeenCalledWith({
-        title: 'Test',
-        url: 'https://test.com',
-        tags: ['test'],
-      });
-      expect(mockResponse.status).toHaveBeenCalledWith(201);
-      expect(mockResponse.json).toHaveBeenCalledWith({
-        code: 201,
-        message: 'success',
-        data: mockBookmark,
-      });
-    });
-
-    it('should call next with validation error for invalid URL', async () => {
-      const mockError = new AppError(
-        'Validation failed: "url" must be a valid URL',
-        400,
-        'VALIDATION_ERROR'
-      );
-      mockRequest = {
-        body: {
-          title: 'Test',
-          url: 'invalid-url',
-        },
-      };
-
-      mockedBookmarkService.createBookmark.mockRejectedValue(mockError);
-
-      await createBookmark(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockNext).toHaveBeenCalledWith(mockError);
-    });
-  });
-
-  describe('updateBookmark', () => {
-    it('should return 200 with updated bookmark', async () => {
-      const mockBookmark = {
-        id: '1',
-        title: 'Updated',
-        url: 'https://updated.com',
-        tags: ['updated'],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      mockRequest = {
-        params: { id: '1' },
-        body: {
-          title: 'Updated',
-          url: 'https://updated.com',
-          tags: ['updated'],
-        },
-      };
-
-      mockedBookmarkService.updateBookmark.mockResolvedValue(mockBookmark);
-
-      await updateBookmark(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockedBookmarkService.updateBookmark).toHaveBeenCalledWith('1', {
-        title: 'Updated',
-        url: 'https://updated.com',
-        tags: ['updated'],
-      });
-      expect(mockResponse.status).toHaveBeenCalledWith(200);
-      expect(mockResponse.json).toHaveBeenCalledWith({
-        code: 200,
-        message: 'success',
-        data: mockBookmark,
-      });
-    });
-
-    it('should call next with 404 when bookmark not found', async () => {
-      const mockError = new AppError('Bookmark not found', 404, 'NOT_FOUND');
-      mockRequest = {
-        params: { id: 'non-existent-id' },
-        body: {
-          title: 'Updated',
-          url: 'https://updated.com',
-          tags: [],
-        },
-      };
-
-      mockedBookmarkService.updateBookmark.mockRejectedValue(mockError);
-
-      await updateBookmark(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockNext).toHaveBeenCalledWith(mockError);
-    });
-  });
-
-  describe('deleteBookmark', () => {
-    it('should return 204 with no content', async () => {
-      mockRequest = {
-        params: { id: '1' },
-      };
-
-      mockedBookmarkService.deleteBookmark.mockResolvedValue(undefined);
-
-      await deleteBookmark(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockedBookmarkService.deleteBookmark).toHaveBeenCalledWith('1');
-      expect(mockResponse.status).toHaveBeenCalledWith(204);
-      expect(mockResponse.send).toHaveBeenCalled();
-    });
-
-    it('should call next with 404 when bookmark not found', async () => {
-      const mockError = new AppError('Bookmark not found', 404, 'NOT_FOUND');
-      mockRequest = {
-        params: { id: 'non-existent-id' },
-      };
-
-      mockedBookmarkService.deleteBookmark.mockRejectedValue(mockError);
-
-      await deleteBookmark(
-        mockRequest as Request,
-        mockResponse as Response,
-        mockNext
-      );
-
-      expect(mockNext).toHaveBeenCalledWith(mockError);
-    });
-  });
-});

package/demo-backend/src/controllers/bookmark.controller.ts

@@ -1,187 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import { AppError } from '../middleware/error.middleware';
-import * as bookmarkService from '../services/bookmark.service';
-
-interface BookmarkQueryParams {
-  limit?: string;
-  offset?: string;
-}
-
-interface CreateBookmarkBody {
-  title?: string;
-  url?: string;
-  tags?: string[];
-}
-
-interface UpdateBookmarkBody {
-  title?: string;
-  url?: string;
-  tags?: string[];
-}
-
-interface BookmarkParams {
-  id?: string;
-}
-
-export class BookmarkController {
-  static async getBookmarks(
-    req: Request<{}, {}, {}, BookmarkQueryParams>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { limit: limitStr, offset: offsetStr } = req.query;
-      
-      const limit = limitStr ? parseInt(limitStr, 10) : 20;
-      const offset = offsetStr ? parseInt(offsetStr, 10) : 0;
-      
-      if (isNaN(limit) || limit <= 0) {
-        throw new AppError(400, '"limit" must be a positive integer');
-      }
-      
-      if (isNaN(offset) || offset < 0) {
-        throw new AppError(400, '"offset" must be a non-negative integer');
-      }
-      
-      const result = await bookmarkService.getBookmarks(limit, offset);
-      
-      res.status(200).json({
-        code: 200,
-        message: 'success',
-        data: {
-          bookmarks: result.bookmarks,
-          total: result.total
-        }
-      });
-    } catch (error) {
-      next(error);
-    }
-  }
-  
-  static async createBookmark(
-    req: Request<{}, {}, CreateBookmarkBody>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { title, url, tags } = req.body;
-      
-      if (!title || typeof title !== 'string' || title.trim() === '') {
-        throw new AppError(400, '"title" is required and must be a non-empty string');
-      }
-      
-      if (!url || typeof url !== 'string') {
-        throw new AppError(400, '"url" is required and must be a string');
-      }
-      
-      try {
-        new URL(url);
-      } catch {
-        throw new AppError(400, '"url" must be a valid URL');
-      }
-      
-      if (tags !== undefined && !Array.isArray(tags)) {
-        throw new AppError(400, '"tags" must be an array of strings');
-      }
-      
-      if (tags && !tags.every(tag => typeof tag === 'string')) {
-        throw new AppError(400, '"tags" must be an array of strings');
-      }
-      
-      const bookmark = await bookmarkService.createBookmark({
-        title: title.trim(),
-        url: url.trim(),
-        tags: tags || []
-      });
-      
-      res.status(201).json({
-        code: 201,
-        message: 'success',
-        data: bookmark
-      });
-    } catch (error) {
-      next(error);
-    }
-  }
-  
-  static async updateBookmark(
-    req: Request<BookmarkParams, {}, UpdateBookmarkBody>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { id } = req.params;
-      const { title, url, tags } = req.body;
-      
-      if (!id) {
-        throw new AppError(400, '"id" parameter is required');
-      }
-      
-      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-      if (!uuidRegex.test(id)) {
-        throw new AppError(400, '"id" must be a valid UUID');
-      }
-      
-      if (!title || typeof title !== 'string' || title.trim() === '') {
-        throw new AppError(400, '"title" is required and must be a non-empty string');
-      }
-      
-      if (!url || typeof url !== 'string') {
-        throw new AppError(400, '"url" is required and must be a string');
-      }
-      
-      try {
-        new URL(url);
-      } catch {
-        throw new AppError(400, '"url" must be a valid URL');
-      }
-      
-      if (!tags || !Array.isArray(tags)) {
-        throw new AppError(400, '"tags" is required and must be an array of strings');
-      }
-      
-      if (!tags.every(tag => typeof tag === 'string')) {
-        throw new AppError(400, '"tags" must be an array of strings');
-      }
-      
-      const bookmark = await bookmarkService.updateBookmark(id, {
-        title: title.trim(),
-        url: url.trim(),
-        tags
-      });
-      
-      res.status(200).json({
-        code: 200,
-        message: 'success',
-        data: bookmark
-      });
-    } catch (error) {
-      next(error);
-    }
-  }
-  
-  static async deleteBookmark(
-    req: Request<BookmarkParams>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { id } = req.params;
-      
-      if (!id) {
-        throw new AppError(400, '"id" parameter is required');
-      }
-      
-      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-      if (!uuidRegex.test(id)) {
-        throw new AppError(400, '"id" must be a valid UUID');
-      }
-      
-      await bookmarkService.deleteBookmark(id);
-      
-      res.status(204).send();
-    } catch (error) {
-      next(error);
-    }
-  }
-}

package/demo-backend/src/index.ts

@@ -1,17 +0,0 @@
-import express from "express";
-import cors from "cors";
-
-const app = express();
-app.use(cors());
-app.use(express.json());
-
-app.get("/health", (_req, res) => {
-  res.json({ status: "ok" });
-});
-
-const PORT = process.env.PORT || 3001;
-app.listen(PORT, () => {
-  console.log(`Server running on http://localhost:${PORT}`);
-});
-
-export default app;