backup

Author: kushagra0304

package-lock.json

@@ -8,7 +8,7 @@ import { revalidateTag } from "next/cache";
 export async function createFolderAction(
   projectId: string,
   parentFolderId: string | null = null,
-  type: "query" | "plot" = "query",
+  type: "query" | "plot" | "stat" = "query",
   name?: string,
 ) {
   const user = await getServerUser();

packages/app/src/actions/data/folders/createFolder.ts

@@ -0,0 +1,76 @@
+"use server";
+
+import { updateStat, readStatForProject } from "@/db/crud/stat";
+import { StatDefinition, validateStatQueries, defaultQueryReference } from "@common/db/schema/stat";
+import { getServerUser } from "@/lib/auth";
+import { getProjectForUser } from "@/lib/dal/projects";
+import { revalidateStatCache } from "@/lib/dal/stats";
+import { notFound } from "next/navigation";
+
+export async function addQueryToStatAction(
+  statId: string,
+  projectId: string,
+  queryId: string,
+  columnName: string,
+  isComputedColumn: boolean = false,
+  label?: string,
+  unit?: string,
+) {
+  const user = await getServerUser();
+
+  if (!user) {
+    throw new Error("Unauthorized");
+  }
+
+  const project = await getProjectForUser(user, projectId);
+
+  if (!project) {
+    notFound();
+  }
+
+  const stat = await readStatForProject(projectId, statId);
+
+  if (!stat) {
+    throw new Error("Stat not found");
+  }
+
+  const currentDefinition = stat.definition || { queries: [] };
+
+  // Check if we already have 4 queries
+  if (currentDefinition.queries.length >= 4) {
+    throw new Error("Maximum of 4 queries allowed");
+  }
+
+  // Check if this query+column combination already exists
+  const existingQuery = currentDefinition.queries.find(
+    q => q.queryId === queryId && q.columnName === columnName
+  );
+
+  if (existingQuery) {
+    throw new Error("This query and column combination already exists");
+  }
+
+  const newQuery = {
+    ...defaultQueryReference,
+    queryId,
+    columnName,
+    isComputedColumn,
+    label: label || null,
+    unit: unit || null,
+  };
+
+  const updatedDefinition: StatDefinition = {
+    queries: [...currentDefinition.queries, newQuery],
+  };
+
+  // Validate the updated definition
+  if (!validateStatQueries(updatedDefinition)) {
+    throw new Error("Invalid query configuration");
+  }
+
+  await updateStat(statId, {
+    definition: updatedDefinition,
+  });
+
+  revalidateStatCache(statId, projectId);
+}

packages/app/src/actions/data/stats/addQueryToStatAction.ts

@@ -0,0 +1,34 @@
+"use server";
+
+import { getServerUser } from "@/lib/auth";
+import { revalidateTag } from "next/cache";
+import { redirect } from "next/navigation";
+import { getProjectForUser } from "@/lib/dal/projects";
+
+import { createStat, generateUniqueStatName } from "@/db/crud/stat";
+import { defaultStatDefinition } from "@common/db/schema/stat";
+
+export async function createStatAction(
+  projectId: string,
+  folderId?: string | null,
+) {
+  const user = await getServerUser();
+  const userProject = await getProjectForUser(user, projectId);
+
+  if (!userProject) {
+    throw new Error("Project not found");
+  }
+
+  const name = await generateUniqueStatName(projectId);
+  const newStat = await createStat({
+    name,
+    projectId,
+    folderId: folderId || null,
+    definition: defaultStatDefinition,
+  });
+
+  revalidateTag(`project-${projectId}-stats`);
+  revalidateTag(`project-${projectId}-data`);
+
+  redirect(`/projects/${projectId}/data/stats/${newStat.id}`);
+}

packages/app/src/actions/data/stats/createStatAction.ts

@@ -0,0 +1,26 @@
+"use server";
+
+import { getServerUser } from "@/lib/auth";
+import { getProjectForUser } from "@/lib/dal/projects";
+import { readStatForProject, deleteStat } from "@/db/crud/stat";
+import { revalidateTag } from "next/cache";
+
+export async function deleteStatAction(projectId: string, statId: string) {
+  const user = await getServerUser();
+  const userProject = await getProjectForUser(user, projectId);
+
+  if (!userProject) {
+    throw new Error("Project not found");
+  }
+
+  const stat = await readStatForProject(projectId, statId);
+
+  if (!stat) {
+    throw new Error("Stat not found");
+  }
+
+  await deleteStat(statId);
+
+  revalidateTag(`project-${projectId}-stats`);
+  revalidateTag(`project-${projectId}-data`);
+}

packages/app/src/actions/data/stats/deleteStatAction.ts

@@ -0,0 +1,109 @@
+"use server";
+
+import { getServerUser } from "@/lib/auth";
+import { getProjectForUser } from "@/lib/dal/projects";
+import { getQueryForProject } from "@/lib/dal/queries";
+import { readDataForQuery } from "@/db/crud/data/query";
+import { readQueryZones } from "@/db/crud/zone";
+
+export async function getQueryDataForStatsAction(
+  projectId: string,
+  queryId: string,
+  columnName: string,
+) {
+  const user = await getServerUser();
+
+  if (!user) {
+    throw new Error("Unauthorized");
+  }
+
+  const project = await getProjectForUser(user, projectId);
+
+  if (!project) {
+    throw new Error("Project not found");
+  }
+
+  const query = await getQueryForProject(projectId, queryId);
+
+  if (!query || !query.definition) {
+    throw new Error("Query not found or not configured");
+  }
+
+  // Get zones for the query
+  const zones = await readQueryZones(queryId);
+
+  // Fetch data for the query
+  const data = await readDataForQuery(
+    projectId,
+    query.definition,
+    undefined, // No pagination - get all data
+    undefined, // No filters
+    zones.map((zone) => zone.zoneId),
+  );
+
+  // Extract values for the specified column
+  const columnValues = data
+    .map((row) => row[columnName])
+    .filter((value) => value !== null && value !== undefined);
+
+  // Convert to numbers and filter out non-numeric values
+  const numericValues = columnValues
+    .map((value) => {
+      const num = typeof value === 'number' ? value : parseFloat(String(value));
+      return isNaN(num) ? null : num;
+    })
+    .filter((value) => value !== null) as number[];
+
+  // Calculate statistics
+  const stats = calculateStatistics(numericValues);
+
+  return {
+    values: numericValues,
+    rawData: data, // Add raw data for histogram visualization
+    stats,
+    totalRows: data.length,
+    validNumericRows: numericValues.length,
+  };
+}
+
+function calculateStatistics(values: number[]) {
+  if (values.length === 0) {
+    return {
+      mean: null,
+      median: null,
+      stdDev: null,
+      min: null,
+      max: null,
+      range: null,
+      count: 0,
+    };
+  }
+
+  const sorted = [...values].sort((a, b) => a - b);
+  const sum = values.reduce((acc, val) => acc + val, 0);
+  const mean = sum / values.length;
+
+  // Calculate median
+  const mid = Math.floor(sorted.length / 2);
+  const median = sorted.length % 2 === 0
+    ? (sorted[mid - 1] + sorted[mid]) / 2
+    : sorted[mid];
+
+  // Calculate standard deviation
+  const variance = values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / values.length;
+  const stdDev = Math.sqrt(variance);
+
+  const min = sorted[0];
+  const max = sorted[sorted.length - 1];
+  const range = max - min;
+
+  return {
+    mean: Math.round(mean * 100) / 100,
+    median: Math.round(median * 100) / 100,
+    stdDev: Math.round(stdDev * 100) / 100,
+    min,
+    max,
+    range: Math.round(range * 100) / 100,
+    count: values.length,
+  };
+}

packages/app/src/actions/data/stats/getQueryDataForStats.ts

@@ -0,0 +1,34 @@
+"use server";
+
+import { getServerUser } from "@/lib/auth";
+import { readStatForProject, updateStat } from "@/db/crud/stat";
+import { getProjectForUser } from "@/lib/dal/projects";
+import { revalidateTag } from "next/cache";
+
+export async function moveStatAction(
+  projectId: string,
+  statId: string,
+  newFolderId: string | null,
+) {
+  const user = await getServerUser();
+  const userProject = await getProjectForUser(user, projectId);
+
+  if (!userProject) {
+    throw new Error("Project not found");
+  }
+
+  const stat = await readStatForProject(projectId, statId);
+
+  if (!stat) {
+    throw new Error("Stat not found");
+  }
+
+  const updatedStat = await updateStat(statId, {
+    folderId: newFolderId,
+  });
+
+  revalidateTag(`project-${projectId}-stats`);
+  revalidateTag(`project-${projectId}-data`);
+
+  return updatedStat;
+}

packages/app/src/actions/data/stats/moveStatAction.ts

@@ -0,0 +1,55 @@
+"use server";
+
+import { updateStat, readStatForProject } from "@/db/crud/stat";
+import { StatDefinition, validateStatQueries } from "@common/db/schema/stat";
+import { getServerUser } from "@/lib/auth";
+import { getProjectForUser } from "@/lib/dal/projects";
+import { revalidateStatCache } from "@/lib/dal/stats";
+import { notFound } from "next/navigation";
+
+export async function removeQueryFromStatAction(
+  statId: string,
+  projectId: string,
+  queryId: string,
+  columnName: string,
+) {
+  const user = await getServerUser();
+
+  if (!user) {
+    throw new Error("Unauthorized");
+  }
+
+  const project = await getProjectForUser(user, projectId);
+
+  if (!project) {
+    notFound();
+  }
+
+  const stat = await readStatForProject(projectId, statId);
+
+  if (!stat) {
+    throw new Error("Stat not found");
+  }
+
+  const currentDefinition = stat.definition || { queries: [] };
+
+  // Remove the specified query
+  const updatedQueries = currentDefinition.queries.filter(
+    q => !(q.queryId === queryId && q.columnName === columnName)
+  );
+
+  const updatedDefinition: StatDefinition = {
+    queries: updatedQueries,
+  };
+
+  // Validate the updated definition
+  if (!validateStatQueries(updatedDefinition)) {
+    throw new Error("Invalid query configuration");
+  }
+
+  await updateStat(statId, {
+    definition: updatedDefinition,
+  });
+
+  revalidateStatCache(statId, projectId);
+}