@openneuro/server 4.20.4 → 4.20.6-alpha.2

package/src/graphql/resolvers/__tests__/importRemoteDataset.spec.ts

@@ -1,43 +1,43 @@
-import { vi } from 'vitest'
-import { importRemoteDataset, allowedImportUrl } from '../importRemoteDataset'
-import createFetchMock from 'vitest-fetch-mock'
+import { vi } from "vitest"
+import { allowedImportUrl, importRemoteDataset } from "../importRemoteDataset"
+import createFetchMock from "vitest-fetch-mock"
 
-vi.mock('ioredis')
-vi.mock('../../../config')
-vi.mock('../../permissions')
+vi.mock("ioredis")
+vi.mock("../../../config")
+vi.mock("../../permissions")
 
-describe('importRemoteDataset mutation', () => {
-  it('given a user with access, it creates an import record for later processing', () => {
+describe("importRemoteDataset mutation", () => {
+  it("given a user with access, it creates an import record for later processing", () => {
     const fetchMock = createFetchMock(vi)
     fetchMock.doMock()
     fetchMock.mockOnce(JSON.stringify(true))
     importRemoteDataset(
       {},
-      { datasetId: 'ds000000', url: '' },
-      { user: '1234', userInfo: { admin: true } },
+      { datasetId: "ds000000", url: "" },
+      { user: "1234", userInfo: { admin: true } },
     )
   })
-  describe('allowedImportUrl()', () => {
-    it('allows brainlife.io', () => {
+  describe("allowedImportUrl()", () => {
+    it("allows brainlife.io", () => {
       expect(
-        allowedImportUrl('https://brainlife.io/ezbids/dataset-to-import.zip'),
+        allowedImportUrl("https://brainlife.io/ezbids/dataset-to-import.zip"),
       ).toBe(true)
     })
-    it('allows a test bucket for OpenNeuro use', () => {
+    it("allows a test bucket for OpenNeuro use", () => {
       expect(
         allowedImportUrl(
-          'https://openneuro-test-import-bucket.s3.us-west-2.amazonaws.com/ds000003.zip',
+          "https://openneuro-test-import-bucket.s3.us-west-2.amazonaws.com/ds000003.zip",
         ),
       ).toBe(true)
     })
-    it('does not allow other URLs', () => {
-      expect(allowedImportUrl('https://openneuro.org')).toBe(false)
-      expect(allowedImportUrl('iiajsdfoijawe')).toBe(false)
-      expect(allowedImportUrl('http://google.com/some-zip-file.zip')).toBe(
+    it("does not allow other URLs", () => {
+      expect(allowedImportUrl("https://openneuro.org")).toBe(false)
+      expect(allowedImportUrl("iiajsdfoijawe")).toBe(false)
+      expect(allowedImportUrl("http://google.com/some-zip-file.zip")).toBe(
         false,
       )
       expect(
-        allowedImportUrl('http://github.com/brainlife.io/somewhere-else.zip'),
+        allowedImportUrl("http://github.com/brainlife.io/somewhere-else.zip"),
       ).toBe(false)
     })
   })

package/src/graphql/resolvers/__tests__/permssions.spec.ts

@@ -0,0 +1,35 @@
+import { vi } from "vitest"
+import { updatePermissions } from "../permissions"
+
+vi.mock("ioredis")
+vi.mock("../../permissions", () => ({
+  checkDatasetAdmin: async () => Promise.resolve(),
+}))
+
+const mockExec = vi.fn()
+
+vi.mock("../../../models/user", () => ({
+  find: () => ({
+    exec: mockExec,
+  }),
+}))
+
+describe("permissions resolvers", () => {
+  describe("updatePermissions()", () => {
+    it("throws an error when no users are found", async () => {
+      mockExec.mockResolvedValue([])
+      let error
+      try {
+        await updatePermissions(
+          {},
+          { datasetId: "ds01234", userEmail: "fake@test.com" },
+          { user: "1234", userInfo: { id: "1234" } },
+        )
+      } catch (err) {
+        error = err
+      }
+
+      return expect(error).toBeInstanceOf(Error)
+    })
+  })
+})

package/src/graphql/resolvers/__tests__/snapshots.spec.ts

@@ -0,0 +1,59 @@
+import { vi } from "vitest"
+import { filterLatestSnapshot, matchKnownObjects } from "../snapshots"
+
+vi.mock("ioredis")
+vi.mock("../../../config.ts")
+
+describe("snapshot resolvers", () => {
+  describe("matchKnownObjects()", () => {
+    it("should return NDA as a source when given a description containing 10.15154 DOIs", () => {
+      expect(
+        matchKnownObjects({
+          ReferencesAndLinks: [
+            "10.18112/openneuro.ds000001.v1.0.0",
+            "10.15154/1503209",
+          ],
+        }).sort(),
+      ).toEqual([
+        {
+          id: "10.18112/openneuro.ds000001.v1.0.0",
+        },
+        {
+          id: "10.15154/1503209",
+          source: "NDA",
+          type: "dataset",
+        },
+      ])
+    })
+  })
+  describe("filterLatestSnapshot()", () => {
+    it("returns the latest snapshot", () => {
+      const testSnapshots = [
+        {
+          id: "ds000247:00002",
+          created: "2018-07-18T02:27:39.000Z",
+          tag: "00002",
+        },
+        {
+          id: "ds000247:00001",
+          created: "2018-07-18T02:35:37.000Z",
+          tag: "00001",
+        },
+        {
+          id: "ds000247:1.0.0",
+          created: "2021-07-05T15:58:18.000Z",
+          tag: "1.0.0",
+        },
+        {
+          id: "ds000247:1.0.1",
+          created: "2021-08-25T23:37:53.000Z",
+          tag: "1.0.1",
+        },
+      ]
+      expect(filterLatestSnapshot(testSnapshots)).toBe("1.0.1")
+    })
+    it("returns null with no snapshots", () => {
+      expect(filterLatestSnapshot([])).toBeNull()
+    })
+  })
+})

package/src/graphql/resolvers/__tests__/user.spec.ts

@@ -0,0 +1,18 @@
+import { vi } from "vitest"
+import { users } from "../user.js"
+
+vi.mock("ioredis")
+
+describe("user resolvers", () => {
+  describe("users()", () => {
+    it("throws an error for non-admins", () => {
+      expect(
+        users(
+          null,
+          { id: "3311cfe8-9764-434d-b80e-1b1ee72c686d" },
+          { userInfo: {} },
+        ),
+      ).rejects.toEqual(new Error("You must be a site admin to retrieve users"))
+    })
+  })
+})

package/src/graphql/resolvers/brainlife.ts

@@ -1,7 +1,7 @@
 import {
   DatasetOrSnapshot,
   getDatasetFromSnapshotId,
-} from '../../utils/datasetOrSnapshot'
+} from "../../utils/datasetOrSnapshot"
 
 interface BrainlifeFindQuery {
   removed: boolean
@@ -19,7 +19,7 @@ export function brainlifeQuery(dataset: DatasetOrSnapshot): URL {
     removed: false,
   }
 
-  if ('tag' in dataset) {
+  if ("tag" in dataset) {
     find.path = {
       $regex: `^OpenNeuro/${getDatasetFromSnapshotId(dataset.id)}`,
     }
@@ -28,8 +28,8 @@ export function brainlifeQuery(dataset: DatasetOrSnapshot): URL {
     find.path = { $regex: `^OpenNeuro/${dataset.id}` }
   }
 
-  const url = new URL('https://brainlife.io/api/warehouse/datalad/datasets')
-  url.searchParams.append('find', JSON.stringify(find))
+  const url = new URL("https://brainlife.io/api/warehouse/datalad/datasets")
+  url.searchParams.append("find", JSON.stringify(find))
 
   return url
 }

package/src/graphql/resolvers/cache.ts

@@ -1,6 +1,6 @@
-import { redis } from '../../libs/redis.js'
-import CacheItem from '../../cache/item'
-import { CacheType } from '../../cache/types'
+import { redis } from "../../libs/redis.js"
+import CacheItem from "../../cache/item"
+import { CacheType } from "../../cache/types"
 
 /**
  * Clear the snapshotDownload cache after exports
@@ -11,7 +11,7 @@ export async function cacheClear(
   { userInfo }: { userInfo: { admin: boolean } },
 ): Promise<boolean> {
   // Check for admin and validate datasetId argument
-  if (userInfo?.admin && datasetId.length == 8 && datasetId.startsWith('ds')) {
+  if (userInfo?.admin && datasetId.length == 8 && datasetId.startsWith("ds")) {
     const downloadCache = new CacheItem(redis, CacheType.snapshotDownload, [
       datasetId,
       tag,

package/src/graphql/resolvers/{comment.js → comment.ts}

@@ -1,21 +1,21 @@
-import Comment from '../../models/comment'
-import notifications from '../../libs/notifications.js'
-import { user } from './user.js'
-import { checkAdmin } from '../permissions'
+import Comment from "../../models/comment"
+import notifications from "../../libs/notifications"
+import { user } from "./user.js"
+import { checkAdmin } from "../permissions"
 
 export const comment = (obj, { id }) => {
   return Comment.findOne({ _id: id }).exec()
 }
 
-export const datasetComments = obj => {
+export const datasetComments = (obj) => {
   return Comment.find({ datasetId: obj.id }).exec()
 }
 
-export const userComments = obj => {
-  return Comment.find({ 'user._id': obj.id }).exec()
+export const userComments = (obj) => {
+  return Comment.find({ "user._id": obj.id }).exec()
 }
 
-const replies = obj => {
+const replies = (obj) => {
   return Comment.find({ parentId: obj._id }).exec()
 }
 
@@ -24,14 +24,14 @@ const replies = obj => {
  * @param {*[][]} arr
  * @returns {*[]}
  */
-export const flatten = arr => [].concat(...arr)
+export const flatten = (arr) => [].concat(...arr)
 
 /**
  * returns a flat array of all the dependencies of the given comment
  * @param {import('../../models/comment').CommentDocument} obj
  * @returns {Promise<import('../../models/comment').CommentDocument[]>}
  */
-const allNestedReplies = async obj => {
+const allNestedReplies = async (obj) => {
   const replies = await Comment.find({ parentId: obj._id }).exec()
   if (!replies.length) {
     return replies
@@ -51,7 +51,7 @@ export const addComment = (
 ) => {
   if (!user) {
     return Promise.reject(
-      new Error('You must be logged in to write a comment.'),
+      new Error("You must be logged in to write a comment."),
     )
   }
   const newComment = new Comment({
@@ -60,7 +60,7 @@ export const addComment = (
     text,
     user: { _id: user },
   })
-  return newComment.save().then(commentInsert => {
+  return newComment.save().then((commentInsert) => {
     notifications.commentCreated(commentInsert)
     return commentInsert._id
   })
@@ -77,7 +77,7 @@ export const editComment = async (
     existingComment.text = text
     return existingComment.save().then(() => true)
   } else {
-    return Promise.reject(new Error('You may only edit your own comments.'))
+    return Promise.reject(new Error("You may only edit your own comments."))
   }
 }
 
@@ -93,7 +93,7 @@ export const deleteComment = async (
   if (deleteChildren) {
     targetComments.push(...(await allNestedReplies(existingComment)))
   }
-  const deletedCommentIds = targetComments.map(c => c._id)
+  const deletedCommentIds = targetComments.map((c) => c._id)
   return Comment.deleteMany({
     _id: {
       $in: deletedCommentIds,
@@ -103,9 +103,9 @@ export const deleteComment = async (
 
 //"5c9bf7e3088cea6fa775c42a"
 const CommentFields = {
-  parent: obj => comment(obj, { id: obj.parentId }),
+  parent: (obj) => comment(obj, { id: obj.parentId }),
   replies,
-  user: obj => user(obj, { id: obj.user._id }),
+  user: (obj) => user(obj, { id: obj.user._id }),
 }
 
 export default CommentFields

package/src/graphql/resolvers/{dataset-search.js → dataset-search.ts}

@@ -1,11 +1,11 @@
-import { elasticClient } from '../../elasticsearch/elastic-client'
-import { dataset } from './dataset'
-import Star from '../../models/stars'
-import Subscription from '../../models/subscription'
-import Permission from '../../models/permission'
-import { hashObject } from '../../libs/authentication/crypto'
+import { elasticClient } from "../../elasticsearch/elastic-client"
+import { dataset } from "./dataset"
+import Star from "../../models/stars"
+import Subscription from "../../models/subscription"
+import Permission from "../../models/permission"
+import { hashObject } from "../../libs/authentication/crypto"
 
-const elasticIndex = 'datasets'
+const elasticIndex = "datasets"
 
 /**
  * Remove a dataset from the index, used when deleting datasets to clean up
@@ -13,7 +13,7 @@ const elasticIndex = 'datasets'
  * @param {string} id Dataset accession number id
  * @returns {Promise}
  */
-export const removeDatasetSearchDocument = id =>
+export const removeDatasetSearchDocument = (id) =>
   elasticClient.delete({ id, index: elasticIndex })
 
 /**
@@ -21,16 +21,16 @@ export const removeDatasetSearchDocument = id =>
  * @param {Array<*>} sort
  * @returns {string}
  */
-export const encodeCursor = sort =>
-  Buffer.from(JSON.stringify(sort)).toString('base64')
+export const encodeCursor = (sort) =>
+  Buffer.from(JSON.stringify(sort)).toString("base64")
 
 /**
  * Accepts a cursor and returns the deserialized elastic search search_after array
  * @param {string} cursor
  * @returns {Array<*>}
  */
-export const decodeCursor = cursor =>
-  JSON.parse(Buffer.from(cursor, 'base64').toString('utf-8'))
+export const decodeCursor = (cursor) =>
+  JSON.parse(Buffer.from(cursor, "base64").toString("utf-8"))
 
 /**
  * Return a relay cursor from an elastic search result
@@ -50,7 +50,7 @@ export const elasticRelayConnection = (
     const hasNextPage = Boolean(body.hits.hits[size - 1])
     return {
       id,
-      edges: body.hits.hits.map(hit => {
+      edges: body.hits.hits.map((hit) => {
         const node = childResolvers.dataset(
           null,
           { id: hit._source.id },
@@ -88,7 +88,8 @@ export const datasetSearchConnection = async (
 ) => {
   const searchId = hashObject({ q })
   const requestBody = {
-    sort: [{ _score: 'asc', id: 'desc' }],
+    sort: [{ _score: "asc", id: "desc" }],
+    search_after: undefined,
   }
   if (after) {
     try {
@@ -108,12 +109,12 @@ export const datasetSearchConnection = async (
 
 export const datasetSearch = {
   search: {
-    type: 'DatasetConnection',
+    type: "DatasetConnection",
     resolve: datasetSearchConnection,
     args: {
-      q: { type: 'String!' },
-      after: { type: 'String' },
-      first: { type: 'Int' },
+      q: { type: "String!" },
+      after: { type: "String" },
+      first: { type: "Int" },
     },
   },
 }
@@ -127,15 +128,15 @@ const addClause = (query, type, clause) => {
 }
 
 const parseQuery = async (query, datasetType, datasetStatus, userId) => {
-  if (datasetType === 'All Public') {
-    addClause(query, 'filter', {
+  if (datasetType === "All Public") {
+    addClause(query, "filter", {
       term: {
         public: {
           value: true,
         },
       },
     })
-  } else if (datasetType === 'Following') {
+  } else if (datasetType === "Following") {
     const results = await Subscription.find({ userId })
     const followedDatasets = results.map(({ datasetId }) => datasetId)
     const termsClause = {
@@ -143,8 +144,8 @@ const parseQuery = async (query, datasetType, datasetStatus, userId) => {
         id: followedDatasets,
       },
     }
-    addClause(query, 'filter', termsClause)
-  } else if (datasetType === 'My Bookmarks') {
+    addClause(query, "filter", termsClause)
+  } else if (datasetType === "My Bookmarks") {
     const results = await Star.find({ userId })
     const bookmarkedDatasets = results.map(({ datasetId }) => datasetId)
     const termsClause = {
@@ -152,8 +153,8 @@ const parseQuery = async (query, datasetType, datasetStatus, userId) => {
         id: bookmarkedDatasets,
       },
     }
-    addClause(query, 'filter', termsClause)
-  } else if (datasetType === 'My Datasets') {
+    addClause(query, "filter", termsClause)
+  } else if (datasetType === "My Datasets") {
     const results = await Permission.find({ userId })
     const bookmarkedDatasets = results.map(({ datasetId }) => datasetId)
     const termsClause = {
@@ -161,26 +162,26 @@ const parseQuery = async (query, datasetType, datasetStatus, userId) => {
         id: bookmarkedDatasets,
       },
     }
-    addClause(query, 'filter', termsClause)
+    addClause(query, "filter", termsClause)
 
-    if (datasetStatus === 'Public') {
-      addClause(query, 'filter', {
+    if (datasetStatus === "Public") {
+      addClause(query, "filter", {
         term: {
           public: {
             value: true,
           },
         },
       })
-    } else if (datasetStatus === 'Shared with Me') {
-      addClause(query, 'filter', {
+    } else if (datasetStatus === "Shared with Me") {
+      addClause(query, "filter", {
         terms: {
-          ['permissions.userPermissions.level']: ['ro', 'rw'],
+          ["permissions.userPermissions.level"]: ["ro", "rw"],
         },
       })
-    } else if (datasetStatus === 'Invalid') {
-      addClause(query, 'filter', {
+    } else if (datasetStatus === "Invalid") {
+      addClause(query, "filter", {
         term: {
-          ['draft.issues.severity']: 'error',
+          ["draft.issues.severity"]: "error",
         },
       })
     }
@@ -221,13 +222,14 @@ export const advancedDatasetSearchConnection = async (
     sortBy,
     user,
   })
-  const sort = [{ _score: 'desc' }, { id: 'desc' }]
+  const sort = [{ _score: "desc" }, { id: "desc" }]
   if (sortBy) sort.unshift(sortBy)
   const requestBody = {
     sort,
     query: allDatasets
       ? query
       : await parseQuery(query, datasetType, datasetStatus, user),
+    search_after: undefined,
   }
   if (after) {
     try {
@@ -253,16 +255,16 @@ export const advancedDatasetSearchConnection = async (
 
 export const advancedDatasetSearch = {
   advancedSearch: {
-    type: 'DatasetConnection',
+    type: "DatasetConnection",
     resolve: advancedDatasetSearchConnection,
     args: {
-      query: { type: 'JSON!' },
-      allDatasets: { type: 'Boolean' },
-      datasetType: { type: 'String' },
-      datasetStatus: { type: 'String' },
-      sortBy: { type: 'JSON' },
-      after: { type: 'String' },
-      first: { type: 'Int' },
+      query: { type: "JSON!" },
+      allDatasets: { type: "Boolean" },
+      datasetType: { type: "String" },
+      datasetStatus: { type: "String" },
+      sortBy: { type: "JSON" },
+      after: { type: "String" },
+      first: { type: "Int" },
     },
   },
 }