Merge pull request #523 from OHDSI/development

Release 0.6

Author: Mikhail-iontsev

backend/.env

@@ -0,0 +1,4 @@
+PORT=3000
+DATABASE_PATH=./annotations.duckdb
+HOSTNAME='localhost'
+NODE_ENV=development

backend/main.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import dotenv from 'dotenv';
+import app from "./src/app.js";
+import logger from "./src/utils/logger.js";
+import debug from "debug"
+import http from 'http';
+
+dotenv.config();
+
+let port = normalizePort(process.env.PORT || '3000');
+const hostName = process.env.HOSTNAME || 'localhost';
+
+app.set('port', port);
+
+let server = http.createServer(app);
+
+server.listen(port, hostName, () => {
+  logger.info(`Server running on ${hostName}:${port}, mode: ${process.env.NODE_ENV}`);
+});
+server.on('error', onError);
+server.on('listening', onListening);
+
+function normalizePort(val) {
+  const port = parseInt(val, 10);
+
+  if (isNaN(port)) {
+    // named pipe
+    return val;
+  }
+
+  if (port >= 0) {
+    // port number
+    return port;
+  }
+
+  return false;
+}
+
+function onError(error) {
+  if (error.syscall !== 'listen') {
+    throw error;
+  }
+
+  const bind = typeof port === 'string'
+    ? 'Pipe ' + port
+    : 'Port ' + port;
+
+  switch (error.code) {
+    case 'EACCES':
+      console.error(bind + ' requires elevated privileges');
+      process.exit(1);
+      break;
+    case 'EADDRINUSE':
+      console.error(bind + ' is already in use');
+      process.exit(1);
+      break;
+    default:
+      throw error;
+  }
+}
+
+function onListening() {
+  const addr = server.address();
+  const bind = typeof addr === 'string'
+    ? 'pipe ' + addr
+    : 'port ' + addr.port;
+  debug('Listening on ' + bind);
+}
+
+const shutdownHandler = (reason) => {
+  logger.info(`${reason === 'SIGINT' ? 'Manual shutdown' : 'Forced shutdown'} initiated`);
+  logger.info(`Server is shutting down...`);
+  server.close(() => {
+    logger.info('Server stopped.');
+    process.exit(0);
+  });
+};
+
+process.on('SIGINT', shutdownHandler);
+process.on('SIGTERM', shutdownHandler);

backend/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "ares-backend",
+  "version": "0.1",
+  "private": true,
+  "scripts": {
+    "start": "node ./main.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "@duckdb/node-api": "^1.1.3-alpha.10",
+    "cookie-parser": "~1.4.4",
+    "cors": "^2.8.5",
+    "debug": "~2.6.9",
+    "dotenv": "^16.4.7",
+    "express": "~4.16.1",
+    "http-errors": "~1.6.3",
+    "winston": "^3.17.0"
+  }
+}

backend/src/app.js

@@ -0,0 +1,42 @@
+import createError from "http-errors"
+import express from "express"
+import cookieParser from "cookie-parser"
+import cors from "cors"
+
+import dbInstance from "./config/dbConnection.js";
+import logger from "./utils/logger.js"
+import indexRouter from "./routes/annotationRoutes.js"
+import initAnnotationTables from "./config/initAnnotationTables.js";
+import "./config/dbConnection.js"
+import "./controllers/annotationsController.js"
+
+const app = express();
+
+app.use((req, res, next) => {
+  logger.http(`Request: ${req.method} ${req.url}`);
+  next();
+});
+app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+app.use(cookieParser());
+
+app.use(cors())
+
+// app.use(express.static(path.join(__dirname, 'public')));
+
+await initAnnotationTables(dbInstance)
+
+app.use('/', indexRouter);
+
+app.use(function(req, res, next) {
+  next(createError(404));
+});
+
+app.use(function(err, req, res, next) {
+  res.locals.message = err.message;
+  res.locals.error = req.app.get('env') === 'development' ? err : {};
+  res.status(err.status || 500);
+  res.render('error');
+});
+
+export default app;

backend/src/config/dbConnection.js

@@ -0,0 +1,8 @@
+import { DuckDBInstance } from '@duckdb/node-api';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const dbInstance = await DuckDBInstance.create(process.env.DATABASE_PATH);
+
+export default dbInstance;

backend/src/config/initAnnotationTables.js

@@ -0,0 +1,86 @@
+import logger from "../utils/logger.js";
+
+const initAnnotationTables = async (instance) => {
+    const connection = await instance.connect();
+    const checkTableExists = async (tableName) => {
+        const result = await connection.runAndReadAll(`
+            SELECT COUNT(*) AS count
+            FROM information_schema.tables
+            WHERE table_name = '${tableName}';
+        `);
+        const rows = result.getRowObjects();
+
+        return rows[0].count;
+    };
+
+
+    const tablesExist = await checkTableExists('charts');
+
+    if (!tablesExist) {
+        logger.info('Running for the first time. Initiating db.')
+        await connection.run(`
+            CREATE TABLE IF NOT EXISTS charts (
+                id TEXT PRIMARY KEY,
+                chart_id TEXT, 
+                chart_name TEXT, 
+                report_name TEXT, 
+                domain_name TEXT,
+                concept_id TEXT
+            );
+        `);
+
+        await connection.run(`
+            CREATE TABLE IF NOT EXISTS annotations (
+                id TEXT PRIMARY KEY,
+                viz_id TEXT REFERENCES charts(id),
+                created_by TEXT,
+                created_at TIMESTAMP,
+                updated_at TIMESTAMP,
+                deleted_at TIMESTAMP
+            );
+        `);
+
+        await connection.run(`
+            CREATE TABLE IF NOT EXISTS annotations_coordinates (
+                annotation_id TEXT REFERENCES annotations(id),
+                xMin DOUBLE PRECISION,
+                xMax DOUBLE PRECISION,
+                yMin DOUBLE PRECISION,
+                yMax DOUBLE PRECISION
+            );
+        `);
+
+        await connection.run(`
+            CREATE TABLE IF NOT EXISTS annotations_metadata (
+                annotation_id TEXT REFERENCES annotations(id),
+                scope_type TEXT,
+                scope_value JSON
+            );
+        `);
+
+        await connection.run(`
+            CREATE TABLE IF NOT EXISTS annotations_body (
+                annotation_id TEXT REFERENCES annotations(id),
+                title TEXT,
+                description TEXT
+            );
+        `);
+
+        await connection.run(`
+            CREATE TABLE IF NOT EXISTS annotations_notes (
+                note_id TEXT PRIMARY KEY,
+                annotation_id TEXT REFERENCES annotations(id),
+                title TEXT,
+                description TEXT,
+                created_at TIMESTAMP,
+                updated_at TIMESTAMP,
+                created_by TEXT,
+                last_updated TIMESTAMP
+            );
+        `);
+    }
+
+    connection.close();
+};
+
+export default initAnnotationTables;