Changes for project-setting service to use schema, knex & feathers 5 (#…

…8746) * Migrated project-setting service * Updated imports * Updated project find method * Removed project-setting service * Updated imports * Fixed project resolvers * Ensuring cloned params * Updated condition for allowed * Ensuring project-setting is object * Added user in project permission find params * Moved resolver converter * Updated project find return type * Updated fetchProjects * Added useGet * Added paginate false * Updated useGet * Removed paginate false
EtherealEngine · Oct 13, 2023 · 45cd16a · 45cd16a
1 parent f14f29b
commit 45cd16a
Show file tree

Hide file tree

Showing 17 changed files with 127 additions and 290 deletions.
diff --git a/packages/client-core/src/admin/components/Setting/Project.tsx b/packages/client-core/src/admin/components/Setting/Project.tsx
@@ -35,31 +35,22 @@ import Button from '@etherealengine/ui/src/primitives/mui/Button'
 import Grid from '@etherealengine/ui/src/primitives/mui/Grid'
 import Typography from '@etherealengine/ui/src/primitives/mui/Typography'
 
-import { useFind, useMutation } from '@etherealengine/engine/src/common/functions/FeathersHooks'
-import { projectPath } from '@etherealengine/engine/src/schemas/projects/project.schema'
+import { useGet, useMutation } from '@etherealengine/engine/src/common/functions/FeathersHooks'
+import { ProjectSettingType, projectPath } from '@etherealengine/engine/src/schemas/projects/project.schema'
 import { ProjectService, ProjectState } from '../../../common/services/ProjectService'
 import styles from '../../styles/settings.module.scss'
 
-interface ProjectSetting {
-  key: string
-  value: any
-}
-
 const Project = () => {
   const { t } = useTranslation()
   const projectState = useHookstate(getMutableState(ProjectState))
   const projects = projectState.projects
 
-  const settings = useHookstate<Array<ProjectSetting> | []>([])
+  const settings = useHookstate<Array<ProjectSettingType> | []>([])
   const selectedProject = useHookstate(projects.get(NO_PROXY).length > 0 ? projects.get(NO_PROXY)[0].id : '')
 
-  let projectSetting = useFind('project-setting', {
-    query: {
-      $limit: 1,
-      id: selectedProject.value,
-      $select: ['settings']
-    }
-  }).data
+  const project = useGet(projectPath, selectedProject.value, { query: { $select: ['settings'] } }).data
+
+  let projectSetting = project?.settings || []
 
   const patchProjectSetting = useMutation(projectPath).patch
 
@@ -80,7 +71,6 @@ const Project = () => {
       return
     }
 
-    if (typeof projectSetting === 'string') projectSetting = JSON.parse(projectSetting)
     const tempSettings = JSON.parse(JSON.stringify(settings.value))
     for (const [index, setting] of tempSettings.entries()) {
       const savedSetting = projectSetting.filter((item) => item.key === setting.key)
@@ -96,7 +86,7 @@ const Project = () => {
     const projectConfig = projectName?.length > 0 && (await loadConfigForProject(projectName[0].name))
 
     if (projectConfig && projectConfig?.settings) {
-      const tempSetting = [] as ProjectSetting[]
+      const tempSetting = [] as ProjectSettingType[]
 
       for (const setting of projectConfig.settings) {
         tempSetting.push({ key: setting.key, value: '' })

diff --git a/packages/client-core/src/common/services/ProjectService.ts b/packages/client-core/src/common/services/ProjectService.ts
@@ -50,6 +50,7 @@ import { projectGithubPushPath } from '@etherealengine/engine/src/schemas/projec
 import { projectInvalidatePath } from '@etherealengine/engine/src/schemas/projects/project-invalidate.schema'
 import { projectPermissionPath } from '@etherealengine/engine/src/schemas/projects/project-permission.schema'
 import { projectPath, ProjectType } from '@etherealengine/engine/src/schemas/projects/project.schema'
+import { Paginated } from '@feathersjs/feathers'
 import { API } from '../../API'
 import { NotificationService } from './NotificationService'
 
@@ -106,10 +107,13 @@ export const ProjectServiceReceptor = (action) => {
 //Service
 export const ProjectService = {
   fetchProjects: async () => {
-    const projects = await API.instance.client.service(projectPath).find({ paginate: false, query: { allowed: true } })
-    dispatchAction(ProjectAction.projectsFetched({ projectResult: projects.data }))
-    for (let error of projects.errors) {
-      NotificationService.dispatchNotify(error.message || JSON.stringify(error), { variant: 'error' })
+    try {
+      const projects = (await API.instance.client
+        .service(projectPath)
+        .find({ query: { allowed: true } })) as Paginated<ProjectType>
+      dispatchAction(ProjectAction.projectsFetched({ projectResult: projects.data }))
+    } catch (err) {
+      NotificationService.dispatchNotify(err.message || JSON.stringify(err), { variant: 'error' })
     }
   },
 

diff --git a/packages/editor/src/functions/projectFunctions.tsx b/packages/editor/src/functions/projectFunctions.tsx
@@ -29,6 +29,7 @@ import { SceneState } from '@etherealengine/engine/src/ecs/classes/Scene'
 import { dispatchAction, getMutableState } from '@etherealengine/hyperflux'
 
 import { ProjectType, projectPath } from '@etherealengine/engine/src/schemas/projects/project.schema'
+import { Paginated } from '@feathersjs/feathers'
 import { EditorHistoryAction } from '../services/EditorHistory'
 import { EditorControlFunctions } from './EditorControlFunctions'
 
@@ -38,10 +39,10 @@ import { EditorControlFunctions } from './EditorControlFunctions'
  */
 export const getProjects = async (): Promise<ProjectType[]> => {
   try {
-    const { data } = await API.instance.client.service(projectPath).find({
+    const projects = (await API.instance.client.service(projectPath).find({
       query: { allowed: true }
-    })
-    return data
+    })) as Paginated<ProjectType>
+    return projects.data
   } catch (error) {
     throw new Error(error)
   }

diff --git a/packages/server-core/src/hooks/project-permission-authenticate.ts b/packages/server-core/src/hooks/project-permission-authenticate.ts
@@ -32,7 +32,7 @@ import {
   ProjectPermissionType,
   projectPermissionPath
 } from '@etherealengine/engine/src/schemas/projects/project-permission.schema'
-import { projectPath } from '@etherealengine/engine/src/schemas/projects/project.schema'
+import { ProjectType, projectPath } from '@etherealengine/engine/src/schemas/projects/project.schema'
 import {
   IdentityProviderType,
   identityProviderPath
@@ -53,12 +53,12 @@ export default (writeAccess) => {
     let projectId, projectRepoPath
     const projectName = context.arguments[0]?.projectName || params.query?.projectName
     if (projectName) {
-      const project = await app.service(projectPath).find({
+      const project = (await app.service(projectPath).find({
         query: {
           name: projectName,
           $limit: 1
         }
-      })
+      })) as Paginated<ProjectType>
 
       if (project.data.length > 0) {
         projectRepoPath = project.data[0].repositoryPath

diff --git a/packages/server-core/src/projects/project-permission/project-permission.class.ts b/packages/server-core/src/projects/project-permission/project-permission.class.ts
@@ -87,20 +87,26 @@ export class ProjectPermissionService<
   }
 
   async find(params?: ProjectPermissionParams) {
-    const loggedInUser = params!.user!
-    if (loggedInUser?.scopes?.find((scope) => scope.type === 'admin:admin')) return super._find(params)
-    if (params?.query?.projectId) {
+    if (!params) params = {}
+    if (!params.query) params.query = {}
+
+    const loggedInUser = params.user
+
+    if (!loggedInUser) throw new BadRequest('User missing from request')
+
+    if (loggedInUser.scopes?.find((scope) => scope.type === 'admin:admin')) return super._find(params)
+
+    if (params.query.projectId) {
       const permissionStatus = (await super._find({
         query: {
           projectId: params.query.projectId,
-          userId: loggedInUser?.id,
+          userId: loggedInUser.id,
           $limit: 1
         }
       })) as Paginated<ProjectPermissionType>
       if (permissionStatus.data.length > 0) return super._find(params)
     }
-    if (!params) params = {}
-    if (!params.query) params.query = {}
+
     params.query.userId = loggedInUser.id
     return super._find(params)
   }

diff --git a/packages/server-core/src/projects/project/project-helper.ts b/packages/server-core/src/projects/project/project-helper.ts
@@ -317,13 +317,15 @@ export const getEnginePackageJson = (): ProjectPackageJsonType => {
 //DO NOT REMOVE!
 //Even though an IDE may say that it's not used in the codebase, projects may use this.
 export const getProjectEnv = async (app: Application, projectName: string) => {
-  const projectSetting = await app.service('project-setting').find({
+  const project = (await app.service(projectPath).find({
     query: {
       $limit: 1,
-      name: projectName,
-      $select: ['settings']
+      name: projectName
     }
-  })
+  })) as Paginated<ProjectType>
+
+  let projectSetting = project.data[0].settings || []
+
   const settings: ProjectSettingType[] = []
   Object.values(projectSetting).map(({ key, value }) => (settings[key] = value))
   return settings
@@ -493,13 +495,15 @@ export const checkProjectDestinationMatch = async (
     Buffer.from(sourceBlobResponse.data.content, sourceBlobResponse.data.encoding).toString()
   )
   if (!existingProject) {
-    const projectExists = await app.service(projectPath).find({
+    const projectExists = (await app.service(projectPath).find({
       query: {
         name: {
           $like: sourceContent.name
-        }
+        },
+        $limit: 1
       }
-    })
+    })) as Paginated<ProjectType>
+
     if (projectExists.data.length > 0)
       return {
         sourceProjectMatchesDestination: false,
@@ -1389,14 +1393,12 @@ export const updateProject = async (
   if (data.sourceURL === 'default-project') {
     copyDefaultProject()
     await uploadLocalProjectToProvider(app, 'default-project')
-    return (
-      await app.service(projectPath).find({
-        query: {
-          name: 'default-project',
-          $limit: 1
-        }
-      })
-    ).data
+    return (await app.service(projectPath).find({
+      query: {
+        name: 'default-project',
+        $limit: 1
+      }
+    })) as Paginated<ProjectType>
   }
 
   const urlParts = data.sourceURL.split('/')
@@ -1415,11 +1417,11 @@ export const updateProject = async (
     deleteFolderRecursive(projectDirectory)
   }
 
-  const projectResult = await app.service(projectPath)._find({
+  const projectResult = (await app.service(projectPath)._find({
     query: {
       name: projectName
     }
-  })
+  })) as Paginated<ProjectType>
 
   let project
   if (projectResult.data.length > 0) project = projectResult.data[0]
@@ -1465,13 +1467,13 @@ export const updateProject = async (
   const projectConfig = getProjectConfig(projectName) ?? {}
 
   // when we have successfully re-installed the project, remove the database entry if it already exists
-  const existingProjectResult = await app.service(projectPath)._find({
+  const existingProjectResult = (await app.service(projectPath)._find({
     query: {
       name: {
         $like: projectName
       }
     }
-  })
+  })) as Paginated<ProjectType>
   const existingProject = existingProjectResult.total > 0 ? existingProjectResult.data[0] : null
   let repositoryPath = data.destinationURL || data.sourceURL
   const publicSignedExec = PUBLIC_SIGNED_REGEX.exec(repositoryPath)

diff --git a/packages/server-core/src/projects/project/project.class.ts b/packages/server-core/src/projects/project/project.class.ts
@@ -315,9 +315,7 @@ export class ProjectService<T = ProjectType, ServiceParams extends Params = Proj
 
   async find(params?: ProjectParams) {
     let projectPushIds: string[] = []
-    let populateProjectPermissions = false
-    const errors = [] as any
-    if (params?.query?.allowed != null) {
+    if (params?.query?.allowed) {
       // See if the user has a GitHub identity-provider, and if they do, also determine which GitHub repos they personally
       // can push to.
 
@@ -391,21 +389,28 @@ export class ProjectService<T = ProjectType, ServiceParams extends Params = Proj
 
       if (!params.user!.scopes?.find((scope) => scope.type === 'admin:admin'))
         params.query.id = { $in: [...new Set(allowedProjects.map((project) => project.id))] }
-      delete params.query.allowed
-
-      populateProjectPermissions = true
     }
 
-    params = {
+    let paramsWithoutExtras = {
       ...params,
+      // Explicitly cloned sort object because otherwise it was affecting default params object as well.
+      query: params?.query ? JSON.parse(JSON.stringify(params?.query)) : {}
+    }
+
+    paramsWithoutExtras = {
+      ...paramsWithoutExtras,
       query: {
-        ...params?.query,
+        ...paramsWithoutExtras.query,
         $limit: params?.query?.$limit || 1000,
         $sort: params?.query?.$sort || { name: 1 }
       }
     }
 
-    const data = ((await super._find(params)) as Paginated<ProjectType>).data
+    if (paramsWithoutExtras?.query?.allowed) delete paramsWithoutExtras.query.allowed
+
+    const result = (await super._find(paramsWithoutExtras)) as Paginated<ProjectType> | ProjectType[]
+
+    const data: ProjectType[] = result['data'] ? result['data'] : result
     for (const item of data) {
       try {
         const packageJson = getProjectPackageJson(item.name)
@@ -420,11 +425,7 @@ export class ProjectService<T = ProjectType, ServiceParams extends Params = Proj
       }
     }
 
-    return {
-      total: data.length,
-      data,
-      errors
-    }
+    return result
   }
 
   async _callOnLoad() {

diff --git a/packages/server-core/src/projects/project/project.resolvers.ts b/packages/server-core/src/projects/project/project.resolvers.ts
@@ -60,29 +60,28 @@ export const projectDbToSchema = (rawData: ProjectDatabaseType): ProjectType =>
   }
 }
 
-export const projectResolver = resolve<ProjectType, HookContext>({
-  projectPermissions: virtual(async (project, context) => {
-    if (context.params?.query?.allowed) {
-      const projectPermissions = (await context.app.service(projectPermissionPath).find({
-        query: {
-          projectId: project.id
-        },
-        paginate: false
-      })) as ProjectPermissionType[]
-
-      return projectPermissions
-    }
-  }),
-
-  commitDate: virtual(async (project) => {
-    if (project.commitDate) return fromDateTimeSql(project.commitDate)
-  }),
-  createdAt: virtual(async (project) => fromDateTimeSql(project.createdAt)),
-  updatedAt: virtual(async (project) => fromDateTimeSql(project.updatedAt))
-})
+export const projectResolver = resolve<ProjectType, HookContext>(
+  {
+    projectPermissions: virtual(async (project, context) => {
+      if (context.params?.query?.allowed) {
+        const projectPermissions = (await context.app.service(projectPermissionPath).find({
+          query: {
+            projectId: project.id
+          },
+          user: context.params?.user,
+          paginate: false
+        })) as ProjectPermissionType[]
+
+        return projectPermissions
+      }
+    }),
 
-export const projectExternalResolver = resolve<ProjectType, HookContext>(
-  {},
+    commitDate: virtual(async (project) => {
+      if (project.commitDate) return fromDateTimeSql(project.commitDate)
+    }),
+    createdAt: virtual(async (project) => fromDateTimeSql(project.createdAt)),
+    updatedAt: virtual(async (project) => fromDateTimeSql(project.updatedAt))
+  },
   {
     // Convert the raw data into a new structure before running property resolvers
     converter: async (rawData, context) => {
@@ -91,6 +90,8 @@ export const projectExternalResolver = resolve<ProjectType, HookContext>(
   }
 )
 
+export const projectExternalResolver = resolve<ProjectType, HookContext>({})
+
 export const projectDataResolver = resolve<ProjectDatabaseType, HookContext>(
   {
     id: async () => {