@openneuro/server 4.38.3 → 4.39.0-alpha.0

package/src/models/datasetEvents.ts

@@ -3,6 +3,7 @@ import type { Document } from "mongoose"
 import type { OpenNeuroUserId } from "../types/user"
 import { v4 as uuidv4 } from "uuid"
 import type { UserDocument } from "./user"
+import type { UserNotificationStatusDocument } from "./userNotificationStatus"
 const { Schema, model } = mongoose
 
 const _datasetEventTypes = [
@@ -14,6 +15,10 @@ const _datasetEventTypes = [
   "git",
   "upload",
   "note",
+  "contributorRequest",
+  "contributorCitation",
+  "contributorRequestResponse",
+  "contributorCitationResponse",
 ] as const
 
 /**
@@ -27,6 +32,8 @@ const _datasetEventTypes = [
  * git - A git event modified the dataset's repository (git history provides details)
  * upload - A non-git upload occurred (typically one file changed)
  * note - A note unrelated to another event
+ * contributorRequest - a request event is created for user access
+ * contributorResponse - response of deny or accept is granted
  */
 export type DatasetEventName = typeof _datasetEventTypes[number]
 
@@ -36,44 +43,95 @@ export type DatasetEventCommon = {
 
 export type DatasetEventCreated = DatasetEventCommon & {
   type: "created"
+  datasetId?: string
 }
 
 export type DatasetEventVersioned = DatasetEventCommon & {
   type: "versioned"
   version: string
+  datasetId?: string
 }
 
 export type DatasetEventDeleted = DatasetEventCommon & {
   type: "deleted"
+  datasetId?: string
 }
 
 export type DatasetEventPublished = DatasetEventCommon & {
   type: "published"
-  // True if made public, false if made private
   public: boolean
+  datasetId?: string
 }
 
 export type DatasetEventPermissionChange = DatasetEventCommon & {
   type: "permissionChange"
-  // User with the permission being changed
   target: OpenNeuroUserId
   level: string
+  datasetId?: string
 }
 
 export type DatasetEventGit = DatasetEventCommon & {
   type: "git"
   commit: string
   reference: string
+  datasetId?: string
 }
 
 export type DatasetEventUpload = DatasetEventCommon & {
   type: "upload"
+  datasetId?: string
 }
 
 export type DatasetEventNote = DatasetEventCommon & {
   type: "note"
-  // Is this note visible only to site admins?
   admin: boolean
+  datasetId?: string
+}
+export interface ContributorDataInput {
+  orcid?: string
+  name?: string
+  email?: string
+  userId?: string
+  contributorType?: string
+  givenName?: string
+  familyName?: string
+}
+
+export type DatasetEventContributorRequest = DatasetEventCommon & {
+  type: "contributorRequest"
+  requestId?: string
+  resolutionStatus?: "pending" | "accepted" | "denied"
+  datasetId?: string
+  contributorData: ContributorDataInput
+}
+
+export type DatasetEventContributorRequestResponse = DatasetEventCommon & {
+  type: "contributorRequestResponse"
+  requestId: string
+  targetUserId: OpenNeuroUserId
+  resolutionStatus: "pending" | "accepted" | "denied"
+  reason?: string
+  datasetId?: string
+  contributorData?: ContributorDataInput
+}
+
+export type DatasetEventContributorCitationResponse = DatasetEventCommon & {
+  type: "contributorCitationResponse"
+  originalCitationId: string
+  resolutionStatus: "pending" | "accepted" | "denied"
+  datasetId: string
+  addedBy: OpenNeuroUserId
+  targetUserId: OpenNeuroUserId
+  contributorData: ContributorDataInput
+}
+
+export type DatasetEventContributorCitation = DatasetEventCommon & {
+  type: "contributorCitation"
+  datasetId: string
+  addedBy: OpenNeuroUserId
+  targetUserId: OpenNeuroUserId
+  contributorData: ContributorDataInput
+  resolutionStatus: "pending" | "accepted" | "denied"
 }
 
 /**
@@ -88,42 +146,72 @@ export type DatasetEventType =
   | DatasetEventGit
   | DatasetEventUpload
   | DatasetEventNote
+  | DatasetEventContributorRequest
+  | DatasetEventContributorCitation
+  | DatasetEventContributorRequestResponse
+  | DatasetEventContributorCitationResponse
 
 /**
  * Dataset events log changes to a dataset
  */
 export interface DatasetEventDocument extends Document {
-  // Unique id for the event
   id: string
-  // Affected dataset
   datasetId: string
-  // Timestamp of the event
   timestamp: Date
-  // User id that triggered the event
   userId: string
-  // User that triggered the event
   user: UserDocument
-  // A description of the event, optional but recommended to provide context
   event: DatasetEventType
-  // Did the action logged succeed?
   success: boolean
-  // Admin notes
   note: string
+  responseStatus?: "pending" | "accepted" | "denied" | null
+  notificationStatus?: UserNotificationStatusDocument | null
 }
 
-const datasetEventSchema = new Schema<DatasetEventDocument>({
-  id: { type: String, required: true, default: uuidv4 },
-  datasetId: { type: String, required: true },
-  timestamp: { type: Date, default: Date.now },
-  userId: { type: String, required: true },
-  event: {
-    type: Object,
-    required: true,
+const datasetEventSchema = new Schema<DatasetEventDocument>(
+  {
+    id: { type: String, required: true, default: uuidv4 },
+    datasetId: { type: String, required: true },
+    timestamp: { type: Date, default: Date.now },
+    userId: { type: String, required: true },
+    event: {
+      type: { type: String, required: true, enum: _datasetEventTypes },
+      version: { type: String },
+      public: { type: Boolean },
+      target: { type: String },
+      level: { type: String },
+      commit: { type: String },
+      reference: { type: String },
+      admin: { type: Boolean, default: false },
+      requestId: { type: String, sparse: true, index: true },
+      targetUserId: { type: String },
+      reason: { type: String },
+      datasetId: { type: String },
+      resolutionStatus: {
+        type: String,
+        enum: ["pending", "accepted", "denied"],
+        default: "pending",
+      },
+      contributorData: {
+        orcid: { type: String },
+        name: { type: String },
+        email: { type: String },
+        userId: { type: String },
+        contributorType: { type: String },
+        givenName: { type: String },
+        familyName: { type: String },
+        default: {},
+      },
+    },
+    success: { type: Boolean, default: false },
+    note: { type: String, default: "" },
   },
-  success: { type: Boolean, default: false },
-  note: { type: String, default: "" },
-})
+  {
+    toObject: { virtuals: true },
+    toJSON: { virtuals: true },
+  },
+)
 
+// Virtual for the user who triggered the event
 datasetEventSchema.virtual("user", {
   ref: "User",
   localField: "userId",
@@ -131,6 +219,22 @@ datasetEventSchema.virtual("user", {
   justOne: true,
 })
 
+datasetEventSchema.add({
+  responseStatus: {
+    type: String,
+    enum: ["pending", "accepted", "denied"],
+    default: null,
+  },
+})
+
+// Virtual for the notification status associated with this event
+datasetEventSchema.virtual("notificationStatus", {
+  ref: "UserNotificationStatus",
+  localField: "id",
+  foreignField: "datasetEventId",
+  justOne: true,
+})
+
 const DatasetEvent = model<DatasetEventDocument>(
   "DatasetEvent",
   datasetEventSchema,

package/src/models/user.ts

@@ -44,6 +44,10 @@ export interface UserDocument extends Document {
   avatar: string
   // githubSynced populated from Github OAuth use
   githubSynced: Date
+  // Defaults to NULL populated from ORCID Consent Form Mutation
+  orcidConsent?: boolean | null
+  givenName?: string
+  familyName?: string
 }
 
 const userSchema = new Schema({
@@ -66,6 +70,10 @@ const userSchema = new Schema({
   github: { type: String, default: "" },
   githubSynced: { type: Date },
   links: { type: [String], default: [] },
+  orcidConsent: {
+    type: Boolean,
+    default: null,
+  },
 }, { timestamps: { createdAt: false, updatedAt: true } })
 
 userSchema.index({ id: 1, provider: 1 }, { unique: true })

package/src/models/userNotificationStatus.ts

@@ -0,0 +1,37 @@
+import mongoose from "mongoose"
+import type { Document } from "mongoose"
+const { Schema, model } = mongoose
+
+export type NotificationStatusType = "UNREAD" | "SAVED" | "ARCHIVED"
+
+export interface UserNotificationStatusDocument extends Document {
+  _id: string
+  userId: string
+  datasetEventId: string
+  status: NotificationStatusType
+  createdAt: Date
+  updatedAt: Date
+}
+
+const userNotificationStatusSchema = new Schema<UserNotificationStatusDocument>(
+  {
+    userId: { type: String, ref: "User", required: true },
+    datasetEventId: { type: String, ref: "DatasetEvent", required: true },
+    status: {
+      type: String,
+      enum: ["UNREAD", "SAVED", "ARCHIVED"],
+      default: "UNREAD",
+      required: true,
+    },
+  },
+  { timestamps: true },
+)
+
+userNotificationStatusSchema.index({ userId: 1, datasetEventId: 1 }, {
+  unique: true,
+})
+
+export const UserNotificationStatus = model<UserNotificationStatusDocument>(
+  "UserNotificationStatus",
+  userNotificationStatusSchema,
+)

package/src/types/datacite.ts

@@ -0,0 +1,97 @@
+/**
+ * Interfaces for working with datacite.yml metadata.
+ * Both contributors and creators
+ */
+
+/**
+ * Unique identifier for a person or organization.
+ */
+export interface NameIdentifier {
+  nameIdentifier: string
+  nameIdentifierScheme: string
+  schemeUri?: string
+}
+
+/**
+ * An interface for an organizational or institutional affiliation.
+ */
+export interface Affiliation {
+  name: string
+  schemeUri?: string
+  affiliationIdentifier?: string
+  affiliationIdentifierScheme?: string
+}
+
+/**
+ * Contributor object (normalized form used internally in app).
+ */
+export interface Contributor {
+  name: string
+  givenName?: string
+  familyName?: string
+  orcid?: string
+  contributorType?: string
+  order?: number
+  userId?: string
+}
+
+/**
+ * Base interface shared by both creators and contributors in datacite.yml
+ */
+export interface RawDataciteBaseContributor {
+  name: string
+  nameType: "Personal" | "Organizational"
+  givenName?: string
+  familyName?: string
+  nameIdentifiers?: NameIdentifier[]
+  affiliation?: Affiliation[]
+}
+
+/**
+ * Raw Creator object as it appears in datacite.yml creators array.
+ * Does NOT have contributorType.
+ */
+export type RawDataciteCreator = RawDataciteBaseContributor
+
+/**
+ * Raw Contributor object as it appears in datacite.yml contributors array.
+ * Adds contributorType, which is required.
+ */
+export interface RawDataciteContributor extends RawDataciteBaseContributor {
+  contributorType: string
+}
+
+/**
+ * An interface for the resource types.
+ */
+export interface RawDataciteTypes {
+  resourceType?: string
+  resourceTypeGeneral: string
+}
+
+/**
+ * The main attributes section of the datacite.yml file.
+ */
+export interface RawDataciteAttributes {
+  contributors?: RawDataciteContributor[]
+  creators?: RawDataciteCreator[]
+  types: RawDataciteTypes
+  descriptions?: {
+    description: string
+    descriptionType: string
+  }[]
+}
+/**
+ * The top-level interface for the entire datacite.yml file structure.
+ */
+export interface RawDataciteYml {
+  data: {
+    attributes: RawDataciteAttributes
+  }
+}
+
+export interface DatasetWithDescription {
+  dataset_description?: {
+    Description?: string
+  }
+}

package/src/utils/datacite-mapper.ts

@@ -0,0 +1,21 @@
+import type { Contributor, RawDataciteContributor } from "../types/datacite"
+
+export const mapToRawContributor = (
+  c: Contributor,
+): RawDataciteContributor => ({
+  name: c.name,
+  nameType: "Personal",
+  contributorType: c.contributorType || "Researcher",
+  givenName: c.givenName,
+  familyName: c.familyName,
+  nameIdentifiers: c.orcid
+    ? [
+      {
+        nameIdentifier: c.orcid,
+        nameIdentifierScheme: "ORCID",
+        schemeUri: "https://orcid.org",
+      },
+    ]
+    : undefined,
+  affiliation: [],
+})

package/src/utils/datacite-utils.ts

@@ -0,0 +1,256 @@
+import * as Sentry from "@sentry/node"
+import yaml from "js-yaml"
+import superagent from "superagent"
+import User from "../models/user"
+import { fileUrl } from "../datalad/files"
+import { commitFiles } from "../datalad/dataset"
+import { getDatasetWorker } from "../libs/datalad-service"
+import type {
+  Contributor,
+  RawDataciteContributor,
+  RawDataciteYml,
+} from "../types/datacite"
+import { validateOrcid } from "../utils/orcid-utils"
+import { description as getDescription } from "../datalad/description"
+
+/**
+ * Returns a minimal datacite.yml structure
+ */
+export const emptyDataciteYml = async (
+  obj?: { datasetId: string; revision?: string },
+): Promise<RawDataciteYml> => {
+  let fallbackDescription = "N/A"
+
+  if (obj?.datasetId) {
+    try {
+      const descObj = await getDescription(obj)
+      if (descObj?.Description) {
+        fallbackDescription = descObj.Description
+      }
+    } catch (_err) {
+      // fallback remains "No description provided"
+    }
+  }
+
+  return {
+    data: {
+      attributes: {
+        types: { resourceTypeGeneral: "Dataset" },
+        contributors: [],
+        creators: [],
+        descriptions: [
+          {
+            description: fallbackDescription,
+            descriptionType: "Abstract",
+          },
+        ],
+      },
+    },
+  }
+}
+
+/**
+ * Fetch datacite.yml for a dataset revision
+ */
+export const getDataciteYml = async (
+  datasetId: string,
+  revision?: string,
+): Promise<RawDataciteYml> => {
+  const dataciteFileUrl = fileUrl(datasetId, "", "datacite", revision)
+
+  try {
+    const res = await fetch(dataciteFileUrl)
+
+    if (res.status === 200) {
+      const text = await res.text()
+      const parsed: RawDataciteYml = yaml.load(text) as RawDataciteYml
+
+      // Add fallback if no descriptions exist
+      if (
+        !parsed.data.attributes.descriptions ||
+        parsed.data.attributes.descriptions.length === 0
+      ) {
+        const descObj = await getDescription({ datasetId, revision })
+        const fallbackDescription = descObj?.Description ||
+          "No description provided"
+
+        parsed.data.attributes.descriptions = [
+          {
+            description: fallbackDescription,
+            descriptionType: "Abstract",
+          },
+        ]
+      }
+
+      return parsed
+    }
+
+    // If datacite.yml missing (404), create from dataset_description
+    if (res.status === 404) {
+      return await emptyDataciteYml({ datasetId, revision })
+    }
+
+    throw new Error(
+      `Unexpected status ${res.status} when fetching datacite.yml`,
+    )
+  } catch (err) {
+    Sentry.captureException(err)
+    // Even if fetch fails, still try to build from dataset_description
+    return await emptyDataciteYml({ datasetId, revision })
+  }
+}
+
+/**
+ * Save datacite.yml back to dataset
+ */
+export const saveDataciteYmlToRepo = async (
+  datasetId: string,
+  cookies: string,
+  dataciteData: RawDataciteYml,
+) => {
+  const url = `${
+    getDatasetWorker(datasetId)
+  }/datasets/${datasetId}/files/datacite.yml`
+
+  try {
+    // Directly PUT the file using the user's request cookies
+    await superagent
+      .post(url)
+      .set("Cookie", cookies)
+      .set("Accept", "application/json")
+      .set("Content-Type", "text/yaml")
+      .send(yaml.dump(dataciteData))
+
+    // Commit the draft after upload
+    const gitRef = await commitFiles(datasetId, cookies)
+    return { id: gitRef }
+  } catch (err) {
+    Sentry.captureException(err)
+    throw err
+  }
+}
+
+/**
+ * Converts RawDataciteContributor -> internal Contributor type.
+ * Optionally attaches a `userId` if the contributor exists as a site user.
+ */
+export const normalizeRawContributors = async (
+  raw: RawDataciteContributor[] | undefined,
+): Promise<Contributor[]> => {
+  if (!Array.isArray(raw)) return []
+
+  const orcids = raw
+    .map((c) => validateOrcid(c.nameIdentifiers?.[0]?.nameIdentifier))
+    .filter(Boolean) as string[]
+
+  const users = await User.find({ orcid: { $in: orcids } }).exec()
+  const orcidToUserId = new Map(users.map((u) => [u.orcid, u.id]))
+
+  return raw.map((c, index) => {
+    const contributorOrcid = validateOrcid(
+      c.nameIdentifiers?.[0]?.nameIdentifier,
+    )
+    return {
+      name: c.name ||
+        [c.familyName, c.givenName].filter(Boolean).join(", ") ||
+        "Unknown Contributor",
+      givenName: c.givenName,
+      familyName: c.familyName,
+      orcid: contributorOrcid,
+      contributorType: c.contributorType || "Researcher",
+      userId: contributorOrcid
+        ? orcidToUserId.get(contributorOrcid)
+        : undefined,
+      order: index + 1,
+    }
+  })
+}
+
+/**
+ * Update contributors in datacite.yml
+ */
+export const updateContributors = async (
+  datasetId: string,
+  revision: string | undefined,
+  newContributors: Contributor[],
+  user: string,
+): Promise<boolean> => {
+  try {
+    let dataciteData = await getDataciteYml(datasetId, revision)
+
+    // If no datacite.yml, create a new one
+    if (!dataciteData) {
+      dataciteData = await emptyDataciteYml({ datasetId, revision })
+    }
+
+    // Map contributors to RawDataciteContributor format
+    const rawContributors: RawDataciteContributor[] = newContributors.map((
+      c,
+    ) => ({
+      name: c.name,
+      givenName: c.givenName,
+      familyName: c.familyName,
+      contributorType: c.contributorType || "Researcher",
+      nameType: "Personal" as const,
+      nameIdentifiers: c.orcid
+        ? [{ nameIdentifier: c.orcid, nameIdentifierScheme: "ORCID" }]
+        : [],
+    }))
+
+    dataciteData.data.attributes.contributors = rawContributors
+    dataciteData.data.attributes.creators = rawContributors
+
+    await saveDataciteYmlToRepo(datasetId, user, dataciteData)
+
+    return true
+  } catch (err) {
+    Sentry.captureException(err)
+    return false
+  }
+}
+
+/**
+ * Utility function to update contributors in datacite.yml
+ */
+export const updateContributorsUtil = async (
+  datasetId: string,
+  newContributors: Contributor[],
+  userId: string,
+) => {
+  let dataciteData = await getDataciteYml(datasetId)
+  if (!dataciteData) dataciteData = await emptyDataciteYml({ datasetId })
+
+  const contributorsCopy: RawDataciteContributor[] = newContributors.map(
+    (c) => ({
+      name: c.name,
+      givenName: c.givenName || "",
+      familyName: c.familyName || "",
+      order: c.order ?? null,
+      nameType: "Personal" as const,
+      nameIdentifiers: c.orcid
+        ? [{
+          nameIdentifier: `https://orcid.org/${c.orcid}`,
+          nameIdentifierScheme: "ORCID",
+          schemeUri: "https://orcid.org",
+        }]
+        : [],
+      contributorType: c.contributorType || "Researcher",
+    }),
+  )
+
+  dataciteData.data.attributes.contributors = contributorsCopy
+  dataciteData.data.attributes.creators = contributorsCopy.map((
+    { contributorType: _, ...rest },
+  ) => rest)
+
+  await saveDataciteYmlToRepo(datasetId, userId, dataciteData)
+
+  return {
+    draft: {
+      id: datasetId,
+      contributors: contributorsCopy,
+      files: [],
+      modified: new Date().toISOString(),
+    },
+  }
+}

package/src/utils/orcid-utils.ts

@@ -0,0 +1,17 @@
+export function validateOrcid(
+  identifier: string | undefined | null,
+): string | undefined {
+  if (!identifier || typeof identifier !== "string") {
+    return undefined
+  }
+  // This regex specifically targets the 16-digit ORCID number pattern.
+  const orcidRegex = /([0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[0-9X])/i
+  const match = identifier.match(orcidRegex)
+
+  if (match && match[1]) {
+    // match[1] contains the actual ORCID number (e.g., "0000-0001-2345-6789")
+    return match[1]
+  }
+
+  return undefined // No valid ORCID pattern found
+}