refactor(app-aco): implement useCase and controller layers

packages/app-aco/src/Domain/Models/Folder/FolderMapper.ts

@@ -1,27 +1,26 @@
-import { Folder } from "./Folder";
 import { IFolderMapper } from "./IFolderMapper";
+import { ROOT_FOLDER } from "~/constants";
+import { Folder } from "~/folders/domain";
 
 export class FolderMapper implements IFolderMapper {
     toDTO(folder: Folder) {
-        console.log("FolderMapper", folder);
-
         return {
             id: folder.id,
             title: folder.title,
             slug: folder.slug,
             type: folder.type,
-            parentId: folder.parentId || "root",
-            createdBy: folder.createdBy,
-            createdOn: folder.createdOn,
-            savedBy: folder.savedBy,
-            savedOn: folder.savedOn,
-            modifiedBy: folder.modifiedBy,
-            modifiedOn: folder.modifiedOn,
+            parentId: folder.parentId ?? ROOT_FOLDER,
             permissions: folder.permissions,
-            hasNonInheritedPermissions: folder.hasNonInheritedPermissions,
-            canManagePermissions: folder.canManagePermissions,
-            canManageStructure: folder.canManageStructure,
-            canManageContent: folder.canManageContent
+            hasNonInheritedPermissions: folder.hasNonInheritedPermissions ?? false,
+            canManagePermissions: folder.canManagePermissions ?? false,
+            canManageStructure: folder.canManageStructure ?? false,
+            canManageContent: folder.canManageContent ?? false,
+            createdBy: folder.createdBy ?? { id: "", type: "", displayName: "" },
+            createdOn: folder.createdOn ?? "",
+            savedBy: folder.savedBy ?? { id: "", type: "", displayName: "" },
+            savedOn: folder.savedOn ?? "",
+            modifiedBy: folder.modifiedBy ?? null,
+            modifiedOn: folder.modifiedOn ?? null
         };
     }
 }

packages/app-aco/src/Domain/Models/Folder/IFolderMapper.ts

@@ -1,6 +1,6 @@
-import { Folder } from "./Folder";
+import { Folder } from "~/folders/domain";
 import { FolderItem } from "~/types";
 
 export interface IFolderMapper {
-    toDTO: (folder: Folder | FolderItem) => FolderItem;
+    toDTO: (folder: Folder) => FolderItem;
 }

packages/app-aco/src/Domain/Models/Folder/index.ts

@@ -1,3 +1,2 @@
-export * from "./Folder";
 export * from "./FolderMapper";
 export * from "./IFolderMapper";

packages/app-aco/src/components/FolderTree/List/index.tsx

@@ -65,13 +65,10 @@ export const List = ({
 
             setTreeData(newTree);
 
-            await updateFolder(
-                {
-                    ...item,
-                    parentId: dropTargetId !== ROOT_FOLDER ? (dropTargetId as string) : null
-                },
-                { refetchFoldersList: true }
-            );
+            await updateFolder({
+                ...item,
+                parentId: dropTargetId !== ROOT_FOLDER ? (dropTargetId as string) : null
+            });
         } catch (error) {
             return showSnackbar(error.message);
         }

packages/app-aco/src/dialogs/useSetPermissionsDialog.tsx

@@ -122,7 +122,7 @@ export const useSetPermissionsDialog = (): UseSetPermissionsDialogResponse => {
         const updateData = { ...folder, ...data };
 
         try {
-            await updateFolder(updateData, { refetchFoldersList: true });
+            await updateFolder(updateData);
             showSnackbar("Folder permissions updated successfully!");
         } catch (error) {
             showSnackbar(error.message);

packages/app-aco/src/Domain/Caches/FoldersCache.ts → packages/app-aco/src/folders/cache/FoldersCache.ts

@@ -1,6 +1,6 @@
 import { makeAutoObservable } from "mobx";
+import { Folder } from "~/folders/domain";
 import { ICache } from "./ICache";
-import { Folder } from "~/Domain/Models";
 
 export class FoldersCache implements ICache<Folder> {
     private folders: Folder[];

packages/app-aco/src/Domain/Caches/FoldersCacheFactory.ts → packages/app-aco/src/folders/cache/FoldersCacheFactory.ts

@@ -1,4 +1,4 @@
-import { FoldersCache } from "~/Domain/Caches/FoldersCache";
+import { FoldersCache } from "./FoldersCache";
 
 export class FoldersCacheFactory {
     private cache: Map<string, FoldersCache> = new Map();

packages/app-aco/src/Domain/Caches/index.ts → packages/app-aco/src/folders/cache/index.ts

@@ -1,3 +1,3 @@
-export * from "./ICache";
 export * from "./FoldersCache";
 export * from "./FoldersCacheFactory";
+export * from "./ICache";

packages/app-aco/src/folders/controllers/CreateFolder/CreateFolderController.ts

@@ -0,0 +1,22 @@
+import { ICreateFolderController } from "./ICreateFolderController";
+import { ICreateFolderUseCase } from "~/folders/useCases";
+import { FolderItem } from "~/types";
+
+export class CreateFolderController implements ICreateFolderController {
+    private useCase: ICreateFolderUseCase;
+
+    constructor(useCase: ICreateFolderUseCase) {
+        this.useCase = useCase;
+    }
+
+    async execute(folder: FolderItem, type: string) {
+        console.log("type", type);
+        await this.useCase.execute({
+            type: type,
+            title: folder.title,
+            slug: folder.slug,
+            parentId: folder.parentId,
+            permissions: folder.permissions
+        });
+    }
+}

packages/app-aco/src/folders/controllers/CreateFolder/ICreateFolderController.ts

@@ -0,0 +1,5 @@
+import { FolderItem } from "~/types";
+
+export interface ICreateFolderController {
+    execute: (folder: FolderItem, type: string) => Promise<void>;
+}

packages/app-aco/src/folders/controllers/CreateFolder/index.ts

@@ -0,0 +1,2 @@
+export * from "./CreateFolderController";
+export * from "./ICreateFolderController";

packages/app-aco/src/folders/controllers/DeleteFolder/DeleteFolderController.ts

@@ -0,0 +1,15 @@
+import { IDeleteFolderController } from "./IDeleteFolderController";
+import { IDeleteFolderUseCase } from "~/folders/useCases";
+import { FolderItem } from "~/types";
+
+export class DeleteFolderController implements IDeleteFolderController {
+    private useCase: IDeleteFolderUseCase;
+
+    constructor(useCase: IDeleteFolderUseCase) {
+        this.useCase = useCase;
+    }
+
+    async execute(folder: FolderItem) {
+        await this.useCase.execute({ id: folder.id });
+    }
+}

packages/app-aco/src/Domain/Repositories/Folders/CreateFolder/ICreateFolderRepository.ts → packages/app-aco/src/folders/controllers/DeleteFolder/IDeleteFolderController.ts

@@ -1,5 +1,5 @@
 import { FolderItem } from "~/types";
 
-export interface ICreateFolderRepository {
+export interface IDeleteFolderController {
     execute: (folder: FolderItem) => Promise<void>;
 }

packages/app-aco/src/folders/controllers/DeleteFolder/index.ts

@@ -0,0 +1,2 @@
+export * from "./DeleteFolderController";
+export * from "./IDeleteFolderController";

packages/app-aco/src/folders/controllers/GetFolder/GetFolderController.ts

@@ -0,0 +1,14 @@
+import { IGetFolderController } from "./IGetFolderController";
+import { IGetFolderUseCase } from "~/folders/useCases";
+
+export class GetFolderController implements IGetFolderController {
+    private useCase: IGetFolderUseCase;
+
+    constructor(useCase: IGetFolderUseCase) {
+        this.useCase = useCase;
+    }
+
+    async execute(id: string) {
+        await this.useCase.execute({ id });
+    }
+}

packages/app-aco/src/folders/controllers/GetFolder/IGetFolderController.ts

@@ -0,0 +1,3 @@
+export interface IGetFolderController {
+    execute: (id: string) => Promise<void>;
+}

packages/app-aco/src/folders/controllers/GetFolder/index.ts

@@ -0,0 +1,2 @@
+export * from "./GetFolderController";
+export * from "./IGetFolderController";

packages/app-aco/src/folders/controllers/ListFolders/IListFoldersController.ts

@@ -0,0 +1,3 @@
+export interface IListFoldersController {
+    execute: (type: string) => Promise<void>;
+}

packages/app-aco/src/folders/controllers/ListFolders/ListFoldersController.ts

@@ -0,0 +1,14 @@
+import { IListFoldersController } from "./IListFoldersController";
+import { IListFoldersUseCase } from "~/folders/useCases";
+
+export class ListFoldersController implements IListFoldersController {
+    private useCase: IListFoldersUseCase;
+
+    constructor(useCase: IListFoldersUseCase) {
+        this.useCase = useCase;
+    }
+
+    async execute(type: string): Promise<void> {
+        await this.useCase.execute({ type });
+    }
+}

packages/app-aco/src/folders/controllers/ListFolders/index.ts

@@ -0,0 +1,2 @@
+export * from "./IListFoldersController";
+export * from "./ListFoldersController";

packages/app-aco/src/Domain/Repositories/Folders/DeleteFolder/IDeleteFolderRepository.ts → packages/app-aco/src/folders/controllers/UpdateFolder/IUpdateFolderController.ts

@@ -1,5 +1,5 @@
 import { FolderItem } from "~/types";
 
-export interface IDeleteFolderRepository {
+export interface IUpdateFolderController {
     execute: (folder: FolderItem) => Promise<void>;
 }

packages/app-aco/src/folders/controllers/UpdateFolder/UpdateFolderController.ts

@@ -0,0 +1,22 @@
+import { IUpdateFolderController } from "./IUpdateFolderController";
+import { IUpdateFolderUseCase } from "~/folders/useCases";
+import { FolderItem } from "~/types";
+
+export class UpdateFolderController implements IUpdateFolderController {
+    private useCase: IUpdateFolderUseCase;
+
+    constructor(useCase: IUpdateFolderUseCase) {
+        this.useCase = useCase;
+    }
+
+    async execute(folder: FolderItem) {
+        await this.useCase.execute({
+            id: folder.id,
+            title: folder.title,
+            slug: folder.slug,
+            type: folder.type,
+            parentId: folder.parentId,
+            permissions: folder.permissions
+        });
+    }
+}

packages/app-aco/src/folders/controllers/UpdateFolder/index.ts

@@ -0,0 +1,2 @@
+export * from "./IUpdateFolderController";
+export * from "./UpdateFolderController";

packages/app-aco/src/folders/domain/Folder.ts

@@ -0,0 +1,62 @@
+import { CmsIdentity, FolderPermission } from "~/types";
+
+export interface FolderData {
+    id?: string;
+    title: string;
+    slug: string;
+    type: string;
+    parentId: string | null;
+    permissions: FolderPermission[];
+    hasNonInheritedPermissions?: boolean;
+    canManagePermissions?: boolean;
+    canManageStructure?: boolean;
+    canManageContent?: boolean;
+    createdBy?: CmsIdentity;
+    createdOn?: string;
+    savedBy?: CmsIdentity;
+    savedOn?: string;
+    modifiedBy?: CmsIdentity | null;
+    modifiedOn?: string | null;
+}
+
+export class Folder {
+    public id: string;
+    public title: string;
+    public slug: string;
+    public type: string;
+    public parentId: string | null;
+    public permissions: FolderPermission[];
+    public hasNonInheritedPermissions?: boolean;
+    public canManagePermissions?: boolean;
+    public canManageStructure?: boolean;
+    public canManageContent?: boolean;
+    public createdBy?: CmsIdentity;
+    public createdOn?: string;
+    public savedBy?: CmsIdentity;
+    public savedOn?: string;
+    public modifiedBy?: CmsIdentity | null;
+    public modifiedOn?: string | null;
+
+    protected constructor(folder: FolderData) {
+        this.id = folder.id ?? "";
+        this.title = folder.title;
+        this.slug = folder.slug;
+        this.type = folder.type;
+        this.parentId = folder.parentId;
+        this.permissions = folder.permissions;
+        this.hasNonInheritedPermissions = folder.hasNonInheritedPermissions;
+        this.canManagePermissions = folder.canManagePermissions;
+        this.canManageStructure = folder.canManageStructure;
+        this.canManageContent = folder.canManageContent;
+        this.createdBy = folder.createdBy;
+        this.createdOn = folder.createdOn;
+        this.savedBy = folder.savedBy;
+        this.savedOn = folder.savedOn;
+        this.modifiedBy = folder.modifiedBy;
+        this.modifiedOn = folder.modifiedOn;
+    }
+
+    static create(folder: FolderData) {
+        return new Folder(folder);
+    }
+}

packages/app-aco/src/folders/domain/index.ts

@@ -0,0 +1 @@
+export * from "./Folder";