@openneuro/server 4.20.5 → 4.20.6-alpha.3

package/src/datalad/files.ts

@@ -1,14 +1,14 @@
-import request from 'superagent'
-import { redis } from '../libs/redis'
-import CacheItem, { CacheType } from '../cache/item'
-import { getDatasetWorker } from '../libs/datalad-service'
+import request from "superagent"
+import { redis } from "../libs/redis"
+import CacheItem, { CacheType } from "../cache/item"
+import { getDatasetWorker } from "../libs/datalad-service"
 
 /**
  * Convert to URL compatible path
  * @param {String} path
  */
 export const encodeFilePath = (path: string): string => {
-  return path.replace(new RegExp('/', 'g'), ':')
+  return path.replace(new RegExp("/", "g"), ":")
 }
 
 /**
@@ -16,7 +16,7 @@ export const encodeFilePath = (path: string): string => {
  * @param {String} path
  */
 export const decodeFilePath = (path: string): string => {
-  return path.replace(new RegExp(':', 'g'), '/')
+  return path.replace(new RegExp(":", "g"), "/")
 }
 
 /**
@@ -25,7 +25,7 @@ export const decodeFilePath = (path: string): string => {
  * @param {String} filename
  */
 export const getFileName = (path: string, filename: string): string => {
-  const filePath = path ? [path, filename].join('/') : filename
+  const filePath = path ? [path, filename].join("/") : filename
   return filename ? encodeFilePath(filePath) : encodeFilePath(path)
 }
 
@@ -44,13 +44,17 @@ export const fileUrl = (
 ): string => {
   const fileName = getFileName(path, filename)
   if (revision) {
-    return `http://${getDatasetWorker(
-      datasetId,
-    )}/datasets/${datasetId}/snapshots/${revision}/files/${fileName}`
+    return `http://${
+      getDatasetWorker(
+        datasetId,
+      )
+    }/datasets/${datasetId}/snapshots/${revision}/files/${fileName}`
   } else {
-    return `http://${getDatasetWorker(
-      datasetId,
-    )}/datasets/${datasetId}/files/${fileName}`
+    return `http://${
+      getDatasetWorker(
+        datasetId,
+      )
+    }/datasets/${datasetId}/files/${fileName}`
   }
 }
 
@@ -88,22 +92,24 @@ export const getFiles = (datasetId, treeish): Promise<[DatasetFile]> => {
     treeish.substring(0, 7),
   ])
   return cache.get(
-    doNotCache =>
+    (doNotCache) =>
       request
         .get(
-          `${getDatasetWorker(
-            datasetId,
-          )}/datasets/${datasetId}/tree/${treeish}`,
+          `${
+            getDatasetWorker(
+              datasetId,
+            )
+          }/datasets/${datasetId}/tree/${treeish}`,
         )
-        .set('Accept', 'application/json')
-        .then(response => {
+        .set("Accept", "application/json")
+        .then((response) => {
           if (response.status === 200) {
             const {
               body: { files },
             } = response
             for (const f of files) {
               // Skip caching this tree if it doesn't contain S3 URLs - likely still exporting
-              if (!f.directory && !f.urls[0].includes('s3.amazonaws.com')) {
+              if (!f.directory && !f.urls[0].includes("s3.amazonaws.com")) {
                 doNotCache(true)
                 break
               }

package/src/datalad/{pagination.js → pagination.ts}

@@ -1,14 +1,14 @@
 // Helpers for pagination
-import Dataset from '../models/dataset'
+import Dataset from "../models/dataset"
 
-const sortEnumToInt = val => (val === 'ascending' ? 1 : -1)
+const sortEnumToInt = (val) => (val === "ascending" ? 1 : -1)
 
 /**
  * Takes an API sort request and converts it to MongoDB
  * @param {object} sortOptions {created: 'ascending'}
  * @returns {object} Mongo suitable sort arguments {created: 1}
  */
-export const enumToMongoSort = sortOptions =>
+export const enumToMongoSort = (sortOptions) =>
   Object.keys(sortOptions).reduce((mongoSort, val) => {
     mongoSort[val] = sortEnumToInt(sortOptions[val])
     return mongoSort
@@ -18,12 +18,12 @@ export const enumToMongoSort = sortOptions =>
  * Encode a cursor offset in a mongodb collection
  * @param {object} value cursor fields
  */
-export const apiCursor = value => {
-  return Buffer.from(JSON.stringify(value)).toString('base64')
+export const apiCursor = (value) => {
+  return Buffer.from(JSON.stringify(value)).toString("base64")
 }
 
-export const decodeCursor = cursor => {
-  return JSON.parse(Buffer.from(cursor, 'base64').toString())
+export const decodeCursor = (cursor) => {
+  return JSON.parse(Buffer.from(cursor, "base64").toString())
 }
 
 /**
@@ -39,14 +39,14 @@ export const applyCursorToEdges = (edges, offset) => {
 }
 
 // Limit to options.first in range 1 <= limit <= 100
-export const maxLimit = limit => Math.max(Math.min(limit, 100), 1)
+export const maxLimit = (limit) => Math.max(Math.min(limit, 100), 1)
 
 // Decode cursor from options object
-export const getOffsetFromCursor = options => {
-  if (options.hasOwnProperty('after') && options.after) {
+export const getOffsetFromCursor = (options) => {
+  if (options.hasOwnProperty("after") && options.after) {
     return decodeCursor(options.after).offset
   }
-  if (options.hasOwnProperty('before') && options.before) {
+  if (options.hasOwnProperty("before") && options.before) {
     return (
       decodeCursor(options.before).offset - Math.max(maxLimit(options.first), 0)
     )
@@ -60,72 +60,72 @@ export const getOffsetFromCursor = options => {
  * @param {object} options Query parameters
  * @returns {array} Steps required to sort any specified fields
  */
-export const sortAggregate = options => {
+export const sortAggregate = (options) => {
   const sortingStages = []
   const finalSort = {}
-  if (options.hasOwnProperty('orderBy')) {
-    if ('created' in options.orderBy && options.orderBy.created) {
-      finalSort['_id'] = sortEnumToInt(options.orderBy.created)
+  if (options.hasOwnProperty("orderBy")) {
+    if ("created" in options.orderBy && options.orderBy.created) {
+      finalSort["_id"] = sortEnumToInt(options.orderBy.created)
     }
-    if ('name' in options.orderBy && options.orderBy.name) {
-      finalSort['name'] = sortEnumToInt(options.orderBy.name)
+    if ("name" in options.orderBy && options.orderBy.name) {
+      finalSort["name"] = sortEnumToInt(options.orderBy.name)
     }
-    if ('uploader' in options.orderBy && options.orderBy.uploader) {
+    if ("uploader" in options.orderBy && options.orderBy.uploader) {
       sortingStages.push({
         $lookup: {
-          from: 'users',
-          localField: 'uploader',
-          foreignField: 'id',
-          as: 'uploadUser',
+          from: "users",
+          localField: "uploader",
+          foreignField: "id",
+          as: "uploadUser",
         },
       })
-      finalSort['uploadUser.name'] = sortEnumToInt(options.orderBy.uploader)
+      finalSort["uploadUser.name"] = sortEnumToInt(options.orderBy.uploader)
     }
-    if ('stars' in options.orderBy && options.orderBy.stars) {
+    if ("stars" in options.orderBy && options.orderBy.stars) {
       // Lookup related collection values
       sortingStages.push({
         $lookup: {
-          from: 'stars',
-          localField: 'id',
-          foreignField: 'datasetId',
-          as: 'stars',
+          from: "stars",
+          localField: "id",
+          foreignField: "datasetId",
+          as: "stars",
         },
       })
       // Count stars
       sortingStages.push({
         $addFields: {
-          starsCount: { $size: '$stars' },
+          starsCount: { $size: "$stars" },
         },
       })
-      finalSort['starsCount'] = sortEnumToInt(options.orderBy.stars)
+      finalSort["starsCount"] = sortEnumToInt(options.orderBy.stars)
     }
-    if ('downloads' in options.orderBy && options.orderBy.downloads) {
-      finalSort['downloads'] = sortEnumToInt(options.orderBy.downloads)
+    if ("downloads" in options.orderBy && options.orderBy.downloads) {
+      finalSort["downloads"] = sortEnumToInt(options.orderBy.downloads)
     }
-    if ('views' in options.orderBy && options.orderBy.views) {
-      finalSort['views'] = sortEnumToInt(options.orderBy.views)
+    if ("views" in options.orderBy && options.orderBy.views) {
+      finalSort["views"] = sortEnumToInt(options.orderBy.views)
     }
-    if ('subscriptions' in options.orderBy && options.orderBy.subscriptions) {
+    if ("subscriptions" in options.orderBy && options.orderBy.subscriptions) {
       sortingStages.push({
         $lookup: {
-          from: 'subscriptions',
-          localField: 'id',
-          foreignField: 'datasetId',
-          as: 'subscriptions',
+          from: "subscriptions",
+          localField: "id",
+          foreignField: "datasetId",
+          as: "subscriptions",
         },
       })
       // Count stars
       sortingStages.push({
         $addFields: {
-          subscriptionsCount: { $size: '$subscriptions' },
+          subscriptionsCount: { $size: "$subscriptions" },
         },
       })
-      finalSort['subscriptionsCount'] = sortEnumToInt(
+      finalSort["subscriptionsCount"] = sortEnumToInt(
         options.orderBy.subscriptions,
       )
     }
-    if ('publishDate' in options.orderBy && options.orderBy.publishDate) {
-      finalSort['publishDate'] = sortEnumToInt(options.orderBy.publishDate)
+    if ("publishDate" in options.orderBy && options.orderBy.publishDate) {
+      finalSort["publishDate"] = sortEnumToInt(options.orderBy.publishDate)
     }
     sortingStages.push({ $sort: finalSort })
   }
@@ -137,7 +137,7 @@ export const sortAggregate = options => {
  * @param {object} options Query options such as {limit: 5, orderBy: {creation: 'descending'}}
  * @returns {(presortAggregate: array) => object} presortAggregate Any presorting / pagination constraints
  */
-export const datasetsConnection = options => presortAggregate => {
+export const datasetsConnection = (options) => (presortAggregate) => {
   const offset = getOffsetFromCursor(options)
   const realLimit = maxLimit(options.first)
   // One query for match -> count -> sort -> skip -> limit
@@ -145,18 +145,18 @@ export const datasetsConnection = options => presortAggregate => {
     ...presortAggregate,
     ...sortAggregate(options),
     {
-      $group: { _id: null, count: { $sum: 1 }, datasets: { $push: '$$ROOT' } },
+      $group: { _id: null, count: { $sum: 1 }, datasets: { $push: "$$ROOT" } },
     },
     {
       $project: {
         count: 1,
-        datasets: { $slice: ['$datasets', offset, realLimit] },
+        datasets: { $slice: ["$datasets", offset, realLimit] },
       },
     },
   ]
   return Dataset.aggregate(pipeline)
     .exec()
-    .then(results => {
+    .then((results) => {
       const result = results.pop()
       if (result) {
         const { datasets, count } = result

package/src/datalad/{readme.js → readme.ts}

@@ -1,16 +1,18 @@
-import { addFileString, commitFiles } from './dataset'
-import { redis } from '../libs/redis'
-import CacheItem, { CacheType } from '../cache/item'
-import { getDatasetWorker } from '../libs/datalad-service'
-import { datasetOrSnapshot } from '../utils/datasetOrSnapshot'
+import { addFileString, commitFiles } from "./dataset"
+import { redis } from "../libs/redis"
+import CacheItem, { CacheType } from "../cache/item"
+import { getDatasetWorker } from "../libs/datalad-service"
+import { datasetOrSnapshot } from "../utils/datasetOrSnapshot"
 
 export const readmeUrl = (datasetId, revision) => {
-  return `http://${getDatasetWorker(
-    datasetId,
-  )}/datasets/${datasetId}/snapshots/${revision}/files/README`
+  return `http://${
+    getDatasetWorker(
+      datasetId,
+    )
+  }/datasets/${datasetId}/snapshots/${revision}/files/README`
 }
 
-export const readme = obj => {
+export const readme = (obj) => {
   const { datasetId, revision } = datasetOrSnapshot(obj)
   const cache = new CacheItem(redis, CacheType.readme, [
     datasetId,
@@ -33,7 +35,7 @@ export const readme = obj => {
 }
 
 export const setReadme = (datasetId, readme, user) => {
-  return addFileString(datasetId, 'README', 'text/plain', readme).then(() =>
-    commitFiles(datasetId, user),
+  return addFileString(datasetId, "README", "text/plain", readme).then(() =>
+    commitFiles(datasetId, user)
   )
 }

package/src/datalad/{reexporter.js → reexporter.ts}

@@ -1,13 +1,13 @@
-import request from 'superagent'
-import { getDatasetWorker } from '../libs/datalad-service'
+import request from "superagent"
+import { getDatasetWorker } from "../libs/datalad-service"
 
 /**
  * Run remote reexporter.
  */
-export const runReexporter = datasetId => {
+export const runReexporter = (datasetId) => {
   const worker = getDatasetWorker(datasetId)
   const uri = `${worker}/datasets/${datasetId}/reexport-remotes`
   return request.post(uri)
 }
 
-export const CHECK = 'hi'
+export const CHECK = "hi"

package/src/datalad/{snapshots.js → snapshots.ts}

@@ -1,26 +1,25 @@
 /**
  * Get snapshots from datalad-service tags
  */
-import request from 'superagent'
-import { reindexDataset } from '../elasticsearch/reindex-dataset'
-import { redis, redlock } from '../libs/redis'
-import CacheItem, { CacheType } from '../cache/item'
-import config from '../config.js'
-import pubsub from '../graphql/pubsub.js'
+import request from "superagent"
+import { reindexDataset } from "../elasticsearch/reindex-dataset"
+import { redis, redlock } from "../libs/redis"
+import CacheItem, { CacheType } from "../cache/item"
+import config from "../config"
 import {
-  updateDatasetName,
   snapshotCreationComparison,
-} from '../graphql/resolvers/dataset.js'
-import { description } from '../graphql/resolvers/description.js'
-import doiLib from '../libs/doi/index.js'
-import { getFiles } from './files'
-import { generateDataladCookie } from '../libs/authentication/jwt'
-import notifications from '../libs/notifications'
-import Dataset from '../models/dataset'
-import Snapshot from '../models/snapshot'
-import { updateDatasetRevision } from './draft.js'
-import { getDatasetWorker } from '../libs/datalad-service'
-import { join } from 'path'
+  updateDatasetName,
+} from "../graphql/resolvers/dataset"
+import { description } from "../graphql/resolvers/description"
+import doiLib from "../libs/doi/index"
+import { getFiles } from "./files"
+import { generateDataladCookie } from "../libs/authentication/jwt"
+import notifications from "../libs/notifications"
+import Dataset from "../models/dataset"
+import Snapshot, { SnapshotDocument } from "../models/snapshot"
+import { updateDatasetRevision } from "./draft"
+import { getDatasetWorker } from "../libs/datalad-service"
+import { join } from "path"
 
 const lockSnapshot = (datasetId, tag) => {
   return redlock.lock(
@@ -53,17 +52,18 @@ const createIfNotExistsDoi = async (
     // Mint a DOI
     // Get the newest description
     try {
-      const oldDesc = await description({ id: datasetId, revision: 'HEAD' })
+      const oldDesc = await description({ id: datasetId, revision: "HEAD" })
       const snapshotDoi = await doiLib.registerSnapshotDoi(
         datasetId,
         tag,
         oldDesc,
       )
-      if (snapshotDoi)
-        descriptionFieldUpdates['DatasetDOI'] = `doi:${snapshotDoi}`
+      if (snapshotDoi) {
+        descriptionFieldUpdates["DatasetDOI"] = `doi:${snapshotDoi}`
+      }
     } catch (err) {
       console.error(err)
-      throw new Error('DOI minting failed.')
+      throw new Error("DOI minting failed.")
     }
   }
 }
@@ -81,8 +81,8 @@ const postSnapshot = async (
       description_fields: descriptionFieldUpdates,
       snapshot_changes: snapshotChanges,
     })
-    .set('Accept', 'application/json')
-    .set('Cookie', generateDataladCookie(config)(user))
+    .set("Accept", "application/json")
+    .set("Cookie", generateDataladCookie(config)(user))
 
   return response.body
 }
@@ -95,11 +95,11 @@ const postSnapshot = async (
  * @param {string} datasetId Dataset accession number
  * @returns {Promise<import('../models/snapshot').SnapshotDocument[]>}
  */
-export const getSnapshots = datasetId => {
+export const getSnapshots = (datasetId): Promise<SnapshotDocument[]> => {
   const url = `${getDatasetWorker(datasetId)}/datasets/${datasetId}/snapshots`
   return request
     .get(url)
-    .set('Accept', 'application/json')
+    .set("Accept", "application/json")
     .then(({ body: { snapshots } }) => {
       return snapshots.sort(snapshotCreationComparison)
     })
@@ -109,14 +109,6 @@ const announceNewSnapshot = async (snapshot, datasetId, user) => {
   if (snapshot.files) {
     notifications.snapshotCreated(datasetId, snapshot, user) // send snapshot notification to subscribers
   }
-  pubsub.publish('snapshotsUpdated', {
-    datasetId,
-    snapshotsUpdated: {
-      id: datasetId,
-      snapshots: await getSnapshots(datasetId),
-      latestSnapshot: snapshot,
-    },
-  })
 }
 
 /**
@@ -146,9 +138,11 @@ export const createSnapshot = async (
   try {
     await createIfNotExistsDoi(datasetId, tag, descriptionFieldUpdates)
 
-    const createSnapshotUrl = `${getDatasetWorker(
-      datasetId,
-    )}/datasets/${datasetId}/snapshots/${tag}`
+    const createSnapshotUrl = `${
+      getDatasetWorker(
+        datasetId,
+      )
+    }/datasets/${datasetId}/snapshots/${tag}`
     const snapshot = await postSnapshot(
       user,
       createSnapshotUrl,
@@ -184,22 +178,17 @@ export const createSnapshot = async (
 }
 
 export const deleteSnapshot = (datasetId, tag) => {
-  const url = `${getDatasetWorker(
-    datasetId,
-  )}/datasets/${datasetId}/snapshots/${tag}`
+  const url = `${
+    getDatasetWorker(
+      datasetId,
+    )
+  }/datasets/${datasetId}/snapshots/${tag}`
   return request.del(url).then(async ({ body }) => {
     const snapshotCache = new CacheItem(redis, CacheType.snapshot, [
       datasetId,
       tag,
     ])
     await snapshotCache.drop()
-    pubsub.publish('snapshotsUpdated', {
-      datasetId,
-      snapshotsUpdated: {
-        id: datasetId,
-        snapshots: await getSnapshots(datasetId),
-      },
-    })
     return body
   })
 }
@@ -210,16 +199,21 @@ export const deleteSnapshot = (datasetId, tag) => {
  * @param {string} commitRef Tag name to retrieve
  * @returns {Promise<import('../models/snapshot').SnapshotDocument>}
  */
-export const getSnapshot = (datasetId, commitRef) => {
-  const url = `${getDatasetWorker(
-    datasetId,
-  )}/datasets/${datasetId}/snapshots/${commitRef}`
+export const getSnapshot = (
+  datasetId,
+  commitRef,
+): Promise<SnapshotDocument> => {
+  const url = `${
+    getDatasetWorker(
+      datasetId,
+    )
+  }/datasets/${datasetId}/snapshots/${commitRef}`
   const cache = new CacheItem(redis, CacheType.snapshot, [datasetId, commitRef])
   return cache.get(() =>
     request
       .get(url)
-      .set('Accept', 'application/json')
-      .then(({ body }) => body),
+      .set("Accept", "application/json")
+      .then(({ body }) => body)
   )
 }
 
@@ -234,7 +228,7 @@ export const getSnapshot = (datasetId, commitRef) => {
 export const getSnapshotHexsha = (datasetId, tag) => {
   return Snapshot.findOne({ datasetId, tag }, { hexsha: true })
     .exec()
-    .then(result => (result ? result.hexsha : null))
+    .then((result) => (result ? result.hexsha : null))
 }
 
 /**
@@ -244,22 +238,22 @@ export const getSnapshotHexsha = (datasetId, tag) => {
  */
 export const getPublicSnapshots = () => {
   // query all publicly available dataset
-  return Dataset.find({ public: true }, 'id')
+  return Dataset.find({ public: true }, "id")
     .exec()
-    .then(datasets => {
-      const datasetIds = datasets.map(dataset => dataset.id)
+    .then((datasets) => {
+      const datasetIds = datasets.map((dataset) => dataset.id)
       return Snapshot.aggregate([
         { $match: { datasetId: { $in: datasetIds } } },
         { $sort: { created: -1 } },
         {
           $group: {
-            _id: '$datasetId',
-            snapshots: { $push: '$$ROOT' },
+            _id: "$datasetId",
+            snapshots: { $push: "$$ROOT" },
           },
         },
         {
           $replaceRoot: {
-            newRoot: { $arrayElemAt: ['$snapshots', 0] },
+            newRoot: { $arrayElemAt: ["$snapshots", 0] },
           },
         },
       ]).exec()
@@ -277,13 +271,13 @@ export const downloadFiles = (datasetId, tag) => {
   // Return an existing cache object if we have one
   return downloadCache.get(async () => {
     // If not, fetch all trees sequentially and cache the result (hopefully some or all trees are cached)
-    const files = await getFilesRecursive(datasetId, tag, '')
+    const files = await getFilesRecursive(datasetId, tag, "")
     files.sort()
     return files
   })
 }
 
-export async function getFilesRecursive(datasetId, tree, path = '') {
+export async function getFilesRecursive(datasetId, tree, path = "") {
   const files = []
   // Fetch files
   const fileTree = await getFiles(datasetId, tree)

package/src/datalad/{upload.js → upload.ts}

@@ -1,9 +1,11 @@
-import { getDatasetWorker } from '../libs/datalad-service'
+import { getDatasetWorker } from "../libs/datalad-service"
 
 export const uploadUrl = (datasetId, uploadId) => {
-  return `http://${getDatasetWorker(
-    datasetId,
-  )}/datasets/${datasetId}/upload/${uploadId}`
+  return `http://${
+    getDatasetWorker(
+      datasetId,
+    )
+  }/datasets/${datasetId}/upload/${uploadId}`
 }
 
 /**
@@ -19,7 +21,7 @@ export const finishUploadRequest = async (
   forwardToken,
 ) => {
   const response = await fetch(uploadUrl(datasetId, uploadId), {
-    method: 'POST',
+    method: "POST",
     body: JSON.stringify({}),
     headers: {
       cookie: `accessToken=${forwardToken}`,

package/src/elasticsearch/elastic-client.ts

@@ -0,0 +1,11 @@
+import config from "../config"
+import { Client } from "@elastic/elasticsearch"
+
+const elasticConfig = {
+  node: config.elasticsearch.connection || "http://mock-client",
+  maxRetries: 3,
+}
+
+export const elasticClient = new Client(elasticConfig)
+
+export default elasticClient

package/src/elasticsearch/reindex-dataset.ts

@@ -1,14 +1,14 @@
-import config from '../config.js'
-import { indexDataset, queryForIndex, indexingToken } from '@openneuro/search'
-import { elasticClient } from './elastic-client'
+import config from "../config"
+import { indexDataset, indexingToken, queryForIndex } from "@openneuro/search"
+import { elasticClient } from "./elastic-client"
 import {
-  from,
   ApolloClient,
+  from,
   InMemoryCache,
   NormalizedCacheObject,
-} from '@apollo/client'
-import { setContext } from '@apollo/client/link/context'
-import { HttpLink } from '@apollo/client/link/http'
+} from "@apollo/client"
+import { setContext } from "@apollo/client/link/context"
+import { HttpLink } from "@apollo/client/link/http"
 
 /**
  * Setup SchemaLink based client for querying

package/src/graphql/__tests__/__snapshots__/permissions.spec.ts.snap

@@ -0,0 +1,5 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`resolver permissions helpers > checkDatasetAdmin() > resolves to false for anonymous users 1`] = `"You do not have admin access to this dataset."`;
+
+exports[`resolver permissions helpers > checkDatasetWrite() > resolves to false for anonymous users 1`] = `"You do not have access to modify this dataset."`;