refact: generate project provider methods

frontend/context/Project/createAreaProviderMethods.ts

@@ -0,0 +1,84 @@
+import { saveDocuments } from '../../useCases/saveData'
+import { GetProcessedAreasByDocumentId, RequestAddArea, RequestAddProcessedArea, RequestChangeAreaOrder, RequestDeleteAreaById, RequestUpdateArea } from '../../wailsjs/wailsjs/go/ipc/Channel'
+import { ipc } from '../../wailsjs/wailsjs/go/models'
+import { AddAreaProps, AreaProps } from './types'
+
+type Dependencies = {
+  documents: ipc.Document[]
+  updateDocuments: () => Promise<ipc.GetDocumentsResponse>
+  selectedDocumentId: string
+}
+
+const createAreaProviderMethods = (dependencies: Dependencies) => {
+  const { documents, updateDocuments, selectedDocumentId } = dependencies
+
+  const getAreaById = (areaId: string): ipc.Area | undefined => (
+    documents.map(d => d.areas).flat().find(a => a.id === areaId)
+  )
+
+  const getProcessedAreaById = async (areaId: string) => {
+    try {
+      if (!selectedDocumentId || !areaId) return
+      const processedAreas = await getProcessedAreasByDocumentId(selectedDocumentId)
+      const foundProcessedArea = processedAreas.find(a => a.id === areaId)
+      return foundProcessedArea
+    } catch (err) {
+      console.error(err)
+      return Promise.resolve(undefined)
+    }
+  }
+
+  const getProcessedAreasByDocumentId = async (documentId: string) => {
+    let response: ipc.ProcessedArea[] = []
+    try {
+      response = await GetProcessedAreasByDocumentId(documentId)
+    } catch (err) {
+      console.log(err)
+    }
+    return response
+  }
+
+  const requestAddArea = async (documentId: string, area: AddAreaProps): Promise<ipc.Area> => {
+    const response = await RequestAddArea(documentId, new ipc.Area(area))
+    if (response.id) await updateDocuments()
+    saveDocuments()
+    return response
+  }
+
+  const requestUpdateArea = async (updatedArea: AreaProps): Promise<ipc.Area> => {
+    const response = await RequestUpdateArea(new ipc.Area(updatedArea))
+
+    if (response.id) await updateDocuments()
+    saveDocuments()
+    return response
+  }
+
+  const requestDeleteAreaById = async (areaId: string): Promise<boolean> => {
+    const wasSuccessfulDeletion = await RequestDeleteAreaById(areaId)
+    if (wasSuccessfulDeletion) updateDocuments()
+    saveDocuments()
+    return wasSuccessfulDeletion
+  }
+
+  const requestAddProcessedArea = async (processedArea: ipc.ProcessedArea) => await RequestAddProcessedArea(processedArea)
+
+  const requestChangeAreaOrder = async (areaId: string, newOrder: number) => {
+    const response = await RequestChangeAreaOrder(areaId, newOrder)
+    await updateDocuments()
+    saveDocuments()
+    return response
+  }
+
+  return {
+    requestAddArea,
+    requestUpdateArea,
+    getAreaById,
+    requestDeleteAreaById,
+    getProcessedAreasByDocumentId,
+    requestAddProcessedArea,
+    requestChangeAreaOrder,
+    getProcessedAreaById,
+  }
+}
+
+export default createAreaProviderMethods

frontend/context/Project/createDocumentMethods.ts

@@ -0,0 +1,78 @@
+import { saveGroups } from '../../useCases/saveData'
+import { RequestAddDocument, RequestAddDocumentGroup, RequestChangeGroupOrder, RequestDeleteDocumentAndChildren, RequestUpdateDocument, RequestUpdateProcessedWordById } from '../../wailsjs/wailsjs/go/ipc/Channel'
+import { ipc } from '../../wailsjs/wailsjs/go/models'
+import { UpdateDocumentRequest } from './types'
+
+type Dependencies = {
+  selectedDocumentId: string
+  documents: ipc.Document[]
+  saveDocuments: () => Promise<void>
+  updateDocuments: () => Promise<ipc.GetDocumentsResponse>
+  groups: ipc.Group[]
+}
+
+const createDocumentProviderMethods = (dependencies: Dependencies) => {
+  const { selectedDocumentId, documents, saveDocuments, updateDocuments, groups } = dependencies
+
+  const getGroupById = (groupId: string): ipc.Group | undefined => (
+    groups.find(g => g.id === groupId)
+  )
+
+  const getSelectedDocument = () => documents.find(d => d.id === selectedDocumentId)
+
+  const requestAddDocument = async (groupId: string, documentName: string) => {
+    const response = await RequestAddDocument(groupId, documentName)
+    if (response.id) await updateDocuments()
+    saveDocuments()
+    return response
+  }
+
+  const requestDeleteDocumentById = async (documentId: string): Promise<boolean> => {
+    const wasSuccessfulDeletion = await RequestDeleteDocumentAndChildren(documentId)
+    updateDocuments()
+    saveDocuments()
+    return wasSuccessfulDeletion
+  }
+
+  const requestAddDocumentGroup = async (groupName: string) => {
+    const response = await RequestAddDocumentGroup(groupName)
+    if (response.id) await updateDocuments()
+    saveGroups()
+    return response
+  }
+
+  const requestUpdateDocument = async (documentProps: UpdateDocumentRequest) => {
+    const response = await RequestUpdateDocument(new ipc.Document(documentProps))
+    await updateDocuments()
+    saveDocuments()
+    return response
+  }
+
+  const requestChangeGroupOrder = async (groupId: string, newOrder: number) => {
+    const response = await RequestChangeGroupOrder(groupId, newOrder)
+    console.log('should be at ', newOrder)
+    console.log(response)
+    await updateDocuments()
+    saveGroups()
+    return response
+  }
+
+
+  const requestUpdateProcessedWordById = async (wordId: string, newTextValue: string) => {
+    const successfulResponse = await RequestUpdateProcessedWordById(wordId, newTextValue)
+    return successfulResponse
+  }
+
+  return {
+    getGroupById,
+    getSelectedDocument,
+    requestAddDocument,
+    requestDeleteDocumentById,
+    requestAddDocumentGroup,
+    requestUpdateDocument,
+    requestChangeGroupOrder,
+    requestUpdateProcessedWordById,
+  }
+}
+
+export default createDocumentProviderMethods

frontend/context/Project/createSessionProviderMethods.ts

@@ -0,0 +1,45 @@
+import { CreateNewProject, RequestChangeSessionProjectByName, RequestChooseUserAvatar, RequestUpdateCurrentUser } from '../../wailsjs/wailsjs/go/ipc/Channel'
+import { ipc } from '../../wailsjs/wailsjs/go/models'
+import { UserProps } from './types'
+
+type Dependencies = {
+  updateSession: () => Promise<ipc.Session>
+  updateDocuments: () => Promise<ipc.GetDocumentsResponse>
+}
+
+const createSessionProviderMethods = (dependencies: Dependencies) => {
+  const { updateSession, updateDocuments } = dependencies
+
+  const createNewProject = async (name: string) => {
+    const sessionResponse = await CreateNewProject(name)
+    await updateSession()
+    return sessionResponse
+  }
+
+  const requestUpdateCurrentUser = async (userProps: UserProps) => {
+    const response = await RequestUpdateCurrentUser(new ipc.User(userProps))
+    await updateSession()
+    return response
+  }
+
+  const requestChooseUserAvatar = async () => {
+    const filePathResponse = await RequestChooseUserAvatar()
+    return filePathResponse
+  }
+
+  const requestSelectProjectByName = async (name: string) => {
+    const successfulResponse = await RequestChangeSessionProjectByName(name)
+    await updateSession()
+    await updateDocuments()
+    return successfulResponse
+  }
+
+  return {
+    createNewProject,
+    requestUpdateCurrentUser,
+    requestChooseUserAvatar,
+    requestSelectProjectByName,
+  }
+}
+
+export default createSessionProviderMethods

frontend/context/Project/createUserMarkdownProviderMethods.ts

@@ -0,0 +1,37 @@
+import { saveUserProcessedMarkdown } from '../../useCases/saveData'
+import { GetUserMarkdownByDocumentId, RequestUpdateDocumentUserMarkdown } from '../../wailsjs/wailsjs/go/ipc/Channel'
+import { ipc } from '../../wailsjs/wailsjs/go/models'
+
+type Dependencies = {}
+
+const createUserMarkdownProviderMethods = (dependencies?: Dependencies) => {
+
+  const requestUpdateDocumentUserMarkdown = async (documentId: string, markdown: string) => {
+    let response: ipc.UserMarkdown = new ipc.UserMarkdown()
+    try {
+      response = await RequestUpdateDocumentUserMarkdown(documentId, markdown)
+      await saveUserProcessedMarkdown()
+    } catch (err) {
+      console.error(err)
+    }
+    return response
+  }
+
+  const getUserMarkdownByDocumentId = async (documentId: string): Promise<ipc.UserMarkdown> => {
+    let response: ipc.UserMarkdown = new ipc.UserMarkdown({})
+    try {
+      response = await GetUserMarkdownByDocumentId(documentId)
+    } catch (err) {
+      console.error(err)
+    }
+
+    return response
+  }
+
+  return {
+    requestUpdateDocumentUserMarkdown,
+    getUserMarkdownByDocumentId,
+  }
+}
+
+export default createUserMarkdownProviderMethods

frontend/context/Project/provider.tsx

@@ -1,24 +1,15 @@
 'use client'
 
 import { createContext, ReactNode, useContext, useEffect, useState } from 'react'
-import {
+import { GetCurrentSession, GetDocuments, } from '../../wailsjs/wailsjs/go/ipc/Channel'
-  CreateNewProject, GetCurrentSession, GetDocuments,
-  GetProcessedAreasByDocumentId, GetUserMarkdownByDocumentId, RequestAddArea,
-  RequestAddDocument, RequestAddDocumentGroup, RequestAddProcessedArea,
-  RequestUpdateArea, RequestUpdateCurrentUser, RequestUpdateDocumentUserMarkdown,
-  RequestChooseUserAvatar,
-  RequestUpdateDocument,
-  RequestChangeAreaOrder,
-  RequestDeleteAreaById,
-  RequestChangeGroupOrder,
-  RequestChangeSessionProjectByName,
-  RequestDeleteDocumentAndChildren,
-  RequestUpdateProcessedWordById
-} from '../../wailsjs/wailsjs/go/ipc/Channel'
 import { ipc } from '../../wailsjs/wailsjs/go/models'
-import { AddAreaProps, AreaProps, ProjectContextType, ProjectProps, UpdateDocumentRequest, UserProps } from './types'
+import { ProjectContextType, ProjectProps } from './types'
 import makeDefaultProject from './makeDefaultProject'
-import { saveDocuments, saveGroups, saveUserProcessedMarkdown } from '../../useCases/saveData'
+import { saveDocuments } from '../../useCases/saveData'
+import createAreaProviderMethods from './createAreaProviderMethods'
+import createDocumentProviderMethods from './createDocumentMethods'
+import createSessionProviderMethods from './createSessionProviderMethods'
+import createUserMarkdownProviderMethods from './createUserMarkdownProviderMethods'
 
 const ProjectContext = createContext<ProjectContextType>(makeDefaultProject())
 
@@ -35,171 +26,23 @@ export function ProjectProvider({ children, projectProps }: Props) {
   const [currentSession, setCurrentSession] = useState<ipc.Session>(new ipc.Session())
 
   const updateDocuments = async () => {
-    GetDocuments().then(response => {
+    const response = await GetDocuments()
-      setDocuments(response.documents)
+    const { documents, groups } = response
-      setGroups(response.groups)
+    setDocuments(documents)
-      Promise.resolve(response)
+    setGroups(groups)
-    })
-  }
-
-  const requestAddDocument = async (groupId: string, documentName: string) => {
-    const response = await RequestAddDocument(groupId, documentName)
-    if (response.id) await updateDocuments()
-    saveDocuments()
     return response
   }
 
-  const requestDeleteDocumentById = async (documentId: string): Promise<boolean> => {
-    const wasSuccessfulDeletion = await RequestDeleteDocumentAndChildren(documentId)
-    updateDocuments()
-    saveDocuments()
-    return wasSuccessfulDeletion
-  }
-
-  const requestAddDocumentGroup = async (groupName: string) => {
-    const response = await RequestAddDocumentGroup(groupName)
-    if (response.id) await updateDocuments()
-    saveGroups()
-    return response
-  }
-
-  const requestAddArea = async (documentId: string, area: AddAreaProps): Promise<ipc.Area> => {
-    const response = await RequestAddArea(documentId, new ipc.Area(area))
-    if (response.id) await updateDocuments()
-    saveDocuments()
-    return response
-  }
-
-  const requestUpdateArea = async (updatedArea: AreaProps): Promise<ipc.Area> => {
-    const response = await RequestUpdateArea(new ipc.Area(updatedArea))
-
-    if (response.id) await updateDocuments()
-    saveDocuments()
-    return response
-  }
-
-  const getAreaById = (areaId: string): ipc.Area | undefined => (
-    documents.map(d => d.areas).flat().find(a => a.id === areaId)
-  )
-
-  const requestDeleteAreaById = async (areaId: string): Promise<boolean> => {
-    const wasSuccessfulDeletion = await RequestDeleteAreaById(areaId)
-    if (wasSuccessfulDeletion) updateDocuments()
-    saveDocuments()
-    return wasSuccessfulDeletion
-  }
-
-  const getSelectedDocument = () => documents.find(d => d.id === selectedDocumentId)
-
-  const getProcessedAreasByDocumentId = async (documentId: string) => {
-    let response: ipc.ProcessedArea[] = []
-    try {
-      response = await GetProcessedAreasByDocumentId(documentId)
-    } catch (err) {
-      console.log(err)
-    }
-    return response
-  }
-
-  const requestUpdateDocumentUserMarkdown = async (documentId: string, markdown: string) => {
-    let response: ipc.UserMarkdown = new ipc.UserMarkdown()
-    try {
-      response = await RequestUpdateDocumentUserMarkdown(documentId, markdown)
-      await saveUserProcessedMarkdown()
-    } catch (err) {
-      console.error(err)
-    }
-    return response
-  }
-
-  const getUserMarkdownByDocumentId = async (documentId: string): Promise<ipc.UserMarkdown> => {
-    let response: ipc.UserMarkdown = new ipc.UserMarkdown({})
-    try {
-      response = await GetUserMarkdownByDocumentId(documentId)
-    } catch (err) {
-      console.error(err)
-    }
-
-    return response
-  }
-
-  const requestAddProcessedArea = async (processedArea: ipc.ProcessedArea) => await RequestAddProcessedArea(processedArea)
-
   const updateSession = async () => {
-    GetCurrentSession().then(response => {
+    const response = await GetCurrentSession()
-      if (response) setCurrentSession(response)
+    if (response) setCurrentSession(response)
-      console.log(response)
-      Promise.resolve(response)
-    })
-  }
-
-  const createNewProject = async (name: string) => {
-    const sessionResponse = await CreateNewProject(name)
-    await updateSession()
-    return sessionResponse
-  }
-
-  const requestUpdateCurrentUser = async (userProps: UserProps) => {
-    const response = await RequestUpdateCurrentUser(new ipc.User(userProps))
-    await updateSession()
     return response
   }
 
-  const requestChooseUserAvatar = async () => {
+  const documentMethods = createDocumentProviderMethods({ documents, saveDocuments, updateDocuments, selectedDocumentId, groups })
-    const filePathResponse = await RequestChooseUserAvatar()
+  const areaMethods = createAreaProviderMethods({ documents, updateDocuments, selectedDocumentId })
-    return filePathResponse
+  const sessionMethods = createSessionProviderMethods({ updateSession, updateDocuments })
-  }
+  const userMarkDownMethods = createUserMarkdownProviderMethods()
-
-  const requestUpdateDocument = async (docuemntProps: UpdateDocumentRequest) => {
-    const response = await RequestUpdateDocument(new ipc.Document(docuemntProps))
-    await updateDocuments()
-    saveDocuments()
-    return response
-  }
-
-  const requestChangeAreaOrder = async (areaId: string, newOrder: number) => {
-    const response = await RequestChangeAreaOrder(areaId, newOrder)
-    await updateDocuments()
-    saveDocuments()
-    return response
-  }
-
-  const getGroupById = (groupId: string): ipc.Group | undefined => (
-    groups.find(g => g.id === groupId)
-  )
-
-  const requestChangeGroupOrder = async (groupId: string, newOrder: number) => {
-    const response = await RequestChangeGroupOrder(groupId, newOrder)
-    console.log('should be at ', newOrder)
-    console.log(response)
-    await updateDocuments()
-    saveGroups()
-    return response
-  }
-
-  const requestSelectProjectByName = async (name: string) => {
-    const successfulResponse = await RequestChangeSessionProjectByName(name)
-    await updateSession()
-    await updateDocuments()
-    return successfulResponse
-  }
-
-  const requestUpdateProcessedWordById = async (wordId: string, newTextValue: string) => {
-    const successfulResponse = await RequestUpdateProcessedWordById(wordId, newTextValue)
-    return successfulResponse
-  }
-
-  const getProcessedAreaById = async (areaId: string) => {
-    try {
-      if (!selectedDocumentId || !areaId) return
-      const processedAreas = await getProcessedAreasByDocumentId(selectedDocumentId)
-      const foundProcessedArea = processedAreas.find(a => a.id === areaId)
-      return foundProcessedArea
-    } catch (err) {
-      console.error(err)
-      return Promise.resolve(undefined)
-    }
-  }
 
 
   useEffect(() => {
@@ -217,33 +60,15 @@ export function ProjectProvider({ children, projectProps }: Props) {
     id: '',
     documents,
     groups,
-    getSelectedDocument,
-    getAreaById,
-    requestAddArea,
-    requestAddDocument,
-    requestDeleteDocumentById,
-    requestAddDocumentGroup,
-    requestUpdateArea,
-    requestDeleteAreaById,
     selectedAreaId,
     setSelectedAreaId,
     selectedDocumentId,
     setSelectedDocumentId,
-    getProcessedAreasByDocumentId,
-    requestAddProcessedArea,
-    requestUpdateDocumentUserMarkdown,
-    getUserMarkdownByDocumentId,
     currentSession,
-    createNewProject,
+    ...areaMethods,
-    requestUpdateCurrentUser,
+    ...documentMethods,
-    requestChooseUserAvatar,
+    ...sessionMethods,
-    requestUpdateDocument,
+    ...userMarkDownMethods,
-    requestChangeAreaOrder,
-    requestChangeGroupOrder,
-    getGroupById,
-    requestSelectProjectByName,
-    requestUpdateProcessedWordById,
-    getProcessedAreaById,
   }
 
   return <ProjectContext.Provider value={value}>