feat: finish group domain

libs/group-domain/src/lib/factories/group.factory.ts

@@ -0,0 +1,61 @@
+import { Factory } from '@toxictoast/azkaban-base-domain';
+import { GroupAggregate, GroupAnemic, GroupData } from '@azkaban/group-domain';
+
+export class GroupFactory
+  implements Factory<GroupAnemic, GroupAggregate, GroupData>
+{
+  reconstitute(data: GroupAnemic): GroupAggregate {
+    const { id, title, slug, active, created_at, updated_at, deleted_at } =
+      data;
+
+    return new GroupAggregate(
+      id,
+      title,
+      slug,
+      active,
+      created_at,
+      updated_at,
+      deleted_at,
+    );
+  }
+
+  constitute(data: GroupAggregate): GroupAnemic {
+    const {
+      id,
+      title,
+      slug,
+      active,
+      created_at,
+      updated_at,
+      deleted_at,
+      isActive,
+      isUpdated,
+      isDeleted,
+    } = data.toAnemic();
+    return {
+      id,
+      title,
+      slug,
+      active,
+      created_at,
+      updated_at,
+      deleted_at,
+      isActive,
+      isUpdated,
+      isDeleted,
+    };
+  }
+
+  createDomain(data: GroupData): GroupAggregate {
+    const { title } = data;
+    return new GroupAggregate(
+      null,
+      title,
+      null,
+      false,
+      new Date(),
+      new Date(),
+      null,
+    );
+  }
+}

libs/group-domain/src/lib/factories/index.ts

@@ -1 +1 @@
-export {};
+export * from './group.factory';

libs/group-domain/src/lib/repositories/group.repository.ts

@@ -0,0 +1,4 @@
+import { GroupAnemic } from '../anemics';
+import { Repository } from '@toxictoast/azkaban-base-domain';
+
+export type GroupRepository = Repository<GroupAnemic>;

libs/group-domain/src/lib/repositories/index.ts

@@ -1 +1 @@
-export {};
+export * from './group.repository';

libs/group-domain/src/lib/services/group.service.ts

@@ -0,0 +1,132 @@
+import { GroupFactory } from '../factories';
+import { GroupRepository } from '../repositories';
+import { GroupAnemic } from '../anemics';
+import { Result } from '@toxictoast/azkaban-base-domain';
+import { Optional } from '@toxictoast/azkaban-base-types';
+import { GroupData } from '../data';
+
+export class GroupService {
+  private readonly factory: GroupFactory = new GroupFactory();
+
+  constructor(private readonly repository: GroupRepository) {}
+
+  private async save(anemic: GroupAnemic): Promise<Result<GroupAnemic>> {
+    try {
+      const result = await this.repository.save(anemic);
+      return Result.ok<GroupAnemic>(result);
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+
+  async getGroups(
+    limit?: Optional<number>,
+    offset?: Optional<number>,
+  ): Promise<Result<Array<GroupAnemic>>> {
+    try {
+      const result = await this.repository.findList(limit, offset);
+      return Result.ok<Array<GroupAnemic>>(result);
+    } catch (error) {
+      return Result.fail<Array<GroupAnemic>>(error);
+    }
+  }
+
+  async getGroupById(id: string): Promise<Result<GroupAnemic>> {
+    try {
+      const result = await this.repository.findById(id);
+      if (result !== null) {
+        return Result.ok<GroupAnemic>(result);
+      }
+      return Result.fail<GroupAnemic>('Group not found'); // TODO: Add error code
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+
+  async createGroup(data: GroupData): Promise<Result<GroupAnemic>> {
+    try {
+      const aggregate = this.factory.createDomain(data);
+      return await this.save(aggregate.toAnemic());
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+
+  async deleteGroup(id: string): Promise<Result<GroupAnemic>> {
+    try {
+      const group = await this.getGroupById(id);
+      if (group.isSuccess) {
+        const groupValue = group.value;
+        const aggregate = this.factory.reconstitute(groupValue);
+        aggregate.delete();
+        return await this.save(aggregate.toAnemic());
+      }
+      return Result.fail<GroupAnemic>('Group not found'); // TODO: Add error code
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+
+  async restoreGroup(id: string): Promise<Result<GroupAnemic>> {
+    try {
+      const group = await this.getGroupById(id);
+      if (group.isSuccess) {
+        const groupValue = group.value;
+        const aggregate = this.factory.reconstitute(groupValue);
+        aggregate.restore();
+        return await this.save(aggregate.toAnemic());
+      }
+      return Result.fail<GroupAnemic>('Group not found'); // TODO: Add error code
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+
+  async updateTitle(id: string, title: string): Promise<Result<GroupAnemic>> {
+    try {
+      const group = await this.getGroupById(id);
+      if (group.isSuccess) {
+        const groupValue = group.value;
+        const aggregate = this.factory.reconstitute(groupValue);
+        aggregate.updateTitle(title);
+        return await this.save(aggregate.toAnemic());
+      }
+      return Result.fail<GroupAnemic>('Group not found'); // TODO: Add error code
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+
+  async updateSlug(id: string, slug: string): Promise<Result<GroupAnemic>> {
+    try {
+      const group = await this.getGroupById(id);
+      if (group.isSuccess) {
+        const groupValue = group.value;
+        const aggregate = this.factory.reconstitute(groupValue);
+        aggregate.updateSlug(slug);
+        return await this.save(aggregate.toAnemic());
+      }
+      return Result.fail<GroupAnemic>('Group not found'); // TODO: Add error code
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+
+  async updateActive(
+    id: string,
+    active: boolean,
+  ): Promise<Result<GroupAnemic>> {
+    try {
+      const group = await this.getGroupById(id);
+      if (group.isSuccess) {
+        const groupValue = group.value;
+        const aggregate = this.factory.reconstitute(groupValue);
+        aggregate.updateActive(active);
+        return await this.save(aggregate.toAnemic());
+      }
+      return Result.fail<GroupAnemic>('Group not found'); // TODO: Add error code
+    } catch (error) {
+      return Result.fail<GroupAnemic>(error);
+    }
+  }
+}

libs/group-domain/src/lib/services/index.ts

@@ -1 +1 @@
-export {};
+export * from './group.service';

libs/user-domain/src/lib/services/user.service.ts

@@ -38,7 +38,7 @@ export class UserService {
       if (result !== null) {
         return Result.ok<UserAnemic>(result);
       }
-      return Result.fail<UserAnemic>(UserErrorCodes.NOT_ACTIVE);
+      return Result.fail<UserAnemic>(UserErrorCodes.NOT_FOUND);
     } catch (error) {
       return Result.fail<UserAnemic>(error);
     }