@openneuro/search 4.6.0-alpha.0

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 The Board of Trustees of the Leland Stanford Junior University
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/auth.d.ts

@@ -0,0 +1,3 @@
+/** Create a dataset:indexing scoped token for search indexing */
+export declare function indexingToken(): string;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,wBAAgB,aAAa,IAAI,MAAM,CAQtC"}

package/dist/auth.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexingToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+/** Create a dataset:indexing scoped token for search indexing */
+function indexingToken() {
+    return jsonwebtoken_1.default.sign({
+        scopes: ['dataset:indexing'],
+    }, process.env.JWT_SECRET || process.env.JEST_WORKER_ID, { expiresIn: 60 * 60 * 3 });
+}
+exports.indexingToken = indexingToken;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { DatasetsIndex } from './indexes/datasets';
+import { DatasetQueryResult, indexDataset, indexQuery, queryForIndex } from './query';
+import { indexingToken } from './auth';
+export { DatasetsIndex, DatasetQueryResult, indexDataset, indexQuery, queryForIndex, indexingToken, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,aAAa,EACd,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,aAAa,EACb,aAAa,GACd,CAAA"}

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexingToken = exports.queryForIndex = exports.indexQuery = exports.indexDataset = exports.DatasetsIndex = void 0;
+const datasets_1 = require("./indexes/datasets");
+Object.defineProperty(exports, "DatasetsIndex", { enumerable: true, get: function () { return datasets_1.DatasetsIndex; } });
+const query_1 = require("./query");
+Object.defineProperty(exports, "indexDataset", { enumerable: true, get: function () { return query_1.indexDataset; } });
+Object.defineProperty(exports, "indexQuery", { enumerable: true, get: function () { return query_1.indexQuery; } });
+Object.defineProperty(exports, "queryForIndex", { enumerable: true, get: function () { return query_1.queryForIndex; } });
+const auth_1 = require("./auth");
+Object.defineProperty(exports, "indexingToken", { enumerable: true, get: function () { return auth_1.indexingToken; } });

package/dist/indexes/datasets.d.ts

@@ -0,0 +1,7 @@
+interface IndexDefinition {
+    name: string;
+    mapping: Record<string, unknown>;
+}
+export declare const DatasetsIndex: IndexDefinition;
+export default DatasetsIndex;
+//# sourceMappingURL=datasets.d.ts.map

package/dist/indexes/datasets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasets.d.ts","sourceRoot":"","sources":["../../src/indexes/datasets.ts"],"names":[],"mappings":"AAGA,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACjC;AAED,eAAO,MAAM,aAAa,EAAE,eAG3B,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/indexes/datasets.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetsIndex = void 0;
+const datasets_mapping_json_1 = __importDefault(require("../mappings/datasets-mapping.json"));
+const names_1 = require("../names");
+exports.DatasetsIndex = {
+    name: (0, names_1.elasticMappingName)('datasets', datasets_mapping_json_1.default),
+    mapping: datasets_mapping_json_1.default,
+};
+exports.default = exports.DatasetsIndex;

package/dist/mappings/datasets-mapping.json

@@ -0,0 +1,100 @@
+{
+    "properties": {
+        "id": { "type": "keyword" },
+        "created": { "type": "date" },
+        "public": { "type": "boolean" },
+        "metadata": {
+            "properties": {
+                "datasetName": { "type": "keyword" },
+                "datasetUrl": { "type": "keyword" },
+                "dataProcessed": { "type": "boolean" },
+                "firstSnapshotCreatedAt": { "type": "date" },
+                "latestSnapshotCreatedAt": { "type": "date" },
+                "ages": { "type": "float" },
+                "modalities": { "type": "keyword" },
+                "datasetId": { "type": "keyword" },
+                "dxStatus": { "type": "keyword" },
+                "trialCount": { "type": "long" },
+                "tasksCompleted": { "type": "keyword" },
+                "studyDesign": { "type": "keyword" },
+                "studyDomain": { "type": "keyword" },
+                "studyLongitudinal": { "type": "keyword" },
+                "species": { "type": "keyword" },
+                "associatedPaperDOI": { "type": "keyword" },
+                "openneuroPaperDOI": { "type": "keyword" },
+                "seniorAuthor": { "type": "keyword" },
+                "grantFunderName": { "type": "keyword" },
+                "grantIdentifier": { "type": "keyword" }
+            }
+        },
+        "latestSnapshot": {
+            "properties": {
+                "id": { "type": "keyword" },
+                "tag": { "type": "keyword" },
+                "summary": {
+                    "properties": {
+                        "tasks": { "type": "keyword" },
+                        "modalities": { "type": "keyword" },
+                        "secondaryModalities": { "type": "keyword" },
+                        "subjects": { "type": "keyword" },
+                        "subjectMetadata": {
+                            "properties": {
+                                "participantId": { "type": "keyword" },
+                                "group": { "type": "keyword" },
+                                "sex": { "type": "keyword" },
+                                "age": { "type": "integer" }
+                            }
+                        },
+                        "pet": {
+                            "properties": {
+                                "BodyPart": { "type": "keyword" },
+                                "ScannerManufacturer": { "type": "keyword" },
+                                "ScannerManufacturersModelName": { "type": "keyword" },
+                                "TracerName": { "type": "keyword" },
+                                "TracerRadionuclide": { "type": "keyword" }
+                            }
+                        }
+                    }
+                },
+                "description": {
+                    "properties": {
+                        "Name": { "type": "text" },
+                        "Authors": { "type": "text" },
+                        "SeniorAuthor": { "type": "text" }
+                    }
+                },
+                "readme": {
+                    "type": "text"
+                }
+            }
+        },
+        "draft": {
+            "properties": {
+                "issues": {
+                    "properties": {
+                        "severity": { "type": "keyword" }
+                    }
+                }
+            }
+        },
+        "permissions": {
+            "properties": {
+                "userPermissions": {
+                    "properties": {
+                        "level": { "type": "keyword" },
+                        "user": {
+                            "properties": {
+                                "id": { "type": "keyword" }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "analytics": {
+            "properties": {
+                "downloads": { "type": "integer" }
+            }
+        }
+    }
+}

package/dist/names.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hash mappping objects to provide a stable index name if the mapping is unchanged
+ * @param mapping ElasticSearch mapping object
+ */
+export declare const hashElasticMapping: (mapping: Record<string, unknown>) => string;
+export declare const elasticMappingName: (name: string, mapping: Record<string, unknown>) => string;
+//# sourceMappingURL=names.d.ts.map

package/dist/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../src/names.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,kBAAkB,YAAa,OAAO,MAAM,EAAE,OAAO,CAAC,KAAG,MACG,CAAA;AAEzE,eAAO,MAAM,kBAAkB,SACvB,MAAM,WACH,OAAO,MAAM,EAAE,OAAO,CAAC,KAC/B,MAAkD,CAAA"}

package/dist/names.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elasticMappingName = exports.hashElasticMapping = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Hash mappping objects to provide a stable index name if the mapping is unchanged
+ * @param mapping ElasticSearch mapping object
+ */
+const hashElasticMapping = (mapping) => crypto_1.default.createHash('sha1').update(JSON.stringify(mapping)).digest('hex');
+exports.hashElasticMapping = hashElasticMapping;
+const elasticMappingName = (name, mapping) => `${name}-${(0, exports.hashElasticMapping)(mapping)}`;
+exports.elasticMappingName = elasticMappingName;

package/dist/query.d.ts

@@ -0,0 +1,29 @@
+import { Client as ElasticClient, RequestParams, ApiResponse } from '@elastic/elasticsearch';
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+export declare const INDEX_DATASET_FRAGMENT: import("@apollo/client").DocumentNode;
+export declare const indexDatasetQuery: import("@apollo/client").DocumentNode;
+export declare const indexQuery: import("@apollo/client").DocumentNode;
+export interface DatasetQueryResult {
+    id: string;
+    metadata: Record<string, any>;
+    latestSnapshot: Record<string, any>;
+    __typename: string;
+}
+/**
+ * Convert from GraphQL dataset object to RequestParams.Index documents
+ * TODO: Use generated GraphQL typing
+ * @param datasetObj GraphQL dataset object from searchDatasets query
+ */
+export declare function extractDatasetDocument(datasetObj: DatasetQueryResult): RequestParams.Index;
+/**
+ * Query a single dataset for indexing
+ * @param datasetId Accession number
+ */
+export declare function queryForIndex(apolloClient: ApolloClient<NormalizedCacheObject>, datasetId: string): Promise<import("@apollo/client").ApolloQueryResult<any>>;
+/**
+ * Index one dataset (latest snapshot)
+ * @param elasticClient Elastic client to submit index data
+ * @param datasetObj OpenNeuro GraphQL dataset object
+ */
+export declare function indexDataset(elasticClient: ElasticClient, datasetObj: DatasetQueryResult): Promise<ApiResponse>;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,IAAI,aAAa,EAEvB,aAAa,EAEb,WAAW,EACZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,YAAY,EAAO,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAGzE,eAAO,MAAM,sBAAsB,uCA0ElC,CAAA;AAED,eAAO,MAAM,iBAAiB,uCAO7B,CAAA;AAED,eAAO,MAAM,UAAU,uCAoBtB,CAAA;AAGD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC7B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACnC,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,kBAAkB,GAC7B,aAAa,CAAC,KAAK,CASrB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,YAAY,EAAE,YAAY,CAAC,qBAAqB,CAAC,EACjD,SAAS,EAAE,MAAM,4DAOlB;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,kBAAkB,GAC7B,OAAO,CAAC,WAAW,CAAC,CAUtB"}

package/dist/query.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexDataset = exports.queryForIndex = exports.extractDatasetDocument = exports.indexQuery = exports.indexDatasetQuery = exports.INDEX_DATASET_FRAGMENT = void 0;
+const client_1 = require("@apollo/client");
+const datasets_1 = require("./indexes/datasets");
+exports.INDEX_DATASET_FRAGMENT = (0, client_1.gql) `
+  fragment DatasetIndex on Dataset {
+    id
+    created
+    public
+    metadata {
+      datasetName
+      datasetUrl
+      dataProcessed
+      firstSnapshotCreatedAt
+      latestSnapshotCreatedAt
+      ages
+      modalities
+      datasetId
+      dxStatus
+      trialCount
+      tasksCompleted
+      studyDesign
+      studyDomain
+      studyLongitudinal
+      dataProcessed
+      species
+      associatedPaperDOI
+      openneuroPaperDOI
+      seniorAuthor
+      grantFunderName
+      grantIdentifier
+    }
+    latestSnapshot {
+      id
+      tag
+      description {
+        Name
+        Authors
+        SeniorAuthor
+      }
+      summary {
+        tasks
+        modalities
+        secondaryModalities
+        subjectMetadata {
+          participantId
+          group
+          sex
+          age
+        }
+        subjects
+        pet {
+          BodyPart
+          ScannerManufacturer
+          ScannerManufacturersModelName
+          TracerName
+          TracerRadionuclide
+        }
+      }
+      readme
+    }
+    draft {
+      issues {
+        severity
+      }
+    }
+    permissions {
+      userPermissions {
+        level
+        user {
+          id
+        }
+      }
+    }
+    analytics {
+      downloads
+    }
+  }
+`;
+exports.indexDatasetQuery = (0, client_1.gql) `
+  query dataset($datasetId: ID!) {
+    dataset(id: $datasetId) {
+      ...DatasetIndex
+    }
+  }
+  ${exports.INDEX_DATASET_FRAGMENT}
+`;
+exports.indexQuery = (0, client_1.gql) `
+  query getDatasets(
+    $cursor: String
+    $orderBy: DatasetSort = { created: descending }
+    $filterBy: DatasetFilter = {}
+  ) {
+    datasets(first: 5, after: $cursor, orderBy: $orderBy, filterBy: $filterBy) {
+      edges {
+        node {
+          ...DatasetIndex
+        }
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+        count
+      }
+    }
+  }
+  ${exports.INDEX_DATASET_FRAGMENT}
+`;
+/**
+ * Convert from GraphQL dataset object to RequestParams.Index documents
+ * TODO: Use generated GraphQL typing
+ * @param datasetObj GraphQL dataset object from searchDatasets query
+ */
+function extractDatasetDocument(datasetObj) {
+    const dataset = {
+        index: datasets_1.DatasetsIndex.name,
+        id: datasetObj.id,
+        body: {
+            ...datasetObj,
+        },
+    };
+    return dataset;
+}
+exports.extractDatasetDocument = extractDatasetDocument;
+/**
+ * Query a single dataset for indexing
+ * @param datasetId Accession number
+ */
+function queryForIndex(apolloClient, datasetId) {
+    return apolloClient.query({
+        query: exports.indexDatasetQuery,
+        variables: { datasetId },
+        errorPolicy: 'all',
+    });
+}
+exports.queryForIndex = queryForIndex;
+/**
+ * Index one dataset (latest snapshot)
+ * @param elasticClient Elastic client to submit index data
+ * @param datasetObj OpenNeuro GraphQL dataset object
+ */
+async function indexDataset(elasticClient, datasetObj) {
+    try {
+        console.log(`Indexing "${datasetObj.id}"`);
+        const response = await elasticClient.index(extractDatasetDocument(datasetObj));
+        return response;
+    }
+    catch (err) {
+        console.dir(err);
+    }
+}
+exports.indexDataset = indexDataset;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@openneuro/search",
+  "version": "4.6.0-alpha.0",
+  "description": "OpenNeuro search client functions.",
+  "main": "dist/index.js",
+  "browser": "src/index.ts",
+  "exports": {
+    "import": "./src/index.js",
+    "require": "./dist/index.js"
+  },
+  "repository": "git@github.com:OpenNeuroOrg/openneuro.git",
+  "author": "Stanford Center for Reproducible Neuroscience",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -b"
+  },
+  "dependencies": {
+    "@apollo/client": "3.4.17",
+    "@elastic/elasticsearch": "7.15.0",
+    "jsonwebtoken": "^8.5.1"
+  },
+  "devDependencies": {
+    "@babel/runtime-corejs3": "^7.13.10",
+    "@types/jsonwebtoken": "^8",
+    "@types/node": "16.11.13",
+    "core-js": "^3.10.1"
+  },
+  "jest": {
+    "testEnvironment": "node"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "ce2db27f750c2614e9cf2f0461add04ca8c3cb48"
+}

package/src/__tests__/indexDatasets.spec.ts

@@ -0,0 +1,50 @@
+import { extractDatasetDocument } from '../query'
+
+describe('indexDatasets', () => {
+  describe('extractDatasetDocument', () => {
+    it('filters __typename fields', () => {
+      expect(
+        extractDatasetDocument({
+          id: 'ds000005',
+          metadata: {
+            species: 'Human',
+          },
+          latestSnapshot: {
+            id: 'ds000005:1.0.0',
+            tag: '1.0.0',
+            name: 'a test dataset',
+            readme: 'a longer description of this dataset',
+            description: {
+              Name: 'a test dataset',
+              Authors: ['J. Doe', 'A. Nonymous'],
+            },
+            __typename: 'Snapshot',
+          },
+          __typename: 'Dataset',
+        }),
+      ).toEqual(
+        expect.objectContaining({
+          id: 'ds000005',
+          body: {
+            id: 'ds000005',
+            metadata: {
+              species: 'Human',
+            },
+            latestSnapshot: {
+              id: 'ds000005:1.0.0',
+              tag: '1.0.0',
+              name: 'a test dataset',
+              readme: 'a longer description of this dataset',
+              description: {
+                Name: 'a test dataset',
+                Authors: ['J. Doe', 'A. Nonymous'],
+              },
+              __typename: 'Snapshot',
+            },
+            __typename: 'Dataset',
+          },
+        }),
+      )
+    })
+  })
+})

package/src/__tests__/names.spec.ts

@@ -0,0 +1,37 @@
+import { hashElasticMapping } from '../names'
+
+const simpleMapping = {
+  properties: {
+    id: { type: 'keyword' },
+    created: { type: 'date' },
+  },
+}
+
+describe('createIndices', () => {
+  describe('hashElasticMapping()', () => {
+    it('works with an empty object', () => {
+      expect(hashElasticMapping({})).toEqual(
+        'bf21a9e8fbc5a3846fb05b4fa0859e0917b2202f',
+      )
+    })
+    it('works with a simple mapping', () => {
+      expect(hashElasticMapping(simpleMapping)).toEqual(
+        '21d2497ac57a2c5e2f258946c8efc2fcdb9221d2',
+      )
+    })
+    it('returns only alphanumeric values', () => {
+      expect(hashElasticMapping(simpleMapping)).toMatch(/^[a-z0-9]+$/)
+    })
+    it('produces different hashes for objects with same byte length', () => {
+      const similarMapping = {
+        properties: {
+          id: { type: 'keyword' },
+          treated: { type: 'date' },
+        },
+      }
+      expect(hashElasticMapping(simpleMapping)).not.toEqual(
+        hashElasticMapping(similarMapping),
+      )
+    })
+  })
+})

package/src/auth.ts

@@ -0,0 +1,12 @@
+import jwt from 'jsonwebtoken'
+
+/** Create a dataset:indexing scoped token for search indexing */
+export function indexingToken(): string {
+  return jwt.sign(
+    {
+      scopes: ['dataset:indexing'],
+    },
+    process.env.JWT_SECRET || process.env.JEST_WORKER_ID,
+    { expiresIn: 60 * 60 * 3 }, // 3 hours
+  )
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+import { DatasetsIndex } from './indexes/datasets'
+import {
+  DatasetQueryResult,
+  indexDataset,
+  indexQuery,
+  queryForIndex,
+} from './query'
+import { indexingToken } from './auth'
+export {
+  DatasetsIndex,
+  DatasetQueryResult,
+  indexDataset,
+  indexQuery,
+  queryForIndex,
+  indexingToken,
+}

package/src/indexes/datasets.ts

@@ -0,0 +1,14 @@
+import datasetsMapping from '../mappings/datasets-mapping.json'
+import { elasticMappingName } from '../names'
+
+interface IndexDefinition {
+  name: string
+  mapping: Record<string, unknown>
+}
+
+export const DatasetsIndex: IndexDefinition = {
+  name: elasticMappingName('datasets', datasetsMapping),
+  mapping: datasetsMapping,
+}
+
+export default DatasetsIndex

package/src/mappings/datasets-mapping.json

@@ -0,0 +1,100 @@
+{
+  "properties": {
+    "id": { "type": "keyword" },
+    "created": { "type": "date" },
+    "public": { "type": "boolean" },
+    "metadata": {
+      "properties": {
+        "datasetName": { "type": "keyword" },
+        "datasetUrl": { "type": "keyword" },
+        "dataProcessed": { "type": "boolean" },
+        "firstSnapshotCreatedAt": { "type": "date" },
+        "latestSnapshotCreatedAt": { "type": "date" },
+        "ages": { "type": "float" },
+        "modalities": { "type": "keyword" },
+        "datasetId": { "type": "keyword" },
+        "dxStatus": { "type": "keyword" },
+        "trialCount": { "type": "long" },
+        "tasksCompleted": { "type": "keyword" },
+        "studyDesign": { "type": "keyword" },
+        "studyDomain": { "type": "keyword" },
+        "studyLongitudinal": { "type": "keyword" },
+        "species": { "type": "keyword" },
+        "associatedPaperDOI": { "type": "keyword" },
+        "openneuroPaperDOI": { "type": "keyword" },
+        "seniorAuthor": { "type": "keyword" },
+        "grantFunderName": { "type": "keyword" },
+        "grantIdentifier": { "type": "keyword" }
+      }
+    },
+    "latestSnapshot": {
+      "properties": {
+        "id": { "type": "keyword" },
+        "tag": { "type": "keyword" },
+        "summary": {
+          "properties": {
+            "tasks": { "type": "keyword" },
+            "modalities": { "type": "keyword" },
+            "secondaryModalities": { "type": "keyword" },
+            "subjects": { "type": "keyword" },
+            "subjectMetadata": {
+              "properties": {
+                "participantId": { "type": "keyword" },
+                "group": { "type": "keyword" },
+                "sex": { "type": "keyword" },
+                "age": { "type": "integer" }
+              }
+            },
+            "pet": {
+              "properties": {
+                "BodyPart": { "type": "keyword" },
+                "ScannerManufacturer": { "type": "keyword" },
+                "ScannerManufacturersModelName": { "type": "keyword" },
+                "TracerName": { "type": "keyword" },
+                "TracerRadionuclide": { "type": "keyword" }
+              }
+            }
+          }
+        },
+        "description": {
+          "properties": {
+            "Name": { "type": "text" },
+            "Authors": { "type": "text" },
+            "SeniorAuthor": { "type": "text" }
+          }
+        },
+        "readme": {
+          "type": "text"
+        }
+      }
+    },
+    "draft": {
+      "properties": {
+        "issues": {
+          "properties": {
+            "severity": { "type": "keyword" }
+          }
+        }
+      }
+    },
+    "permissions": {
+      "properties": {
+        "userPermissions": {
+          "properties": {
+            "level": { "type": "keyword" },
+            "user": {
+              "properties": {
+                "id": { "type": "keyword" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "analytics": {
+      "properties": {
+        "downloads": { "type": "integer" }
+      }
+    }
+  }
+}

package/src/names.ts

@@ -0,0 +1,13 @@
+import crypto from 'crypto'
+
+/**
+ * Hash mappping objects to provide a stable index name if the mapping is unchanged
+ * @param mapping ElasticSearch mapping object
+ */
+export const hashElasticMapping = (mapping: Record<string, unknown>): string =>
+  crypto.createHash('sha1').update(JSON.stringify(mapping)).digest('hex')
+
+export const elasticMappingName = (
+  name: string,
+  mapping: Record<string, unknown>,
+): string => `${name}-${hashElasticMapping(mapping)}`

package/src/query.ts

@@ -0,0 +1,177 @@
+import {
+  Client as ElasticClient,
+  // Object that contains the type definitions of every API method
+  RequestParams,
+  // Interface of the generic API response
+  ApiResponse,
+} from '@elastic/elasticsearch'
+import { ApolloClient, gql, NormalizedCacheObject } from '@apollo/client'
+import { DatasetsIndex } from './indexes/datasets'
+
+export const INDEX_DATASET_FRAGMENT = gql`
+  fragment DatasetIndex on Dataset {
+    id
+    created
+    public
+    metadata {
+      datasetName
+      datasetUrl
+      dataProcessed
+      firstSnapshotCreatedAt
+      latestSnapshotCreatedAt
+      ages
+      modalities
+      datasetId
+      dxStatus
+      trialCount
+      tasksCompleted
+      studyDesign
+      studyDomain
+      studyLongitudinal
+      dataProcessed
+      species
+      associatedPaperDOI
+      openneuroPaperDOI
+      seniorAuthor
+      grantFunderName
+      grantIdentifier
+    }
+    latestSnapshot {
+      id
+      tag
+      description {
+        Name
+        Authors
+        SeniorAuthor
+      }
+      summary {
+        tasks
+        modalities
+        secondaryModalities
+        subjectMetadata {
+          participantId
+          group
+          sex
+          age
+        }
+        subjects
+        pet {
+          BodyPart
+          ScannerManufacturer
+          ScannerManufacturersModelName
+          TracerName
+          TracerRadionuclide
+        }
+      }
+      readme
+    }
+    draft {
+      issues {
+        severity
+      }
+    }
+    permissions {
+      userPermissions {
+        level
+        user {
+          id
+        }
+      }
+    }
+    analytics {
+      downloads
+    }
+  }
+`
+
+export const indexDatasetQuery = gql`
+  query dataset($datasetId: ID!) {
+    dataset(id: $datasetId) {
+      ...DatasetIndex
+    }
+  }
+  ${INDEX_DATASET_FRAGMENT}
+`
+
+export const indexQuery = gql`
+  query getDatasets(
+    $cursor: String
+    $orderBy: DatasetSort = { created: descending }
+    $filterBy: DatasetFilter = {}
+  ) {
+    datasets(first: 5, after: $cursor, orderBy: $orderBy, filterBy: $filterBy) {
+      edges {
+        node {
+          ...DatasetIndex
+        }
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+        count
+      }
+    }
+  }
+  ${INDEX_DATASET_FRAGMENT}
+`
+
+// TODO: This would be better to generate from the GraphQL schema
+export interface DatasetQueryResult {
+  id: string
+  metadata: Record<string, any>
+  latestSnapshot: Record<string, any>
+  __typename: string
+}
+
+/**
+ * Convert from GraphQL dataset object to RequestParams.Index documents
+ * TODO: Use generated GraphQL typing
+ * @param datasetObj GraphQL dataset object from searchDatasets query
+ */
+export function extractDatasetDocument(
+  datasetObj: DatasetQueryResult,
+): RequestParams.Index {
+  const dataset: RequestParams.Index = {
+    index: DatasetsIndex.name,
+    id: datasetObj.id,
+    body: {
+      ...datasetObj,
+    },
+  }
+  return dataset
+}
+
+/**
+ * Query a single dataset for indexing
+ * @param datasetId Accession number
+ */
+export function queryForIndex(
+  apolloClient: ApolloClient<NormalizedCacheObject>,
+  datasetId: string,
+) {
+  return apolloClient.query({
+    query: indexDatasetQuery,
+    variables: { datasetId },
+    errorPolicy: 'all',
+  })
+}
+
+/**
+ * Index one dataset (latest snapshot)
+ * @param elasticClient Elastic client to submit index data
+ * @param datasetObj OpenNeuro GraphQL dataset object
+ */
+export async function indexDataset(
+  elasticClient: ElasticClient,
+  datasetObj: DatasetQueryResult,
+): Promise<ApiResponse> {
+  try {
+    console.log(`Indexing "${datasetObj.id}"`)
+    const response: ApiResponse = await elasticClient.index(
+      extractDatasetDocument(datasetObj),
+    )
+    return response
+  } catch (err) {
+    console.dir(err)
+  }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "../../.build-cache/search.tsbuildinfo"
+  },
+  "extends": "../../tsconfig.json",
+  "include": ["./src"],
+  "exclude": ["node_modules", "**/*.spec.ts"],
+  "files": ["./src/mappings/datasets-mapping.json"],
+  "references": [{ "path": "../openneuro-client" }]
+}