Feature: Add External Source (and External Event) Attribute Validation

package.json

@@ -60,6 +60,6 @@
     "nodemon": "^3.1.4",
     "prettier": "^3.0.0",
     "typescript": "^5.1.6",
-    "vitest": "^1.2.2"
+    "vitest": "^1.4.0"
   }
 }

src/main.ts

@@ -11,6 +11,8 @@ import initHasuraRoutes from './packages/hasura/hasura-events.js';
 import initHealthRoutes from './packages/health/health.js';
 import initPlanRoutes from './packages/plan/plan.js';
 import initSwaggerRoutes from './packages/swagger/swagger.js';
+import initExternalSourceRoutes from './packages/external-source/external-source.js';
+import initExternalEventRoutes from './packages/external-event/external-event.js';
 import cookieParser from 'cookie-parser';
 import { AuthAdapter } from './types/auth.js';
 import { NoAuthAdapter } from './packages/auth/adapters/NoAuthAdapter.js';
@@ -48,6 +50,8 @@ async function main(): Promise<void> {
   initHealthRoutes(app);
   initHasuraRoutes(app);
   initPlanRoutes(app);
+  initExternalSourceRoutes(app);
+  initExternalEventRoutes(app);
   initSwaggerRoutes(app);
 
   app.listen(PORT, () => {

src/packages/external-event/external-event.ts

@@ -0,0 +1,136 @@
+import type { Express, Request, Response } from 'express';
+import type { ExternalEventTypeInsertInput } from '../../types/external-event.js';
+import Ajv from 'ajv';
+import { getEnv } from '../../env.js';
+import getLogger from '../../logger.js';
+import gql from './gql.js';
+import { HasuraError } from '../../types/hasura.js';
+
+const logger = getLogger('packages/external-event/external-event');
+const { HASURA_API_URL } = getEnv();
+const GQL_API_URL = `${HASURA_API_URL}/v1/graphql`;
+
+const ajv = new Ajv();
+
+async function uploadExternalEventType(req: Request, res: Response) {
+  const authorizationHeader = req.get('authorization');
+
+  const {
+    headers: { 'x-hasura-role': roleHeader, 'x-hasura-user-id': userHeader },
+  } = req;
+
+  const { body } = req;
+  const { external_event_type_name, attribute_schema } = body;
+  logger.info(`POST /uploadExternalEventType: Uploading External Event Type: ${external_event_type_name}`);
+
+  const headers: HeadersInit = {
+    Authorization: authorizationHeader ?? '',
+    'Content-Type': 'application/json',
+    'x-hasura-role': roleHeader ? `${roleHeader}` : '',
+    'x-hasura-user-id': userHeader ? `${userHeader}` : '',
+  };
+
+  // Validate schema is valid JSON Schema
+  const schemaIsValid: boolean = ajv.validateSchema(attribute_schema);
+  if (!schemaIsValid) {
+    logger.error(
+      `POST /uploadExternalEventType: Schema validation failed for External Event Type ${external_event_type_name}`,
+    );
+    ajv.errors?.forEach(ajvError => logger.error(ajvError));
+    res.status(500).send({ message: ajv.errors });
+    return;
+  }
+
+  // Make sure name in schema (title) and provided name match
+  try {
+    if (attribute_schema['title'] === undefined || attribute_schema.title !== external_event_type_name) {
+      throw new Error('Schema title does not match provided external event type name.');
+    }
+  } catch (error) {
+    logger.error(
+      `POST /uploadExternalEventType: Error occurred during External Event Type ${external_event_type_name} upload`,
+    );
+    logger.error((error as Error).message);
+    res.status(500).send({ message: (error as Error).message });
+    return;
+  }
+
+  logger.info(`POST /uploadExternalEventType: Attribute schema was VALID`);
+
+  // Run the Hasura migration for creating an external event
+  const externalEventTypeInsertInput: ExternalEventTypeInsertInput = {
+    attribute_schema: attribute_schema,
+    name: external_event_type_name,
+  };
+
+  const response = await fetch(GQL_API_URL, {
+    body: JSON.stringify({
+      query: gql.CREATE_EXTERNAL_EVENT_TYPE,
+      variables: { eventType: externalEventTypeInsertInput },
+    }),
+    headers,
+    method: 'POST',
+  });
+
+  type CreateExternalEventTypeResponse = {
+    data: { createExternalEventType: { attribute_schema: object; name: string } | null };
+  };
+  const jsonResponse = await response.json();
+  const createExternalEventTypeResponse = jsonResponse as CreateExternalEventTypeResponse | HasuraError;
+
+  res.json(createExternalEventTypeResponse);
+}
+
+export default (app: Express) => {
+  /**
+   * @swagger
+   * /uploadExternalEventType:
+   *   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:
+   *               attribute_schema:
+   *                 type: object
+   *               external_event_type_name:
+   *                 type: string
+   *             required:
+   *               - external_event_type_name
+   *                 attribute_schema
+   *     responses:
+   *       200:
+   *         description: Created External Event Type
+   *         content:
+   *           application/json:
+   *             schema:
+   *                properties:
+   *                  attribute_schema:
+   *                    description: JSON Schema for the created External Event Type's attributes
+   *                    type: object
+   *                  name:
+   *                    description: Name of the created External Event Type
+   *                    type: string
+   *       403:
+   *         description: Unauthorized error
+   *       401:
+   *         description: Unauthenticated error
+   *     summary: Uploads an External Event Type definition (containing name & attributes schema) to Hasura.
+   *     tags:
+   *       - Hasura
+   */
+  app.post('/uploadExternalEventType', uploadExternalEventType);
+};

src/packages/external-event/gql.ts

@@ -0,0 +1,11 @@
+export default {
+  CREATE_EXTERNAL_EVENT_TYPE: `#graphql
+    mutation CreateExternalEventType($eventType: external_event_type_insert_input!)
+    {
+      createExternalEventType: insert_external_event_type_one(object: $eventType) {
+        attribute_schema
+        name
+      }
+    }
+  `,
+};