Blame for src/lib/tools.ts

import { randomUUID } from "node:crypto";
import { BigQuery } from "@google-cloud/bigquery";
import type { SupplyChainTool, ToolCategory } from "@/lib/tool-types";
import { categories } from "@/lib/tool-types";

type NewTool = Omit<
  SupplyChainTool,
  "id" | "slug" | "createdAt" | "averageRating" | "ratingCount"
>;

type DemoState = {
  tools: SupplyChainTool[];
  ratings: Map<string, number>;
};

declare global {
  var __chainkitDemoState: DemoState | undefined;
}

const demoTools: SupplyChainTool[] = [
  {
    id: "intelligent-supply-chain",
    slug: "intelligent-supply-chain-management",
    name: "Intelligent Supply Chain Management",
    summary:
      "Azure ML accelerator using deep-learning forecasts and distributed computing to simulate inventory optimization.",
    category: "Planning",
    repoUrl: "https://github.com/MSUSAzureAccelerators/Intelligent-Supply-Chain-Management",
    websiteUrl: "",
    submittedBy: "Chainkit demo",
    createdAt: "2026-11-06T10:00:00.000Z",
    averageRating: 0,
    ratingCount: 0,
  },
  {
    id: "scimai-gym",
    slug: "scimai-gym",
    name: "SCIMAI Gym",
    summary:
      "Python environment for supply-chain inventory management experiments with deep reinforcement learning.",
    category: "Planning",
    repoUrl: "https://github.com/frenkowski/SCIMAI-Gym",
    websiteUrl: "",
    submittedBy: "Chainkit demo",
    createdAt: "2026-11-06T10:00:00.000Z",
    averageRating: 0,
    ratingCount: 0,
  },
  {
    id: "product-demand-forecasting",
    slug: "product-demand-forecasting-ml",
    name: "Product Demand Forecasting with ML",
    summary:
      "Machine-learning project exploring product demand forecasting for supply-chain planning.",
    category: "Planning",
    repoUrl: "https://github.com/trydoff/Product-Demand-Forecasting-Using-ML",
    websiteUrl: "",
    submittedBy: "Chainkit demo",
    createdAt: "2026-11-06T10:00:00.000Z",
    averageRating: 0,
    ratingCount: 0,
  },
  {
    id: "timefold-solver",
    slug: "timefold-solver",
    name: "Timefold Solver",
    summary:
      "Open-source AI solver for vehicle routing, task assignment, and other operational planning problems.",
    category: "Logistics",
    repoUrl: "https://github.com/TimefoldAI/timefold-solver",
    websiteUrl: "",
    submittedBy: "Chainkit demo",
    createdAt: "2026-11-06T10:00:00.000Z",
    averageRating: 0,
    ratingCount: 0,
  },
  {
    id: "late-delivery-prediction",
    slug: "supply-chain-late-delivery-prediction",
    name: "Late Delivery Prediction",
    summary:
      "Industrial ML pipeline for shipment-delay prediction with model comparisons and a Streamlit batch app.",
    category: "Visibility",
    repoUrl: "https://github.com/workkrishnpatel/supply-chain-late-delivery-prediction",
    websiteUrl: "",
    submittedBy: "Chainkit demo",
    createdAt: "2026-11-06T10:00:00.000Z",
    averageRating: 0,
    ratingCount: 0,
  },
  {
    id: "ai-warehouse-slotting",
    slug: "ai-warehouse-slotting",
    name: "AI Warehouse Slotting",
    summary:
      "Warehouse-management prototype integrating ML demand forecasting and dynamic slotting optimization.",
    category: "Warehousing",
    repoUrl: "https://github.com/ArwaElsayed5/Graduation-Project",
    websiteUrl: "",
    submittedBy: "Chainkit demo",
    createdAt: "2026-11-06T10:00:00.000Z",
    averageRating: 0,
    ratingCount: 0,
  },
  {
    id: "fraudlens-ai",
    slug: "fraudlens-ai",
    name: "FraudLens AI",
    summary:
      "Procurement audit prototype that applies anomaly detection and NLP to flag suspicious bid and vendor patterns.",
    category: "Procurement",
    repoUrl: "https://github.com/thenishantraj/fraudlens-ai",
    websiteUrl: "",
    submittedBy: "Chainkit demo",
    createdAt: "2026-11-06T10:00:00.000Z",
    averageRating: 0,
    ratingCount: 0,
  },
];

function getDemoState(): DemoState {
  globalThis.__chainkitDemoState ??= {
    tools: demoTools.map((tool) => ({ ...tool })),
    ratings: new Map(),
  };
  return globalThis.__chainkitDemoState;
}

function getBigQueryConfig() {
  const projectId = process.env.BIGQUERY_PROJECT_ID;
  const dataset = process.env.BIGQUERY_DATASET;
  if (!projectId && !dataset) return undefined;
  if (!projectId || !dataset) {
    throw new Error(
      "Set both BIGQUERY_PROJECT_ID and BIGQUERY_DATASET to enable BigQuery.",
    );
  }
  if (!/^[a-z][a-z0-9-]{4,28}[a-z0-9]$/.test(projectId)) {
    throw new Error("BIGQUERY_PROJECT_ID is not a valid Google Cloud project ID.");
  }
  if (!/^[A-Za-z0-9_]{1,1024}$/.test(dataset)) {
    throw new Error("BIGQUERY_DATASET contains unsupported characters.");
  }
  return { projectId, dataset };
}

let bigQueryClient: BigQuery | undefined;

function getBigQuery() {
  const config = getBigQueryConfig();
  if (!config) return undefined;
  bigQueryClient ??= new BigQuery({ projectId: config.projectId });
  return { client: bigQueryClient, ...config };
}

function toolTable(projectId: string, dataset: string) {
  return `\`${projectId}.${dataset}.tools\``;
}

function ratingTable(projectId: string, dataset: string) {
  return `\`${projectId}.${dataset}.tool_ratings\``;
}

function isToolCategory(value: string): value is ToolCategory {
  return categories.some((item) => item === value);
}

function mapBigQueryRow(row: Record<string, unknown>): SupplyChainTool {
  const category = String(row.category);
  if (!isToolCategory(category)) {
    throw new Error(`BigQuery returned an unsupported category: ${category}`);
  }
  return {
    id: String(row.id),
    slug: String(row.slug),
    name: String(row.name),
    summary: String(row.summary),
    category,
    repoUrl: String(row.repoUrl),
    websiteUrl: String(row.websiteUrl ?? ""),
    submittedBy: String(row.submittedBy),
    createdAt: new Date(String(row.createdAt)).toISOString(),
    averageRating: Number(row.averageRating ?? 0),
    ratingCount: Number(row.ratingCount ?? 0),
  };
}

function buildToolQuery(
  projectId: string,
  dataset: string,
  where = "",
  order = "",
) {
  return `
    SELECT
      t.tool_id AS id,
      t.slug,
      t.name,
      t.summary,
      t.category,
      t.repo_url AS repoUrl,
      t.website_url AS websiteUrl,
      t.submitted_by AS submittedBy,
      t.created_at AS createdAt,
      COALESCE(AVG(r.rating), 0) AS averageRating,
      COUNT(r.rating) AS ratingCount
    FROM ${toolTable(projectId, dataset)} AS t
    LEFT JOIN ${ratingTable(projectId, dataset)} AS r
      ON t.tool_id = r.tool_id
    ${where}
    GROUP BY
      t.tool_id, t.slug, t.name, t.summary, t.category, t.repo_url,
      t.website_url, t.submitted_by, t.created_at
    ${order}
  `;
}

export async function getTools(): Promise<SupplyChainTool[]> {
  const bigQuery = getBigQuery();
  if (!bigQuery) return getDemoState().tools;

  const [rows] = await bigQuery.client.query({
    query: buildToolQuery(
      bigQuery.projectId,
      bigQuery.dataset,
      "",
      "ORDER BY t.created_at DESC",
    ),
  });
  return rows.map(mapBigQueryRow);
}

export async function getToolBySlug(slug: string) {
  const bigQuery = getBigQuery();
  if (!bigQuery) {
    return getDemoState().tools.find((tool) => tool.slug === slug);
  }
  const [rows] = await bigQuery.client.query({
    query: `${buildToolQuery(
      bigQuery.projectId,
      bigQuery.dataset,
      "WHERE t.slug = @slug",
    )} LIMIT 1`,
    params: { slug },
  });
  return rows[0] ? mapBigQueryRow(rows[0]) : undefined;
}

async function getToolById(toolId: string) {
  const bigQuery = getBigQuery();
  if (!bigQuery) {
    return getDemoState().tools.find((tool) => tool.id === toolId);
  }
  const [rows] = await bigQuery.client.query({
    query: `${buildToolQuery(
      bigQuery.projectId,
      bigQuery.dataset,
      "WHERE t.tool_id = @toolId",
    )} LIMIT 1`,
    params: { toolId },
  });
  return rows[0] ? mapBigQueryRow(rows[0]) : undefined;
}

export async function submitTool(input: NewTool) {
  const createdAt = new Date().toISOString();
  const id = randomUUID();
  const slugBase =
    input.name
      .toLowerCase()
      .normalize("NFKD")
      .replace(/[\u0300-\u036f]/g, "")
      .replace(/[^a-z0-9]+/g, "-")
      .replace(/^-|-$/g, "")
      .slice(0, 48) || "supply-chain-tool";
  const tool: SupplyChainTool = {
    ...input,
    id,
    slug: `${slugBase}-${id.slice(0, 8)}`,
    createdAt,
    averageRating: 0,
    ratingCount: 0,
  };
  const bigQuery = getBigQuery();

  if (!bigQuery) {
    getDemoState().tools.unshift(tool);
    return tool;
  }

  await bigQuery.client.query({
    query: `
      INSERT INTO ${toolTable(bigQuery.projectId, bigQuery.dataset)}
        (tool_id, slug, name, summary, category, repo_url, website_url, submitted_by, created_at)
      VALUES
        (@id, @slug, @name, @summary, @category, @repoUrl, @websiteUrl, @submittedBy, TIMESTAMP(@createdAt))
    `,
    params: {
      id: tool.id,
      slug: tool.slug,
      name: tool.name,
      summary: tool.summary,
      category: tool.category,
      repoUrl: tool.repoUrl,
      websiteUrl: tool.websiteUrl,
      submittedBy: tool.submittedBy,
      createdAt: tool.createdAt,
    },
  });
  return tool;
}

export async function rateTool(toolId: string, voterId: string, rating: number) {
  const bigQuery = getBigQuery();
  if (!bigQuery) {
    const state = getDemoState();
    const tool = state.tools.find((candidate) => candidate.id === toolId);
    if (!tool) return undefined;

    const key = `${toolId}:${voterId}`;
    const previousRating = state.ratings.get(key);
    const total = tool.averageRating * tool.ratingCount;
    const nextCount = tool.ratingCount + (previousRating === undefined ? 1 : 0);
    const nextTotal = total - (previousRating ?? 0) + rating;
    state.ratings.set(key, rating);
    tool.averageRating = Number((nextTotal / nextCount).toFixed(1));
    tool.ratingCount = nextCount;
    return tool;
  }

  const tool = await getToolById(toolId);
  if (!tool) return undefined;

  await bigQuery.client.query({
    query: `
      MERGE ${ratingTable(bigQuery.projectId, bigQuery.dataset)} AS target
      USING (SELECT @toolId AS tool_id, @voterId AS voter_id, @rating AS rating) AS source
        ON target.tool_id = source.tool_id AND target.voter_id = source.voter_id
      WHEN MATCHED THEN
        UPDATE SET rating = source.rating, updated_at = CURRENT_TIMESTAMP()
      WHEN NOT MATCHED THEN
        INSERT (tool_id, voter_id, rating, created_at, updated_at)
        VALUES (source.tool_id, source.voter_id, source.rating, CURRENT_TIMESTAMP(), CURRENT_TIMESTAMP())
    `,
    params: { toolId, voterId, rating },
  });
  return getToolById(toolId);
}