wip: feat: collection service & controller

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

@@ -0,0 +1,18 @@
+import { newCollection } from "./service.js";
+import type { NewCollectionRequestHandler } from "./types.js";
+
+export const newCollectionController: NewCollectionRequestHandler = async (
+  _req,
+  res,
+) => {
+  try {
+    const params = res.locals.parsedReq.body;
+    const collection = await newCollection(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/service.ts

@@ -1,0 +1,90 @@
+import { MetabaseError, createMetabaseClient } from "../shared/client.js";
+import type { NewCollectionParams } from "./types.js";
+import { toSnakeCase } from "../shared/utils.js";
+
+const client = createMetabaseClient();
+
+export async function authentication(): Promise<boolean> {
+  try {
+    const response = await client.get("/user/current");
+    return response.status === 200;
+  } catch (error) {
+    console.error("Error testing Metabase connection:", error);
+    return false;
+  }
+}
+
+export async function newCollection({
+  name,
+  description,
+  parent_id,
+}: NewCollectionParams): Promise<any> {
+  try {
+    // Check if collection exists
+    const existingCollectionId = await checkCollections(name);
+    if (existingCollectionId) {
+      console.log(
+        `Collection "${name}" already exists with ID: ${existingCollectionId}`,
+      );
+      return existingCollectionId;
+    }
+
+    // If no existing collection, create new one
+    const requestBody = toSnakeCase({
+      name,
+      description,
+      parent_id,
+    });
+
+    // Remove undefined properties
+    Object.keys(requestBody).forEach(
+      (key) => requestBody[key] === undefined && delete requestBody[key],
+    );
+
+    const response = await client.post(`/api/collection/`, {
+      name,
+      description,
+      parent_id,
+    });
+    console.log(
+      `New collection: ${response.data.name}, new collection ID: ${response.data.id}`,
+    );
+    return response.data.id;
+  } catch (error) {
+    console.error("Error in newCollection:");
+    throw error;
+  }
+}
+
+/**
+ * Checks if a collection exists with name matching `teamName` exists.
+ * Returns the matching collection ID if exists, otherwise false. */
+export async function checkCollections(teamName: string): Promise<any> {
+  try {
+    console.log("Checking for collection: ", teamName);
+
+    // Get collections from Metabase
+    const response = await client.get(`/api/collection/`);
+
+    const matchingCollection = response.data.find((collection: any) =>
+      collection.name.toLowerCase().includes(teamName.toLowerCase()),
+    );
+
+    if (matchingCollection) {
+      console.log("Matching collection found with ID: ", matchingCollection.id);
+      return matchingCollection.id;
+    } else {
+      console.log("No matching collection found");
+      return undefined;
+    }
+  } catch (error) {
+    console.error("Error: ", error);
+    if (error instanceof MetabaseError) {
+      console.error("Metabase API error:", {
+        message: error.message,
+        statusCode: error.statusCode,
+      });
+    }
+    throw error;
+  }
+}

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { ValidatedRequestHandler } from "../../../../shared/middleware/validate.js";
+
+type ApiResponse<T> = {
+  data?: T;
+  error?: string;
+};
+
+export interface NewCollectionParams {
+  name: string;
+  description?: string;
+  /** Optional; if the collection is a child of a parent, specify parent ID here
+   * For council teams, parent collection should be 58
+   */
+  parent_id?: number;
+}
+
+/** Metbase collection ID for the the "Council" collection **/
+const COUNCIL_COLLECTION_ID = 58;
+
+export const newCollectionSchema = z.object({
+  body: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    parent_id: z.number().default(COUNCIL_COLLECTION_ID),
+  }),
+});
+
+export type NewCollectionRequestHandler = ValidatedRequestHandler<
+  typeof newCollectionSchema,
+  ApiResponse<NewCollectionResponse>
+>;
+
+export interface NewCollectionResponse {
+  id: number;
+  name: string;
+}

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

@@ -0,0 +1,40 @@
+export interface Input {
+  teamName: string;
+  originalDashboardId: number;
+  /** The name of the filter to be updated */
+  filter: string;
+  /** The value of the new filter; updateFilter() only supports strings right now */
+  filterValue: string;
+}
+
+export function validateInput(input: unknown): input is Input {
+  // check that input type is object
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+
+  // check that input object is same shape as Input type with same properties
+  const { teamName, originalDashboardId, filter, filterValue } = input as Input;
+
+  if (typeof teamName !== "string" || teamName.trim() === "") {
+    console.error("Invalid teamName: must be a non-empty string");
+    return false;
+  }
+
+  if (!Number.isInteger(originalDashboardId) || originalDashboardId <= 0) {
+    console.error("Invalid originalDashboardId: must be a positive integer");
+    return false;
+  }
+
+  if (typeof filter !== "string" || filter.trim() === "") {
+    console.error("Invalid filter: must be a non-empty string");
+    return false;
+  }
+
+  if (typeof filterValue !== "string") {
+    console.error("Invalid filterValue: must be a string");
+    return false;
+  }
+  console.log("Input valid");
+  return true;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Converts object keys from camelCase to snake_case
+ */
+export function toSnakeCase<T extends object>(obj: T): Record<string, unknown> {
+  return Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      // Convert camelCase to snake_case
+      const snakeKey = key.replace(
+        /[A-Z]/g,
+        (letter) => `_${letter.toLowerCase()}`,
+      );
+      acc[snakeKey] = value;
+      return acc;
+    },
+    {} as Record<string, unknown>,
+  );
+}
+
+/**
+ * Converts object keys from snake_case to camelCase
+ */
+export function toCamelCase<T extends object>(obj: T): Record<string, unknown> {
+  return Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      // Convert snake_case to camelCase
+      const camelKey = key.replace(/_([a-z])/g, (_, letter) =>
+        letter.toUpperCase(),
+      );
+      acc[camelKey] = value;
+      return acc;
+    },
+    {} as Record<string, unknown>,
+  );
+}