mrc-6097 Metadata endpoint

src/controllers/metadataController.ts

@@ -0,0 +1,9 @@
+import { Request, Response } from "express";
+import { jsonResponseSuccess } from "../jsonResponse";
+
+export class MetadataController {
+    static getMetadata = (req: Request, res: Response) => {
+        const metadata = req.app.locals.metadata;
+        jsonResponseSuccess(metadata, res);
+    };
+}

src/routes.ts

@@ -2,10 +2,12 @@ import { Router } from "express";
 import { IndexController } from "./controllers/indexController";
 import { TileController } from "./controllers/tileController";
 import notFound from "./errors/notFound";
+import { MetadataController } from "./controllers/metadataController";
 
 export const registerRoutes = () => {
     const router = Router();
     router.get("/", IndexController.getIndex);
+    router.get("/metadata", MetadataController.getMetadata);
     router.get("/tile/:dataset/:level/:z/:x/:y", TileController.getTile);
 
     // provide an endpoint we can use to test 500 response behaviour by throwing an "unexpected error" - but only if we

src/server.ts

@@ -2,12 +2,13 @@ import compression from "compression";
 import cors from "cors";
 import express from "express";
 import * as path from "node:path";
-import { ConfigReader } from "./configReader";
+import { ConfigReader } from "./server/configReader";
 import { GroutConfig } from "./types/app";
 import { registerRoutes } from "./routes";
 import { initialiseLogging } from "./logging";
-import { discoverTileDatasets } from "./discover";
+import { discoverTileDatasets } from "./server/discover";
 import { handleError } from "./errors/handleError";
+import { buildMetadata } from "./server/buildMetadata";
 
 // Wrap the main server set-up functionality in a non-top-level method so we can use async - we can revert this in
 // https://mrc-ide.myjetbrains.com/youtrack/issue/mrc-6134/Add-Vite-build-and-related-tidy-up
@@ -27,8 +28,11 @@ const main = async () => {
         path.resolve(path.join(rootDir, "data"))
     );
 
+    const metadata = buildMetadata(tileDatasets);
+
     Object.assign(app.locals, {
-        tileDatasets
+        tileDatasets,
+        metadata
     });
     Object.freeze(app.locals); // We don't expect anything else to modify app.locals
 

src/server/buildMetadata.ts

@@ -0,0 +1,19 @@
+import { GroutMetadata, TileDataset } from "../types/app";
+import { Dict } from "../types/utils";
+
+// Build metadata response on start-up as it will not change while the app is running
+export const buildMetadata = (
+    tileDatasets: Dict<TileDataset>
+): GroutMetadata => {
+    const tileDatasetMetadata = {};
+    for (const datasetName of Object.keys(tileDatasets)) {
+        tileDatasetMetadata[datasetName] = {
+            levels: Object.keys(tileDatasets[datasetName])
+        };
+    }
+    return {
+        datasets: {
+            tile: tileDatasetMetadata
+        }
+    };
+};

src/discover.ts → src/server/discover.ts

@@ -1,8 +1,8 @@
 import * as fs from "fs";
 import * as path from "node:path";
-import { TileDatabase } from "./db/tileDatabase";
-import { TileDataset } from "./types/app";
-import { Dict } from "./types/utils";
+import { TileDatabase } from "../db/tileDatabase";
+import { TileDataset } from "../types/app";
+import { Dict } from "../types/utils";
 
 export const discoverTileDatasets = async (
     root: string

src/types/app.ts

@@ -8,6 +8,19 @@ export interface GroutConfig {
 // We represent this as a dict, where the keys are the level names
 export type TileDataset = Dict<TileDatabase>;
 
+export type GroutDatasetMetadata = {
+    levels: string[];
+};
+
+// We only support tile datasets at the moment
+export type datasetTypes = "tile";
+
+// Data type of metadata response - currently provides only the dataset names and levels for tile data, but will
+// eventually include other types of metadata
+export interface GroutMetadata {
+    datasets: Record<datasetTypes, Dict<GroutDatasetMetadata>>;
+}
+
 export interface AppLocals {
     tileDatasets: Dict<TileDataset>;
 }

tests/integration/index.spec.ts

@@ -1,14 +1,9 @@
 import { describe, expect, test } from "vitest";
-import { grout } from "./integrationTest";
+import { getData } from "./integrationTest";
 
 describe("index endpoint", () => {
     test("returns package version", async () => {
-        const response = await grout.get("/");
-        expect(response.status).toBe(200);
-        expect(response.body.status).toBe("success");
-        expect(response.body.errors).toBe(null);
-        const data = response.body.data;
-
+        const data = await getData("/");
         const expectedVersion = process.env.npm_package_version;
         expect(data.version).toBe(expectedVersion);
     });

tests/integration/integrationTest.ts

@@ -1,3 +1,13 @@
 import request from "supertest";
+import { expect } from "vitest";
 
 export const grout = request("http://localhost:5000");
+
+// Get data from server, expect successful result and return body.data
+export const getData = async (url: string) => {
+    const response = await grout.get(url);
+    expect(response.status).toBe(200);
+    expect(response.body.status).toBe("success");
+    expect(response.body.errors).toBe(null);
+    return response.body.data;
+};

tests/integration/metadata.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "vitest";
+import { getData } from "./integrationTest";
+
+describe("metadata endpoint", () => {
+    test("returns expected dataset metadata", async () => {
+        const data = await getData("/metadata");
+        expect(data).toStrictEqual({
+            datasets: {
+                tile: {
+                    gadm41: {
+                        levels: ["admin0", "admin1"]
+                    }
+                }
+            }
+        });
+    });
+});

tests/unit/controllers/metadataController.spec.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test, vi } from "vitest";
+import { MetadataController } from "../../../src/controllers/metadataController";
+
+const mockJsonResponseSuccess = vi.hoisted(() => vi.fn());
+vi.mock("../../../src/jsonResponse", () => ({
+    jsonResponseSuccess: mockJsonResponseSuccess
+}));
+
+describe("MetadataController", () => {
+    test("returns metadata from app locals", () => {
+        const mockMetadata = {
+            datasets: {}
+        };
+        const mockReq = {
+            app: {
+                locals: {
+                    metadata: mockMetadata
+                }
+            }
+        } as any;
+        const mockRes = {} as any;
+        MetadataController.getMetadata(mockReq, mockRes);
+        expect(mockJsonResponseSuccess).toHaveBeenCalledWith(
+            mockMetadata,
+            mockRes
+        );
+    });
+});

tests/unit/routes.spec.ts

@@ -3,6 +3,7 @@ import { registerRoutes } from "../../src/routes";
 import { IndexController } from "../../src/controllers/indexController";
 import { TileController } from "../../src/controllers/tileController";
 import notFound from "../../src/errors/notFound";
+import { MetadataController } from "../../src/controllers/metadataController";
 
 const { mockRouterConstructor, mockRouter } = vi.hoisted(() => {
     const mockRouter = {
@@ -29,6 +30,11 @@ describe("registerRoutes", () => {
         );
         expect(mockRouter.get).toHaveBeenNthCalledWith(
             2,
+            "/metadata",
+            MetadataController.getMetadata
+        );
+        expect(mockRouter.get).toHaveBeenNthCalledWith(
+            3,
             "/tile/:dataset/:level/:z/:x/:y",
             TileController.getTile
         );

tests/unit/server/buildMetadata.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import { buildMetadata } from "../../../src/server/buildMetadata";
+
+describe("buildMetadata", () => {
+    test("builds expected metadata from datasets", () => {
+        const mockTileDatasets = {
+            ds1: {
+                level0: {
+                    db: {}
+                },
+                level1: {
+                    db: {}
+                }
+            },
+            ds2: {
+                level2: {
+                    db: {}
+                }
+            }
+        } as any;
+        const result = buildMetadata(mockTileDatasets);
+        expect(result).toStrictEqual({
+            datasets: {
+                tile: {
+                    ds1: {
+                        levels: ["level0", "level1"]
+                    },
+                    ds2: {
+                        levels: ["level2"]
+                    }
+                }
+            }
+        });
+    });
+});

tests/unit/configReader.spec.ts → tests/unit/server/configReader.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test, beforeEach, vi } from "vitest";
 import { fs, vol } from "memfs";
-import { ConfigReader } from "../../src/configReader";
+import { ConfigReader } from "../../../src/server/configReader";
 
 // tell vitest to use fs mock from __mocks__ folder
 vi.mock("fs");

tests/unit/discover.spec.ts → tests/unit/server/discover.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test, vi, beforeEach } from "vitest";
 import { fs, vol } from "memfs";
-import { discoverTileDatasets } from "../../src/discover";
+import { discoverTileDatasets } from "../../../src/server/discover";
 
 // tell vitest to use fs mock from __mocks__ folder
 vi.mock("fs");
@@ -17,7 +17,7 @@ const mockDatabaseConstructor = vi.hoisted(() => {
         .mockImplementation((path: string) => ({ path, open: vi.fn() }));
 });
 
-vi.mock("../../src/db/tileDatabase", () => ({
+vi.mock("../../../src/db/tileDatabase", () => ({
     TileDatabase: mockDatabaseConstructor
 }));