Add /modelExtraction endpoint

src/main.ts

@@ -7,6 +7,7 @@ import initApiPlaygroundRoutes from './packages/api-playground/api-playground.js
 import initAuthRoutes from './packages/auth/routes.js';
 import { DbMerlin } from './packages/db/db.js';
 import initFileRoutes from './packages/files/files.js';
+import initHasuraRoutes from './packages/hasura/hasura-events.js';
 import initHealthRoutes from './packages/health/health.js';
 import initSwaggerRoutes from './packages/swagger/swagger.js';
 import cookieParser from 'cookie-parser';
@@ -44,6 +45,7 @@ async function main(): Promise<void> {
   initAuthRoutes(app, authHandler);
   initFileRoutes(app);
   initHealthRoutes(app);
+  initHasuraRoutes(app);
   initSwaggerRoutes(app);
 
   app.listen(PORT, () => {

src/packages/hasura/hasura-events.ts

@@ -0,0 +1,185 @@
+import type { Express } from 'express';
+import { adminOnlyAuth } from '../auth/middleware.js';
+import rateLimit from 'express-rate-limit';
+import getLogger from '../../logger.js';
+import { getEnv } from '../../env.js';
+import { generateJwt, decodeJwt } from '../auth/functions.js';
+
+export default (app: Express) => {
+  const logger = getLogger('packages/hasura/hasura-events');
+  const { RATE_LIMITER_LOGIN_MAX } = getEnv();
+
+  const refreshLimiter = rateLimit({
+    legacyHeaders: false,
+    max: RATE_LIMITER_LOGIN_MAX,
+    standardHeaders: true,
+    windowMs: 15 * 60 * 1000, // 15 minutes
+  });
+
+  /**
+   * @swagger
+   * /modelExtraction:
+   *   post:
+   *     security:
+   *       - bearerAuth: []
+   *     consumes:
+   *       - application/json
+   *     produces:
+   *       - application/json
+   *     parameters:
+   *      - in: header
+   *        name: x-hasura-role
+   *        schema:
+   *          type: string
+   *          required: false
+   *     requestBody:
+   *       content:
+   *         application/json:
+   *          schema:
+   *            type: object
+   *            properties:
+   *              missionModelId:
+   *                type: integer
+   *     responses:
+   *       200:
+   *         description: ExtractionResponse
+   *       403:
+   *         description: Unauthorized error
+   *       401:
+   *         description: Unauthenticated error
+   *     summary: Request extraction of a Mission Model's JAR
+   *     tags:
+   *       - Hasura
+   */
+  app.post('/modelExtraction', refreshLimiter, adminOnlyAuth, async (req, res) => {
+    const { jwtPayload } = decodeJwt(req.get('authorization'));
+    const username = jwtPayload?.username as string;
+
+    const { body } = req;
+    const { missionModelId } = body;
+
+    // Invoke endpoints using the Hasura Metadata API
+    const { HASURA_METADATA_API_URL: metadataURL } = getEnv();
+
+    // Generate a temporary token that has Hasura Admin access
+    const tempToken = generateJwt(username, 'admin', ['admin'], '10s');
+
+    const headers = {
+      Authorization: `Bearer ${tempToken}`,
+      'Content-Type': 'application/json',
+      'x-hasura-role': 'admin',
+      'x-hasura-user-id': username,
+    };
+    const payload = { id: missionModelId };
+
+    const activityTypesRQ = {
+      args: {
+        name: 'refreshActivityTypes',
+        payload,
+        source: 'Aerie',
+      },
+      type: 'pg_invoke_event_trigger',
+    };
+    const modelParametersRQ = {
+      args: {
+        name: 'refreshModelParameters',
+        payload,
+        source: 'Aerie',
+      },
+      type: 'pg_invoke_event_trigger',
+    };
+    const resourceTypesRQ = {
+      args: {
+        name: 'refreshResourceTypes',
+        payload,
+        source: 'Aerie',
+      },
+      type: 'pg_invoke_event_trigger',
+    };
+
+    const refreshActivityTypes = fetch(metadataURL, {
+      body: JSON.stringify(activityTypesRQ),
+      headers,
+      method: 'POST',
+    });
+    const refreshModelParameters = fetch(metadataURL, {
+      body: JSON.stringify(modelParametersRQ),
+      headers,
+      method: 'POST',
+    });
+    const refreshResourceTypes = fetch(metadataURL, {
+      body: JSON.stringify(resourceTypesRQ),
+      headers,
+      method: 'POST',
+    });
+
+    // Awaiting all requests in parallel
+    const [activityTypeResp, modelParameterResp, resourceTypeResp] = await Promise.all([
+      refreshActivityTypes
+        .then(response => {
+          if (!response.ok) {
+            logger.error(
+              `Bad status received when extracting model activity types: [${response.status}] ${response.statusText}`,
+            );
+            return {
+              error: `Bad status received when extracting model activity types: [${response.status}] ${response.statusText}`,
+              status: response.status,
+              statusText: response.statusText,
+            };
+          }
+          return response.json();
+        })
+        .catch(error => {
+          logger.error(`Error connecting to Hasura metadata API at ${metadataURL}. Full error below:\n${error}`);
+          return { error: `Error connecting to metadata API at ${metadataURL}` };
+        }),
+      refreshModelParameters
+        .then(response => {
+          if (!response.ok) {
+            logger.error(
+              `Bad status received when extracting model parameters: [${response.status}] ${response.statusText}`,
+            );
+            return {
+              error: `Bad status received when extracting model parameters: [${response.status}] ${response.statusText}`,
+              status: response.status,
+              statusText: response.statusText,
+            };
+          }
+          return response.json();
+        })
+        .catch(error => {
+          logger.error(`Error connecting to Hasura metadata API at ${metadataURL}. Full error below:\n${error}`);
+          return { error: `Error connecting to metadata API at ${metadataURL}` };
+        }),
+      refreshResourceTypes
+        .then(response => {
+          if (!response.ok) {
+            logger.error(
+              `Bad status received when extracting model resource types: [${response.status}] ${response.statusText}`,
+            );
+            return {
+              error: `Bad status received when extracting model resource types: [${response.status}] ${response.statusText}`,
+              status: response.status,
+              statusText: response.statusText,
+            };
+          }
+          return response.json();
+        })
+        .catch(error => {
+          logger.error(`Error connecting to Hasura metadata API at ${metadataURL}. Full error below:\n${error}`);
+          return { error: `Error connecting to metadata API at ${metadataURL}` };
+        }),
+    ]);
+
+    logger.info(`POST /modelExtraction: Extraction triggered for model: ${missionModelId}`);
+
+    res.json({
+      message: `Extraction triggered for model: ${missionModelId}`,
+      response: {
+        activity_types: await activityTypeResp,
+        model_parameters: await modelParameterResp,
+        resource_types: await resourceTypeResp,
+      },
+    });
+  });
+};