added project repository

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

@@ -0,0 +1,64 @@
+import 'package:backend_dart/common/extensions.dart';
+import 'package:backend_dart/domain/entities/project.dart';
+import 'package:backend_dart/domain/interface/error.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 ProjectDboMapper {
+  TaskEither<IError, ProjectDbo> toDbo(Project project) {
+    return TaskEither.of(ProjectDbo(
+      id: project.id,
+      name: project.name,
+      description: project.description,
+      clientId: project.clientId,
+      userId: project.userId,
+      createdAt: project.createdAt,
+      updatedAt: project.updatedAt,
+    ));
+  }
+
+  TaskEither<IError, Project> fromDbo(ProjectDbo dbo) {
+    return TaskEither.of(Project(
+      id: dbo.id!,
+      name: dbo.name!,
+      description: dbo.description,
+      clientId: dbo.clientId,
+      userId: dbo.userId!,
+      createdAt: dbo.createdAt!,
+      updatedAt: dbo.updatedAt!,
+    ));
+  }
+
+  TaskEither<IError, ProjectDboCreateInput> fromCreatetoDbo(
+      ProjectCreate project) {
+    return TaskEither.of(ProjectDboCreateInput(
+      name: project.name,
+      description: project.description.let(PrismaUnion.$1),
+      clientId: project.clientId.let(PrismaUnion.$1),
+      user: UserDboCreateNestedOneWithoutProjectsInput(
+        connect: UserDboWhereUniqueInput(id: project.userId),
+      ),
+    ));
+  }
+
+  TaskEither<IError, ProjectDboUpdateInput> fromUpdateToDbo(
+      ProjectUpdate project) {
+    return TaskEither.of(ProjectDboUpdateInput(
+      id: PrismaUnion.$1(project.id),
+      name: project.name.let(PrismaUnion.$1),
+      description: project.description.let(PrismaUnion.$1),
+      clientId: project.clientId.let(PrismaUnion.$1),
+      user: project.userId.let(
+        (userId) => UserDboUpdateOneRequiredWithoutProjectsNestedInput(
+          connect: UserDboWhereUniqueInput(id: userId),
+        ),
+      ),
+    ));
+  }
+
+  TaskEither<IError, List<Project>> listFrom(Iterable<ProjectDbo> dbos) {
+    return TaskEither.traverseList(dbos.toList(), fromDbo);
+  }
+}

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

@@ -21,9 +21,8 @@ class UserDboMapper {
     return TaskEither.traverseList(targets.toList(), from);
   }
 
-  TaskEither<IError, UserDboUncheckedUpdateInput> fromUpdateTo(
-          UserUpdate origin) =>
-      TaskEither.of(UserDboUncheckedUpdateInput(
+  TaskEither<IError, UserDboUpdateInput> fromUpdateTo(UserUpdate origin) =>
+      TaskEither.of(UserDboUpdateInput(
         id: PrismaUnion.$1(origin.id),
         name: origin.name.let(PrismaUnion.$1),
         email: origin.email.let(PrismaUnion.$1),

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

@@ -0,0 +1,128 @@
+import 'package:backend_dart/common/error_on_null.dart';
+import 'package:backend_dart/domain/data/project_data_source.dart';
+import 'package:backend_dart/domain/entities/project.dart';
+import 'package:backend_dart/domain/errors/app_error.dart';
+import 'package:backend_dart/domain/interface/error.dart';
+import 'package:backend_dart/infrastructure/persistence/db/client.dart';
+import 'package:backend_dart/infrastructure/persistence/db/model.dart';
+import 'package:backend_dart/infrastructure/persistence/db/prisma.dart';
+import 'package:backend_dart/infrastructure/persistence/mapper/project_dbo_mapper.dart';
+import 'package:fpdart/fpdart.dart';
+import 'package:orm/orm.dart';
+
+class PrismaProjectDataSource implements ProjectDataSource {
+  final PrismaClient prisma;
+  final ProjectDboMapper mapper = ProjectDboMapper();
+
+  PrismaProjectDataSource(this.prisma);
+
+  @override
+  TaskEither<IError, Project> createProject(ProjectCreate project) {
+    return mapper
+        .fromCreatetoDbo(project)
+        .flatMap((projectDbo) => TaskEither.tryCatch(
+              () async {
+                return await prisma.projectDbo.create(
+                  data: PrismaUnion.$1(projectDbo),
+                );
+              },
+              (error, _) => AppError.databaseError(
+                message: 'Failed to create project: ${error.toString()}',
+              ),
+            ))
+        .flatMap(mapper.fromDbo);
+  }
+
+  @override
+  TaskEither<IError, Project> findProjectById(String id) {
+    return TaskEither<IError, ProjectDbo?>.tryCatch(
+      () async {
+        final project = await prisma.projectDbo
+            .findUnique(where: ProjectDboWhereUniqueInput(id: id));
+        return project;
+      },
+      (error, _) => AppError.databaseError(
+        message: 'Failed to find project by ID: ${error.toString()}',
+      ),
+    )
+        .flatMap(
+            errorOnNull(AppError.notFound('Project with ID $id not found')))
+        .flatMap(mapper.fromDbo);
+  }
+
+  @override
+  TaskEither<IError, List<Project>> findProjectsByUserId(String userId) {
+    return TaskEither<IError, Iterable<ProjectDbo>>.tryCatch(
+      () async {
+        final projects = await prisma.projectDbo.findMany(
+          where: ProjectDboWhereInput(
+              userId: PrismaUnion.$1(StringFilter(
+            equals: PrismaUnion.$1(userId),
+          ))),
+        );
+        return projects;
+      },
+      (error, _) => AppError.databaseError(
+        message: 'Failed to find projects by user ID: ${error.toString()}',
+      ),
+    ).flatMap(mapper.listFrom);
+  }
+
+  @override
+  TaskEither<IError, Project> updateProject(ProjectUpdate project) {
+    return mapper
+        .fromUpdateToDbo(project)
+        .flatMap(
+          (projectDbo) => TaskEither.tryCatch(
+            () async {
+              return await prisma.projectDbo.update(
+                data: PrismaUnion.$1(projectDbo),
+                where: ProjectDboWhereUniqueInput(id: project.id),
+              );
+            },
+            (error, _) => AppError.databaseError(
+              message: 'Failed to update project: ${error.toString()}',
+            ),
+          ),
+        )
+        .flatMap(
+          errorOnNull(
+            AppError.notFound(
+              'Project with ID ${project.id} not found',
+            ),
+          ),
+        )
+        .flatMap(mapper.fromDbo);
+  }
+
+  @override
+  TaskEither<IError, Project> deleteProject(String id) {
+    return TaskEither<IError, ProjectDbo?>.tryCatch(
+      () async {
+        return await prisma.projectDbo
+            .delete(where: ProjectDboWhereUniqueInput(id: id));
+      },
+      (error, _) => AppError.databaseError(
+        message: 'Failed to delete project: ${error.toString()}',
+      ),
+    )
+        .flatMap(
+          errorOnNull(
+            AppError.notFound(
+              'Project with ID $id not found',
+            ),
+          ),
+        )
+        .flatMap(mapper.fromDbo);
+  }
+
+  @override
+  TaskEither<IError, List<Project>> findAllProjects() {
+    return TaskEither<IError, Iterable<ProjectDbo>>.tryCatch(
+      () async => await prisma.projectDbo.findMany(),
+      (error, _) => AppError.databaseError(
+        message: 'Failed to fetch all projects: ${error.toString()}',
+      ),
+    ).flatMap(mapper.listFrom);
+  }
+}

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

@@ -82,7 +82,7 @@ class PrismaUserDataSource implements UserDataSource {
               }
 
               final updatedUser = await prisma.userDbo.update(
-                data: PrismaUnion.$2(userDbo),
+                data: PrismaUnion.$1(userDbo),
                 where: UserDboWhereUniqueInput(id: user.id),
               );