@openneuro/server 5.0.0 → 5.1.0

package/src/graphql/schema/enums.ts

@@ -0,0 +1,55 @@
+import { builder } from "../builder"
+
+export const SortOrdering = builder.enumType("SortOrdering", {
+  values: ["ascending", "descending"] as const,
+})
+
+export const UserProvider = builder.enumType("UserProvider", {
+  description: "Which provider a user login comes from",
+  values: ["google", "orcid"] as const,
+})
+
+export const AnalyticTypes = builder.enumType("AnalyticTypes", {
+  values: ["downloads", "views"] as const,
+})
+
+export const ResponseStatusType = builder.enumType("ResponseStatusType", {
+  values: ["PENDING", "ACCEPTED", "DENIED"] as const,
+})
+
+export const NotificationStatusType = builder.enumType(
+  "NotificationStatusType",
+  {
+    values: ["UNREAD", "SAVED", "ARCHIVED"] as const,
+  },
+)
+
+export const Severity = builder.enumType("Severity", {
+  values: ["error", "warning"] as const,
+})
+
+export const RelatedObjectRelation = builder.enumType(
+  "RelatedObjectRelation",
+  {
+    description: "RelatedObject nature of relationship",
+    values: ["sameAs", "derivative", "source"] as const,
+  },
+)
+
+export const RelatedObjectKind = builder.enumType("RelatedObjectKind", {
+  description: "RelatedObject kind of target object",
+  values: ["Dataset", "Article"] as const,
+})
+
+export const SearchSortOption = builder.enumType("SearchSortOption", {
+  description: "Sort options for advanced dataset search",
+  values: [
+    "relevance",
+    "newest",
+    "oldest",
+    "activity",
+    "name_asc",
+    "name_desc",
+    "last_updated",
+  ] as const,
+})

package/src/graphql/schema/files.ts

@@ -0,0 +1,44 @@
+import { builder } from "../builder"
+import { Severity } from "./enums"
+
+export const DatasetFile = builder.simpleObject("DatasetFile", {
+  description: "File metadata and link to contents",
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    filename: t.string({ nullable: false }),
+    size: t.field({ type: "BigInt" }),
+    annexed: t.boolean(),
+    urls: t.stringList({ nullable: { list: true, items: true } }),
+    directory: t.boolean(),
+  }),
+})
+
+export const ValidationIssueFile = builder.simpleObject("ValidationIssueFile", {
+  fields: (t) => ({
+    name: t.string(),
+    path: t.string(),
+    key: t.string({ nullable: false }),
+    code: t.int(),
+    file: t.field({ type: ValidationIssueFileDetail }),
+    evidence: t.string(),
+    line: t.int(),
+    character: t.int(),
+    severity: t.field({
+      type: Severity,
+      nullable: false,
+    }),
+    reason: t.string(),
+    helpUrl: t.string(),
+  }),
+})
+
+export const ValidationIssueFileDetail = builder.simpleObject(
+  "ValidationIssueFileDetail",
+  {
+    fields: (t) => ({
+      name: t.string(),
+      path: t.string(),
+      relativePath: t.string(),
+    }),
+  },
+)

package/src/graphql/schema/inputs.ts

@@ -0,0 +1,231 @@
+import { builder } from "../builder"
+import { SearchSortOption, Severity, SortOrdering } from "./enums"
+
+export const UserSortInput = builder.inputType("UserSortInput", {
+  fields: (t) => ({
+    field: t.string({ required: true }),
+    order: t.field({ type: SortOrdering, defaultValue: "ascending" }),
+  }),
+})
+
+export const DatasetSort = builder.inputType("DatasetSort", {
+  fields: (t) => ({
+    created: t.field({ type: SortOrdering }),
+    name: t.field({ type: SortOrdering }),
+    uploader: t.field({ type: SortOrdering }),
+    stars: t.field({ type: SortOrdering }),
+    downloads: t.field({ type: SortOrdering }),
+    views: t.field({ type: SortOrdering }),
+    subscriptions: t.field({ type: SortOrdering }),
+    publishDate: t.field({ type: SortOrdering }),
+  }),
+})
+
+export const DatasetFilter = builder.inputType("DatasetFilter", {
+  fields: (t) => ({
+    public: t.boolean({
+      description: "Limit to datasets available publicly",
+    }),
+    shared: t.boolean({
+      description: "Return only datasets that are shared with the user",
+    }),
+    invalid: t.boolean({
+      description: "Return only datasets with an invalid Draft",
+    }),
+    starred: t.boolean({
+      description: "Return only datasets starred by the query user",
+    }),
+    all: t.boolean({
+      description:
+        "Return all datasets, ignores any other constraints but not sorts",
+    }),
+  }),
+})
+
+export const DeleteFile = builder.inputType("DeleteFile", {
+  fields: (t) => ({
+    path: t.string({ required: true }),
+    filename: t.string(),
+  }),
+})
+
+export const SummaryPetInput = builder.inputType("SummaryPetInput", {
+  fields: (t) => ({
+    BodyPart: t.stringList(),
+    ScannerManufacturer: t.stringList(),
+    ScannerManufacturersModelName: t.stringList(),
+    TracerName: t.stringList(),
+    TracerRadionuclide: t.stringList(),
+  }),
+})
+
+export const ValidatorMetadataInput = builder.inputType(
+  "ValidatorMetadataInput",
+  {
+    fields: (t) => ({
+      validator: t.string(),
+      version: t.string(),
+    }),
+  },
+)
+
+export const SubjectMetadataInput = builder.inputType(
+  "SubjectMetadataInput",
+  {
+    fields: (t) => ({
+      participantId: t.string({ required: true }),
+      age: t.float(),
+      sex: t.string(),
+      group: t.string(),
+    }),
+  },
+)
+
+export const SummaryInput = builder.inputType("SummaryInput", {
+  fields: (t) => ({
+    id: t.id({ required: true }),
+    datasetId: t.id({ required: true }),
+    modalities: t.stringList(),
+    secondaryModalities: t.stringList(),
+    dataTypes: t.stringList(),
+    sessions: t.stringList(),
+    subjects: t.stringList(),
+    subjectMetadata: t.field({ type: [SubjectMetadataInput] }),
+    tasks: t.stringList(),
+    size: t.field({ type: "BigInt", required: true }),
+    totalFiles: t.int({ required: true }),
+    dataProcessed: t.boolean(),
+    pet: t.field({ type: SummaryPetInput }),
+    validatorMetadata: t.field({ type: ValidatorMetadataInput }),
+    schemaVersion: t.string(),
+  }),
+})
+
+export const ValidatorIssueInput = builder.inputType("ValidatorIssueInput", {
+  fields: (t) => ({
+    code: t.string({ required: true }),
+    subCode: t.string(),
+    location: t.string(),
+    severity: t.field({ type: Severity }),
+    rule: t.string(),
+    issueMessage: t.string(),
+    affects: t.string(),
+    line: t.int(),
+  }),
+})
+
+export const ValidatorCodeMessageInput = builder.inputType(
+  "ValidatorCodeMessageInput",
+  {
+    fields: (t) => ({
+      code: t.string({ required: true }),
+      message: t.string({ required: true }),
+    }),
+  },
+)
+
+export const ValidatorInput = builder.inputType("ValidatorInput", {
+  fields: (t) => ({
+    id: t.id({ required: true }),
+    datasetId: t.id({ required: true }),
+    issues: t.field({ type: [ValidatorIssueInput], required: true }),
+    codeMessages: t.field({
+      type: [ValidatorCodeMessageInput],
+      required: true,
+    }),
+    validatorMetadata: t.field({
+      type: ValidatorMetadataInput,
+      required: true,
+    }),
+  }),
+})
+
+export const MetadataInput = builder.inputType("MetadataInput", {
+  fields: (t) => ({
+    datasetId: t.id({ required: true }),
+    datasetUrl: t.string(),
+    datasetName: t.string(),
+    firstSnapshotCreatedAt: t.field({ type: "DateTime" }),
+    latestSnapshotCreatedAt: t.field({ type: "DateTime" }),
+    dxStatus: t.string(),
+    tasksCompleted: t.stringList(),
+    trialCount: t.int(),
+    studyDesign: t.string(),
+    studyDomain: t.string(),
+    studyLongitudinal: t.string(),
+    dataProcessed: t.boolean(),
+    species: t.string(),
+    associatedPaperDOI: t.string(),
+    openneuroPaperDOI: t.string(),
+    seniorAuthor: t.string(),
+    adminUsers: t.stringList(),
+    ages: t.floatList(),
+    modalities: t.stringList(),
+    grantFunderName: t.string(),
+    grantIdentifier: t.string(),
+    affirmedDefaced: t.boolean(),
+    affirmedConsent: t.boolean(),
+  }),
+})
+
+export const AnnexFsckInput = builder.inputType("AnnexFsckInput", {
+  fields: (t) => ({
+    command: t.string(),
+    errorMessages: t.stringList(),
+    file: t.string(),
+    key: t.string(),
+    note: t.string(),
+    success: t.boolean(),
+    dead: t.stringList(),
+    missing: t.stringList(),
+    untrusted: t.stringList(),
+    input: t.stringList(),
+  }),
+})
+
+export const ContributorInput = builder.inputType("ContributorInput", {
+  fields: (t) => ({
+    name: t.string(),
+    givenName: t.string(),
+    familyName: t.string(),
+    orcid: t.string(),
+    contributorType: t.string(),
+    order: t.int(),
+  }),
+})
+
+export const DatasetSearchInput = builder.inputType("DatasetSearchInput", {
+  description: "Search input for advanced dataset search",
+  fields: (t) => ({
+    keywords: t.stringList(),
+    modality: t.string(),
+    ageRange: t.field({
+      type: ["Int"],
+      required: { list: false, items: false },
+    }),
+    subjectCountRange: t.field({
+      type: ["Int"],
+      required: { list: false, items: false },
+    }),
+    diagnosis: t.string(),
+    tasks: t.stringList(),
+    authors: t.stringList(),
+    sex: t.string(),
+    dateRange: t.string(),
+    species: t.string(),
+    studyStructure: t.string(),
+    studyDomains: t.stringList(),
+    bidsDatasetType: t.string(),
+    brainInitiative: t.boolean(),
+    bodyParts: t.stringList(),
+    scannerManufacturers: t.stringList(),
+    scannerManufacturersModelNames: t.stringList(),
+    tracerNames: t.stringList(),
+    tracerRadionuclides: t.stringList(),
+    sortBy: t.field({ type: SearchSortOption }),
+    userId: t.string({
+      description: "Filter datasets by a specific user's permissions",
+    }),
+    publicOnly: t.boolean({ description: "Filter to only public datasets" }),
+  }),
+})

package/src/graphql/schema/metadata.ts

@@ -0,0 +1,86 @@
+import { builder } from "../builder"
+
+export const SubjectMetadata = builder.simpleObject("SubjectMetadata", {
+  fields: (t) => ({
+    participantId: t.string({ nullable: false }),
+    age: t.float(),
+    sex: t.string(),
+    group: t.string(),
+  }),
+})
+
+export const SummaryPetFields = builder.simpleObject("SummaryPetFields", {
+  fields: (t) => ({
+    BodyPart: t.stringList({ nullable: { list: true, items: true } }),
+    ScannerManufacturer: t.stringList({
+      nullable: { list: true, items: true },
+    }),
+    ScannerManufacturersModelName: t.stringList({
+      nullable: { list: true, items: true },
+    }),
+    TracerName: t.stringList({ nullable: { list: true, items: true } }),
+    TracerRadionuclide: t.stringList({ nullable: { list: true, items: true } }),
+  }),
+})
+
+export const ValidatorMetadata = builder.simpleObject("ValidatorMetadata", {
+  description: "BIDS Validator metadata",
+  fields: (t) => ({
+    validator: t.string(),
+    version: t.string(),
+  }),
+})
+
+export const Summary = builder.simpleObject("Summary", {
+  description: "Validator summary from bids-validator",
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    modalities: t.stringList({ nullable: { list: true, items: true } }),
+    primaryModality: t.string(),
+    secondaryModalities: t.stringList({
+      nullable: { list: true, items: true },
+    }),
+    sessions: t.stringList({ nullable: { list: true, items: true } }),
+    subjects: t.stringList({ nullable: { list: true, items: true } }),
+    subjectMetadata: t.field({
+      type: [SubjectMetadata],
+      nullable: { list: true, items: true },
+    }),
+    tasks: t.stringList({ nullable: { list: true, items: true } }),
+    size: t.field({ type: "BigInt", nullable: false }),
+    totalFiles: t.int({ nullable: false }),
+    dataProcessed: t.boolean(),
+    pet: t.field({ type: SummaryPetFields }),
+    schemaVersion: t.string(),
+    validatorMetadata: t.field({ type: ValidatorMetadata }),
+  }),
+})
+
+export const Metadata = builder.simpleObject("Metadata", {
+  description: "Dataset Metadata",
+  fields: (t) => ({
+    datasetId: t.id({ nullable: false }),
+    datasetUrl: t.string(),
+    datasetName: t.string(),
+    firstSnapshotCreatedAt: t.field({ type: "DateTime" }),
+    latestSnapshotCreatedAt: t.field({ type: "DateTime" }),
+    dxStatus: t.string(),
+    tasksCompleted: t.stringList({ nullable: { list: true, items: true } }),
+    trialCount: t.int(),
+    studyDesign: t.string(),
+    studyDomain: t.string(),
+    studyLongitudinal: t.string(),
+    dataProcessed: t.boolean(),
+    species: t.string(),
+    associatedPaperDOI: t.string(),
+    openneuroPaperDOI: t.string(),
+    seniorAuthor: t.string(),
+    adminUsers: t.stringList({ nullable: { list: true, items: true } }),
+    ages: t.floatList({ nullable: { list: true, items: true } }),
+    modalities: t.stringList({ nullable: { list: true, items: true } }),
+    grantFunderName: t.string(),
+    grantIdentifier: t.string(),
+    affirmedDefaced: t.boolean(),
+    affirmedConsent: t.boolean(),
+  }),
+})

package/src/graphql/schema/misc.ts

@@ -0,0 +1,154 @@
+import { builder } from "../builder"
+import { UserRef } from "./refs"
+import {
+  NotificationStatusType,
+  RelatedObjectKind,
+  RelatedObjectRelation,
+} from "./enums"
+
+export const RepoMetadata = builder.simpleObject("RepoMetadata", {
+  description: "Info needed to access git repositories directly",
+  fields: (t) => ({
+    token: t.string(),
+    endpoint: t.int(),
+  }),
+})
+
+export const FlaggedFile = builder.simpleObject("FlaggedFile", {
+  description: "An annexed file that has been flagged for removal.",
+  fields: (t) => ({
+    datasetId: t.string(),
+    snapshot: t.string(),
+    filepath: t.string(),
+    annexKey: t.string(),
+    removed: t.boolean(),
+    remover: t.field({ type: UserRef }),
+    flagged: t.boolean(),
+    flagger: t.field({ type: UserRef }),
+    createdAt: t.field({ type: "DateTime" }),
+  }),
+})
+
+export const AnnexFsck = builder.simpleObject("AnnexFsck", {
+  fields: (t) => ({
+    command: t.string(),
+    errorMessages: t.stringList({ nullable: { list: true, items: true } }),
+    file: t.string(),
+    key: t.string(),
+    note: t.string(),
+    success: t.boolean(),
+  }),
+})
+
+export const FileCheck = builder.simpleObject("FileCheck", {
+  fields: (t) => ({
+    datasetId: t.string({ nullable: false }),
+    hexsha: t.string({ nullable: false }),
+    refs: t.stringList({ nullable: { list: false, items: false } }),
+    annexFsck: t.field({
+      type: [AnnexFsck],
+      nullable: { list: true, items: false },
+    }),
+    remote: t.string(),
+  }),
+})
+
+export const UserNotificationStatus = builder.simpleObject(
+  "UserNotificationStatus",
+  {
+    description: "User's notification status",
+    fields: (t) => ({
+      status: t.field({
+        type: NotificationStatusType,
+        nullable: false,
+      }),
+    }),
+  },
+)
+
+export const DiffFiles = builder.simpleObject("DiffFiles", {
+  fields: (t) => ({
+    status: t.string(),
+    mode: t.int(),
+    old: t.string(),
+    new: t.string(),
+    binary: t.boolean(),
+  }),
+})
+
+export const DatasetCommit = builder.simpleObject("DatasetCommit", {
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    date: t.field({ type: "DateTime" }),
+    authorName: t.string(),
+    authorEmail: t.string(),
+    message: t.string(),
+    references: t.string(),
+  }),
+})
+
+export const Follower = builder.simpleObject("Follower", {
+  description: "Dataset Followers",
+  fields: (t) => ({
+    userId: t.string(),
+    datasetId: t.string(),
+  }),
+})
+
+export const FollowDatasetResponse = builder.simpleObject(
+  "FollowDatasetResponse",
+  {
+    fields: (t) => ({
+      following: t.boolean(),
+      newFollower: t.field({ type: Follower }),
+    }),
+  },
+)
+
+export const Star = builder.simpleObject("Star", {
+  description: "Dataset Stars",
+  directives: { cacheControl: { maxAge: 300 } },
+  fields: (t) => ({
+    userId: t.string(),
+    datasetId: t.string(),
+  }),
+})
+
+export const StarDatasetResponse = builder.simpleObject(
+  "StarDatasetResponse",
+  {
+    fields: (t) => ({
+      starred: t.boolean(),
+      newStar: t.field({ type: Star }),
+    }),
+  },
+)
+
+export const RelatedObject = builder.simpleObject("RelatedObject", {
+  description: "DOI for an external object",
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    relation: t.field({ type: RelatedObjectRelation, nullable: false }),
+    kind: t.field({ type: RelatedObjectKind, nullable: false }),
+    description: t.string(),
+  }),
+})
+
+export const DeprecatedSnapshot = builder.simpleObject("DeprecatedSnapshot", {
+  description: "Set on snapshots that have been deprecated",
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    user: t.string(),
+    reason: t.string(),
+    timestamp: t.field({ type: "Date" }),
+  }),
+})
+
+export const DatasetDerivatives = builder.simpleObject("DatasetDerivatives", {
+  fields: (t) => ({
+    name: t.string(),
+    local: t.boolean(),
+    s3Url: t.string(),
+    dataladUrl: t.string(),
+  }),
+})