feat: Metabase module controller and service

api.planx.uk/modules/analytics/metabase/collection/collection.test.ts

@@ -1,6 +1,136 @@
+import { createCollectionIfDoesNotExist } from "./service.js";
+import { getCollection } from "./getCollection.js";
+import nock from "nock";
+import { MetabaseError } from "../shared/client.js";
 import { $api } from "../../../../client/index.js";
 import { updateMetabaseId } from "./updateMetabaseId.js";
 import { getTeamIdAndMetabaseId } from "./getTeamIdAndMetabaseId.js";
+import { createCollection } from "./createCollection.js";
+
+describe("createCollectionIfDoesNotExist", () => {
+  beforeEach(() => {
+    nock.cleanAll();
+  });
+
+  test("creates new collection when metabase ID doesn't exist", async () => {
+    // Mock getTeamIdAndMetabaseId response with null metabase_id
+    vi.spyOn($api.client, "request").mockResolvedValueOnce({
+      teams: [
+        {
+          id: 26,
+          name: "Barnet",
+          metabase_id: null,
+        },
+      ],
+    });
+
+    // Mock Metabase API calls
+    const metabaseMock = nock(process.env.METABASE_URL_EXT!)
+      .post("/api/collection/", {
+        name: "Barnet",
+      })
+      .reply(200, {
+        id: 123,
+        name: "Barnet",
+      });
+
+    const collectionId = await createCollection({
+      name: "Barnet",
+    });
+
+    expect(collectionId).toBe(123);
+    expect(metabaseMock.isDone()).toBe(true);
+  });
+
+  test("successfully places new collection in parent", async () => {
+    // Mock updateMetabaseId response
+    vi.spyOn($api.client, "request").mockResolvedValueOnce({
+      update_teams: {
+        returning: [
+          {
+            id: 26,
+            name: "Barnet",
+            metabase_id: 123,
+          },
+        ],
+      },
+    });
+
+    const testName = "Example council";
+    const metabaseMock = nock(process.env.METABASE_URL_EXT!);
+
+    // Mock collection creation endpoint
+    metabaseMock
+      .post("/api/collection/", {
+        name: testName,
+        parent_id: 100,
+      })
+      .reply(200, {
+        id: 123,
+        name: testName,
+        parent_id: 100,
+      });
+
+    // Mock GET request for verifying the new collection
+    metabaseMock.get("/api/collection/123").reply(200, {
+      id: 123,
+      name: testName,
+      parent_id: 100,
+    });
+
+    const collectionId = await createCollection({
+      name: testName,
+      parentId: 100,
+    });
+
+    // Check the ID is returned correctly
+    expect(collectionId).toBe(123);
+
+    // Verify the collection details using the service function
+    const collection = await getCollection(collectionId);
+    expect(collection.parent_id).toBe(100);
+    expect(metabaseMock.isDone()).toBe(true);
+  });
+
+  test("returns collection correctly no matter collection name case", async () => {
+    vi.spyOn($api.client, "request").mockResolvedValueOnce({
+      teams: [
+        {
+          id: 26,
+          name: "barnet",
+          metabaseId: 20,
+        },
+      ],
+    });
+
+    const collection = await getTeamIdAndMetabaseId("BARNET");
+    expect(collection.metabaseId).toBe(20);
+  });
+
+  test("throws error if network failure", async () => {
+    nock(process.env.METABASE_URL_EXT!)
+      .get("/api/collection/")
+      .replyWithError("Network error occurred");
+
+    await expect(
+      createCollection({
+        name: "Test Collection",
+      }),
+    ).rejects.toThrow("Network error occurred");
+  });
+
+  test("throws error if API error", async () => {
+    nock(process.env.METABASE_URL_EXT!).get("/api/collection/").reply(400, {
+      message: "Bad request",
+    });
+
+    await expect(
+      createCollection({
+        name: "Test Collection",
+      }),
+    ).rejects.toThrow(MetabaseError);
+  });
+});
 
 describe("getTeamIdAndMetabaseId", () => {
   beforeEach(() => {
@@ -90,3 +220,59 @@ describe("updateMetabaseId", () => {
     await expect(updateMetabaseId(1, 123)).rejects.toThrow("GraphQL error");
   });
 });
+
+describe("edge cases", () => {
+  beforeEach(() => {
+    nock.cleanAll();
+    vi.clearAllMocks();
+    vi.resetAllMocks();
+  });
+
+  test("handles missing name", async () => {
+    await expect(
+      createCollectionIfDoesNotExist({
+        name: "",
+      }),
+    ).rejects.toThrow();
+  });
+
+  test("handles names with special characters", async () => {
+    const specialName = "@#$%^&*";
+
+    nock(process.env.METABASE_URL_EXT!).get("/api/collection/").reply(200, []);
+
+    nock(process.env.METABASE_URL_EXT!)
+      .post("/api/collection/", {
+        name: specialName,
+      })
+      .reply(200, {
+        id: 789,
+        name: specialName,
+      });
+
+    const collection = await createCollection({
+      name: specialName,
+    });
+    expect(collection).toBe(789);
+  });
+
+  test("handles very long names", async () => {
+    const longName = "A".repeat(101);
+
+    nock(process.env.METABASE_URL_EXT!).get("/api/collection/").reply(200, []);
+
+    nock(process.env.METABASE_URL_EXT!)
+      .post("/api/collection/", {
+        name: longName,
+      })
+      .reply(400, {
+        message: "Name too long",
+      });
+
+    await expect(
+      createCollectionIfDoesNotExist({
+        name: longName,
+      }),
+    ).rejects.toThrow();
+  });
+});

api.planx.uk/modules/analytics/metabase/collection/controller.ts

@@ -0,0 +1,18 @@
+import { createCollectionIfDoesNotExist } from "./service.js";
+import type { NewCollectionRequestHandler } from "./types.js";
+
+export const MetabaseCollectionsController: NewCollectionRequestHandler =
+  async (_req, res) => {
+    try {
+      const params = res.locals.parsedReq.body;
+      const collection = await createCollectionIfDoesNotExist(params);
+      res.status(201).json({ data: collection });
+    } catch (error) {
+      res.status(400).json({
+        error:
+          error instanceof Error
+            ? error.message
+            : "An unexpected error occurred",
+      });
+    }
+  };

api.planx.uk/modules/analytics/metabase/collection/createCollection.ts

@@ -0,0 +1,20 @@
+import { createMetabaseClient } from "../shared/client.js";
+import type { NewCollectionParams } from "./types.js";
+
+const client = createMetabaseClient();
+
+export async function createCollection(
+  params: NewCollectionParams,
+): Promise<any> {
+  const transformedParams = {
+    name: params.name,
+    parent_id: params.parentId,
+  };
+
+  const response = await client.post(`/api/collection/`, transformedParams);
+
+  console.log(
+    `New collection: ${response.data.name}, new collection ID: ${response.data.id}`,
+  );
+  return response.data.id;
+}

api.planx.uk/modules/analytics/metabase/collection/getCollection.ts

@@ -0,0 +1,15 @@
+import { createMetabaseClient } from "../shared/client.js";
+import type { GetCollectionResponse } from "./types.js";
+
+const client = createMetabaseClient();
+/**
+ * Retrieves info on a collection from Metabase, use to check a parent. Currently only used in tests but could be useful for other Metabase functionality
+ * @param id
+ * @returns
+ */
+export async function getCollection(
+  id: number,
+): Promise<GetCollectionResponse> {
+  const response = await client.get(`/api/collection/${id}`);
+  return response.data;
+}

api.planx.uk/modules/analytics/metabase/collection/service.ts

@@ -0,0 +1,33 @@
+import { updateMetabaseId } from "./updateMetabaseId.js";
+import type { NewCollectionParams } from "./types.js";
+import { getTeamIdAndMetabaseId } from "./getTeamIdAndMetabaseId.js";
+import { createCollection } from "./createCollection.js";
+
+/**
+ * First uses name to get teams.id and .metabase_id, if present.
+ * If metabase_id is null, return an object that includes its id. If not, create the collection.
+ * @params `name` is required, but `description` and `parent_id` are optional.
+ * @returns `response.data`, so use dot notation to access `id` or `parent_id`.
+ */
+export async function createCollectionIfDoesNotExist(
+  params: NewCollectionParams,
+): Promise<number> {
+  try {
+    const { metabaseId, id: teamId } = await getTeamIdAndMetabaseId(
+      params.name,
+    );
+
+    if (metabaseId) {
+      return metabaseId;
+    }
+
+    // Create new Metabase collection if !metabaseId
+    const newMetabaseId = await createCollection(params);
+    await updateMetabaseId(teamId, newMetabaseId);
+    console.log({ newMetabaseId });
+    return newMetabaseId;
+  } catch (error) {
+    console.error("Error in createCollectionIfDoesNotExist:", error);
+    throw error;
+  }
+}

api.planx.uk/modules/analytics/metabase/collection/types.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import type { ValidatedRequestHandler } from "../../../../shared/middleware/validate.js";
+
+type ApiResponse<T> = {
+  data?: T;
+  error?: string;
+};
+
+/** Interface for incoming request, in camelCase */
+export interface NewCollectionParams {
+  name: string;
+  description?: string;
+  /** Optional; if the collection is a child of a parent, specify parent ID here */
+  parentId?: number;
+}
+
+/** Interface for request after transforming to snake case (Metabase takes snake while PlanX API takes camel) */
+export interface MetabaseCollectionParams {
+  name: string;
+  description?: string;
+  parent_id?: number;
+}
+
+/** Metbase collection ID for the the "Council" collection **/
+// const COUNCILS_COLLECTION_ID = 58;
+
+export const createCollectionIfDoesNotExistSchema = z.object({
+  body: z
+    .object({
+      name: z.string(),
+      description: z.string().optional(),
+      parentId: z.number().optional(), //.default(COUNCILS_COLLECTION_ID),
+    })
+    .transform((data) => ({
+      name: data.name,
+      description: data.description,
+      parent_id: data.parentId,
+    })),
+});
+
+export type NewCollectionRequestHandler = ValidatedRequestHandler<
+  typeof createCollectionIfDoesNotExistSchema,
+  ApiResponse<number>
+>;
+
+export interface NewCollectionResponse {
+  id: number;
+  name: string;
+}
+
+export interface GetCollectionResponse {
+  id: number;
+  name: string;
+  parent_id: number;
+}

api.planx.uk/modules/analytics/metabase/shared/client.test.ts

@@ -1,13 +1,10 @@
-import axios from "axios";
 import {
   validateConfig,
   createMetabaseClient,
   MetabaseError,
 } from "./client.js";
 import nock from "nock";
 
-const axiosCreateSpy = vi.spyOn(axios, "create");
-
 describe("Metabase client", () => {
   beforeEach(() => {
     vi.clearAllMocks();

api.planx.uk/modules/analytics/metabase/shared/client.ts

@@ -1,4 +1,5 @@
 import axios from "axios";
+import assert from "assert";
 import type {
   AxiosInstance,
   AxiosError,
@@ -52,7 +53,7 @@
 export const createMetabaseClient = (): AxiosInstance => {
   const config = validateConfig();
 
   const client = axios.create({
     baseURL: config.baseURL,
     headers: {
       "X-API-Key": config.apiKey,

api.planx.uk/modules/analytics/routes.ts

@@ -5,6 +5,8 @@ import {
   logUserExitController,
   logUserResumeController,
 } from "./analyticsLog/controller.js";
+import { MetabaseCollectionsController } from "./metabase/collection/controller.js";
+import { createCollectionIfDoesNotExistSchema } from "./metabase/collection/types.js";
 
 const router = Router();
 
@@ -18,5 +20,10 @@ router.post(
   validate(logAnalyticsSchema),
   logUserResumeController,
 );
+router.post(
+  "/collection",
+  validate(createCollectionIfDoesNotExistSchema),
+  MetabaseCollectionsController,
+);
 
 export default router;