thryve-mcp-server 0.0.1

package/src/tools/search-filters.ts

@@ -0,0 +1,253 @@
+import type { Request } from "express";
+import type { z } from "zod";
+import type { SearchFiltersSchema } from "../schemas.js";
+import type { HealthDataRecord } from "../types.js";
+import {
+  extractThryveHeaders,
+  buildUrlEncodedBody,
+  getDefaultDateRange,
+  getDefaultTimestampRange,
+  THRYVE_API_BASE_URL,
+  sortHealthData,
+  paginateResults,
+} from "../helpers.js";
+import { getDataTypeIdsForCategories, CATEGORY_MAPPINGS, type HealthCategory } from "../category-mappings.js";
+import { flattenThryveResponse, enrichWithDataTypes } from "../data-enrichment.js";
+
+export async function searchFilters(req: Request, args: z.infer<typeof SearchFiltersSchema>) {
+  const { headers, authToken } = extractThryveHeaders(req);
+
+  // Determine date/timestamp ranges
+  let startDay: string;
+  let endDay: string;
+  let startTimestamp: string;
+  let endTimestamp: string;
+
+  // Prefer explicit timestamps if provided, otherwise use dates
+  if (args.startTimestamp || args.endTimestamp) {
+    const defaults = getDefaultTimestampRange();
+    startTimestamp = args.startTimestamp || defaults.startTimestamp;
+    endTimestamp = args.endTimestamp || defaults.endTimestamp;
+    // Extract dates from timestamps
+    startDay = startTimestamp.split('T')[0];
+    endDay = endTimestamp.split('T')[0];
+  } else if (args.startDate || args.endDate) {
+    const defaults = getDefaultDateRange();
+    startDay = args.startDate || defaults.startDay;
+    endDay = args.endDate || defaults.endDay;
+    startTimestamp = `${startDay}T00:00:00Z`;
+    endTimestamp = `${endDay}T23:59:59Z`;
+  } else {
+    const defaults = getDefaultDateRange();
+    startDay = defaults.startDay;
+    endDay = defaults.endDay;
+    startTimestamp = `${startDay}T00:00:00Z`;
+    endTimestamp = `${endDay}T23:59:59Z`;
+  }
+
+  // Convert dataSources array to comma-separated string
+  const dataSourcesParam = args.dataSources?.join(',');
+
+  // Determine resolution (default: "both")
+  const resolution = args.resolution || "both";
+
+  // Fetch data based on resolution
+  const fetchPromises: Promise<Response>[] = [];
+
+  if (resolution === "daily" || resolution === "both") {
+    const dailyBody = buildUrlEncodedBody({
+      authenticationToken: authToken,
+      startDay,
+      endDay,
+      dataSources: dataSourcesParam,
+      displayTypeName: "true",
+    });
+
+    fetchPromises.push(
+      fetch(`${THRYVE_API_BASE_URL}/v5/dailyDynamicValues`, {
+        method: "POST",
+        headers,
+        body: dailyBody,
+      })
+    );
+  }
+
+  if (resolution === "epoch" || resolution === "both") {
+    const epochBody = buildUrlEncodedBody({
+      authenticationToken: authToken,
+      startTimestamp,
+      endTimestamp,
+      dataSources: dataSourcesParam,
+      displayTypeName: "true",
+    });
+
+    fetchPromises.push(
+      fetch(`${THRYVE_API_BASE_URL}/v5/dynamicEpochValues`, {
+        method: "POST",
+        headers,
+        body: epochBody,
+      })
+    );
+  }
+
+  const responses = await Promise.all(fetchPromises);
+
+  // Check for errors
+  for (const response of responses) {
+    if (!response.ok) {
+      throw new Error(`Thryve API error: ${response.status} ${response.statusText}`);
+    }
+  }
+
+  // Parse responses
+  const jsonData = await Promise.all(responses.map(r => r.json()));
+
+  // Flatten and enrich data
+  let allData: HealthDataRecord[] = [];
+  for (const data of jsonData) {
+    const flattened = flattenThryveResponse(data);
+    enrichWithDataTypes(flattened);
+    allData = allData.concat(flattened);
+  }
+
+  // Apply filters
+  let filteredData = allData;
+
+  // Filter by categories (convert to data type IDs)
+  if (args.categories && args.categories.length > 0) {
+    const categoryDataTypeIds = getDataTypeIdsForCategories(args.categories as HealthCategory[]);
+    const dataTypeIdSet = new Set(categoryDataTypeIds);
+
+    filteredData = filteredData.filter((record) => {
+      const typeId = record.dataType || record.dailyDynamicValueType || record.dynamicEpochValueType;
+      return typeId && dataTypeIdSet.has(typeId);
+    });
+  }
+
+  // Filter by specific data type IDs
+  if (args.dataTypes && args.dataTypes.length > 0) {
+    const dataTypeIdSet = new Set(args.dataTypes);
+    filteredData = filteredData.filter((record) => {
+      const typeId = record.dataType || record.dailyDynamicValueType || record.dynamicEpochValueType;
+      return typeId !== undefined && dataTypeIdSet.has(typeId);
+    });
+  }
+
+  // Filter by value range
+  if (args.valueMin !== undefined || args.valueMax !== undefined) {
+    filteredData = filteredData.filter((record) => {
+      const value = typeof record.value === "string" ? parseFloat(record.value) : record.value;
+      if (isNaN(value)) return false;
+
+      if (args.valueMin !== undefined && value < args.valueMin) return false;
+      if (args.valueMax !== undefined && value > args.valueMax) return false;
+
+      return true;
+    });
+  }
+
+  // Apply limit if specified (before pagination/grouping)
+  if (args.limit) {
+    filteredData = filteredData.slice(0, args.limit);
+  }
+
+  // Check if we should group by category
+  if (args.groupByCategory && args.categories && args.categories.length > 0) {
+    // Group results by category (like getDailyData/getEpochData)
+    const groupedResults = groupByCategory(filteredData, args.categories as HealthCategory[]);
+
+    // Build metadata
+    const dataTypesFound = new Set<string>();
+    filteredData.forEach((record) => {
+      const typeName = record.dailyDynamicValueTypeName || record.dynamicEpochValueTypeName;
+      if (typeName) dataTypesFound.add(typeName);
+    });
+
+    const metadata = {
+      resolution,
+      categories: args.categories,
+      timeRange: {
+        start: startTimestamp,
+        end: endTimestamp,
+      },
+      totalRecords: filteredData.length,
+      dataTypesFound: Array.from(dataTypesFound).sort(),
+      dataSources: args.dataSources,
+      filters: {
+        dataTypes: args.dataTypes,
+        valueMin: args.valueMin,
+        valueMax: args.valueMax,
+      },
+      limitApplied: args.limit,
+    };
+
+    return {
+      results: groupedResults,
+      metadata,
+    };
+  } else {
+    // Return flat paginated results (original behavior)
+    const sortedData = sortHealthData(filteredData, args.sortBy, args.sortOrder);
+    const paginatedResult = paginateResults(sortedData, args.page, args.pageSize);
+
+    return {
+      ...paginatedResult,
+      resolution,
+      filters: {
+        dataTypes: args.dataTypes,
+        dataSources: args.dataSources,
+        categories: args.categories,
+        startDate: startDay,
+        endDate: endDay,
+        startTimestamp: args.startTimestamp,
+        endTimestamp: args.endTimestamp,
+        valueMin: args.valueMin,
+        valueMax: args.valueMax,
+        limitApplied: args.limit,
+      },
+    };
+  }
+}
+
+/**
+ * Group records by requested categories
+ * (Copied from getDailyData/getEpochData for compatibility)
+ */
+function groupByCategory(
+  records: HealthDataRecord[],
+  requestedCategories: HealthCategory[]
+): Record<string, HealthDataRecord[]> {
+  const grouped: Record<string, HealthDataRecord[]> = {};
+
+  // Initialize structure for requested categories
+  for (const category of requestedCategories) {
+    grouped[category] = [];
+  }
+
+  // Get category data type IDs for matching
+  const categoryDataTypes = new Map<number, HealthCategory[]>();
+  for (const category of requestedCategories) {
+    const mapping = CATEGORY_MAPPINGS[category];
+    if (mapping) {
+      for (const dataTypeId of mapping.dataTypeIds) {
+        if (!categoryDataTypes.has(dataTypeId)) {
+          categoryDataTypes.set(dataTypeId, []);
+        }
+        categoryDataTypes.get(dataTypeId)!.push(category);
+      }
+    }
+  }
+
+  // Group records
+  for (const record of records) {
+    const typeId = record.dataType || record.dailyDynamicValueType || record.dynamicEpochValueType;
+    if (typeId && categoryDataTypes.has(typeId)) {
+      const categories = categoryDataTypes.get(typeId)!;
+      for (const category of categories) {
+        grouped[category].push(record);
+      }
+    }
+  }
+
+  return grouped;
+}

package/src/tools/search-keyword.ts

@@ -0,0 +1,162 @@
+import type { Request } from "express";
+import type { z } from "zod";
+import type { SearchKeywordSchema } from "../schemas.js";
+import type { HealthDataRecord } from "../types.js";
+import {
+  extractThryveHeaders,
+  buildUrlEncodedBody,
+  getDefaultDateRange,
+  THRYVE_API_BASE_URL,
+  sortHealthData,
+  paginateResults,
+} from "../helpers.js";
+import { ALL_DATA_TYPES } from "../data-types-generated.js";
+import { flattenThryveResponse, enrichWithDataTypes } from "../data-enrichment.js";
+
+export async function searchKeyword(req: Request, args: z.infer<typeof SearchKeywordSchema>) {
+  const { headers, authToken } = extractThryveHeaders(req);
+
+  // Step 1: Search for matching property names in ALL_DATA_TYPES
+  const lowerQuery = args.query.toLowerCase();
+  const matchingDataTypes = ALL_DATA_TYPES.filter((dataType) =>
+    dataType.name.toLowerCase().includes(lowerQuery)
+  );
+
+  if (matchingDataTypes.length === 0) {
+    return {
+      data: [],
+      totalRecords: 0,
+      page: args.page,
+      pageSize: args.pageSize,
+      totalPages: 0,
+      query: args.query,
+      matchingPropertyNames: [],
+      message: `No property names found matching "${args.query}"`,
+    };
+  }
+
+  // Step 2: Get the data type IDs for matching properties
+  const matchingDataTypeIds = new Set(matchingDataTypes.map((dt) => dt.id));
+  const matchingPropertyNames = matchingDataTypes.map((dt) => dt.name);
+
+  // Determine date range
+  let startDay: string;
+  let endDay: string;
+  let startTimestamp: string;
+  let endTimestamp: string;
+
+  if (args.startDate || args.endDate) {
+    const defaults = getDefaultDateRange();
+    startDay = args.startDate || defaults.startDay;
+    endDay = args.endDate || defaults.endDay;
+    startTimestamp = `${startDay}T00:00:00Z`;
+    endTimestamp = `${endDay}T23:59:59Z`;
+  } else {
+    const defaults = getDefaultDateRange();
+    startDay = defaults.startDay;
+    endDay = defaults.endDay;
+    startTimestamp = `${startDay}T00:00:00Z`;
+    endTimestamp = `${endDay}T23:59:59Z`;
+  }
+
+  // Step 3: Determine which endpoint(s) to fetch from based on temporal resolution
+  const needsDaily = matchingDataTypes.some((dt) =>
+    dt.temporalResolution === "Daily" || dt.temporalResolution === "Both"
+  );
+  const needsEpoch = matchingDataTypes.some((dt) =>
+    dt.temporalResolution === "Epoch" || dt.temporalResolution === "Both"
+  );
+
+  const fetchPromises = [];
+
+  // Fetch daily data if needed
+  if (needsDaily) {
+    const dailyBody = buildUrlEncodedBody({
+      authenticationToken: authToken,
+      startDay,
+      endDay,
+      dataSources: args.dataSource,
+      displayTypeName: "true",
+    });
+
+    fetchPromises.push(
+      fetch(`${THRYVE_API_BASE_URL}/v5/dailyDynamicValues`, {
+        method: "POST",
+        headers,
+        body: dailyBody,
+      })
+    );
+  }
+
+  // Fetch epoch data if needed
+  if (needsEpoch) {
+    const epochBody = buildUrlEncodedBody({
+      authenticationToken: authToken,
+      startTimestamp,
+      endTimestamp,
+      dataSources: args.dataSource,
+      displayTypeName: "true",
+    });
+
+    fetchPromises.push(
+      fetch(`${THRYVE_API_BASE_URL}/v5/dynamicEpochValues`, {
+        method: "POST",
+        headers,
+        body: epochBody,
+      })
+    );
+  }
+
+  const responses = await Promise.all(fetchPromises);
+
+  // Check for errors
+  for (const response of responses) {
+    if (!response.ok) {
+      throw new Error(`Thryve API error: ${response.status} ${response.statusText}`);
+    }
+  }
+
+  // Parse responses
+  const jsonData = await Promise.all(responses.map((r) => r.json()));
+
+  // Flatten and enrich data
+  let allData: HealthDataRecord[] = [];
+  for (const data of jsonData) {
+    const flattened = flattenThryveResponse(data);
+    enrichWithDataTypes(flattened);
+    allData = allData.concat(flattened);
+  }
+
+  // Step 4: Filter by matching data type IDs
+  let filteredData = allData.filter((record) => {
+    const typeId = record.dataType || record.dailyDynamicValueType || record.dynamicEpochValueType;
+    return typeId && matchingDataTypeIds.has(typeId);
+  });
+
+  // Optional: Filter by data type category if specified
+  if (args.dataType) {
+    const lowerDataType = args.dataType.toLowerCase();
+    filteredData = filteredData.filter((record) => {
+      const typeName = record.dailyDynamicValueTypeName || record.dynamicEpochValueTypeName || "";
+      return typeName.toLowerCase().includes(lowerDataType);
+    });
+  }
+
+  // Sort the results
+  const sortedData = sortHealthData(filteredData, args.sortBy, args.sortOrder);
+
+  // Paginate the results
+  const paginatedResult = paginateResults(sortedData, args.page, args.pageSize);
+
+  return {
+    ...paginatedResult,
+    query: args.query,
+    matchingPropertyNames,
+    filters: {
+      startDate: startDay,
+      endDate: endDay,
+      dataType: args.dataType,
+      dataSource: args.dataSource,
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,44 @@
+// Type for health data records (unified format for daily and epoch data)
+export interface HealthDataRecord {
+  day?: string;
+  timestamp?: string;
+  value: string | number;
+  dataType?: number;
+  dataTypeName?: string;
+  dailyDynamicValueType?: number;
+  dynamicEpochValueType?: number;
+  dailyDynamicValueTypeName?: string;
+  dynamicEpochValueTypeName?: string;
+  dataSource?: number;
+  dataSourceName?: string;
+  unit?: string;
+  category?: string;
+  [key: string]: any;
+}
+
+// Pagination result structure
+export interface PaginationMetadata {
+  currentPage: number;
+  pageSize: number;
+  totalResults: number;
+  totalPages: number;
+}
+
+export interface PaginatedResult<T> {
+  results: T[];
+  pagination: PaginationMetadata;
+}
+
+// Parsed record ID structure
+export interface ParsedRecordId {
+  type: 'daily' | 'epoch';
+  dataType: string;
+  timeKey: string;
+  dataSource: string;
+}
+
+// Thryve API headers structure
+export interface ThryveHeaders {
+  headers: Record<string, string>;
+  authToken: string;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}