@openneuro/server 5.0.0 → 5.1.0

package/src/graphql/resolvers/user.ts

@@ -2,19 +2,18 @@ import type { PipelineStage } from "mongoose"
 import User from "../../models/user"
 import DatasetEvent from "../../models/datasetEvents"
 import type { UserNotificationStatusDocument } from "../../models/userNotificationStatus"
-
 function isValidOrcid(orcid: string): boolean {
   return /^[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[0-9X]$/.test(orcid || "")
 }
 
 // TODO - Use GraphQL codegen
-type GraphQLUserType = {
+export type GraphQLUserType = {
   id: string
   provider: "orcid" | "google"
   avatar: string
   orcid: string
   created: Date
-  modified: Date
+  updatedAt: Date
   lastSeen: Date
   email: string
   name: string
@@ -24,16 +23,15 @@ type GraphQLUserType = {
   institution: string
   github: string
   githubSynced: Date
-  links: [string]
-  notifications: [Record<string, unknown>]
-  orcidConsent: boolean
+  links: string[]
+  orcidConsent: boolean | null
 }
 
 export async function user(
-  obj,
-  { id },
-  { userInfo }: { userInfo?: Record<string, unknown> } = {},
-): Promise<Partial<GraphQLUserType> | null> {
+  obj: unknown,
+  { id }: { id: string },
+  { userInfo }: Partial<GraphQLContext> = {},
+): Promise<GraphQLUserType | null> {
   if (userInfo?.reviewer) {
     const oneWeekAgo = new Date()
     oneWeekAgo.setDate(oneWeekAgo.getDate() - 7)
@@ -42,15 +40,19 @@ export async function user(
       name: "Anonymous Reviewer",
       email: "reviewer@openneuro.org",
       provider: "orcid",
+      avatar: "",
       orcid: "0000-0000-0000-0000",
       admin: false,
       blocked: false,
       location: "",
       institution: "",
+      github: "",
+      githubSynced: oneWeekAgo,
+      links: [],
       orcidConsent: true,
       created: oneWeekAgo,
       lastSeen: new Date(),
-      modified: oneWeekAgo,
+      updatedAt: oneWeekAgo,
     }
   }
 
@@ -76,19 +78,7 @@ export async function user(
   }
 }
 
-export interface UserInfo {
-  userId: string
-  admin: boolean
-  username?: string
-  provider?: string
-  providerId?: string
-  blocked?: boolean
-  orcidConsent?: boolean | null
-}
-
-export interface GraphQLContext {
-  userInfo: UserInfo | null
-}
+import type { GraphQLContext } from "../builder"
 
 type MongoOperatorValue =
   | string
@@ -202,7 +192,11 @@ export const users = async (
   }
 }
 
-export const removeUser = (obj, { id }, { userInfo }) => {
+export const removeUser = (
+  obj: unknown,
+  { id }: { id: string },
+  { userInfo }: GraphQLContext,
+) => {
   if (userInfo.admin) {
     return User.findByIdAndDelete(id).exec()
   } else {
@@ -210,7 +204,11 @@ export const removeUser = (obj, { id }, { userInfo }) => {
   }
 }
 
-export const setAdmin = (obj, { id, admin }, { userInfo }) => {
+export const setAdmin = (
+  obj: unknown,
+  { id, admin }: { id: string; admin: boolean },
+  { userInfo }: GraphQLContext,
+) => {
   if (userInfo.admin) {
     return User.findOneAndUpdate({ id }, { admin }).exec()
   } else {
@@ -220,7 +218,11 @@ export const setAdmin = (obj, { id, admin }, { userInfo }) => {
   }
 }
 
-export const setBlocked = (obj, { id, blocked }, { userInfo }) => {
+export const setBlocked = (
+  obj: unknown,
+  { id, blocked }: { id: string; blocked: boolean },
+  { userInfo }: GraphQLContext,
+) => {
   if (userInfo.admin) {
     return User.findOneAndUpdate({ id }, { blocked }).exec()
   } else {
@@ -229,9 +231,15 @@ export const setBlocked = (obj, { id, blocked }, { userInfo }) => {
 }
 
 export const updateUser = async (
-  obj,
-  { id, location, institution, links, orcidConsent },
-  { userInfo },
+  obj: unknown,
+  { id, location, institution, links, orcidConsent }: {
+    id: string
+    location?: string
+    institution?: string
+    links?: string[]
+    orcidConsent?: boolean
+  },
+  { userInfo }: GraphQLContext,
 ) => {
   if (!userInfo) {
     throw new Error("You must be logged in to update a user")
@@ -267,7 +275,7 @@ export const updateUser = async (
 
     return user
   } catch (err) {
-    throw new Error("Failed to update user: " + err.message)
+    throw new Error("Failed to update user: " + err.message, { cause: err })
   }
 }
 
@@ -275,7 +283,11 @@ export const updateUser = async (
  * Get all events associated with a specific user (for their notifications feed).
  * Uses a single aggregation pipeline for improved performance.
  */
-export async function notifications(obj, _, { userInfo }) {
+export async function notifications(
+  obj: Pick<GraphQLUserType, "id">,
+  _: unknown,
+  { userInfo }: GraphQLContext,
+) {
   const userId = obj.id
 
   // Reviewers never have notifications

package/src/graphql/resolvers/validation.ts

@@ -2,16 +2,17 @@ import config from "../../config"
 import { generateDataladCookie } from "../../libs/authentication/jwt"
 import { getDatasetWorker } from "../../libs/datalad-service"
 import Validation from "../../models/validation"
-import { redis } from "../../libs/redis"
+import { getRedis } from "../../libs/redis"
 import CacheItem from "../../cache/item"
 import { CacheType } from "../../cache/types"
+import type { GraphQLContext } from "../builder"
 
 /**
  * Issues resolver for schema validator
  */
-export const validation = async (dataset, _, { userInfo }) => {
+export const validation = async (dataset, _, { userInfo }: GraphQLContext) => {
   const cache = new CacheItem(
-    redis,
+    getRedis(),
     CacheType.validation,
     [dataset.id, dataset.revision],
   )
@@ -79,7 +80,7 @@ export const validation = async (dataset, _, { userInfo }) => {
 /**
  * Snapshot issues resolver for schema validator
  */
-export const snapshotValidation = async (snapshot, _, context) => {
+export const snapshotValidation = async (snapshot, _, context: GraphQLContext) => {
   const dataset = {
     id: snapshot.id.split(":")[0],
     revision: snapshot.hexsha,
@@ -132,7 +133,7 @@ export const validationUrl = (datasetId, ref) => {
  * @param {string} args.datasetId Dataset accession number
  * @param {string} args.ref Git hexsha
  */
-export const revalidate = async (obj, { datasetId, ref }, { userInfo }) => {
+export const revalidate = async (obj, { datasetId, ref }, { userInfo }: Pick<GraphQLContext, "userInfo">) => {
   try {
     const response = await fetch(validationUrl(datasetId, ref), {
       method: "POST",

package/src/graphql/resolvers/worker.ts

@@ -1,12 +1,13 @@
 import WorkerTask from "../../models/worker-task"
 import { checkWorker } from "../permissions"
+import type { GraphQLContext } from "../builder"
 
 /**
  * Update a worker task record
  *
  * This can be called for new tasks, or to update existing tasks.
  */
-export const updateWorkerTask = async (obj, args, { userInfo }) => {
+export const updateWorkerTask = async (obj, args, { userInfo }: GraphQLContext) => {
   checkWorker(userInfo)
   const { id, ...updateData } = args
 

package/src/graphql/schema/analytics.ts

@@ -0,0 +1,12 @@
+import { builder } from "../builder"
+
+export const Analytic = builder.simpleObject("Analytic", {
+  description: "Analytics for a dataset",
+  directives: { cacheControl: { maxAge: 300 } },
+  fields: (t) => ({
+    datasetId: t.id({ nullable: false }),
+    tag: t.string(),
+    views: t.int(),
+    downloads: t.int(),
+  }),
+})

package/src/graphql/schema/comment.ts

@@ -0,0 +1,30 @@
+import { CommentRef, UserRef } from "./refs"
+import CommentFields from "../resolvers/comment"
+
+CommentRef.implement({
+  fields: (t) => ({
+    id: t.id({
+      nullable: false,
+      resolve: (obj) => obj._id ?? obj.id,
+    }),
+    text: t.string({ nullable: false, resolve: (obj) => obj.text }),
+    user: t.field({
+      type: UserRef,
+      resolve: (obj) => CommentFields.user(obj),
+    }),
+    createDate: t.field({
+      type: "DateTime",
+      nullable: false,
+      resolve: (obj) => obj.createDate,
+    }),
+    parent: t.field({
+      type: CommentRef,
+      resolve: (obj) => CommentFields.parent(obj),
+    }),
+    replies: t.field({
+      type: [CommentRef],
+      nullable: { list: true, items: true },
+      resolve: (obj) => CommentFields.replies(obj),
+    }),
+  }),
+})

package/src/graphql/schema/dataset-events.ts

@@ -0,0 +1,91 @@
+import { DatasetEventDescriptionRef, DatasetEventRef, UserRef } from "./refs"
+import { ResponseStatusType } from "./enums"
+import { UserNotificationStatus } from "./misc"
+import { Contributor } from "./description"
+import {
+  DatasetEventDescriptionTypeResolvers,
+  DatasetEventTypeResolvers,
+} from "../resolvers/datasetEvents"
+
+DatasetEventDescriptionRef.implement({
+  fields: (t) => ({
+    type: t.string({ resolve: (obj) => obj.type }),
+    version: t.string({
+      resolve: (obj) => "version" in obj ? obj.version : null,
+    }),
+    public: t.boolean({
+      resolve: (obj) => "public" in obj ? obj.public : null,
+    }),
+    target: t.field({
+      type: UserRef,
+      resolve: (obj) => ("target" in obj ? obj.target : null) as never,
+    }),
+    targetUserId: t.id({
+      resolve: (obj) => "targetUserId" in obj ? obj.targetUserId : null,
+    }),
+    level: t.string({
+      resolve: (obj) => "level" in obj ? obj.level : null,
+    }),
+    ref: t.string({
+      resolve: (obj) => "reference" in obj ? obj.reference : null,
+    }),
+    message: t.string({
+      resolve: () => null,
+    }),
+    requestId: t.id({
+      resolve: (obj) => "requestId" in obj ? obj.requestId : null,
+    }),
+    reason: t.string({
+      resolve: (obj) => "reason" in obj ? obj.reason : null,
+    }),
+    datasetId: t.id({
+      resolve: (obj) => "datasetId" in obj ? obj.datasetId : null,
+    }),
+    resolutionStatus: t.field({
+      type: ResponseStatusType,
+      resolve: (obj) =>
+        DatasetEventDescriptionTypeResolvers.resolutionStatus(
+          obj as {
+            resolutionStatus?: "pending" | "accepted" | "denied" | null
+          },
+        ),
+    }),
+    contributorData: t.field({
+      type: Contributor,
+      resolve: (obj) =>
+        "contributorData" in obj ? obj.contributorData : null,
+    }),
+  }),
+})
+
+DatasetEventRef.implement({
+  fields: (t) => ({
+    id: t.id({ resolve: (obj) => obj.id }),
+    timestamp: t.field({
+      type: "DateTime",
+      resolve: (obj) => obj.timestamp,
+    }),
+    user: t.field({
+      type: UserRef,
+      resolve: (obj) => obj.user as never,
+    }),
+    event: t.field({
+      type: DatasetEventDescriptionRef,
+      resolve: (obj) => obj.event,
+    }),
+    success: t.boolean({ resolve: (obj) => obj.success }),
+    note: t.string({ resolve: (obj) => obj.note }),
+    datasetId: t.id({ resolve: (obj) => obj.datasetId }),
+    notificationStatus: t.field({
+      type: UserNotificationStatus,
+      resolve: (obj) => obj.notificationStatus,
+    }),
+    responseStatus: t.field({
+      type: ResponseStatusType,
+      resolve: (ev) => DatasetEventTypeResolvers.responseStatus(ev),
+    }),
+    hasBeenRespondedTo: t.boolean({
+      resolve: (ev) => DatasetEventTypeResolvers.hasBeenRespondedTo(ev),
+    }),
+  }),
+})

package/src/graphql/schema/dataset-search.ts

@@ -0,0 +1,32 @@
+import { builder } from "../builder"
+import { DatasetConnection } from "./dataset"
+import { DatasetSearchInput } from "./inputs"
+import {
+  advancedDatasetSearchConnection,
+  datasetSearchConnection,
+} from "../resolvers/dataset-search"
+
+builder.queryFields((t) => ({
+  search: t.field({
+    type: DatasetConnection,
+    args: {
+      q: t.arg.string({ required: true }),
+      after: t.arg.string(),
+      first: t.arg.int(),
+    },
+    resolve: (root, args) => datasetSearchConnection(root, args as never),
+  }),
+  advancedSearch: t.field({
+    type: DatasetConnection,
+    args: {
+      query: t.arg({ type: DatasetSearchInput, required: true }),
+      allDatasets: t.arg.boolean(),
+      datasetType: t.arg.string(),
+      datasetStatus: t.arg.string(),
+      after: t.arg.string(),
+      first: t.arg.int(),
+    },
+    resolve: (root, args, ctx) =>
+      advancedDatasetSearchConnection(root, args as never, ctx),
+  }),
+}))

package/src/graphql/schema/dataset.ts

@@ -0,0 +1,167 @@
+import { builder } from "../builder"
+import {
+  CommentRef,
+  DatasetEventRef,
+  DatasetRef,
+  DraftRef,
+  SnapshotRef,
+  UserRef,
+} from "./refs"
+import { PageInfo } from "./pagination"
+import { DatasetPermissions } from "./permissions"
+import { Analytic } from "./analytics"
+import { DatasetCommit, DatasetDerivatives, Follower, Star } from "./misc"
+import { Metadata } from "./metadata"
+import { DatasetReviewer } from "./reviewer"
+import {
+  analytics,
+  datasetName,
+  followers,
+  following,
+  starred,
+  stars,
+} from "../resolvers/dataset"
+import { user } from "../resolvers/user"
+import { latestSnapshot, snapshots } from "../resolvers/snapshots"
+import { permissions } from "../resolvers/permissions"
+import { datasetComments } from "../resolvers/comment"
+import { metadata } from "../resolvers/metadata"
+import { history } from "../resolvers/history"
+import { onBrainlife } from "../resolvers/brainlife"
+import { brainInitiative } from "../resolvers/brainInitiative"
+import { derivatives } from "../resolvers/derivatives"
+import { reviewers } from "../resolvers/reviewer"
+import { datasetEvents } from "../resolvers/datasetEvents"
+import { getDatasetWorker } from "../../libs/datalad-service"
+import { getDraftInfo } from "../../datalad/draft"
+
+export const DatasetEdge = builder.simpleObject("DatasetEdge", {
+  fields: (t) => ({
+    id: t.string({ nullable: false }),
+    node: t.field({ type: DatasetRef, nullable: false }),
+    cursor: t.string({ nullable: false }),
+  }),
+})
+
+export const DatasetConnection = builder.simpleObject("DatasetConnection", {
+  fields: (t) => ({
+    edges: t.field({
+      type: [DatasetEdge],
+      nullable: { list: true, items: true },
+    }),
+    pageInfo: t.field({ type: PageInfo, nullable: false }),
+  }),
+})
+
+DatasetRef.implement({
+  fields: (t) => ({
+    id: t.id({ nullable: false, resolve: (obj) => obj.id }),
+    created: t.field({
+      type: "DateTime",
+      nullable: false,
+      resolve: (obj) => obj.created,
+    }),
+    uploader: t.field({
+      type: UserRef,
+      resolve: (obj, _args, ctx) =>
+        user(null, { id: obj.uploader }, ctx),
+    }),
+    public: t.boolean({ resolve: (obj) => obj.public }),
+    draft: t.field({
+      type: DraftRef,
+      resolve: async (obj) => {
+        const draftHead = await getDraftInfo(obj.id)
+        return {
+          id: obj.id,
+          revision: draftHead.ref,
+          modified: new Date(draftHead.modified),
+        }
+      },
+    }),
+    snapshots: t.field({
+      type: [SnapshotRef],
+      nullable: { list: true, items: true },
+      resolve: (obj) => snapshots(obj) as never,
+    }),
+    latestSnapshot: t.field({
+      type: SnapshotRef,
+      nullable: false,
+      resolve: (obj, _args, ctx) => latestSnapshot(obj, null, ctx),
+    }),
+    permissions: t.field({
+      type: DatasetPermissions,
+      resolve: (obj, _args, ctx) => permissions(obj, null, ctx) as never,
+    }),
+    analytics: t.field({
+      type: Analytic,
+      resolve: (obj) => analytics(obj),
+    }),
+    stars: t.field({
+      type: [Star],
+      nullable: { list: true, items: true },
+      resolve: (obj) => stars(obj),
+    }),
+    followers: t.field({
+      type: [Follower],
+      nullable: { list: true, items: true },
+      resolve: (obj) => followers(obj),
+    }),
+    name: t.string({
+      resolve: (obj) => datasetName(obj),
+    }),
+    comments: t.field({
+      type: [CommentRef],
+      nullable: { list: true, items: true },
+      resolve: (obj) => datasetComments(obj),
+    }),
+    following: t.boolean({
+      resolve: (obj, _args, ctx) => following(obj, _args, ctx),
+    }),
+    starred: t.boolean({
+      resolve: (obj, _args, ctx) => starred(obj, _args, ctx),
+    }),
+    publishDate: t.field({
+      type: "DateTime",
+      resolve: (obj) => obj.publishDate,
+    }),
+    onBrainlife: t.boolean({
+      directives: { cacheControl: { maxAge: 10080 } },
+      resolve: (obj) => onBrainlife(obj as never) as never,
+    }),
+    derivatives: t.field({
+      type: [DatasetDerivatives],
+      nullable: { list: true, items: true },
+      directives: { cacheControl: { maxAge: 3600 } },
+      resolve: (obj) => derivatives(obj as never) as never,
+    }),
+    metadata: t.field({
+      type: Metadata,
+      resolve: (obj, _args, ctx) => metadata(obj, null, ctx),
+    }),
+    history: t.field({
+      type: [DatasetCommit],
+      nullable: { list: true, items: true },
+      resolve: (obj) => history(obj),
+    }),
+    worker: t.string({
+      resolve: (obj) => getDatasetWorker(obj.id),
+    }),
+    reviewers: t.field({
+      type: [DatasetReviewer],
+      nullable: { list: true, items: true },
+      resolve: (obj, _args, ctx) => reviewers(obj, null, ctx),
+    }),
+    brainInitiative: t.boolean({
+      resolve: (obj, _args, ctx) =>
+        brainInitiative(obj as never, null, ctx) as never,
+    }),
+    events: t.field({
+      type: [DatasetEventRef],
+      nullable: { list: true, items: true },
+      resolve: (obj, _args, ctx) => datasetEvents(obj, null, ctx),
+    }),
+    holdDeletion: t.boolean({
+      resolve: (obj) => obj.holdDeletion
+    }),
+  }),
+})

package/src/graphql/schema/description.ts

@@ -0,0 +1,44 @@
+import { builder } from "../builder"
+import { DatasetRef } from "./refs"
+
+export const Description = builder.simpleObject("Description", {
+  description: "Contents of dataset_description.json",
+  directives: { cacheControl: { maxAge: 30 } },
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    Name: t.string({ nullable: false }),
+    BIDSVersion: t.string({ nullable: false }),
+    License: t.string(),
+    Authors: t.stringList({ nullable: { list: true, items: true } }),
+    SeniorAuthor: t.string(),
+    Acknowledgements: t.string(),
+    HowToAcknowledge: t.string(),
+    Funding: t.stringList({ nullable: { list: true, items: true } }),
+    ReferencesAndLinks: t.stringList({ nullable: { list: true, items: true } }),
+    DatasetDOI: t.string(),
+    DatasetType: t.string(),
+    EthicsApprovals: t.stringList({ nullable: { list: true, items: true } }),
+  }),
+})
+
+export const Contributor = builder.simpleObject("Contributor", {
+  description: "Defines the Contributor type in contributors.ts",
+  fields: (t) => ({
+    name: t.string({ nullable: false }),
+    givenName: t.string(),
+    familyName: t.string(),
+    orcid: t.string(),
+    contributorType: t.string({ nullable: false }),
+    order: t.int(),
+  }),
+})
+
+export const UpdateContributorsPayload = builder.simpleObject(
+  "UpdateContributorsPayload",
+  {
+    fields: (t) => ({
+      success: t.boolean({ nullable: false }),
+      dataset: t.field({ type: DatasetRef }),
+    }),
+  },
+)

package/src/graphql/schema/draft.ts

@@ -0,0 +1,80 @@
+import { DatasetRef, DraftRef } from "./refs"
+import { Summary } from "./metadata"
+import { ValidationIssue, ValidationIssueStatus } from "./validation"
+import { DatasetValidation } from "./validation"
+import { DatasetFile } from "./files"
+import { Description } from "./description"
+import { Contributor } from "./description"
+import { UploadMetadata } from "./upload"
+import { FileCheck } from "./misc"
+import DraftFields, { draftFiles, fileCheck } from "../resolvers/draft"
+
+DraftRef.implement({
+  fields: (t) => ({
+    id: t.id({ resolve: (obj) => obj.id }),
+    dataset: t.field({
+      type: DatasetRef,
+      resolve: (obj) => ({ id: obj.id }) as never,
+    }),
+    modified: t.field({
+      type: "DateTime",
+      resolve: (obj) =>
+        obj.modified ?? null,
+    }),
+    summary: t.field({
+      type: Summary,
+      resolve: (obj) => DraftFields.summary(obj) as never,
+    }),
+    issues: t.field({
+      type: [ValidationIssue],
+      nullable: { list: true, items: true },
+      resolve: (obj, _args, ctx) => DraftFields.issues(obj, null, ctx),
+    }),
+    issuesStatus: t.field({
+      type: ValidationIssueStatus,
+      resolve: (obj) => DraftFields.issuesStatus(obj),
+    }),
+    validation: t.field({
+      type: DatasetValidation,
+      resolve: (obj, _args, ctx) =>
+        DraftFields.validation(obj, null, ctx) as never,
+    }),
+    files: t.field({
+      type: [DatasetFile],
+      nullable: { list: true, items: true },
+      args: {
+        tree: t.arg.string(),
+        recursive: t.arg.boolean(),
+      },
+      resolve: (obj, args, ctx) => draftFiles(obj, args, ctx),
+    }),
+    description: t.field({
+      type: Description,
+      resolve: (obj) => DraftFields.description(obj),
+    }),
+    readme: t.string({
+      resolve: (obj) => DraftFields.readme(obj),
+    }),
+    uploads: t.field({
+      type: [UploadMetadata],
+      nullable: { list: true, items: true },
+      resolve: () => null,
+    }),
+    head: t.string({
+      resolve: (obj) => DraftFields.head(obj),
+    }),
+    size: t.field({
+      type: "BigInt",
+      resolve: (obj, _args, ctx) => DraftFields.size(obj, null, ctx) as never,
+    }),
+    fileCheck: t.field({
+      type: FileCheck,
+      resolve: (obj) => fileCheck(obj),
+    }),
+    contributors: t.field({
+      type: [Contributor],
+      nullable: { list: true, items: true },
+      resolve: (obj) => DraftFields.contributors(obj),
+    }),
+  }),
+})