@openneuro/app 4.47.7 → 5.0.0

package/src/scripts/users/user-datasets-view.tsx

@@ -9,36 +9,51 @@ import { Loading } from "../components/loading/Loading"
 import type { Dataset, UserDatasetsViewProps } from "../types/user-types"
 import styles from "./scss/datasetcard.module.scss"
 
-type SortByType = {
-  [key: string]: "asc" | "desc"
-} | null
+interface SearchInput {
+  keywords?: string[]
+  userId?: string
+  publicOnly?: boolean
+  sortBy?: string
+}
 
-interface ElasticsearchQuery {
-  bool: {
-    filter: (
-      | { terms: { "permissions.userPermissions.user.id": string[] } }
-      | { term: { public: boolean | null } }
-    )[]
-    must: (
-      | {
-        bool: {
-          should: (
-            | {
-              multi_match: {
-                query: string
-                fields: string[]
-                fuzziness: number
-              }
-            }
-            | { prefix: { name: string } }
-            | { prefix: { "description.Name": string } }
-          )[]
-          minimum_should_match: number
-        }
-      }
-      | { match_all: Record<string, never> }
-    )[]
+const buildSearchInput = (
+  searchQuery: string,
+  publicFilter: string,
+  userId: string | undefined,
+  hasEdit: boolean,
+  sortBy: string | undefined,
+): SearchInput => {
+  const input: SearchInput = {}
+
+  if (userId) {
+    input.userId = userId
+  }
+
+  if (hasEdit) {
+    if (publicFilter === "public") {
+      input.publicOnly = true
+    }
+  } else {
+    input.publicOnly = true
+  }
+
+  if (searchQuery) {
+    input.keywords = [searchQuery]
   }
+
+  if (sortBy) {
+    input.sortBy = sortBy
+  }
+
+  return input
+}
+
+const SORT_MAP: Record<string, string | undefined> = {
+  "name-asc": "name_asc",
+  "name-desc": "name_desc",
+  "date-newest": "newest",
+  "date-oldest": "oldest",
+  "date-updated": "last_updated",
 }
 
 export const UserDatasetsView: React.FC<UserDatasetsViewProps> = ({
@@ -52,81 +67,12 @@ export const UserDatasetsView: React.FC<UserDatasetsViewProps> = ({
   const [loadMoreLoading, setLoadMoreLoading] = useState(false)
   const [cursor, setCursor] = useState<string | null>(null)
   const [hasNextPage, setHasNextPage] = useState(false)
-  const [sortBy, setSortBy] = useState<SortByType>(null)
   const loadAmount = 26
 
-  const generateElasticsearchQuery = useCallback(
-    (
-      currentSearchQuery: string,
-      currentPublicFilter: string,
-    ): ElasticsearchQuery => {
-      const baseQuery: ElasticsearchQuery = {
-        bool: {
-          filter: [],
-          must: [],
-        },
-      }
-
-      if (orcidUser?.id) {
-        baseQuery.bool.filter.push({
-          terms: {
-            "permissions.userPermissions.user.id": [orcidUser.id],
-          },
-        })
-      }
+  const sortByValue = SORT_MAP[sortOrder]
 
-      if (hasEdit) {
-        if (currentPublicFilter === "public") {
-          baseQuery.bool.filter.push({ term: { public: true } })
-        }
-      } else {
-        baseQuery.bool.filter.push({ term: { public: true } })
-      }
-
-      if (currentSearchQuery) {
-        baseQuery.bool.must.push({
-          bool: {
-            should: [
-              {
-                multi_match: {
-                  query: currentSearchQuery,
-                  fields: [
-                    "id^3",
-                    "name^3",
-                    "description.Name^3",
-                    "description.Authors^3",
-                    "latestSnapshot.description.Name",
-                    "latestSnapshot.description.Authors",
-                    "latestSnapshot.readme",
-                  ],
-                  fuzziness: 1,
-                },
-              },
-              {
-                prefix: {
-                  name: currentSearchQuery.toLowerCase(),
-                },
-              },
-              {
-                prefix: {
-                  "description.Name": currentSearchQuery.toLowerCase(),
-                },
-              },
-            ],
-            minimum_should_match: 1,
-          },
-        })
-      } else {
-        baseQuery.bool.must.push({ match_all: {} })
-      }
-
-      return baseQuery
-    },
-    [orcidUser?.id, hasEdit],
-  )
-
-  const [elasticsearchQuery, setElasticsearchQuery] = useState(() =>
-    generateElasticsearchQuery("", "all")
+  const [searchInput, setSearchInput] = useState(() =>
+    buildSearchInput("", "all", orcidUser?.id, hasEdit, sortByValue)
   )
 
   const { data, loading, error, fetchMore, refetch } = useQuery(
@@ -134,8 +80,7 @@ export const UserDatasetsView: React.FC<UserDatasetsViewProps> = ({
     {
       variables: {
         first: loadAmount,
-        query: elasticsearchQuery,
-        sortBy: sortBy,
+        query: searchInput,
         cursor: null,
         allDatasets: true,
         datasetStatus: undefined,
@@ -161,89 +106,63 @@ export const UserDatasetsView: React.FC<UserDatasetsViewProps> = ({
     (newSearchQuery: string, currentPublicFilter: string) => {
       setSearchQuery(newSearchQuery)
       setPublicFilter(currentPublicFilter)
-      const newElasticsearchQuery = generateElasticsearchQuery(
+      const newInput = buildSearchInput(
         newSearchQuery,
         currentPublicFilter,
+        orcidUser?.id,
+        hasEdit,
+        sortByValue,
       )
-      setElasticsearchQuery(newElasticsearchQuery)
+      setSearchInput(newInput)
       refetch({
-        query: newElasticsearchQuery,
+        query: newInput,
         cursor: null,
-        sortBy: sortBy,
         datasetStatus: undefined,
       })
     },
-    [
-      generateElasticsearchQuery,
-      refetch,
-      setSearchQuery,
-      setPublicFilter,
-      setElasticsearchQuery,
-      sortBy,
-      hasEdit,
-      orcidUser?.id,
-    ],
+    [refetch, sortByValue, hasEdit, orcidUser?.id],
   )
 
   const handlePublicFilterChange = useCallback(
     (newPublicFilter) => {
       setPublicFilter(newPublicFilter)
-      const newElasticsearchQuery = generateElasticsearchQuery(
+      const newInput = buildSearchInput(
         searchQuery,
         newPublicFilter,
+        orcidUser?.id,
+        hasEdit,
+        sortByValue,
       )
-      setElasticsearchQuery(newElasticsearchQuery)
+      setSearchInput(newInput)
       refetch({
-        query: newElasticsearchQuery,
+        query: newInput,
         cursor: null,
-        sortBy: sortBy,
         datasetStatus: undefined,
       })
     },
-    [
-      setPublicFilter,
-      generateElasticsearchQuery,
-      refetch,
-      searchQuery,
-      sortBy,
-      hasEdit,
-      orcidUser?.id,
-    ],
+    [refetch, searchQuery, sortByValue, hasEdit, orcidUser?.id],
   )
 
   const handleSortOrderChange = useCallback(
     (newSortOrder) => {
       setSortOrder(newSortOrder)
-      let newSortBy = null
-      switch (newSortOrder) {
-        case "name-asc":
-          newSortBy = { "metadata.datasetName": "asc" }
-          break
-        case "name-desc":
-          newSortBy = { "metadata.datasetName": "desc" }
-          break
-        case "date-newest":
-          newSortBy = { created: "desc" }
-          break
-        case "date-oldest":
-          newSortBy = { created: "asc" }
-          break
-        case "date-updated":
-          newSortBy = { "metadata.latestSnapshotCreatedAt": "desc" }
-          break
-        default:
-          newSortBy = null
-      }
-      setSortBy(newSortBy)
+      const newSortByValue = SORT_MAP[newSortOrder]
+      const newInput = buildSearchInput(
+        searchQuery,
+        publicFilter,
+        orcidUser?.id,
+        hasEdit,
+        newSortByValue,
+      )
+      setSearchInput(newInput)
       refetch({
-        sortBy: newSortBy,
+        query: newInput,
         first: loadAmount,
         cursor: null,
-        query: elasticsearchQuery,
         datasetStatus: undefined,
       })
     },
-    [setSortOrder, refetch, setSortBy, elasticsearchQuery, hasEdit],
+    [refetch, searchQuery, publicFilter, hasEdit, orcidUser?.id],
   )
 
   const handleLoadMore = useCallback(() => {
@@ -256,8 +175,7 @@ export const UserDatasetsView: React.FC<UserDatasetsViewProps> = ({
       variables: {
         first: loadAmount,
         cursor: cursor,
-        query: elasticsearchQuery,
-        sortBy: sortBy,
+        query: searchInput,
         allDatasets: true,
         datasetStatus: undefined,
       },
@@ -293,8 +211,7 @@ export const UserDatasetsView: React.FC<UserDatasetsViewProps> = ({
     hasNextPage,
     loadMoreLoading,
     cursor,
-    elasticsearchQuery,
-    sortBy,
+    searchInput,
     hasEdit,
   ])
 
@@ -307,23 +224,25 @@ export const UserDatasetsView: React.FC<UserDatasetsViewProps> = ({
   }, [data, hasEdit, loadAmount])
 
   useEffect(() => {
-    const newElasticsearchQuery = generateElasticsearchQuery(
+    const newInput = buildSearchInput(
       searchQuery,
       publicFilter,
+      orcidUser?.id,
+      hasEdit,
+      sortByValue,
     )
-    setElasticsearchQuery(newElasticsearchQuery)
-  }, [searchQuery, publicFilter, generateElasticsearchQuery])
+    setSearchInput(newInput)
+  }, [searchQuery, publicFilter, orcidUser?.id, hasEdit, sortByValue])
 
   useEffect(() => {
-    if (elasticsearchQuery) {
+    if (searchInput) {
       refetch({
-        query: elasticsearchQuery,
+        query: searchInput,
         cursor: null,
-        sortBy: sortBy,
         datasetStatus: undefined,
       })
     }
-  }, [elasticsearchQuery, refetch, sortBy, hasEdit])
+  }, [searchInput, refetch, hasEdit])
 
   if (loading) return <Loading />
   if (error) {

package/src/scripts/datalad/dataset/comments-fragments.js

@@ -1,22 +0,0 @@
-import { gql } from "@apollo/client"
-
-export const DATASET_COMMENTS = gql`
-  fragment DatasetComments on Dataset {
-    id
-    comments {
-      id
-      text
-      createDate
-      user {
-        name
-        orcid
-      }
-      parent {
-        id
-      }
-      replies {
-        id
-      }
-    }
-  }
-`

package/src/scripts/datalad/mutations/follow.jsx

@@ -1,54 +0,0 @@
-import React from "react"
-import PropTypes from "prop-types"
-import { gql } from "@apollo/client"
-import { Mutation } from "@apollo/client/react/components"
-import WarnButton from "../../common/forms/warn-button.jsx"
-import { datasetCacheId } from "./cache-id.js"
-
-const FOLLOW_DATASET = gql`
-  mutation followDataset($datasetId: ID!) {
-    followDataset(datasetId: $datasetId)
-  }
-`
-
-const USER_FOLLOWING = gql`
-  fragment UserFollowing on Dataset {
-    id
-    following
-  }
-`
-
-const FollowDataset = ({ datasetId, following }) => (
-  <Mutation
-    mutation={FOLLOW_DATASET}
-    update={(cache, { data: { followDataset } }) => {
-      cache.writeFragment({
-        id: datasetCacheId(datasetId),
-        fragment: USER_FOLLOWING,
-        data: {
-          __typename: "Dataset",
-          id: datasetId,
-          following: followDataset,
-        },
-      })
-    }}
-  >
-    {(followDataset) => (
-      <WarnButton
-        tooltip="Follow Dataset"
-        icon={following ? "fa-tag icon-minus" : "fa-tag icon-plus"}
-        warn={false}
-        action={(cb) => {
-          followDataset({ variables: { datasetId } }).then(() => cb())
-        }}
-      />
-    )}
-  </Mutation>
-)
-
-FollowDataset.propTypes = {
-  datasetId: PropTypes.string,
-  following: PropTypes.bool,
-}
-
-export default FollowDataset

package/src/scripts/datalad/mutations/publish.jsx

@@ -1,58 +0,0 @@
-import React from "react"
-import PropTypes from "prop-types"
-import { gql } from "@apollo/client"
-import { Mutation } from "@apollo/client/react/components"
-import { useNavigate } from "react-router-dom"
-import { datasetCacheId } from "./cache-id.js"
-
-const PUBLISH_DATASET = gql`
-  mutation publishDataset($datasetId: ID!) {
-    publishDataset(datasetId: $datasetId)
-  }
-`
-
-const DATASET_PUBLISHED = gql`
-  fragment DatasetPublished on Dataset {
-    id
-    public
-  }
-`
-
-const PublishDataset = ({ datasetId }) => {
-  const navigate = useNavigate()
-  return (
-    <Mutation
-      mutation={PUBLISH_DATASET}
-      update={(cache) => {
-        cache.writeFragment({
-          id: datasetCacheId(datasetId),
-          fragment: DATASET_PUBLISHED,
-          data: {
-            __typename: "Dataset",
-            id: datasetId,
-            public: true,
-          },
-        })
-      }}
-    >
-      {(publishDataset) => (
-        <button
-          className="btn-modal-action"
-          onClick={() =>
-            publishDataset({ variables: { datasetId } }).then(() => {
-              navigate(`/datasets/${datasetId}`)
-            })}
-        >
-          Publish
-        </button>
-      )}
-    </Mutation>
-  )
-}
-
-PublishDataset.propTypes = {
-  datasetId: PropTypes.string,
-  history: PropTypes.object,
-}
-
-export default PublishDataset

package/src/scripts/datalad/mutations/star.jsx

@@ -1,54 +0,0 @@
-import React from "react"
-import PropTypes from "prop-types"
-import { gql } from "@apollo/client"
-import { Mutation } from "@apollo/client/react/components"
-import WarnButton from "../../common/forms/warn-button.jsx"
-import { datasetCacheId } from "./cache-id.js"
-
-const STAR_DATASET = gql`
-  mutation starDataset($datasetId: ID!) {
-    starDataset(datasetId: $datasetId)
-  }
-`
-
-const USER_STARRED = gql`
-  fragment UserStarred on Dataset {
-    id
-    starred
-  }
-`
-
-const StarDataset = ({ datasetId, starred }) => (
-  <Mutation
-    mutation={STAR_DATASET}
-    update={(cache, { data: { starDataset } }) => {
-      cache.writeFragment({
-        id: datasetCacheId(datasetId),
-        fragment: USER_STARRED,
-        data: {
-          __typename: "Dataset",
-          id: datasetId,
-          starred: starDataset,
-        },
-      })
-    }}
-  >
-    {(starDataset) => (
-      <WarnButton
-        tooltip="Save Dataset"
-        icon={starred ? "fa-star icon-minus" : "fa-star icon-plus"}
-        warn={false}
-        action={(cb) => {
-          starDataset({ variables: { datasetId } }).then(() => cb())
-        }}
-      />
-    )}
-  </Mutation>
-)
-
-StarDataset.propTypes = {
-  datasetId: PropTypes.string,
-  starred: PropTypes.bool,
-}
-
-export default StarDataset

package/src/scripts/pages/admin/user-fragment.ts

@@ -1,21 +0,0 @@
-import { gql } from "@apollo/client"
-
-export const USER_FRAGMENT = gql`
-  fragment userFields on User {
-    id
-    name
-    admin
-    blocked
-    email
-    provider
-    lastSeen
-    created
-    avatar
-    github
-    institution
-    location
-    modified
-    orcid
-  
-  }
-`

package/src/scripts/search/es-query-builders.ts

@@ -1,107 +0,0 @@
-// Builds query components using the Elasticsearch Query DSL
-// https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
-
-const emptyQuery = () => ({
-  bool: {},
-})
-export function BoolQuery() {
-  this.query = emptyQuery()
-}
-BoolQuery.prototype.addClause = function (type: string, query: object) {
-  if (this.query.bool[type]) {
-    this.query.bool[type] = [...this.query.bool[type], query]
-  } else {
-    this.query.bool[type] = [query]
-  }
-}
-BoolQuery.prototype.get = function () {
-  return this.query
-}
-BoolQuery.prototype.toString = function () {
-  return JSON.stringify(this.query)
-}
-BoolQuery.prototype.isEmpty = function () {
-  return JSON.stringify(this.query) === JSON.stringify(emptyQuery())
-}
-
-export const simpleQueryString = (
-  queryString: string,
-  fields?: string[],
-  fuzzy = true,
-) => ({
-  simple_query_string: {
-    query: `${queryString}${fuzzy ? "~" : ""}`,
-    fields,
-  },
-})
-
-export const matchQuery = (
-  field: string,
-  queryString: string,
-  fuzziness?: string,
-  operator?: string,
-) => ({
-  match: {
-    [field]: {
-      query: queryString,
-      fuzziness,
-      operator,
-    },
-  },
-})
-
-export const multiMatchQuery = (
-  field: string,
-  queryStrings: string[],
-  fuzziness?: string,
-  operator?: string,
-) => {
-  return {
-    bool: {
-      should: queryStrings.map((queryString) =>
-        matchQuery(field, queryString, fuzziness, operator)
-      ),
-      minimum_should_match: 1,
-    },
-  }
-}
-
-export const rangeQuery = (
-  field,
-  gte?: number | string,
-  lte?: number | string,
-  relation: string = "INTERSECTS",
-) => ({
-  range: {
-    [field]: {
-      gte,
-      lte,
-      relation,
-    },
-  },
-})
-
-export const rangeListLengthQuery = (field, gte: number, lte: number) => {
-  return {
-    script: {
-      script: {
-        lang: "painless",
-        source: `
-          if (doc[params.field].size() != 0) {
-            return ( doc[params.field].size() >= params.gte && doc[params.field].size() <= params.lte )
-          } else return false`,
-        params: {
-          field,
-          gte,
-          lte,
-        },
-      },
-    },
-  }
-}
-
-/** SimpleQueryString join multiple terms with and `+`. */
-export const sqsJoinWithAND = (list: string[]) =>
-  list.map((str) => `${str}`).join(" + ")
-export const joinWithOR = (list: string[]) =>
-  list.map((str) => `${str}`).join(" | ")