@openneuro/server 4.38.3 → 4.39.0-alpha.0

package/src/graphql/resolvers/datasetEvents.ts

@@ -1,27 +1,196 @@
 import DatasetEvent from "../../models/datasetEvents"
+import User from "../../models/user"
+import type { UserDocument } from "../../models/user"
+import { checkDatasetAdmin } from "../permissions"
+import type {
+  DatasetEventContributorCitation,
+  DatasetEventContributorCitationResponse,
+  DatasetEventContributorRequest,
+  DatasetEventContributorRequestResponse,
+  DatasetEventDocument,
+} from "../../models/datasetEvents"
+import { UserNotificationStatus } from "../../models/userNotificationStatus"
+import type { UserNotificationStatusDocument } from "../../models/userNotificationStatus"
+import {
+  getDataciteYml,
+  updateContributorsUtil,
+} from "../../utils/datacite-utils"
+import type { Contributor } from "../../types/datacite"
+
+/** Helper type guards */
+function isContributorRequest(
+  event: DatasetEventDocument,
+): event is DatasetEventDocument & { event: DatasetEventContributorRequest } {
+  return event.event.type === "contributorRequest"
+}
+
+function isContributorCitation(
+  event: DatasetEventDocument,
+): event is DatasetEventDocument & { event: DatasetEventContributorCitation } {
+  return event.event.type === "contributorCitation"
+}
+
+function isContributorRequestResponse(
+  event: DatasetEventDocument,
+): event is DatasetEventDocument & {
+  event: DatasetEventContributorRequestResponse
+} {
+  return event.event.type === "contributorRequestResponse"
+}
+
+function isContributorCitationResponse(
+  event: DatasetEventDocument,
+): event is DatasetEventDocument & {
+  event: DatasetEventContributorCitationResponse
+} {
+  return event.event.type === "contributorCitationResponse"
+}
+
+/** Enriched type for GraphQL */
+export type EnrichedDatasetEvent =
+  & Omit<DatasetEventDocument, "notificationStatus">
+  & {
+    hasBeenRespondedTo?: boolean
+    responseStatus?: "pending" | "accepted" | "denied" | null
+    notificationStatus?: UserNotificationStatusDocument
+  }
 
 /**
  * Get all events for a dataset
  */
-export function datasetEvents(obj, _, { userInfo }) {
-  if (userInfo.admin) {
-    // Site admins can see all events
-    return DatasetEvent.find({ datasetId: obj.id })
-      .sort({ timestamp: -1 })
-      .populate("user")
-      .exec()
-  } else {
-    // Non-admin users can only see notes without the admin flag
-    return DatasetEvent.find({
-      datasetId: obj.id,
-      event: { admin: { $ne: true } },
-    })
-      .sort({ timestamp: -1 })
-      .populate("user")
-      .exec()
-  }
+export async function datasetEvents(
+  obj,
+  _,
+  { userInfo, user },
+): Promise<EnrichedDatasetEvent[]> {
+  const allEvents: DatasetEventDocument[] = await DatasetEvent.find({
+    datasetId: obj.id,
+  })
+    .sort({ timestamp: -1 })
+    .populate("user")
+    .populate({ path: "notificationStatus", match: { userId: user } })
+
+  const enriched: EnrichedDatasetEvent[] = allEvents.map((e) => {
+    const ev = e.toObject() as EnrichedDatasetEvent
+
+    if (!ev.notificationStatus || typeof ev.notificationStatus === "string") {
+      ev.notificationStatus = new UserNotificationStatus({
+        userId: user,
+        datasetEventId: e.id,
+        status: "UNREAD",
+      }) as UserNotificationStatusDocument
+    }
+
+    if ("resolutionStatus" in e.event) {
+      ev.responseStatus = e.event.resolutionStatus as
+        | "pending"
+        | "accepted"
+        | "denied"
+      ev.hasBeenRespondedTo = ev.responseStatus !== null &&
+        ev.responseStatus !== "pending"
+    } else {
+      ev.responseStatus = null
+      ev.hasBeenRespondedTo = false
+    }
+
+    return ev
+  })
+
+  return userInfo?.admin ? enriched : enriched.filter(
+    (ev) =>
+      !(ev.event.type === "note" && ev.event.admin) &&
+      ev.event.type !== "permissionChange",
+  )
 }
 
+// --- Field-level resolvers ---
+export const DatasetEventResolvers = {
+  hasBeenRespondedTo: (ev: EnrichedDatasetEvent) =>
+    ev.hasBeenRespondedTo ?? false,
+  responseStatus: (ev: EnrichedDatasetEvent) => ev.responseStatus ?? null,
+  notificationStatus: (ev: EnrichedDatasetEvent) =>
+    ev.notificationStatus?.status ?? "UNREAD",
+  requestId: (ev: EnrichedDatasetEvent) =>
+    isContributorRequest(ev) || isContributorRequestResponse(ev)
+      ? ev.event.requestId
+      : null,
+  target: async (ev: EnrichedDatasetEvent): Promise<UserDocument | null> => {
+    const targetUserId = isContributorRequestResponse(ev) ||
+        isContributorCitation(ev) ||
+        isContributorCitationResponse(ev)
+      ? ev.event.targetUserId
+      : undefined
+
+    if (!targetUserId) return null
+    // Use findOne({ id }) for UUID strings
+    return User.findOne({ id: targetUserId })
+  },
+  user: async (ev: EnrichedDatasetEvent): Promise<UserDocument | null> =>
+    ev.userId ? User.findOne({ id: ev.userId }) : null,
+  contributorData: (ev: EnrichedDatasetEvent) => {
+    let data: DatasetEventContributorCitation["contributorData"] | undefined
+
+    if (
+      (isContributorCitation(ev) || isContributorCitationResponse(ev)) &&
+      ev.event.contributorData
+    ) {
+      data = ev.event.contributorData
+    } else if (
+      (isContributorRequest(ev) || isContributorRequestResponse(ev)) &&
+      ev.event.contributorData
+    ) {
+      data = ev.event.contributorData
+    }
+
+    return {
+      ...data,
+      contributorType: data?.contributorType || "Researcher",
+    }
+  },
+}
+/**
+ * Create a 'contributor request' event
+ */
+export async function createContributorRequestEvent(
+  obj,
+  { datasetId },
+  { user },
+) {
+  if (!user) {
+    throw new Error("Authentication required to request contributor status.")
+  }
+
+  // Fetch user info for contributorData
+  const targetUser = await User.findOne({ id: user })
+  if (!targetUser) throw new Error("User not found.")
+
+  const contributorData = {
+    userId: targetUser.id,
+    name: targetUser.name || "Unknown Contributor",
+    givenName: targetUser.givenName || "",
+    familyName: targetUser.familyName || "",
+    orcid: targetUser.orcid,
+    contributorType: "Researcher",
+  }
+
+  const event = new DatasetEvent({
+    datasetId,
+    userId: user,
+    event: {
+      type: "contributorRequest",
+      datasetId,
+      resolutionStatus: "pending",
+      contributorData,
+    },
+    success: true,
+    note: "User requested contributor status for this dataset.",
+  })
+  ;(event.event as DatasetEventContributorRequest).requestId = event.id
+
+  await event.save()
+  await event.populate("user")
+  return event
+}
 /**
  * Create or update an admin note event
  */
@@ -30,30 +199,296 @@ export async function saveAdminNote(
   { id, datasetId, note },
   { user, userInfo },
 ) {
-  // Only site admin users can create an admin note
-  if (!userInfo?.admin) {
-    throw new Error("Not authorized")
-  }
+  if (!userInfo?.admin) throw new Error("Not authorized")
+
   if (id) {
-    const event = await DatasetEvent.findOne({ id, datasetId })
-    event.note = note
-    await event.save()
-    await event.populate("user")
-    return event
+    const updatedEvent = await DatasetEvent.findOneAndUpdate(
+      { id, datasetId },
+      { note },
+      { new: true },
+    )
+    if (!updatedEvent) {
+      throw new Error(`Event with ID ${id} not found for dataset ${datasetId}.`)
+    }
+    await updatedEvent.populate("user")
+    return updatedEvent
   } else {
-    const event = new DatasetEvent({
-      id,
+    const newEvent = new DatasetEvent({
       datasetId,
       userId: user,
-      event: {
-        type: "note",
-        admin: true,
-      },
+      event: { type: "note", admin: true, datasetId },
       success: true,
       note,
     })
-    await event.save()
-    await event.populate("user")
-    return event
+    await newEvent.save()
+    await newEvent.populate("user")
+    return newEvent
   }
 }
+
+/**
+ * Process a contributor request (accept or deny) and update Datacite YAML if accepted
+ */
+export async function processContributorRequest(
+  obj: unknown,
+  {
+    datasetId,
+    requestId,
+    targetUserId,
+    resolutionStatus,
+    reason,
+  }: {
+    datasetId: string
+    requestId: string
+    targetUserId: string
+    resolutionStatus: "accepted" | "denied"
+    reason?: string
+  },
+  { user: currentUserId, userInfo }: {
+    user: string
+    userInfo: { admin: boolean }
+  },
+) {
+  if (!currentUserId) {
+    throw new Error("Authentication required to process contributor requests.")
+  }
+
+  await checkDatasetAdmin(datasetId, currentUserId, userInfo)
+
+  const originalRequestEvent = await DatasetEvent.findOne({
+    "event.type": "contributorRequest",
+    "event.requestId": requestId,
+  }).populate("user")
+
+  if (!originalRequestEvent || !isContributorRequest(originalRequestEvent)) {
+    throw new Error("Original contributor request event not found or invalid.")
+  }
+
+  const existingResponse = await DatasetEvent.findOne({
+    "event.type": "contributorRequestResponse",
+    "event.requestId": requestId,
+  })
+  if (existingResponse) {
+    throw new Error("This contributor request has already been processed.")
+  }
+
+  originalRequestEvent.event.resolutionStatus = resolutionStatus
+  await originalRequestEvent.save()
+
+  const responseEvent = new DatasetEvent({
+    datasetId,
+    userId: currentUserId,
+    event: {
+      type: "contributorRequestResponse",
+      requestId,
+      targetUserId,
+      reason,
+      datasetId,
+      resolutionStatus,
+      contributorData: originalRequestEvent.event.contributorData,
+    },
+    success: true,
+    note: reason?.trim() ||
+      `Admin ${currentUserId} processed contributor request for user ${targetUserId} as '${resolutionStatus}'.`,
+  })
+
+  await responseEvent.save()
+  await responseEvent.populate("user")
+
+  if (resolutionStatus === "accepted") {
+    const targetUser = await User.findOne({ id: targetUserId })
+    if (!targetUser) throw new Error("Target user not found.")
+
+    const existingDatacite = await getDataciteYml(datasetId)
+    const existingContributors =
+      existingDatacite?.data.attributes.contributors || []
+
+    const mappedExisting: Contributor[] = existingContributors.map((
+      c,
+      index,
+    ) => ({
+      name: c.name || "Unknown Contributor",
+      givenName: c.givenName || "",
+      familyName: c.familyName || "",
+      orcid: c.nameIdentifiers?.[0]?.nameIdentifier,
+      contributorType: c.contributorType || "Researcher",
+      order: index + 1,
+    }))
+
+    const newContributor: Contributor = {
+      name: targetUser.name || "Unknown Contributor",
+      givenName: targetUser?.givenName || "",
+      familyName: targetUser?.familyName || "",
+      orcid: targetUser.orcid,
+      contributorType: "Researcher",
+      order: mappedExisting.length + 1,
+    }
+
+    await updateContributorsUtil(
+      datasetId,
+      [...mappedExisting, newContributor],
+      currentUserId,
+    )
+  }
+
+  return responseEvent
+}
+
+/**
+ * Update a user's notification status
+ */
+export async function updateEventStatus(obj, { eventId, status }, { user }) {
+  if (!user) throw new Error("Authentication required.")
+  return await UserNotificationStatus.findOneAndUpdate(
+    { userId: user, datasetEventId: eventId },
+    { status },
+    { new: true, upsert: true },
+  )
+}
+
+/**
+ * Create a 'contributor citation' event
+ * Immediately adds the contributor to datacite.yml
+ * Automatically sets the resolutionStatus to 'accepted'
+ */
+export async function createContributorCitationEvent(
+  obj,
+  { datasetId, targetUserId, contributorData }: {
+    datasetId: string
+    targetUserId: string
+    contributorData: {
+      orcid?: string
+      name?: string
+      email?: string
+      userId?: string
+      contributorType?: string
+      givenName?: string
+      familyName?: string
+    }
+  },
+  { user }: { user: string },
+) {
+  if (!user) throw new Error("Authentication required.")
+
+  const finalContributorData = {
+    ...contributorData,
+    contributorType: contributorData.contributorType || "Researcher",
+  }
+
+  // --- Immediately add to datacite.yml ---
+  const existingDatacite = await getDataciteYml(datasetId)
+  const existingContributors = existingDatacite?.data.attributes.contributors ||
+    []
+
+  const mappedExisting: Contributor[] = existingContributors.map((
+    c,
+    index,
+  ) => ({
+    name: c.name || "Unknown Contributor",
+    givenName: c.givenName || "",
+    familyName: c.familyName || "",
+    orcid: c.nameIdentifiers?.[0]?.nameIdentifier,
+    contributorType: c.contributorType || "Researcher",
+    order: index + 1,
+  }))
+
+  const newContributor: Contributor = {
+    name: finalContributorData.name || "Unknown Contributor",
+    givenName: finalContributorData.givenName || "",
+    familyName: finalContributorData.familyName || "",
+    orcid: finalContributorData.orcid,
+    contributorType: finalContributorData.contributorType || "Researcher",
+    order: mappedExisting.length + 1,
+  }
+
+  await updateContributorsUtil(
+    datasetId,
+    [...mappedExisting, newContributor],
+    user,
+  )
+
+  // --- Log dataset event ---
+  const event = new DatasetEvent({
+    datasetId,
+    userId: user,
+    event: {
+      type: "contributorCitation",
+      datasetId,
+      addedBy: user,
+      targetUserId,
+      contributorData: finalContributorData,
+      resolutionStatus: "accepted", // auto-approved
+    },
+    success: true,
+    note: `User ${user} added a contributor citation for user ${targetUserId}.`,
+  })
+
+  await event.save()
+  await event.populate("user")
+
+  return event
+}
+
+/**
+ * Process a contributor citation (accept or deny)
+ * No longer updates datacite.yml — only logs a response event
+ */
+export async function processContributorCitation(
+  obj,
+  {
+    eventId,
+    status,
+  }: {
+    eventId: string
+    status: "accepted" | "denied"
+  },
+  { user, userInfo }: { user: string; userInfo: { admin?: boolean } },
+) {
+  if (!user) throw new Error("Authentication required.")
+
+  const citationEvent = await DatasetEvent.findOne({ id: eventId })
+
+  if (!citationEvent || citationEvent.event.type !== "contributorCitation") {
+    throw new Error("Contributor citation event not found.")
+  }
+
+  const currentUser = await User.findOne({ id: user })
+
+  const isTargetUser = citationEvent.event.targetUserId === user ||
+    citationEvent.event.targetUserId === currentUser?.orcid
+  const isAdmin = userInfo?.admin === true
+
+  if (!isTargetUser && !isAdmin) {
+    throw new Error("Not authorized to respond to this contributor citation.")
+  }
+
+  if (citationEvent.event.resolutionStatus !== "pending") {
+    throw new Error("This contributor citation has already been responded to.")
+  }
+
+  citationEvent.event.resolutionStatus = status
+  await citationEvent.save()
+
+  // --- Only log response event ---
+  const responseEvent = new DatasetEvent({
+    datasetId: citationEvent.datasetId,
+    userId: user,
+    event: {
+      type: "contributorCitationResponse",
+      originalCitationId: citationEvent.id,
+      resolutionStatus: status,
+      datasetId: citationEvent.datasetId,
+      addedBy: citationEvent.event.addedBy,
+      targetUserId: citationEvent.event.targetUserId,
+      contributorData: citationEvent.event.contributorData,
+    },
+    success: true,
+    note:
+      `User ${user} ${status} contributor citation for ${citationEvent.event.targetUserId}.`,
+  })
+
+  await responseEvent.save()
+  await responseEvent.populate("user")
+
+  return responseEvent
+}

package/src/graphql/resolvers/draft.ts

@@ -9,6 +9,7 @@ import { getFiles } from "../../datalad/files"
 import { filterRemovedAnnexObjects } from "../utils/file.js"
 import { validation } from "./validation"
 import FileCheck from "../../models/fileCheck"
+import { contributors } from "../../datalad/contributors"
 
 // A draft must have a dataset parent
 export const draftFiles = async (dataset, args, { userInfo }) => {
@@ -59,6 +60,7 @@ const draft = {
   readme,
   head: (obj) => obj.revision,
   fileCheck,
+  contributors: (parent) => contributors(parent),
 }
 
 export default draft

package/src/graphql/resolvers/mutation.ts

@@ -43,9 +43,17 @@ import {
   finishImportRemoteDataset,
   importRemoteDataset,
 } from "./importRemoteDataset"
-import { saveAdminNote } from "./datasetEvents"
+import {
+  createContributorCitationEvent,
+  createContributorRequestEvent,
+  processContributorCitation,
+  processContributorRequest,
+  saveAdminNote,
+  updateEventStatus,
+} from "./datasetEvents"
 import { createGitEvent } from "./gitEvents"
 import { updateFileCheck } from "./fileCheck"
+import { updateContributors } from "../../datalad/contributors"
 import { updateWorkerTask } from "./worker"
 
 const Mutation = {
@@ -94,8 +102,14 @@ const Mutation = {
   finishImportRemoteDataset,
   updateUser,
   saveAdminNote,
+  createContributorRequestEvent,
+  createContributorCitationEvent,
+  processContributorRequest,
+  processContributorCitation,
   createGitEvent,
   updateFileCheck,
+  updateEventStatus,
+  updateContributors,
   updateWorkerTask,
 }
 

package/src/graphql/resolvers/snapshots.ts

@@ -18,6 +18,7 @@ import { getDraftHead } from "../../datalad/dataset"
 import { downloadFiles } from "../../datalad/snapshots"
 import { snapshotValidation } from "./validation"
 import { advancedDatasetSearchConnection } from "./dataset-search"
+import { contributors } from "../../datalad/contributors"
 
 export const snapshots = (obj) => {
   return datalad.getSnapshots(obj.id)
@@ -28,6 +29,7 @@ export const snapshot = (obj, { datasetId, tag }, context) => {
     () => {
       return datalad.getSnapshot(datasetId, tag).then((snapshot) => ({
         ...snapshot,
+        datasetId,
         dataset: () => dataset(snapshot, { id: datasetId }, context),
         description: () => description(snapshot),
         readme: () => readme(snapshot),
@@ -310,6 +312,14 @@ const Snapshot = {
   issues: (snapshot) => snapshotIssues(snapshot),
   issuesStatus: (snapshot) => issuesSnapshotStatus(snapshot),
   validation: (snapshot) => snapshotValidation(snapshot),
+  contributors: (snapshot) => {
+    const datasetId = snapshot.datasetId
+    return contributors({
+      id: `${datasetId}:${snapshot.hexsha}`,
+      tag: snapshot.tag,
+      hexsha: snapshot.hexsha,
+    })
+  },
 }
 
 export default Snapshot