refactor user repo with helpers. better api validation etc.

backend-dart/lib/infrastructure/persistence/mapper/user_dbo_mapper.dart

@@ -1,37 +1,40 @@
+import 'package:backend_dart/common/extensions.dart';
+import 'package:backend_dart/common/secure_hash.dart';
 import 'package:backend_dart/domain/entities/user.dart';
 import 'package:backend_dart/domain/interface/error.dart';
-import 'package:backend_dart/domain/interface/mapper.dart';
 import 'package:backend_dart/infrastructure/persistence/db/model.dart';
+import 'package:backend_dart/infrastructure/persistence/db/prisma.dart';
 import 'package:fpdart/fpdart.dart';
+import 'package:orm/orm.dart';
 
-class UserDboMapper implements IMapper<User, UserDbo> {
-  @override
+class UserDboMapper {
   TaskEither<IError, User> from(UserDbo target) => TaskEither.of(User(
         id: target.id!,
         name: target.name!,
         email: target.email!,
-        password: target.password,
+        passwordHash: target.password,
         createdAt: target.createdAt,
         updatedAt: target.updatedAt,
       ));
 
-  @override
   TaskEither<IError, List<User>> listFrom(Iterable<UserDbo> targets) {
     return TaskEither.traverseList(targets.toList(), from);
   }
 
-  @override
-  TaskEither<IError, List<UserDbo>> listTo(Iterable<User> origins) {
-    return TaskEither.traverseList(origins.toList(), to);
-  }
+  TaskEither<IError, UserDboUncheckedUpdateInput> fromUpdateTo(
+          UserUpdate origin) =>
+      TaskEither.of(UserDboUncheckedUpdateInput(
+        id: PrismaUnion.$1(origin.id),
+        name: origin.name.let(PrismaUnion.$1),
+        email: origin.email.let(PrismaUnion.$1),
+        password: origin.password.let(generateSecureHash).let(PrismaUnion.$1),
+      ));
 
-  @override
-  TaskEither<IError, UserDbo> to(User origin) => TaskEither.of(UserDbo(
+  TaskEither<IError, UserDboCreateInput> fromCreateTo(UserCreate origin) =>
+      TaskEither.of(UserDboCreateInput(
         id: origin.id,
         name: origin.name,
         email: origin.email,
-        password: origin.password,
-        createdAt: origin.createdAt,
-        updatedAt: origin.updatedAt,
+        password: generateSecureHash(origin.password),
       ));
 }

backend-dart/lib/infrastructure/persistence/prisma_database.dart

@@ -1,4 +1,4 @@
-import 'package:backend_dart/domain/interface/database.dart';
+import 'package:backend_dart/domain/data/database.dart';
 import 'package:backend_dart/infrastructure/persistence/db/client.dart';
 import 'package:backend_dart/infrastructure/persistence/prisma_user_data_source.dart';
 

backend-dart/lib/infrastructure/persistence/prisma_user_data_source.dart

@@ -12,36 +12,25 @@ import 'package:uuid/uuid.dart';
 
 import 'db/client.dart';
 
-class PrismaUserDataSource implements UserDataSource<User> {
+class PrismaUserDataSource implements UserDataSource {
   final PrismaClient prisma;
   final UserDboMapper mapper = UserDboMapper();
   PrismaUserDataSource(this.prisma);
 
   @override
-  TaskEither<IError, User> create(User user) {
-    return TaskEither<IError, UserDbo>.tryCatch(
-      () async {
-        if (user.password == null) {
-          throw Exception('Password is required');
-        }
-        if (user.email == null) {
-          throw Exception('Email is required');
-        }
-        final createdUser = await prisma.userDbo.create(
-          data: PrismaUnion.$1(UserDboCreateInput(
-            id: user.id,
-            name: user.name!,
-            email: user.email!,
-            password: user.password!,
-          )),
-        );
-        return createdUser;
-      },
-      (error, _) => AppError.databaseError(
-        message: 'Failed to create user: ${error.toString()}',
-      ),
-    ).flatMap(mapper.from);
-  }
+  TaskEither<IError, User> create(UserCreate user) => mapper
+      .fromCreateTo(user)
+      .flatMap((userDbo) => TaskEither<IError, UserDbo>.tryCatch(
+            () async {
+              final createdUser = await prisma.userDbo.create(
+                data: PrismaUnion.$1(userDbo),
+              );
+              return createdUser;
+            },
+            (error, _) => AppError.databaseError(
+              message: 'Failed to create user: ${error.toString()}',
+            ),
+          ).flatMap(mapper.from));
 
   @override
   TaskEither<IError, User> findByEmail(String email) {
@@ -81,41 +70,36 @@ class PrismaUserDataSource implements UserDataSource<User> {
   }
 
   @override
-  TaskEither<IError, User> update(User user) {
+  TaskEither<IError, User> update(UserUpdate user) {
     return mapper
-        .to(user)
-        .flatMap((userDbo) => TaskEither.tryCatch(() async {
+        .fromUpdateTo(user)
+        .flatMap(
+          (userDbo) => TaskEither.tryCatch(
+            () async {
               // Führe das Update durch
               if (userDbo.id == null) {
                 throw Exception('User ID is required');
               }
 
               final updatedUser = await prisma.userDbo.update(
-                data: PrismaUnion.$2(
-                  UserDboUncheckedUpdateInput(
-                    id: PrismaUnion.$1(userDbo.id!),
-                    name: userDbo.name != null
-                        ? PrismaUnion.$1(userDbo.name!)
-                        : null,
-                    email: userDbo.email != null
-                        ? PrismaUnion.$1(userDbo.email!)
-                        : null,
-                    password: userDbo.password != null
-                        ? PrismaUnion.$1(userDbo.password!)
-                        : null,
-                  ),
-                ),
-                where: UserDboWhereUniqueInput(id: userDbo.id),
+                data: PrismaUnion.$2(userDbo),
+                where: UserDboWhereUniqueInput(id: user.id),
               );
 
               return updatedUser;
             },
-                (error, _) => AppError.databaseError(
-                      message: 'Failed to update user: ${error.toString()}',
-                    )))
-        .flatMap(errorOnNull(AppError.notFound(
-          'User not found',
-        )))
+            (error, _) => AppError.databaseError(
+              message: 'Failed to update user: ${error.toString()}',
+            ),
+          ),
+        )
+        .flatMap(
+          errorOnNull(
+            AppError.notFound(
+              'User not found',
+            ),
+          ),
+        )
         .flatMap(mapper.from);
   }