oh-my-customcode 0.1.0

package/templates/guides/springboot/best-practices.md

@@ -0,0 +1,361 @@
+# Spring Boot Best Practices
+
+> Source: Spring Documentation and Baeldung
+
+## Project Structure
+
+```
+com.example.app/
+├── controller/          # REST endpoints
+├── service/             # Business logic
+│   └── impl/
+├── repository/          # Data access
+├── model/               # Domain entities
+├── dto/                 # Data transfer objects
+├── config/              # Configuration
+├── exception/           # Custom exceptions
+└── util/                # Utilities
+```
+
+## Dependency Injection
+
+### Constructor Injection (Recommended)
+
+```java
+@Service
+@RequiredArgsConstructor
+public class UserService {
+    private final UserRepository userRepository;
+    private final EmailService emailService;
+}
+```
+
+### Avoid Field Injection
+
+```java
+// NOT RECOMMENDED
+@Service
+public class UserService {
+    @Autowired
+    private UserRepository userRepository;
+}
+```
+
+## REST Controllers
+
+```java
+@RestController
+@RequestMapping("/api/v1/users")
+@RequiredArgsConstructor
+public class UserController {
+
+    private final UserService userService;
+
+    @GetMapping
+    public List<UserResponse> getAllUsers() {
+        return userService.findAll();
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<UserResponse> getUser(@PathVariable Long id) {
+        return ResponseEntity.ok(userService.findById(id));
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public UserResponse createUser(@Valid @RequestBody UserRequest request) {
+        return userService.create(request);
+    }
+
+    @PutMapping("/{id}")
+    public UserResponse updateUser(
+        @PathVariable Long id,
+        @Valid @RequestBody UserRequest request
+    ) {
+        return userService.update(id, request);
+    }
+
+    @DeleteMapping("/{id}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    public void deleteUser(@PathVariable Long id) {
+        userService.delete(id);
+    }
+}
+```
+
+## Service Layer
+
+```java
+public interface UserService {
+    UserResponse findById(Long id);
+    UserResponse create(UserRequest request);
+    UserResponse update(Long id, UserRequest request);
+    void delete(Long id);
+}
+
+@Service
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+public class UserServiceImpl implements UserService {
+
+    private final UserRepository userRepository;
+    private final UserMapper userMapper;
+
+    @Override
+    public UserResponse findById(Long id) {
+        User user = userRepository.findById(id)
+            .orElseThrow(() -> new UserNotFoundException(id));
+        return userMapper.toResponse(user);
+    }
+
+    @Override
+    @Transactional
+    public UserResponse create(UserRequest request) {
+        User user = userMapper.toEntity(request);
+        User saved = userRepository.save(user);
+        return userMapper.toResponse(saved);
+    }
+}
+```
+
+## Repository Layer
+
+```java
+public interface UserRepository extends JpaRepository<User, Long> {
+
+    Optional<User> findByEmail(String email);
+
+    List<User> findByStatusOrderByCreatedAtDesc(UserStatus status);
+
+    @Query("SELECT u FROM User u WHERE u.department = :dept AND u.status = 'ACTIVE'")
+    List<User> findActiveDepartmentMembers(@Param("dept") String department);
+
+    @Modifying
+    @Query("UPDATE User u SET u.status = :status WHERE u.id = :id")
+    int updateStatus(@Param("id") Long id, @Param("status") UserStatus status);
+}
+```
+
+## Entity Design
+
+```java
+@Entity
+@Table(name = "users")
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@EntityListeners(AuditingEntityListener.class)
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false, unique = true, length = 100)
+    private String email;
+
+    @Column(nullable = false)
+    private String password;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private UserStatus status = UserStatus.ACTIVE;
+
+    @CreatedDate
+    @Column(updatable = false)
+    private LocalDateTime createdAt;
+
+    @LastModifiedDate
+    private LocalDateTime updatedAt;
+
+    public User(String email, String password) {
+        this.email = email;
+        this.password = password;
+    }
+
+    public void updatePassword(String newPassword) {
+        this.password = newPassword;
+    }
+}
+```
+
+## Exception Handling
+
+```java
+// Custom Exception
+public class UserNotFoundException extends RuntimeException {
+    public UserNotFoundException(Long id) {
+        super("User not found: " + id);
+    }
+}
+
+// Global Handler
+@RestControllerAdvice
+@Slf4j
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(UserNotFoundException.class)
+    @ResponseStatus(HttpStatus.NOT_FOUND)
+    public ErrorResponse handleUserNotFound(UserNotFoundException ex) {
+        log.warn("User not found: {}", ex.getMessage());
+        return new ErrorResponse("USER_NOT_FOUND", ex.getMessage());
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public ErrorResponse handleValidation(MethodArgumentNotValidException ex) {
+        List<String> errors = ex.getBindingResult()
+            .getFieldErrors()
+            .stream()
+            .map(e -> e.getField() + ": " + e.getDefaultMessage())
+            .toList();
+        return new ErrorResponse("VALIDATION_ERROR", String.join(", ", errors));
+    }
+
+    @ExceptionHandler(Exception.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public ErrorResponse handleGeneral(Exception ex) {
+        log.error("Unexpected error", ex);
+        return new ErrorResponse("INTERNAL_ERROR", "An unexpected error occurred");
+    }
+}
+```
+
+## Configuration
+
+```yaml
+# application.yml
+spring:
+  profiles:
+    active: ${SPRING_PROFILES_ACTIVE:local}
+  datasource:
+    url: ${DATABASE_URL}
+    username: ${DATABASE_USERNAME}
+    password: ${DATABASE_PASSWORD}
+  jpa:
+    hibernate:
+      ddl-auto: validate
+    properties:
+      hibernate:
+        format_sql: true
+        default_batch_fetch_size: 100
+
+logging:
+  level:
+    org.hibernate.SQL: DEBUG
+    org.hibernate.type.descriptor.sql: TRACE
+```
+
+```java
+@Configuration
+@ConfigurationProperties(prefix = "app")
+@Validated
+@Getter
+@Setter
+public class AppProperties {
+
+    @NotBlank
+    private String name;
+
+    @NotNull
+    private Security security = new Security();
+
+    @Getter
+    @Setter
+    public static class Security {
+        private String jwtSecret;
+        private Duration jwtExpiration = Duration.ofHours(24);
+    }
+}
+```
+
+## Security Configuration
+
+```java
+@Configuration
+@EnableWebSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+
+    private final JwtAuthenticationFilter jwtFilter;
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        return http
+            .csrf(AbstractHttpConfigurer::disable)
+            .sessionManagement(session ->
+                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            .authorizeHttpRequests(auth -> auth
+                .requestMatchers("/api/v1/auth/**").permitAll()
+                .requestMatchers("/api/v1/admin/**").hasRole("ADMIN")
+                .anyRequest().authenticated())
+            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
+            .build();
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}
+```
+
+## Testing
+
+### Controller Test
+
+```java
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private UserService userService;
+
+    @Test
+    void getUser_shouldReturnUser() throws Exception {
+        given(userService.findById(1L))
+            .willReturn(new UserResponse(1L, "test@example.com"));
+
+        mockMvc.perform(get("/api/v1/users/1")
+                .contentType(MediaType.APPLICATION_JSON))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.id").value(1))
+            .andExpect(jsonPath("$.email").value("test@example.com"));
+    }
+}
+```
+
+### Integration Test
+
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+class UserIntegrationTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    void createUser_shouldPersistUser() throws Exception {
+        String request = """
+            {
+                "email": "test@example.com",
+                "password": "password123"
+            }
+            """;
+
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(request))
+            .andExpect(status().isCreated());
+
+        assertThat(userRepository.findByEmail("test@example.com")).isPresent();
+    }
+}
+```

package/templates/guides/springboot/index.yaml

@@ -0,0 +1,22 @@
+# Spring Boot Guide
+
+metadata:
+  name: springboot
+  description: Spring Boot framework reference documentation
+
+source:
+  type: external
+  origin: spring.io
+  urls:
+    - https://docs.spring.io/spring-boot/docs/current/reference/html/
+    - https://spring.io/guides
+    - https://www.baeldung.com/spring-boot
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: best-practices
+    path: ./best-practices.md
+    description: Spring Boot best practices and patterns
+
+used_by:
+  - springboot-expert

package/templates/guides/typescript/advanced-types.md

@@ -0,0 +1,225 @@
+# TypeScript Advanced Types
+
+> Reference for advanced TypeScript type patterns
+
+## Utility Types
+
+```typescript
+// Partial - make all properties optional
+type PartialUser = Partial<User>;
+
+// Required - make all properties required
+type RequiredUser = Required<User>;
+
+// Readonly - make all properties readonly
+type ReadonlyUser = Readonly<User>;
+
+// Pick - select specific properties
+type UserName = Pick<User, 'name' | 'email'>;
+
+// Omit - exclude specific properties
+type UserWithoutId = Omit<User, 'id'>;
+
+// Record - create object type with key-value pairs
+type UserMap = Record<string, User>;
+
+// Exclude - exclude types from union
+type NonNullStatus = Exclude<Status | null, null>;
+
+// Extract - extract types from union
+type StringStatus = Extract<Status, string>;
+
+// NonNullable - remove null and undefined
+type DefinedValue = NonNullable<string | null | undefined>;
+
+// ReturnType - get function return type
+type Result = ReturnType<typeof fetchUser>;
+
+// Parameters - get function parameter types
+type Params = Parameters<typeof fetchUser>;
+```
+
+## Mapped Types
+
+```typescript
+// Make all properties optional
+type Optional<T> = {
+  [P in keyof T]?: T[P];
+};
+
+// Make all properties readonly
+type Immutable<T> = {
+  readonly [P in keyof T]: T[P];
+};
+
+// Make all properties nullable
+type Nullable<T> = {
+  [P in keyof T]: T[P] | null;
+};
+
+// Remap keys
+type Getters<T> = {
+  [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
+};
+
+// Filter properties by type
+type OnlyStrings<T> = {
+  [P in keyof T as T[P] extends string ? P : never]: T[P];
+};
+```
+
+## Conditional Types
+
+```typescript
+// Basic conditional
+type IsString<T> = T extends string ? true : false;
+
+// With infer
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+
+// Array element type
+type ElementType<T> = T extends (infer E)[] ? E : never;
+
+// Function return type
+type GetReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
+
+// Distributive conditional
+type ToArray<T> = T extends any ? T[] : never;
+// ToArray<string | number> = string[] | number[]
+```
+
+## Template Literal Types
+
+```typescript
+// Simple template
+type Greeting = `Hello, ${string}!`;
+
+// With union
+type EventHandler = `on${Capitalize<'click' | 'hover' | 'focus'>}`;
+// 'onClick' | 'onHover' | 'onFocus'
+
+// Extract from string
+type ExtractRouteParams<T extends string> =
+  T extends `${string}:${infer Param}/${infer Rest}`
+    ? Param | ExtractRouteParams<Rest>
+    : T extends `${string}:${infer Param}`
+    ? Param
+    : never;
+
+// ExtractRouteParams<'/users/:id/posts/:postId'>
+// = 'id' | 'postId'
+```
+
+## Discriminated Unions
+
+```typescript
+interface Circle {
+  kind: 'circle';
+  radius: number;
+}
+
+interface Square {
+  kind: 'square';
+  side: number;
+}
+
+interface Rectangle {
+  kind: 'rectangle';
+  width: number;
+  height: number;
+}
+
+type Shape = Circle | Square | Rectangle;
+
+function getArea(shape: Shape): number {
+  switch (shape.kind) {
+    case 'circle':
+      return Math.PI * shape.radius ** 2;
+    case 'square':
+      return shape.side ** 2;
+    case 'rectangle':
+      return shape.width * shape.height;
+  }
+}
+```
+
+## Index Signatures
+
+```typescript
+// String index
+interface Dictionary {
+  [key: string]: string;
+}
+
+// Number index
+interface NumberMap {
+  [index: number]: string;
+}
+
+// With specific properties
+interface User {
+  id: string;
+  name: string;
+  [key: string]: string; // additional properties
+}
+
+// Template literal index
+type Handlers = {
+  [K in `on${Capitalize<string>}`]: (event: Event) => void;
+};
+```
+
+## Type Narrowing
+
+```typescript
+// Control flow analysis
+function process(value: string | number | null) {
+  if (value === null) {
+    return; // value is null
+  }
+
+  if (typeof value === 'string') {
+    console.log(value.toUpperCase()); // value is string
+  } else {
+    console.log(value.toFixed(2)); // value is number
+  }
+}
+
+// Assertion functions
+function assertIsString(value: unknown): asserts value is string {
+  if (typeof value !== 'string') {
+    throw new Error('Not a string');
+  }
+}
+
+// Type predicates
+function isNonNull<T>(value: T): value is NonNullable<T> {
+  return value !== null && value !== undefined;
+}
+
+const filtered = items.filter(isNonNull);
+```
+
+## Brand Types
+
+```typescript
+// Create distinct types for same underlying type
+type UserId = string & { readonly brand: unique symbol };
+type PostId = string & { readonly brand: unique symbol };
+
+function createUserId(id: string): UserId {
+  return id as UserId;
+}
+
+function createPostId(id: string): PostId {
+  return id as PostId;
+}
+
+function getUser(id: UserId): User { ... }
+
+const userId = createUserId('123');
+const postId = createPostId('456');
+
+getUser(userId); // OK
+getUser(postId); // Error: PostId not assignable to UserId
+```

package/templates/guides/typescript/index.yaml

@@ -0,0 +1,26 @@
+# TypeScript Guide
+
+metadata:
+  name: typescript
+  description: TypeScript language reference documentation
+
+source:
+  type: external
+  origin: typescriptlang.org
+  urls:
+    - https://www.typescriptlang.org/docs/handbook/
+    - https://google.github.io/styleguide/tsguide.html
+    - https://basarat.gitbook.io/typescript/
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: type-system
+    path: ./type-system.md
+    description: TypeScript type system fundamentals
+
+  - name: advanced-types
+    path: ./advanced-types.md
+    description: Advanced TypeScript type patterns
+
+used_by:
+  - typescript-expert