fix: Set '@typescript-eslint/return-await' rule to 'always' for node code (no-changelog) (#8363)

Co-authored-by: कारतोफ्फेलस्क्रिप्ट™ <aditya@netroy.in>

packages/cli/test/integration/shared/db/credentials.ts

@@ -55,17 +55,17 @@ export async function shareCredentialWithUsers(credential: CredentialsEntity, us
 			roleId: role?.id,
 		}),
 	);
-	return Container.get(SharedCredentialsRepository).save(newSharedCredentials);
+	return await Container.get(SharedCredentialsRepository).save(newSharedCredentials);
 }
 
 export function affixRoleToSaveCredential(role: Role) {
 	return async (credentialPayload: CredentialPayload, { user }: { user: User }) =>
-		saveCredential(credentialPayload, { user, role });
+		await saveCredential(credentialPayload, { user, role });
 }
 
 export async function getAllCredentials() {
-	return Container.get(CredentialsRepository).find();
+	return await Container.get(CredentialsRepository).find();
 }
 
 export const getCredentialById = async (id: string) =>
-	Container.get(CredentialsRepository).findOneBy({ id });
+	await Container.get(CredentialsRepository).findOneBy({ id });

packages/cli/test/integration/shared/db/executions.ts

@@ -10,8 +10,8 @@ export async function createManyExecutions(
 	workflow: WorkflowEntity,
 	callback: (workflow: WorkflowEntity) => Promise<ExecutionEntity>,
 ) {
-	const executionsRequests = [...Array(amount)].map(async (_) => callback(workflow));
-	return Promise.all(executionsRequests);
+	const executionsRequests = [...Array(amount)].map(async (_) => await callback(workflow));
+	return await Promise.all(executionsRequests);
 }
 
 /**
@@ -47,23 +47,29 @@ export async function createExecution(
  * Store a successful execution in the DB and assign it to a workflow.
  */
 export async function createSuccessfulExecution(workflow: WorkflowEntity) {
-	return createExecution({ finished: true, status: 'success' }, workflow);
+	return await createExecution({ finished: true, status: 'success' }, workflow);
 }
 
 /**
  * Store an error execution in the DB and assign it to a workflow.
  */
 export async function createErrorExecution(workflow: WorkflowEntity) {
-	return createExecution({ finished: false, stoppedAt: new Date(), status: 'failed' }, workflow);
+	return await createExecution(
+		{ finished: false, stoppedAt: new Date(), status: 'failed' },
+		workflow,
+	);
 }
 
 /**
  * Store a waiting execution in the DB and assign it to a workflow.
  */
 export async function createWaitingExecution(workflow: WorkflowEntity) {
-	return createExecution({ finished: false, waitTill: new Date(), status: 'waiting' }, workflow);
+	return await createExecution(
+		{ finished: false, waitTill: new Date(), status: 'waiting' },
+		workflow,
+	);
 }
 
 export async function getAllExecutions() {
-	return Container.get(ExecutionRepository).find();
+	return await Container.get(ExecutionRepository).find();
 }

packages/cli/test/integration/shared/db/roles.ts

@@ -2,31 +2,31 @@ import Container from 'typedi';
 import { RoleService } from '@/services/role.service';
 
 export async function getGlobalOwnerRole() {
-	return Container.get(RoleService).findGlobalOwnerRole();
+	return await Container.get(RoleService).findGlobalOwnerRole();
 }
 
 export async function getGlobalMemberRole() {
-	return Container.get(RoleService).findGlobalMemberRole();
+	return await Container.get(RoleService).findGlobalMemberRole();
 }
 
 export async function getGlobalAdminRole() {
-	return Container.get(RoleService).findGlobalAdminRole();
+	return await Container.get(RoleService).findGlobalAdminRole();
 }
 
 export async function getWorkflowOwnerRole() {
-	return Container.get(RoleService).findWorkflowOwnerRole();
+	return await Container.get(RoleService).findWorkflowOwnerRole();
 }
 
 export async function getWorkflowEditorRole() {
-	return Container.get(RoleService).findWorkflowEditorRole();
+	return await Container.get(RoleService).findWorkflowEditorRole();
 }
 
 export async function getCredentialOwnerRole() {
-	return Container.get(RoleService).findCredentialOwnerRole();
+	return await Container.get(RoleService).findCredentialOwnerRole();
 }
 
 export async function getAllRoles() {
-	return Promise.all([
+	return await Promise.all([
 		getGlobalOwnerRole(),
 		getGlobalMemberRole(),
 		getWorkflowOwnerRole(),

packages/cli/test/integration/shared/db/users.ts

@@ -27,7 +27,7 @@ export async function createUser(attributes: Partial<User> = {}): Promise<User>
 	});
 	user.computeIsOwner();
 
-	return Container.get(UserRepository).save(user);
+	return await Container.get(UserRepository).save(user);
 }
 
 export async function createLdapUser(attributes: Partial<User>, ldapId: string): Promise<User> {
@@ -70,15 +70,15 @@ export async function createUserWithMfaEnabled(
 }
 
 export async function createOwner() {
-	return createUser({ globalRole: await getGlobalOwnerRole() });
+	return await createUser({ globalRole: await getGlobalOwnerRole() });
 }
 
 export async function createMember() {
-	return createUser({ globalRole: await getGlobalMemberRole() });
+	return await createUser({ globalRole: await getGlobalMemberRole() });
 }
 
 export async function createAdmin() {
-	return createUser({ globalRole: await getGlobalAdminRole() });
+	return await createUser({ globalRole: await getGlobalAdminRole() });
 }
 
 export async function createUserShell(globalRole: Role): Promise<User> {
@@ -92,7 +92,7 @@ export async function createUserShell(globalRole: Role): Promise<User> {
 		shell.email = randomEmail();
 	}
 
-	return Container.get(UserRepository).save(shell);
+	return await Container.get(UserRepository).save(shell);
 }
 
 /**
@@ -120,27 +120,27 @@ export async function createManyUsers(
 		),
 	);
 
-	return Container.get(UserRepository).save(users);
+	return await Container.get(UserRepository).save(users);
 }
 
 export async function addApiKey(user: User): Promise<User> {
 	user.apiKey = randomApiKey();
-	return Container.get(UserRepository).save(user);
+	return await Container.get(UserRepository).save(user);
 }
 
 export const getAllUsers = async () =>
-	Container.get(UserRepository).find({
+	await Container.get(UserRepository).find({
 		relations: ['globalRole', 'authIdentities'],
 	});
 
 export const getUserById = async (id: string) =>
-	Container.get(UserRepository).findOneOrFail({
+	await Container.get(UserRepository).findOneOrFail({
 		where: { id },
 		relations: ['globalRole', 'authIdentities'],
 	});
 
 export const getLdapIdentities = async () =>
-	Container.get(AuthIdentityRepository).find({
+	await Container.get(AuthIdentityRepository).find({
 		where: { providerType: 'ldap' },
 		relations: ['user'],
 	});

packages/cli/test/integration/shared/db/workflowHistory.ts

@@ -7,7 +7,7 @@ export async function createWorkflowHistoryItem(
 	workflowId: string,
 	data?: Partial<WorkflowHistory>,
 ) {
-	return Container.get(WorkflowHistoryRepository).save({
+	return await Container.get(WorkflowHistoryRepository).save({
 		authors: 'John Smith',
 		connections: {},
 		nodes: [
@@ -32,12 +32,13 @@ export async function createManyWorkflowHistoryItems(
 	time?: Date,
 ) {
 	const baseTime = (time ?? new Date()).valueOf();
-	return Promise.all(
-		[...Array(count)].map(async (_, i) =>
-			createWorkflowHistoryItem(workflowId, {
-				createdAt: new Date(baseTime + i),
-				updatedAt: new Date(baseTime + i),
-			}),
+	return await Promise.all(
+		[...Array(count)].map(
+			async (_, i) =>
+				await createWorkflowHistoryItem(workflowId, {
+					createdAt: new Date(baseTime + i),
+					updatedAt: new Date(baseTime + i),
+				}),
 		),
 	);
 }

packages/cli/test/integration/shared/db/workflows.ts

@@ -11,8 +11,10 @@ export async function createManyWorkflows(
 	attributes: Partial<WorkflowEntity> = {},
 	user?: User,
 ) {
-	const workflowRequests = [...Array(amount)].map(async (_) => createWorkflow(attributes, user));
-	return Promise.all(workflowRequests);
+	const workflowRequests = [...Array(amount)].map(
+		async (_) => await createWorkflow(attributes, user),
+	);
+	return await Promise.all(workflowRequests);
 }
 
 /**
@@ -60,11 +62,11 @@ export async function shareWorkflowWithUsers(workflow: WorkflowEntity, users: Us
 		workflow,
 		role,
 	}));
-	return Container.get(SharedWorkflowRepository).save(sharedWorkflows);
+	return await Container.get(SharedWorkflowRepository).save(sharedWorkflows);
 }
 
 export async function getWorkflowSharing(workflow: WorkflowEntity) {
-	return Container.get(SharedWorkflowRepository).findBy({
+	return await Container.get(SharedWorkflowRepository).findBy({
 		workflowId: workflow.id,
 	});
 }
@@ -115,8 +117,8 @@ export async function createWorkflowWithTrigger(
 }
 
 export async function getAllWorkflows() {
-	return Container.get(WorkflowRepository).find();
+	return await Container.get(WorkflowRepository).find();
 }
 
 export const getWorkflowById = async (id: string) =>
-	Container.get(WorkflowRepository).findOneBy({ id });
+	await Container.get(WorkflowRepository).findOneBy({ id });