Promise all async loops in Typescript

typescript
Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {

Install this rule for wispbit Cloud

Add this rule to wispbit and it will run when you open a pull request

Install this rule with wispbit CLI

Run this command in your terminal to install the rule locally

npx @wispbit/cli rule install typescript-promise-async-loops

Install this rule for Coderabbit

Copy the configuration below and add it to your repository as .coderabbit.yml in your project root.

reviews:
  path_instructions:
    - path: "*.ts"
      instructions: |
                
        Use `Promise.all` when processing multiple async operations in loops.
        
        Bad:
        
        ```typescript
        async function processItems(items: string[]) {
          const results = []
        
          for (const item of items) {
            // Sequential execution - slower
            const result = await fetchData(item)
            results.push(result)
          }
        
          return results
        }
        ```
        
        Good:
        
        ```typescript
        async function processItems(items: string[]) {
          // Parallel execution - faster
          const results = await Promise.all(
            items.map(async (item) => {
              return await fetchData(item)
            })
          )
        
          return results
        }
        ```

Install this rule for Greptile

Greptile rules can be added through the web interface. Please see this documentation for details on how to add custom rules and context.

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```

File Path Patterns:

*.ts

Install this rule for GitHub Copilot

Copilot instructions can be added through the interface. See the documentation for details on how to create coding guidelines.

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```

File Path Patterns:

*.ts

Install this rule for Graphite Diamond

Diamond custom rules can be added through the interface. See the documentation for details on how to create custom rules.

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```

File Path Patterns:

*.ts

Use with Cline

Copy the rule below and ask Cline to review your code using this rule

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```

Use with OpenAI Codex

Copy the rule below and ask OpenAI Codex to review your code using this rule

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```

Use with Cursor

Copy the rule below and ask Cursor to review your code using this rule

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```

Use with Claude Code

Copy the rule below and ask Claude Code to review your code using this rule

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```

Install this rule for Windsurf

To set up rules for Windsurf Reviews, please see this documentation 

Use `Promise.all` when processing multiple async operations in loops.
Bad:
```typescript
async function processItems(items: string[]) {
  const results = []
  for (const item of items) {
    // Sequential execution - slower
    const result = await fetchData(item)
    results.push(result)
  }
  return results
}
```
Good:
```typescript
async function processItems(items: string[]) {
  // Parallel execution - faster
  const results = await Promise.all(
    items.map(async (item) => {
      return await fetchData(item)
    })
  )
  return results
}
```