jskos-server 2.4.0

package/routes/data.js

@@ -0,0 +1,19 @@
+import express from "express"
+import { DataService } from "../services/data.js"
+import { wrapAsync, supportDownloadFormats, returnJSON } from "../utils/middleware.js"
+import { useAuth } from "../utils/auth.js"
+
+export default config => {
+  const router = express.Router()
+  const dataService = new DataService(config)
+
+  router.get(
+    "/",
+    useAuth(false),
+    supportDownloadFormats([]),
+    wrapAsync(async req => dataService.getData(req)),
+    returnJSON,
+  )
+
+  return router
+}

package/routes/mappings.js

@@ -0,0 +1,108 @@
+import express from "express"
+import { MappingService } from "../services/mappings.js"
+import * as utils from "../utils/middleware.js"
+import { wrapAsync, wrapDownload } from "../utils/middleware.js"
+import { useAuth } from "../utils/auth.js"
+import { readRoute, createRoute } from "./common.js"
+
+export default config => {
+  const router = express.Router()
+  const service = new MappingService(config)
+
+  // /mappings/suggest and /mappings/voc need to come before /mappings/:_id!
+  router.get(
+    "/suggest",
+    useAuth(config.concepts?.read?.auth),
+    wrapAsync(async (req) => {
+      return await service.getNotationSuggestions(req.query)
+    }),
+    utils.addPaginationHeaders,
+    utils.returnJSON,
+  )
+  router.get(
+    "/voc",
+    useAuth(config.schemes?.read?.auth),
+    wrapAsync(async (req) => {
+      return await service.getMappingSchemes(req.query)
+    }),
+    utils.addPaginationHeaders,
+    utils.adjust,
+    utils.returnJSON,
+  )
+
+  readRoute(router, "/", config.mappings.read, service, "mappings", ["json", "ndjson", "csv", "tsv"])
+  createRoute(router, "/", config.mappings.create, service)
+
+  if (config.mappings.read) {
+    router.get(
+      "/infer",
+      useAuth(config.mappings.read.auth),
+      wrapAsync(async req => service.inferMappings(req.query)),
+      utils.addPaginationHeaders,
+      utils.adjust,
+      utils.returnJSON,
+    )
+
+    router.get(
+      "/:_id",
+      useAuth(config.mappings.read.auth),
+      utils.supportDownloadFormats(["json", "ndjson", "csv", "tsv"]),
+      wrapAsync(async req => service.getMapping(req.params._id)),
+      wrapDownload(utils.adjust, false),
+      wrapDownload(utils.returnJSON, false),
+      wrapDownload(utils.handleDownload("mapping"), true),
+    )
+  }
+
+  if (config.mappings.update) {
+    router.put(
+      "/:_id",
+      useAuth(config.mappings.update.auth),
+      utils.bodyParser,
+      wrapAsync(async (req) => {
+        return await service.putMapping({
+          _id: req.params._id,
+          body: req.body,
+          user: req.user,
+          existing: req.existing,
+        })
+      }),
+      utils.adjust,
+      utils.returnJSON,
+    )
+
+    router.patch(
+      "/:_id",
+      useAuth(config.mappings.update.auth),
+      utils.bodyParser,
+      wrapAsync(async (req) => {
+        return await service.patchMapping({
+          _id: req.params._id,
+          body: req.body,
+          user: req.user,
+          existing: req.existing,
+        })
+      }),
+      utils.adjust,
+      utils.returnJSON,
+    )
+  }
+
+  if (config.mappings.delete) {
+    router.delete(
+      "/:_id",
+      useAuth(config.mappings.delete.auth),
+      utils.bodyParser,
+      wrapAsync(async (req) => {
+        return await service.deleteItem({
+          _id: req.params._id,
+          user: req.user,
+          existing: req.existing,
+        })
+      }),
+      (req, res) => res.sendStatus(204),
+    )
+  }
+
+  return router
+}

package/routes/registries.js

@@ -0,0 +1,24 @@
+import express from "express"
+import { RegistryService } from "../services/registries.js"
+import { createRoute, readRoute, updateRoute, deleteRoute, suggestRoute } from "./common.js"
+
+export default config => {
+  const router = express.Router()
+  const { registries } = config
+  if (!registries) {
+    return router
+  }
+
+  const service = new RegistryService(config)
+
+  readRoute(router, "/", registries.read, service, "registries")
+  createRoute(router, "/", registries.create, service)
+  updateRoute(router, "/", registries.update, service)
+  deleteRoute(router, "/", registries.delete, service)
+
+  // TODO: patchRoute
+
+  suggestRoute(router, "/suggest", registries.read, service)
+
+  return router
+}

package/routes/schemes.js

@@ -0,0 +1,72 @@
+import express from "express"
+import { SchemeService } from "../services/schemes.js"
+import { ConceptService } from "../services/concepts.js"
+import * as utils from "../utils/middleware.js"
+import { wrapAsync, wrapDownload } from "../utils/middleware.js"
+import { useAuth } from "../utils/auth.js"
+import { MalformedRequestError } from "../errors/index.js"
+import { readRoute, createRoute, updateRoute, deleteRoute, suggestRoute } from "./common.js"
+
+export default config => {
+  const router = express.Router()
+  const service = new SchemeService(config)
+  const { schemes, concepts } = config
+
+  readRoute(router, "/", schemes.read, service, "schemes")
+  createRoute(router, "/", schemes.create, service)
+  updateRoute(router, "/", schemes.update, service)
+  deleteRoute(router, "/", schemes.delete, service)
+
+  suggestRoute(router, "/suggest", schemes.read, service)
+
+  if (concepts) {
+    const conceptService = new ConceptService(config)
+
+    router.get(
+      "/top",
+      useAuth(concepts.read.auth),
+      utils.supportDownloadFormats([]),
+      wrapAsync(async (req) => {
+        return await conceptService.getTop(req.query)
+      }),
+      utils.addPaginationHeaders,
+      utils.adjust,
+      utils.returnJSON,
+    )
+
+    router.get(
+      "/concepts",
+      useAuth(concepts.read.auth),
+      utils.supportDownloadFormats(["json", "ndjson"]),
+      wrapAsync(async (req) => {
+        if (!req.query.uri) {
+          throw new MalformedRequestError("Parameter `uri` (URI of a vocabulary) is required for endpoint /voc/concepts")
+        }
+        const query = { ...req.query, voc: req.query.uri }
+        delete query.uri
+        return await conceptService.queryItems(query)
+      }),
+      wrapDownload(utils.addPaginationHeaders, false),
+      wrapDownload(utils.adjust, false),
+      wrapDownload(utils.returnJSON, false),
+      wrapDownload(utils.handleDownload("concepts"), true),
+    )
+
+    if (concepts.delete) {
+      router.delete(
+        "/concepts",
+        useAuth(concepts.delete.auth),
+        utils.bodyParser,
+        wrapAsync(async (req) => {
+          return await conceptService.deleteConceptsFromScheme({
+            scheme: req.existing,
+            setApi: req.query.setApi,
+          })
+        }),
+        (req, res) => res.sendStatus(204),
+      )
+    }
+  }
+
+  return router
+}

package/routes/validate.js

@@ -0,0 +1,37 @@
+import express from "express"
+import { ValidateService } from "../services/validate.js"
+import { wrapAsync, returnJSON } from "../utils/middleware.js"
+import axios from "axios"
+import { MalformedRequestError } from "../errors/index.js"
+
+export default config => {
+  const router = express.Router()
+  const service = new ValidateService(config)
+
+  router.get(
+    "/",
+    wrapAsync(async req => {
+      const url = req.query.url
+      if (!url) {
+        throw new MalformedRequestError("Please use HTTP POST or provide an URL to load data from!")
+      }
+      try {
+        const data = (await axios.get(url)).data
+        return await service.validate(data, req.query)
+      } catch (error) {
+        console.log(error)
+        throw new MalformedRequestError(`Error loading data from URL ${url}.`)
+      }
+    }),
+    returnJSON,
+  )
+
+  router.post(
+    "/",
+    express.json(),
+    wrapAsync(async req => service.validate(req.body, req.query)),
+    returnJSON,
+  )
+
+  return router
+}

package/server.js

@@ -0,0 +1,190 @@
+import config from "./config/index.js"
+import * as utils from "./utils/middleware.js"
+import express from "express"
+import * as db from "./utils/db.js"
+import morgan from "morgan"
+import nocache from "nocache"
+
+import createAnnotationRouter from "./routes/annotations.js"
+import createConceptRouter from "./routes/concepts.js"
+import createConcordanceRouter from "./routes/concordances.js"
+import createMappingRouter from "./routes/mappings.js"
+import createSchemeRouter from "./routes/schemes.js"
+import createRegistryRouter from "./routes/registries.js"
+import createDataRouter from "./routes/data.js"
+import createValidateRouter from "./routes/validate.js"
+
+import { serverStatus } from "./utils/status.js"
+
+import { ipcheck } from "./utils/ipcheck.js"
+import { useAuth } from "./utils/auth.js"
+import * as errors from "./errors/index.js"
+import portfinder from "portfinder"
+import expressWs from "express-ws"
+import { setupChangesApi, isChangesApiAvailable } from "./utils/changes.js"
+
+const __dirname = import.meta.dirname
+const connection = db.connection
+
+config.log(`Running in ${config.env} mode.`)
+
+if (!config.baseUrl) {
+  config.warn("Warning: If you're using jskos-server behind a reverse proxy, it is necessary to add `baseUrl` to the configuration file!")
+}
+
+// Initialize express with settings
+const app = express()
+
+// Initialize WebSocket support
+expressWs(app)
+
+
+app.set("json spaces", 2)
+if (config.proxies && config.proxies.length) {
+  app.set("trust proxy", config.proxies)
+}
+
+// Configure view engine to render EJS templates.
+app.set("views", __dirname + "/views")
+app.set("view engine", "ejs")
+
+// Database connection
+const connect = async () => {
+  try {
+    await db.connect(true)
+    // TODO: `indexExists` causes a deprecation warning. Find a different solution.
+    if (config.schemes && !(await connection.collection("terminologies").indexExists("text"))) {
+      config.warn("Text index on terminologies collection missing. /voc/search and /voc/suggest are disabled. Run `npm run import -- --indexes` or `npm run import -- -i schemes` to created indexes.")
+      config.status["voc-search"] = null
+      config.status["voc-suggest"] = null
+    }
+    if (config.concepts && !(await connection.collection("concepts").indexExists("text"))) {
+      config.warn("Text index on concepts collection missing. /concepts/search and /concepts/suggest are disabled. Run `npm run import -- --indexes` or `npm run import -- -i concepts` to created indexes.")
+      config.status.search = null
+      config.status.suggest = null
+    }
+    if (config.annotations?.mismatchTagVocabulary?.uri) {
+      const model = await import("./models/concepts.js")
+      const concepts = await model.Concept.find({ "inScheme.uri": config.annotations.mismatchTagVocabulary.uri })
+      if (concepts.length === 0) {
+        config.warn("annotations.mismatchTagVocabulary is configured, but no data for that vocabulary could be found in the database. Import the vocabulary data into this instance for the setting to work.")
+      }
+    }
+  } catch (error) {
+    config.warn("Error connecting to database, reconnect in a few seconds...")
+  }
+}
+// Connect immediately on startup
+connect()
+
+// Logging for access logs
+if (config.verbosity === true || config.verbosity === "log") {
+  app.use(morgan(":date[iso] \":method :url HTTP/:http-version\" :status :res[content-length] \":referrer\" \":user-agent\""))
+}
+
+// Add default headers
+app.use(utils.addDefaultHeaders)
+
+// Disable client side caching
+app.use(nocache())
+
+// Disable ETags
+app.set("etag", false)
+app.use(express.urlencoded({ extended: false }))
+
+// Set some properties on req that will be used by other middleware
+app.use(utils.addMiddlewareProperties)
+
+// Add routes
+
+// Root path for static page
+app.get("/", (req, res) => {
+  res.setHeader("Content-Type", "text/html")
+  res.render("base", {
+    config,
+    isChangesApiAvailable,
+  })
+})
+// JSON Schema for /status
+app.use("/status.schema.json", express.static(__dirname + "/status.schema.json"))
+
+// Status page /status
+app.get("/status",
+  (req, res) => {
+    res.status(200).json(serverStatus(config, connection.readyState === 1))
+  })
+
+// Database check middleware
+app.use((req, res, next) => {
+  if (connection.readyState === 1) {
+    next()
+  } else {
+    // No connection to database, return error
+    next(new errors.DatabaseAccessError())
+  }
+})
+// IP check middleware
+app.use(ipcheck(config))
+
+// /checkAuth
+app.get("/checkAuth", useAuth(true), (req, res) => {
+  res.sendStatus(204)
+})
+
+// Add conditional routes
+if (config.schemes) {
+  app.use("/voc", createSchemeRouter(config))
+}
+if (config.mappings) {
+  app.use("/mappings", createMappingRouter(config))
+}
+if (config.concordances) {
+  app.use("/concordances", createConcordanceRouter(config))
+}
+if (config.annotations) {
+  app.use("/annotations", createAnnotationRouter(config))
+}
+if (config.concepts) {
+  app.use(createConceptRouter(config))
+}
+if (config.registries) {
+  app.use("/registries", createRegistryRouter(config))
+}
+
+// These routes are always enabled
+app.use("/data", createDataRouter(config))
+app.use("/validate", createValidateRouter(config))
+
+// Error handling
+app.use((error, req, res, next) => {
+  // Check if error is defined in errors
+  if (Object.values(errors).includes(error.constructor)) {
+    res.status(error.statusCode).send({
+      error: error.constructor.name,
+      status: error.statusCode,
+      message: error.message,
+    })
+  } else {
+    next(error)
+  }
+})
+
+// Changes API
+await setupChangesApi(app, config)
+
+const start = async () => {
+  if (config.env == "test") {
+    portfinder.basePort = config.port
+    config.port = await portfinder.getPortPromise()
+  }
+  app.listen(config.port, () => {
+    config.log(`Now listening on port ${config.port}`)
+  })
+}
+// Start express server immediately even if database is not yet connected
+start()
+
+export {
+  app,
+  connection as db,
+}