refactor: Use callback to handle forEachIn errors

backend/src/modules/DataModule.ts

@@ -298,18 +298,13 @@ export class DataModule extends BaseModule {
 			throw error;
 		}
 
-		const { completed } = await forEachIn(
-			migrations,
-			async migrationFile => {
-				const { default: Migrate }: { default: typeof Migration } =
-					await import(
-						`./DataModule/models/${modelName}/migrations/${migrationFile}`
-					);
-				return new Migrate(this._mongoConnection as Connection);
-			}
-		);
-
-		return completed;
+		return forEachIn(migrations, async migrationFile => {
+			const { default: Migrate }: { default: typeof Migration } =
+				await import(
+					`./DataModule/models/${modelName}/migrations/${migrationFile}`
+				);
+			return new Migrate(this._mongoConnection as Connection);
+		});
 	}
 
 	private async _loadMigrations() {
@@ -317,11 +312,9 @@ export class DataModule extends BaseModule {
 			path.resolve(__dirname, "./DataModule/models/")
 		);
 
-		const { completed } = await forEachIn(models, async modelName =>
+		return forEachIn(models, async modelName =>
 			this._loadModelMigrations(modelName)
 		);
-
-		return completed;
 	}
 
 	private async _runMigrations() {

backend/src/modules/DataModule/models/users/jobs/GetModelPermissions.ts

@@ -53,7 +53,7 @@ export default class GetModelPermissions extends DataModuleJob {
 
 		if (modelId && !model) throw new Error("Model not found");
 
-		const { completed: jobs } = await forEachIn(
+		const jobs = await forEachIn(
 			Object.entries(
 				ModuleManager.getModule("data")?.getJobs() ?? {}
 			).filter(

backend/src/utils/forEachIn.ts

@@ -8,12 +8,18 @@ export const forEachIn = async <
 >(
 	items: ItemsType,
 	callback: CallbackType,
-	options: { abortOnError?: boolean; concurrency?: number } = {}
-): Promise<{ completed: CallbackReturnType[]; failed: any[] }> => {
-	const { abortOnError = true, concurrency = 10 } = options;
+	options: {
+		concurrency?: number;
+		onError?: (
+			error: any,
+			item: ItemsType[number],
+			index: number
+		) => Promise<void>;
+	} = {}
+): Promise<CallbackReturnType[]> => {
+	const { concurrency = 10, onError } = options;
 
 	const queued = items.slice();
-	const failed: any[] = [];
 	const completed: CallbackReturnType[] = [];
 
 	const next = async () => {
@@ -26,9 +32,8 @@ export const forEachIn = async <
 		try {
 			completed[index] = await callback(item, index);
 		} catch (error) {
-			if (abortOnError) throw error;
-
-			failed[index] = error;
+			if (onError) await onError(error, item, index);
+			else throw error;
 		}
 
 		await next();
@@ -38,5 +43,5 @@ export const forEachIn = async <
 		Array.from(Array(Math.min(items.length, concurrency)).keys()).map(next)
 	);
 
-	return { completed, failed };
+	return completed;
 };