@openneuro/server 5.0.0 → 5.1.0

package/src/graphql/schema/refs.ts

@@ -0,0 +1,23 @@
+import { builder } from "../builder"
+import type { FlattenMaps } from "mongoose"
+import type { CommentDocument } from "../../models/comment"
+import type { DatasetDocument } from "../../models/dataset"
+import type { DatasetEventType } from "../../models/datasetEvents"
+import type { GraphQLUserType } from "../resolvers/user"
+import type { EnrichedDatasetEvent } from "../resolvers/datasetEvents"
+import type { SnapshotShape } from "../resolvers/snapshots"
+import type { DraftShape } from "../resolvers/draft"
+
+export const UserRef = builder.objectRef<GraphQLUserType>("User")
+export const DatasetRef = builder.objectRef<FlattenMaps<DatasetDocument>>(
+  "Dataset",
+)
+export const DraftRef = builder.objectRef<DraftShape>("Draft")
+export const SnapshotRef = builder.objectRef<SnapshotShape>("Snapshot")
+export const CommentRef = builder.objectRef<CommentDocument>("Comment")
+export const DatasetEventDescriptionRef = builder.objectRef<DatasetEventType>(
+  "DatasetEventDescription",
+)
+export const DatasetEventRef = builder.objectRef<EnrichedDatasetEvent>(
+  "DatasetEvent",
+)

package/src/graphql/schema/reviewer.ts

@@ -0,0 +1,11 @@
+import { builder } from "../builder"
+
+export const DatasetReviewer = builder.simpleObject("DatasetReviewer", {
+  description: "Anonymous dataset reviewer",
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    datasetId: t.id({ nullable: false }),
+    expiration: t.field({ type: "DateTime" }),
+    url: t.string({ nullable: false }),
+  }),
+})

package/src/graphql/schema/scalars.ts

@@ -0,0 +1,9 @@
+import { builder } from "../builder"
+import { GraphQLDate, GraphQLDateTime } from "graphql-iso-date"
+import GraphQLBigInt from "graphql-bigint"
+import GraphQLJSON from "graphql-type-json"
+
+builder.addScalarType("Date", GraphQLDate)
+builder.addScalarType("DateTime", GraphQLDateTime)
+builder.addScalarType("BigInt", GraphQLBigInt)
+builder.addScalarType("JSON", GraphQLJSON)

package/src/graphql/schema/snapshot.ts

@@ -0,0 +1,111 @@
+import { DatasetRef, SnapshotRef } from "./refs"
+import { Summary } from "./metadata"
+import {
+  DatasetValidation,
+  ValidationIssue,
+  ValidationIssueStatus,
+} from "./validation"
+import { DatasetFile } from "./files"
+import { Description } from "./description"
+import { Contributor } from "./description"
+import { Analytic } from "./analytics"
+import { DeprecatedSnapshot, RelatedObject } from "./misc"
+import SnapshotFields from "../resolvers/snapshots"
+
+SnapshotRef.implement({
+  directives: { cacheControl: { maxAge: 3600 } },
+  fields: (t) => ({
+    id: t.id({ nullable: false, resolve: (obj) => obj.id }),
+    tag: t.string({ nullable: false, resolve: (obj) => obj.tag }),
+    dataset: t.field({
+      type: DatasetRef,
+      nullable: false,
+      resolve: (obj) => obj.dataset() as never,
+    }),
+    created: t.field({
+      type: "DateTime",
+      resolve: (obj) => obj.created ?? null,
+    }),
+    summary: t.field({
+      type: Summary,
+      resolve: (obj) => obj.summary() as never,
+    }),
+    issues: t.field({
+      type: [ValidationIssue],
+      nullable: { list: true, items: true },
+      resolve: (obj) => SnapshotFields.issues(obj),
+    }),
+    issuesStatus: t.field({
+      type: ValidationIssueStatus,
+      resolve: (obj) => SnapshotFields.issuesStatus(obj),
+    }),
+    validation: t.field({
+      type: DatasetValidation,
+      resolve: (obj, _args, ctx) =>
+        SnapshotFields.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) =>
+        (typeof obj.files === "function"
+          ? obj.files({ tree: args.tree, recursive: args.recursive })
+          : obj.files) as never,
+    }),
+    description: t.field({
+      type: Description,
+      resolve: (obj) =>
+        typeof obj.description === "function"
+          ? obj.description()
+          : obj.description,
+    }),
+    analytics: t.field({
+      type: Analytic,
+      resolve: (obj) => SnapshotFields.analytics(obj),
+    }),
+    readme: t.string({
+      directives: { cacheControl: { maxAge: 31536000 } },
+      resolve: (obj) =>
+        (typeof obj.readme === "function" ? obj.readme() : obj.readme) as never,
+    }),
+    hexsha: t.string({
+      resolve: (obj) => obj.hexsha ?? null,
+    }),
+    deprecated: t.field({
+      type: DeprecatedSnapshot,
+      resolve: (obj) =>
+        typeof obj.deprecated === "function"
+          ? obj.deprecated()
+          : obj.deprecated,
+    }),
+    related: t.field({
+      type: [RelatedObject],
+      nullable: { list: true, items: true },
+      resolve: (obj) =>
+        (typeof obj.related === "function"
+          ? obj.related()
+          : obj.related) as never,
+    }),
+    onBrainlife: t.boolean({
+      directives: { cacheControl: { maxAge: 10080 } },
+      resolve: (obj) =>
+        typeof obj.onBrainlife === "function"
+          ? obj.onBrainlife()
+          : obj.onBrainlife,
+    }),
+    size: t.field({
+      type: "BigInt",
+      resolve: (obj) =>
+        (typeof obj.size === "function" ? obj.size() : obj.size) as never,
+    }),
+    contributors: t.field({
+      type: [Contributor],
+      nullable: { list: true, items: true },
+      resolve: (obj) => SnapshotFields.contributors(obj),
+    }),
+  }),
+})

package/src/graphql/schema/upload.ts

@@ -0,0 +1,13 @@
+import { builder } from "../builder"
+
+export const UploadMetadata = builder.simpleObject("UploadMetadata", {
+  description: "Client metadata needed to complete an upload",
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    datasetId: t.id({ nullable: false }),
+    complete: t.boolean({ nullable: false }),
+    estimatedSize: t.field({ type: "BigInt" }),
+    token: t.string(),
+    endpoint: t.int(),
+  }),
+})

package/src/graphql/schema/user.ts

@@ -0,0 +1,61 @@
+import { builder } from "../builder"
+import { DatasetEventRef, UserRef } from "./refs"
+import { UserProvider } from "./enums"
+import { notifications } from "../resolvers/user"
+
+UserRef.implement({
+  description: "OpenNeuro user records from all providers",
+  fields: (t) => ({
+    id: t.id({ resolve: (obj) => obj.id }),
+    provider: t.field({
+      type: UserProvider,
+      resolve: (obj) => obj.provider,
+    }),
+    avatar: t.string({ resolve: (obj) => obj.avatar }),
+    orcid: t.string({ resolve: (obj) => obj.orcid }),
+    created: t.field({
+      type: "DateTime",
+      nullable: false,
+      resolve: (obj) => obj.created,
+    }),
+    modified: t.field({
+      type: "DateTime",
+      resolve: (obj) => obj.updatedAt,
+    }),
+    lastSeen: t.field({
+      type: "DateTime",
+      resolve: (obj) => obj.lastSeen,
+    }),
+    email: t.string({ resolve: (obj) => obj.email }),
+    name: t.string({ resolve: (obj) => obj.name }),
+    admin: t.boolean({ resolve: (obj) => obj.admin }),
+    blocked: t.boolean({ resolve: (obj) => obj.blocked }),
+    location: t.string({ resolve: (obj) => obj.location }),
+    institution: t.string({ resolve: (obj) => obj.institution }),
+    github: t.string({ resolve: (obj) => obj.github }),
+    githubSynced: t.field({
+      type: "Date",
+      resolve: (obj) => obj.githubSynced,
+    }),
+    links: t.stringList({
+      nullable: { list: true, items: true },
+      resolve: (obj) => obj.links,
+    }),
+    notifications: t.field({
+      type: [DatasetEventRef],
+      nullable: { list: true, items: false },
+      resolve: (obj, args, ctx) => notifications(obj, args, ctx),
+    }),
+    orcidConsent: t.boolean({ resolve: (obj) => obj.orcidConsent }),
+  }),
+})
+
+export const UserList = builder.simpleObject("UserList", {
+  fields: (t) => ({
+    users: t.field({
+      type: [UserRef],
+      nullable: { list: false, items: false },
+    }),
+    totalCount: t.int({ nullable: false }),
+  }),
+})

package/src/graphql/schema/validation.ts

@@ -0,0 +1,70 @@
+import { builder } from "../builder"
+import { Severity } from "./enums"
+import { ValidationIssueFile } from "./files"
+
+export const ValidatorCodeMessage = builder.simpleObject(
+  "ValidatorCodeMessage",
+  {
+    fields: (t) => ({
+      code: t.string({ nullable: false }),
+      message: t.string({ nullable: false }),
+    }),
+  },
+)
+
+export const ValidatorIssue = builder.simpleObject("ValidatorIssue", {
+  description: "BIDS Validator (schema) issues",
+  fields: (t) => ({
+    code: t.string({ nullable: false }),
+    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 DatasetValidation = builder.simpleObject("DatasetValidation", {
+  fields: (t) => ({
+    id: t.string(),
+    datasetId: t.string(),
+    issues: t.field({
+      type: [ValidatorIssue],
+      nullable: { list: true, items: true },
+    }),
+    codeMessages: t.field({
+      type: [ValidatorCodeMessage],
+      nullable: { list: true, items: true },
+    }),
+    errors: t.int(),
+    warnings: t.int(),
+  }),
+})
+
+export const ValidationIssue = builder.simpleObject("ValidationIssue", {
+  fields: (t) => ({
+    severity: t.field({ type: Severity, nullable: false }),
+    key: t.string({ nullable: false }),
+    code: t.int(),
+    reason: t.string({ nullable: false }),
+    files: t.field({
+      type: [ValidationIssueFile],
+      nullable: { list: true, items: true },
+    }),
+    additionalFileCount: t.int(),
+    helpUrl: t.string(),
+  }),
+})
+
+export const ValidationIssueStatus = builder.simpleObject(
+  "ValidationIssueStatus",
+  {
+    description: "Legacy validator count of errors and warnings",
+    fields: (t) => ({
+      errors: t.int(),
+      warnings: t.int(),
+    }),
+  },
+)

package/src/graphql/schema/worker.ts

@@ -0,0 +1,16 @@
+import { builder } from "../builder"
+
+export const WorkerTask = builder.simpleObject("WorkerTask", {
+  fields: (t) => ({
+    id: t.id({ nullable: false }),
+    args: t.field({ type: "JSON" }),
+    kwargs: t.field({ type: "JSON" }),
+    taskName: t.string(),
+    worker: t.string(),
+    queuedAt: t.field({ type: "DateTime" }),
+    startedAt: t.field({ type: "DateTime" }),
+    finishedAt: t.field({ type: "DateTime" }),
+    error: t.string(),
+    executionTime: t.int(),
+  }),
+})