ai-spec-dev 0.42.0 → 0.55.0

package/demo-backend/src/services/bookmark.service.test.ts

@@ -1,433 +0,0 @@
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
-import { BookmarkService } from './bookmark.service';
-import { AppError } from '../../middleware/error.middleware';
-
-const mockPrisma = {
-  bookmark: {
-    findMany: vi.fn(),
-    count: vi.fn(),
-    create: vi.fn(),
-    update: vi.fn(),
-    delete: vi.fn(),
-  },
-};
-
-vi.mock('@prisma/client', () => ({
-  PrismaClient: vi.fn(() => mockPrisma),
-}));
-
-describe('BookmarkService', () => {
-  let service: BookmarkService;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    service = new BookmarkService();
-  });
-
-  describe('getBookmarks', () => {
-    it('should return paginated bookmarks with default parameters', async () => {
-      const mockBookmarks = [
-        {
-          id: '550e8400-e29b-41d4-a716-446655440000',
-          title: 'Example Domain',
-          url: 'https://example.com',
-          tags: ['example', 'test'],
-          createdAt: new Date('2023-10-27T10:00:00.000Z'),
-          updatedAt: new Date('2023-10-27T10:00:00.000Z'),
-        },
-      ];
-      const mockTotal = 10;
-
-      mockPrisma.bookmark.findMany.mockResolvedValue(mockBookmarks);
-      mockPrisma.bookmark.count.mockResolvedValue(mockTotal);
-
-      const result = await service.getBookmarks({});
-
-      expect(mockPrisma.bookmark.findMany).toHaveBeenCalledWith({
-        skip: 0,
-        take: 20,
-        orderBy: { createdAt: 'desc' },
-      });
-      expect(mockPrisma.bookmark.count).toHaveBeenCalled();
-      expect(result).toEqual({
-        bookmarks: mockBookmarks,
-        total: mockTotal,
-      });
-    });
-
-    it('should return paginated bookmarks with custom parameters', async () => {
-      const mockBookmarks = [
-        {
-          id: '550e8400-e29b-41d4-a716-446655440000',
-          title: 'Example Domain',
-          url: 'https://example.com',
-          tags: ['example', 'test'],
-          createdAt: new Date('2023-10-27T10:00:00.000Z'),
-          updatedAt: new Date('2023-10-27T10:00:00.000Z'),
-        },
-      ];
-      const mockTotal = 10;
-
-      mockPrisma.bookmark.findMany.mockResolvedValue(mockBookmarks);
-      mockPrisma.bookmark.count.mockResolvedValue(mockTotal);
-
-      const result = await service.getBookmarks({ limit: 5, offset: 10 });
-
-      expect(mockPrisma.bookmark.findMany).toHaveBeenCalledWith({
-        skip: 10,
-        take: 5,
-        orderBy: { createdAt: 'desc' },
-      });
-      expect(mockPrisma.bookmark.count).toHaveBeenCalled();
-      expect(result).toEqual({
-        bookmarks: mockBookmarks,
-        total: mockTotal,
-      });
-    });
-
-    it('should handle database errors', async () => {
-      const dbError = new Error('Database connection failed');
-      mockPrisma.bookmark.findMany.mockRejectedValue(dbError);
-
-      await expect(service.getBookmarks({})).rejects.toThrow(AppError);
-      await expect(service.getBookmarks({})).rejects.toMatchObject({
-        code: 500,
-        message: 'Failed to retrieve bookmarks',
-      });
-    });
-  });
-
-  describe('createBookmark', () => {
-    it('should create a bookmark with valid data', async () => {
-      const input = {
-        title: 'GitHub',
-        url: 'https://github.com',
-        tags: ['code', 'repository'],
-      };
-
-      const createdBookmark = {
-        id: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
-        ...input,
-        createdAt: new Date('2023-10-27T11:00:00.000Z'),
-        updatedAt: new Date('2023-10-27T11:00:00.000Z'),
-      };
-
-      mockPrisma.bookmark.create.mockResolvedValue(createdBookmark);
-
-      const result = await service.createBookmark(input);
-
-      expect(mockPrisma.bookmark.create).toHaveBeenCalledWith({
-        data: {
-          title: input.title,
-          url: input.url,
-          tags: input.tags,
-        },
-      });
-      expect(result).toEqual(createdBookmark);
-    });
-
-    it('should create a bookmark without tags', async () => {
-      const input = {
-        title: 'GitHub',
-        url: 'https://github.com',
-      };
-
-      const createdBookmark = {
-        id: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
-        title: input.title,
-        url: input.url,
-        tags: [],
-        createdAt: new Date('2023-10-27T11:00:00.000Z'),
-        updatedAt: new Date('2023-10-27T11:00:00.000Z'),
-      };
-
-      mockPrisma.bookmark.create.mockResolvedValue(createdBookmark);
-
-      const result = await service.createBookmark(input);
-
-      expect(mockPrisma.bookmark.create).toHaveBeenCalledWith({
-        data: {
-          title: input.title,
-          url: input.url,
-          tags: [],
-        },
-      });
-      expect(result).toEqual(createdBookmark);
-    });
-
-    it('should throw validation error for empty title', async () => {
-      const input = {
-        title: '',
-        url: 'https://github.com',
-      };
-
-      await expect(service.createBookmark(input)).rejects.toThrow(AppError);
-      await expect(service.createBookmark(input)).rejects.toMatchObject({
-        code: 400,
-        message: 'Validation failed: "title" is not allowed to be empty',
-      });
-    });
-
-    it('should throw validation error for missing title', async () => {
-      const input = {
-        url: 'https://github.com',
-      };
-
-      await expect(
-        service.createBookmark(input as { title: string; url: string })
-      ).rejects.toThrow(AppError);
-      await expect(
-        service.createBookmark(input as { title: string; url: string })
-      ).rejects.toMatchObject({
-        code: 400,
-        message: 'Validation failed: "title" is required',
-      });
-    });
-
-    it('should throw validation error for invalid URL', async () => {
-      const input = {
-        title: 'GitHub',
-        url: 'not-a-valid-url',
-      };
-
-      await expect(service.createBookmark(input)).rejects.toThrow(AppError);
-      await expect(service.createBookmark(input)).rejects.toMatchObject({
-        code: 400,
-        message: 'Validation failed: "url" must be a valid URL',
-      });
-    });
-
-    it('should throw validation error for missing URL', async () => {
-      const input = {
-        title: 'GitHub',
-      };
-
-      await expect(
-        service.createBookmark(input as { title: string; url: string })
-      ).rejects.toThrow(AppError);
-      await expect(
-        service.createBookmark(input as { title: string; url: string })
-      ).rejects.toMatchObject({
-        code: 400,
-        message: 'Validation failed: "url" is required',
-      });
-    });
-
-    it('should handle database errors', async () => {
-      const input = {
-        title: 'GitHub',
-        url: 'https://github.com',
-      };
-
-      const dbError = new Error('Database connection failed');
-      mockPrisma.bookmark.create.mockRejectedValue(dbError);
-
-      await expect(service.createBookmark(input)).rejects.toThrow(AppError);
-      await expect(service.createBookmark(input)).rejects.toMatchObject({
-        code: 500,
-        message: 'Failed to create bookmark',
-      });
-    });
-  });
-
-  describe('updateBookmark', () => {
-    it('should update a bookmark with valid data', async () => {
-      const id = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-      const input = {
-        title: 'GitHub: Let’s build from here',
-        url: 'https://github.com',
-        tags: ['code', 'repository', 'dev'],
-      };
-
-      const existingBookmark = {
-        id,
-        title: 'GitHub',
-        url: 'https://github.com',
-        tags: ['code', 'repository'],
-        createdAt: new Date('2023-10-27T11:00:00.000Z'),
-        updatedAt: new Date('2023-10-27T11:00:00.000Z'),
-      };
-
-      const updatedBookmark = {
-        id,
-        ...input,
-        createdAt: existingBookmark.createdAt,
-        updatedAt: new Date('2023-10-27T11:05:00.000Z'),
-      };
-
-      mockPrisma.bookmark.findMany.mockResolvedValue([existingBookmark]);
-      mockPrisma.bookmark.update.mockResolvedValue(updatedBookmark);
-
-      const result = await service.updateBookmark(id, input);
-
-      expect(mockPrisma.bookmark.findMany).toHaveBeenCalledWith({
-        where: { id },
-      });
-      expect(mockPrisma.bookmark.update).toHaveBeenCalledWith({
-        where: { id },
-        data: {
-          title: input.title,
-          url: input.url,
-          tags: input.tags,
-        },
-      });
-      expect(result).toEqual(updatedBookmark);
-    });
-
-    it('should throw not found error when bookmark does not exist', async () => {
-      const id = 'non-existent-id';
-      const input = {
-        title: 'GitHub: Let’s build from here',
-        url: 'https://github.com',
-        tags: ['code', 'repository', 'dev'],
-      };
-
-      mockPrisma.bookmark.findMany.mockResolvedValue([]);
-
-      await expect(service.updateBookmark(id, input)).rejects.toThrow(AppError);
-      await expect(service.updateBookmark(id, input)).rejects.toMatchObject({
-        code: 404,
-        message: 'Bookmark not found',
-      });
-    });
-
-    it('should throw validation error for empty title', async () => {
-      const id = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-      const input = {
-        title: '',
-        url: 'https://github.com',
-        tags: ['code', 'repository', 'dev'],
-      };
-
-      await expect(service.updateBookmark(id, input)).rejects.toThrow(AppError);
-      await expect(service.updateBookmark(id, input)).rejects.toMatchObject({
-        code: 400,
-        message: 'Validation failed: "title" is not allowed to be empty',
-      });
-    });
-
-    it('should throw validation error for invalid URL', async () => {
-      const id = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-      const input = {
-        title: 'GitHub: Let’s build from here',
-        url: 'not-a-valid-url',
-        tags: ['code', 'repository', 'dev'],
-      };
-
-      await expect(service.updateBookmark(id, input)).rejects.toThrow(AppError);
-      await expect(service.updateBookmark(id, input)).rejects.toMatchObject({
-        code: 400,
-        message: 'Validation failed: "url" must be a valid URL',
-      });
-    });
-
-    it('should throw validation error for invalid tags', async () => {
-      const id = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-      const input = {
-        title: 'GitHub: Let’s build from here',
-        url: 'https://github.com',
-        tags: 'not-an-array',
-      };
-
-      await expect(
-        service.updateBookmark(id, input as unknown as { title: string; url: string; tags: string[] })
-      ).rejects.toThrow(AppError);
-      await expect(
-        service.updateBookmark(id, input as unknown as { title: string; url: string; tags: string[] })
-      ).rejects.toMatchObject({
-        code: 400,
-        message: 'Validation failed: "tags" must be an array',
-      });
-    });
-
-    it('should handle database errors', async () => {
-      const id = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-      const input = {
-        title: 'GitHub: Let’s build from here',
-        url: 'https://github.com',
-        tags: ['code', 'repository', 'dev'],
-      };
-
-      const existingBookmark = {
-        id,
-        title: 'GitHub',
-        url: 'https://github.com',
-        tags: ['code', 'repository'],
-        createdAt: new Date('2023-10-27T11:00:00.000Z'),
-        updatedAt: new Date('2023-10-27T11:00:00.000Z'),
-      };
-
-      mockPrisma.bookmark.findMany.mockResolvedValue([existingBookmark]);
-      const dbError = new Error('Database connection failed');
-      mockPrisma.bookmark.update.mockRejectedValue(dbError);
-
-      await expect(service.updateBookmark(id, input)).rejects.toThrow(AppError);
-      await expect(service.updateBookmark(id, input)).rejects.toMatchObject({
-        code: 500,
-        message: 'Failed to update bookmark',
-      });
-    });
-  });
-
-  describe('deleteBookmark', () => {
-    it('should delete an existing bookmark', async () => {
-      const id = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-
-      const existingBookmark = {
-        id,
-        title: 'GitHub',
-        url: 'https://github.com',
-        tags: ['code', 'repository'],
-        createdAt: new Date('2023-10-27T11:00:00.000Z'),
-        updatedAt: new Date('2023-10-27T11:00:00.000Z'),
-      };
-
-      mockPrisma.bookmark.findMany.mockResolvedValue([existingBookmark]);
-      mockPrisma.bookmark.delete.mockResolvedValue(existingBookmark);
-
-      await service.deleteBookmark(id);
-
-      expect(mockPrisma.bookmark.findMany).toHaveBeenCalledWith({
-        where: { id },
-      });
-      expect(mockPrisma.bookmark.delete).toHaveBeenCalledWith({
-        where: { id },
-      });
-    });
-
-    it('should throw not found error when bookmark does not exist', async () => {
-      const id = 'non-existent-id';
-
-      mockPrisma.bookmark.findMany.mockResolvedValue([]);
-
-      await expect(service.deleteBookmark(id)).rejects.toThrow(AppError);
-      await expect(service.deleteBookmark(id)).rejects.toMatchObject({
-        code: 404,
-        message: 'Bookmark not found',
-      });
-    });
-
-    it('should handle database errors', async () => {
-      const id = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-
-      const existingBookmark = {
-        id,
-        title: 'GitHub',
-        url: 'https://github.com',
-        tags: ['code', 'repository'],
-        createdAt: new Date('2023-10-27T11:00:00.000Z'),
-        updatedAt: new Date('2023-10-27T11:00:00.000Z'),
-      };
-
-      mockPrisma.bookmark.findMany.mockResolvedValue([existingBookmark]);
-      const dbError = new Error('Database connection failed');
-      mockPrisma.bookmark.delete.mockRejectedValue(dbError);
-
-      await expect(service.deleteBookmark(id)).rejects.toThrow(AppError);
-      await expect(service.deleteBookmark(id)).rejects.toMatchObject({
-        code: 500,
-        message: 'Failed to delete bookmark',
-      });
-    });
-  });
-});

package/demo-backend/src/services/bookmark.service.ts

@@ -1,261 +0,0 @@
-import { randomUUID } from 'crypto';
-
-interface Bookmark {
-  id: string;
-  title: string;
-  url: string;
-  tags: string[];
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-interface CreateBookmarkData {
-  title: string;
-  url: string;
-  tags?: string[];
-}
-
-interface UpdateBookmarkData {
-  title: string;
-  url: string;
-  tags: string[];
-}
-
-interface PaginationParams {
-  limit?: number;
-  offset?: number;
-}
-
-interface PaginatedResult {
-  bookmarks: Bookmark[];
-  total: number;
-}
-
-interface ValidationResult {
-  isValid: boolean;
-  error?: string;
-}
-
-class AppError extends Error {
-  code: number;
-  
-  constructor(code: number, message: string) {
-    super(message);
-    this.code = code;
-  }
-}
-
-export class BookmarkService {
-  private bookmarks: Bookmark[] = [];
-
-  private validateUrl(url: string): ValidationResult {
-    if (!url || typeof url !== 'string') {
-      return { isValid: false, error: '"url" is required and must be a string' };
-    }
-    
-    try {
-      new URL(url);
-      return { isValid: true };
-    } catch {
-      return { isValid: false, error: '"url" must be a valid URL' };
-    }
-  }
-
-  private validateTitle(title: string): ValidationResult {
-    if (!title || typeof title !== 'string' || title.trim().length === 0) {
-      return { isValid: false, error: '"title" is required and cannot be empty' };
-    }
-    return { isValid: true };
-  }
-
-  private validateTags(tags: unknown): ValidationResult {
-    if (tags === undefined || tags === null) {
-      return { isValid: true };
-    }
-    
-    if (!Array.isArray(tags)) {
-      return { isValid: false, error: '"tags" must be an array of strings' };
-    }
-    
-    for (const tag of tags) {
-      if (typeof tag !== 'string') {
-        return { isValid: false, error: 'Each tag must be a string' };
-      }
-    }
-    
-    return { isValid: true };
-  }
-
-  private validateId(id: string): ValidationResult {
-    if (!id || typeof id !== 'string') {
-      return { isValid: false, error: '"id" is required' };
-    }
-    
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    if (!uuidRegex.test(id)) {
-      return { isValid: false, error: '"id" must be a valid UUID' };
-    }
-    
-    return { isValid: true };
-  }
-
-  private validatePaginationParams(params: PaginationParams): ValidationResult {
-    const { limit, offset } = params;
-    
-    if (limit !== undefined) {
-      if (typeof limit !== 'number' || !Number.isInteger(limit) || limit <= 0) {
-        return { isValid: false, error: '"limit" must be a positive integer' };
-      }
-    }
-    
-    if (offset !== undefined) {
-      if (typeof offset !== 'number' || !Number.isInteger(offset) || offset < 0) {
-        return { isValid: false, error: '"offset" must be a non-negative integer' };
-      }
-    }
-    
-    return { isValid: true };
-  }
-
-  async getBookmarks(params: PaginationParams = {}): Promise<PaginatedResult> {
-    const validation = this.validatePaginationParams(params);
-    if (!validation.isValid) {
-      throw new AppError(400, `Validation failed: ${validation.error}`);
-    }
-
-    const limit = params.limit ?? 20;
-    const offset = params.offset ?? 0;
-
-    try {
-      const sortedBookmarks = [...this.bookmarks].sort(
-        (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-      );
-      
-      const paginatedBookmarks = sortedBookmarks.slice(offset, offset + limit);
-      
-      return {
-        bookmarks: paginatedBookmarks,
-        total: this.bookmarks.length
-      };
-    } catch (error) {
-      throw new AppError(500, 'Failed to retrieve bookmarks');
-    }
-  }
-
-  async createBookmark(data: CreateBookmarkData): Promise<Bookmark> {
-    const titleValidation = this.validateTitle(data.title);
-    if (!titleValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${titleValidation.error}`);
-    }
-
-    const urlValidation = this.validateUrl(data.url);
-    if (!urlValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${urlValidation.error}`);
-    }
-
-    const tagsValidation = this.validateTags(data.tags);
-    if (!tagsValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${tagsValidation.error}`);
-    }
-
-    try {
-      const now = new Date();
-      const bookmark: Bookmark = {
-        id: randomUUID(),
-        title: data.title.trim(),
-        url: data.url.trim(),
-        tags: data.tags?.map(tag => tag.trim()) || [],
-        createdAt: now,
-        updatedAt: now
-      };
-
-      this.bookmarks.push(bookmark);
-      return bookmark;
-    } catch (error) {
-      throw new AppError(500, 'Failed to create bookmark');
-    }
-  }
-
-  async updateBookmark(id: string, data: UpdateBookmarkData): Promise<Bookmark> {
-    const idValidation = this.validateId(id);
-    if (!idValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${idValidation.error}`);
-    }
-
-    const titleValidation = this.validateTitle(data.title);
-    if (!titleValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${titleValidation.error}`);
-    }
-
-    const urlValidation = this.validateUrl(data.url);
-    if (!urlValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${urlValidation.error}`);
-    }
-
-    const tagsValidation = this.validateTags(data.tags);
-    if (!tagsValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${tagsValidation.error}`);
-    }
-
-    try {
-      const bookmarkIndex = this.bookmarks.findIndex(b => b.id === id);
-      if (bookmarkIndex === -1) {
-        throw new AppError(404, 'Bookmark not found');
-      }
-
-      const existingBookmark = this.bookmarks[bookmarkIndex];
-      const updatedBookmark: Bookmark = {
-        ...existingBookmark,
-        title: data.title.trim(),
-        url: data.url.trim(),
-        tags: data.tags.map(tag => tag.trim()),
-        updatedAt: new Date()
-      };
-
-      this.bookmarks[bookmarkIndex] = updatedBookmark;
-      return updatedBookmark;
-    } catch (error) {
-      if (error instanceof AppError) {
-        throw error;
-      }
-      throw new AppError(500, 'Failed to update bookmark');
-    }
-  }
-
-  async deleteBookmark(id: string): Promise<void> {
-    const idValidation = this.validateId(id);
-    if (!idValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${idValidation.error}`);
-    }
-
-    try {
-      const bookmarkIndex = this.bookmarks.findIndex(b => b.id === id);
-      if (bookmarkIndex === -1) {
-        throw new AppError(404, 'Bookmark not found');
-      }
-
-      this.bookmarks.splice(bookmarkIndex, 1);
-    } catch (error) {
-      if (error instanceof AppError) {
-        throw error;
-      }
-      throw new AppError(500, 'Failed to delete bookmark');
-    }
-  }
-
-  async getBookmarkById(id: string): Promise<Bookmark | null> {
-    const idValidation = this.validateId(id);
-    if (!idValidation.isValid) {
-      throw new AppError(400, `Validation failed: ${idValidation.error}`);
-    }
-
-    try {
-      const bookmark = this.bookmarks.find(b => b.id === id);
-      return bookmark || null;
-    } catch (error) {
-      throw new AppError(500, 'Failed to retrieve bookmark');
-    }
-  }
-}
-
-export const bookmarkService = new BookmarkService();

package/demo-backend/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src"]
-}