@contractspec/integration.providers-impls 2.8.0 → 2.10.0

package/dist/impls/health-provider-factory.js

@@ -0,0 +1,495 @@
+// @bun
+// src/impls/health/base-health-provider.ts
+class BaseHealthProvider {
+  providerKey;
+  transport;
+  apiBaseUrl;
+  mcpUrl;
+  apiKey;
+  accessToken;
+  mcpAccessToken;
+  webhookSecret;
+  fetchFn;
+  mcpRequestId = 0;
+  constructor(options) {
+    this.providerKey = options.providerKey;
+    this.transport = options.transport;
+    this.apiBaseUrl = options.apiBaseUrl ?? "https://api.example-health.local";
+    this.mcpUrl = options.mcpUrl;
+    this.apiKey = options.apiKey;
+    this.accessToken = options.accessToken;
+    this.mcpAccessToken = options.mcpAccessToken;
+    this.webhookSecret = options.webhookSecret;
+    this.fetchFn = options.fetchFn ?? fetch;
+  }
+  async listActivities(params) {
+    const result = await this.fetchList("activities", params);
+    return {
+      activities: result.items,
+      nextCursor: result.nextCursor,
+      hasMore: result.hasMore,
+      source: this.currentSource()
+    };
+  }
+  async listWorkouts(params) {
+    const result = await this.fetchList("workouts", params);
+    return {
+      workouts: result.items,
+      nextCursor: result.nextCursor,
+      hasMore: result.hasMore,
+      source: this.currentSource()
+    };
+  }
+  async listSleep(params) {
+    const result = await this.fetchList("sleep", params);
+    return {
+      sleep: result.items,
+      nextCursor: result.nextCursor,
+      hasMore: result.hasMore,
+      source: this.currentSource()
+    };
+  }
+  async listBiometrics(params) {
+    const result = await this.fetchList("biometrics", params);
+    return {
+      biometrics: result.items,
+      nextCursor: result.nextCursor,
+      hasMore: result.hasMore,
+      source: this.currentSource()
+    };
+  }
+  async listNutrition(params) {
+    const result = await this.fetchList("nutrition", params);
+    return {
+      nutrition: result.items,
+      nextCursor: result.nextCursor,
+      hasMore: result.hasMore,
+      source: this.currentSource()
+    };
+  }
+  async getConnectionStatus(params) {
+    const payload = await this.fetchRecord("connection/status", params);
+    const status = readString(payload, "status") ?? "healthy";
+    return {
+      tenantId: params.tenantId,
+      connectionId: params.connectionId,
+      status: status === "healthy" || status === "degraded" || status === "error" || status === "disconnected" ? status : "healthy",
+      source: this.currentSource(),
+      lastCheckedAt: readString(payload, "lastCheckedAt") ?? new Date().toISOString(),
+      errorCode: readString(payload, "errorCode"),
+      errorMessage: readString(payload, "errorMessage"),
+      metadata: asRecord(payload.metadata)
+    };
+  }
+  async syncActivities(params) {
+    return this.sync("activities", params);
+  }
+  async syncWorkouts(params) {
+    return this.sync("workouts", params);
+  }
+  async syncSleep(params) {
+    return this.sync("sleep", params);
+  }
+  async syncBiometrics(params) {
+    return this.sync("biometrics", params);
+  }
+  async syncNutrition(params) {
+    return this.sync("nutrition", params);
+  }
+  async parseWebhook(request) {
+    const payload = request.parsedBody ?? safeJsonParse(request.rawBody);
+    const body = asRecord(payload);
+    return {
+      providerKey: this.providerKey,
+      eventType: readString(body, "eventType") ?? readString(body, "event"),
+      externalEntityId: readString(body, "externalEntityId") ?? readString(body, "entityId"),
+      entityType: normalizeEntityType(readString(body, "entityType") ?? readString(body, "type")),
+      receivedAt: new Date().toISOString(),
+      verified: await this.verifyWebhook(request),
+      payload
+    };
+  }
+  async verifyWebhook(request) {
+    if (!this.webhookSecret) {
+      return true;
+    }
+    const signature = readHeader(request.headers, "x-webhook-signature");
+    return signature === this.webhookSecret;
+  }
+  async fetchList(resource, params) {
+    const payload = await this.fetchRecord(resource, params);
+    const items = asArray(payload.items) ?? asArray(payload[resource]) ?? asArray(payload.records) ?? [];
+    return {
+      items,
+      nextCursor: readString(payload, "nextCursor") ?? readString(payload, "cursor"),
+      hasMore: readBoolean(payload, "hasMore")
+    };
+  }
+  async sync(resource, params) {
+    const payload = await this.fetchRecord(`sync/${resource}`, params, "POST");
+    return {
+      synced: readNumber(payload, "synced") ?? 0,
+      failed: readNumber(payload, "failed") ?? 0,
+      nextCursor: readString(payload, "nextCursor"),
+      errors: asArray(payload.errors)?.map((item) => String(item)),
+      source: this.currentSource()
+    };
+  }
+  async fetchRecord(resource, params, method = "GET") {
+    if (this.transport.endsWith("mcp")) {
+      return this.callMcpTool(resource, params);
+    }
+    const url = new URL(`${this.apiBaseUrl.replace(/\/$/, "")}/${resource}`);
+    if (method === "GET") {
+      for (const [key, value] of Object.entries(params)) {
+        if (value == null)
+          continue;
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            url.searchParams.append(key, String(item));
+          });
+          continue;
+        }
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const response = await this.fetchFn(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.accessToken || this.apiKey ? { Authorization: `Bearer ${this.accessToken ?? this.apiKey}` } : {}
+      },
+      body: method === "POST" ? JSON.stringify(params) : undefined
+    });
+    if (!response.ok) {
+      const errorBody = await safeResponseText(response);
+      throw new Error(`${this.providerKey} ${resource} failed (${response.status}): ${errorBody}`);
+    }
+    const data = await response.json();
+    return asRecord(data) ?? {};
+  }
+  async callMcpTool(resource, params) {
+    if (!this.mcpUrl) {
+      return {};
+    }
+    const response = await this.fetchFn(this.mcpUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.mcpAccessToken ? { Authorization: `Bearer ${this.mcpAccessToken}` } : {}
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: ++this.mcpRequestId,
+        method: "tools/call",
+        params: {
+          name: `${this.providerKey.replace("health.", "")}_${resource.replace(/\//g, "_")}`,
+          arguments: params
+        }
+      })
+    });
+    if (!response.ok) {
+      const errorBody = await safeResponseText(response);
+      throw new Error(`${this.providerKey} MCP ${resource} failed (${response.status}): ${errorBody}`);
+    }
+    const rpcPayload = await response.json();
+    const rpc = asRecord(rpcPayload);
+    const result = asRecord(rpc?.result) ?? {};
+    const structured = asRecord(result.structuredContent);
+    if (structured)
+      return structured;
+    const data = asRecord(result.data);
+    if (data)
+      return data;
+    return result;
+  }
+  currentSource() {
+    return {
+      providerKey: this.providerKey,
+      transport: this.transport,
+      route: "primary"
+    };
+  }
+}
+function safeJsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { rawBody: raw };
+  }
+}
+function readHeader(headers, key) {
+  const match = Object.entries(headers).find(([headerKey]) => headerKey.toLowerCase() === key.toLowerCase());
+  if (!match)
+    return;
+  const value = match[1];
+  return Array.isArray(value) ? value[0] : value;
+}
+function normalizeEntityType(value) {
+  if (!value)
+    return;
+  if (value === "activity" || value === "workout" || value === "sleep" || value === "biometric" || value === "nutrition") {
+    return value;
+  }
+  return;
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  return value;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : undefined;
+}
+function readString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" ? value : undefined;
+}
+function readBoolean(record, key) {
+  const value = record?.[key];
+  return typeof value === "boolean" ? value : undefined;
+}
+function readNumber(record, key) {
+  const value = record?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+async function safeResponseText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return response.statusText;
+  }
+}
+
+// src/impls/health/providers.ts
+function createProviderOptions(options, fallbackTransport) {
+  return {
+    ...options,
+    transport: options.transport ?? fallbackTransport
+  };
+}
+
+class OpenWearablesHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.openwearables",
+      ...createProviderOptions(options, "aggregator-api")
+    });
+  }
+}
+
+class WhoopHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.whoop",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class AppleHealthBridgeProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.apple-health",
+      ...createProviderOptions(options, "aggregator-api")
+    });
+  }
+}
+
+class OuraHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.oura",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class StravaHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.strava",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class GarminHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.garmin",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class FitbitHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.fitbit",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class MyFitnessPalHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.myfitnesspal",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class EightSleepHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.eightsleep",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class PelotonHealthProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      providerKey: "health.peloton",
+      ...createProviderOptions(options, "official-api")
+    });
+  }
+}
+
+class UnofficialHealthAutomationProvider extends BaseHealthProvider {
+  constructor(options) {
+    super({
+      ...createProviderOptions(options, "unofficial"),
+      providerKey: options.providerKey
+    });
+  }
+}
+
+// src/impls/health-provider-factory.ts
+import {
+  isUnofficialHealthProviderAllowed,
+  resolveHealthStrategyOrder
+} from "@contractspec/integration.runtime/runtime";
+function createHealthProviderFromContext(context, secrets) {
+  const providerKey = context.spec.meta.key;
+  const config = toFactoryConfig(context.config);
+  const strategyOrder = buildStrategyOrder(config);
+  const errors = [];
+  for (const strategy of strategyOrder) {
+    const provider = createHealthProviderForStrategy(providerKey, strategy, config, secrets);
+    if (provider) {
+      return provider;
+    }
+    errors.push(`${strategy}: not available`);
+  }
+  throw new Error(`Unable to resolve health provider for ${providerKey}. Strategies attempted: ${errors.join(", ")}.`);
+}
+function createHealthProviderForStrategy(providerKey, strategy, config, secrets) {
+  const options = {
+    transport: strategy,
+    apiBaseUrl: config.apiBaseUrl,
+    mcpUrl: config.mcpUrl,
+    apiKey: getSecretString(secrets, "apiKey"),
+    accessToken: getSecretString(secrets, "accessToken"),
+    mcpAccessToken: getSecretString(secrets, "mcpAccessToken"),
+    webhookSecret: getSecretString(secrets, "webhookSecret")
+  };
+  if (strategy === "aggregator-api" || strategy === "aggregator-mcp") {
+    return new OpenWearablesHealthProvider(options);
+  }
+  if (strategy === "unofficial") {
+    if (!isUnofficialHealthProviderAllowed(providerKey, config)) {
+      return;
+    }
+    if (providerKey !== "health.myfitnesspal" && providerKey !== "health.eightsleep" && providerKey !== "health.peloton" && providerKey !== "health.garmin") {
+      return;
+    }
+    return new UnofficialHealthAutomationProvider({
+      ...options,
+      providerKey
+    });
+  }
+  if (strategy === "official-mcp") {
+    return createOfficialProvider(providerKey, {
+      ...options,
+      transport: "official-mcp"
+    });
+  }
+  return createOfficialProvider(providerKey, options);
+}
+function createOfficialProvider(providerKey, options) {
+  switch (providerKey) {
+    case "health.openwearables":
+      return new OpenWearablesHealthProvider(options);
+    case "health.whoop":
+      return new WhoopHealthProvider(options);
+    case "health.apple-health":
+      return new AppleHealthBridgeProvider(options);
+    case "health.oura":
+      return new OuraHealthProvider(options);
+    case "health.strava":
+      return new StravaHealthProvider(options);
+    case "health.garmin":
+      return new GarminHealthProvider(options);
+    case "health.fitbit":
+      return new FitbitHealthProvider(options);
+    case "health.myfitnesspal":
+      return new MyFitnessPalHealthProvider(options);
+    case "health.eightsleep":
+      return new EightSleepHealthProvider(options);
+    case "health.peloton":
+      return new PelotonHealthProvider(options);
+    default:
+      throw new Error(`Unsupported health provider key: ${providerKey}`);
+  }
+}
+function toFactoryConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return {};
+  }
+  const record = config;
+  return {
+    apiBaseUrl: asString(record.apiBaseUrl),
+    mcpUrl: asString(record.mcpUrl),
+    defaultTransport: normalizeTransport(record.defaultTransport),
+    strategyOrder: normalizeTransportArray(record.strategyOrder),
+    allowUnofficial: typeof record.allowUnofficial === "boolean" ? record.allowUnofficial : false,
+    unofficialAllowList: Array.isArray(record.unofficialAllowList) ? record.unofficialAllowList.map((item) => typeof item === "string" ? item : undefined).filter((item) => Boolean(item)) : undefined
+  };
+}
+function buildStrategyOrder(config) {
+  const order = resolveHealthStrategyOrder(config);
+  if (!config.defaultTransport) {
+    return order;
+  }
+  const withoutDefault = order.filter((item) => item !== config.defaultTransport);
+  return [config.defaultTransport, ...withoutDefault];
+}
+function normalizeTransport(value) {
+  if (typeof value !== "string")
+    return;
+  if (value === "official-api" || value === "official-mcp" || value === "aggregator-api" || value === "aggregator-mcp" || value === "unofficial") {
+    return value;
+  }
+  return;
+}
+function normalizeTransportArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const transports = value.map((item) => normalizeTransport(item)).filter((item) => Boolean(item));
+  return transports.length > 0 ? transports : undefined;
+}
+function getSecretString(secrets, key) {
+  const value = secrets[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+export {
+  createHealthProviderFromContext
+};

package/dist/impls/index.d.ts

@@ -24,4 +24,6 @@ export * from './granola-meeting-recorder';
 export * from './tldv-meeting-recorder';
 export * from './fireflies-meeting-recorder';
 export * from './fathom-meeting-recorder';
+export * from './health-provider-factory';
+export * from './health/providers';
 export * from './provider-factory';