JS-0116 @ 7fec537 • Olimpiadas-INET-2024-Escuela-Tecnica-21 / fase1

Run summary

a month ago

92ded5c..7fec537

16 s

async function should have await expression JS-0116

Bug risk

Minor

9 occurrences in this check

Found async function without any await expressions

entities/salesManager.js

11        })
12    }
13
14    static async findMany(){1516        return prisma.salesManager.findMany({1718            include: {19                profile: true20            }2122        })23        24    }25    
26    static async findById({id}){
27        const salesManagerFound = await prisma.salesManager.findFirst({

Found async function without any await expressions

entities/salesManager.js

 2
 3class SalesManagerModel{
 4
 5    static async create({username, password}) { 6        return prisma.salesManager.create({ 7            data:{ 8                username, 9                password10            }11        })12    }13
14    static async findMany(){
15

Found async function without any await expressions

entities/profile.js

 2
 3class ProfileModel{
 4
 5    static async create({name}) { 6        return prisma.profile.create({ 7            data:{ 8                name 9            }10        })11    }12
13    static async findMany(){
14

Found async function without any await expressions

entities/product.js

14        })
15    }
16
17    static async findMany(){1819        return prisma.product.findMany()20        21    }22    
23    static async findById({id}){
24        const productFound = await prisma.product.findFirst({

Found async function without any await expressions

entities/product.js

 2
 3class ProductModel{
 4
 5    static async create({username, category, stock, price, description}) { 6        return prisma.product.create({ 7            data:{ 8                username,  9                category, 10                stock, 11                price, 12                description13            }14        })15    }16
17    static async findMany(){
18

Found async function without any await expressions

entities/order.js

14        })
15    }
16
17    static async findMany(){1819        return prisma.order.findMany({2021            include: {22                client: true,23                seller: true,24                salesManager: true25            }2627        })28        29    }30    
31    static async findById({id}){
32        const orderFound = await prisma.order.findFirst({

Found async function without any await expressions

entities/order.js

 2
 3class OrderModel{
 4
 5    static async create({date, state, totalPrice, check, paymentMethod}) { 6        return prisma.order.create({ 7            data:{ 8                date,  9                state, 10                totalPrice, 11                check, 12                paymentMethod13            }14        })15    }16
17    static async findMany(){
18

Found async function without any await expressions

entities/client.js

36        })
37    }
38
39    static async findMany(){4041        return prisma.client.findMany({clientInclude})4243    }44    
45    static async findById({id}){
46        const clientFound = await prisma.client.findFirst({

Found async function without any await expressions

entities/client.js

16
17class ClientModel {
18
19    static async create({username, email, password, address}) {20        return prisma.client.create({21            data:{22                username,23                email,24                password,25                address,26                shoppingCart:{2728                    create:{2930                        //Nothing3132                    }3334                }35            }36        })37    }38
39    static async findMany(){
40

Description

A function that does not contain any await expressions should not be async (except for some edge cases in TypeScript which are discussed below). Asynchronous functions in JavaScript behave differently than other functions in two important ways:

The return value is always a Promise.
You can use the await operator inside them.

Functions are made async so that we can use the await operator inside them. Consider this example:

async function fetchData(processDataItem) {
    const response = await fetch(DATA_URL);
    const data = await response.json();

    return data.map(processDataItem);
}

Asynchronous functions that don't use await might be an unintentional result of refactoring.

Note: This issue ignores async generator functions. Generators yield rather than return a value and async generators might yield all the values of another async generator without ever actually needing to use await.

In TypeScript, one might feel the need to make a function async to comply with type signatures defined by an interface. Ideally, the code should be refactored to get rid of such restrictions, but sometimes that isn't feasible (For example, when we are implementing an interface defined in a 3rd party library like Next.js).

This situation can easily be circumvented by returning the value with a call to Promise.resolve:

interface HasAsyncFunc {
  getNum: () => Promise<number>
}

// Not recommended:
const o: HasAsyncFunc = {
  async getNum() { return 1 }
}

// Recommended:
const o: HasAsyncFunc = {
  // We only use `Promise.resolve` to adhere to the type
  // of the surrounding object.
  getNum() { return Promise.resolve(1) }
}

It is also advised to add a comment near the redundant promise to make the intent clear.

Bad Practice

async function fetchData(): string {
    // `readFileSync` is a synchronous function that blocks
    // the main thread, and thus does not need to be `await`ed
    return fs.readFileSync("data.txt", "utf-8");
}

performAction(async () => { console.log("no awaits in here") });

Olimpiadas-INET-2024-Escuela-Tecnica-21 / fase1_backend

Bad Practice

Recommended