Cursor rule

1---
2description: TypeScript best practices and conventions for the NOWCRM codebase
3globs: ["**/*.ts", "**/*.tsx"]
4alwaysApply: false
5---
6 
7# TypeScript Guidelines
8 
9## Core TypeScript Principles
10NOWCRM enforces strict TypeScript usage to ensure type safety and maintainable code. This document outlines our TypeScript conventions and best practices.
11 
12## Type Safety
13 
14### Strict Typing
15- **No 'any' type allowed**
16- TypeScript strict mode enabled
17- noImplicitAny enabled
18```typescript
19  // ✅ Correct
20  function processUser(user: User) {
21    return user.name;
22  }
23 
24  // ❌ Incorrect
25  function processUser(user: any) {
26    return user.name;
27  }
28```
29 
30### Type Definitions
31 
32#### Types over Interfaces
33- Use `type` for all type definitions
34- Exception: When extending third-party interfaces
35```typescript
36  // ✅ Correct
37  type User = {
38    id: string;
39    name: string;
40    email: string;
41  };
42 
43  // ❌ Incorrect
44  interface User {
45    id: string;
46    name: string;
47    email: string;
48  }
49```
50 
51### String Literals over Enums
52- Use string literal unions instead of enums
53- Exception: GraphQL enums
54```typescript
55  // ✅ Correct
56  type UserRole = 'admin' | 'user' | 'guest';
57 
58  // ❌ Incorrect
59  enum UserRole {
60    Admin = 'admin',
61    User = 'user',
62    Guest = 'guest',
63  }
64```
65 
66## Naming Conventions
67 
68### Component Props
69- Suffix component prop types with 'Props'
70- Keep props focused and single-purpose
71```typescript
72  // ✅ Correct
73  type ButtonProps = {
74    label: string;
75    onClick: () => void;
76    variant?: 'primary' | 'secondary';
77  };
78 
79  // ❌ Incorrect
80  type ButtonParameters = {
81    label: string;
82    onClick: () => void;
83    variant?: 'primary' | 'secondary';
84  };
85```
86 
87## Type Inference
88 
89### Leverage TypeScript Inference
90- Use type inference when types are clear
91- Explicitly type when inference is ambiguous
92```typescript
93  // ✅ Correct - Clear inference
94  const users = ['John', 'Jane']; // inferred as string[]
95 
96  // ✅ Correct - Explicit typing needed
97  const processUser = (user: User): UserResponse => {
98    // Complex processing
99    return response;
100  };
101 
102  // ❌ Incorrect - Unnecessary explicit typing
103  const users: string[] = ['John', 'Jane'];
104```
105 
106## Best Practices
107 
108### Type Guards
109- Use type guards for runtime type checking
110- Prefer discriminated unions
111```typescript
112  // ✅ Correct
113  type Success = {
114    type: 'success';
115    data: User;
116  };
117 
118  type Error = {
119    type: 'error';
120    message: string;
121  };
122 
123  type Result = Success | Error;
124 
125  function handleResult(result: Result) {
126    if (result.type === 'success') {
127      // TypeScript knows result.data exists
128      console.log(result.data);
129    }
130  }
131```
132 
133### Generics
134- Use generics for reusable type patterns
135- Keep generic names descriptive
136```typescript
137  // ✅ Correct
138  type ApiResponse<TData> = {
139    data: TData;
140    status: number;
141    message: string;
142  };
143 
144  // ❌ Incorrect
145  type ApiResponse<T> = {
146    data: T;
147    status: number;
148    message: string;
149  };
150```
151 
152### Type Exports
153- Export types when they're used across files
154- Keep type definitions close to their usage
155```typescript
156  // types.ts
157  export type User = {
158    id: string;
159    name: string;
160  };
161 
162  // UserComponent.tsx
163  import { type User } from './types';
164```
165 
166### Utility Types
167- Leverage TypeScript utility types
168- Create custom utility types for repeated patterns
169```typescript
170  // Built-in utility types
171  type UserPartial = Partial<User>;
172  type UserReadonly = Readonly<User>;
173 
174  // Custom utility types
175  type NonNullableProperties<T> = {
176    [P in keyof T]: NonNullable<T[P]>;
177  };
178```