@clipin/convex-wearables 0.0.2 → 0.1.0

package/src/component/_generated/component.ts

@@ -0,0 +1,74 @@
+/* eslint-disable */
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+import type { GenericId as ConvexId } from "convex/values";
+
+type Modules = {
+  backfillJobs: typeof import("../backfillJobs.js");
+  connections: typeof import("../connections.js");
+  dataPoints: typeof import("../dataPoints.js");
+  dataSources: typeof import("../dataSources.js");
+  events: typeof import("../events.js");
+  garminBackfill: typeof import("../garminBackfill.js");
+  garminWebhooks: typeof import("../garminWebhooks.js");
+  lifecycle: typeof import("../lifecycle.js");
+  menstrualCycles: typeof import("../menstrualCycles.js");
+  oauthActions: typeof import("../oauthActions.js");
+  sdkPush: typeof import("../sdkPush.js");
+  summaries: typeof import("../summaries.js");
+  syncJobs: typeof import("../syncJobs.js");
+  syncWorkflow: typeof import("../syncWorkflow.js");
+};
+
+type PublicApi = FilterApi<
+  ApiFromModules<Modules>,
+  FunctionReference<any, "public", any, any>
+>;
+
+type ConvertComponentBoundary<T> =
+  T extends ConvexId<string>
+    ? string
+    : T extends readonly (infer Item)[]
+      ? Array<ConvertComponentBoundary<Item>>
+      : T extends object
+        ? { [Key in keyof T]: ConvertComponentBoundary<T[Key]> }
+        : T;
+
+type ConvertComponentArgs<Args extends Record<string, any>> = {
+  [Key in keyof Args]: ConvertComponentBoundary<Args[Key]>;
+};
+
+type ToComponentApi<API, Name extends string | undefined> =
+  API extends FunctionReference<infer Type, any, infer Args, infer ReturnType>
+    ? FunctionReference<
+        Type,
+        "internal",
+        ConvertComponentArgs<Args>,
+        ConvertComponentBoundary<ReturnType>,
+        Name
+      >
+    : API extends object
+      ? { [Key in keyof API]: ToComponentApi<API[Key], Name> }
+      : never;
+
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> =
+  ToComponentApi<PublicApi, Name>;

package/src/component/_generated/dataModel.ts

@@ -0,0 +1,40 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ */
+export type Id<TableName extends TableNames> = GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/src/component/_generated/server.ts

@@ -0,0 +1,48 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+
+export type QueryCtx = GenericQueryCtx<DataModel>;
+export type MutationCtx = GenericMutationCtx<DataModel>;
+export type ActionCtx = GenericActionCtx<DataModel>;
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/component/backfillJobs.test.ts

@@ -0,0 +1,47 @@
+import { convexTest } from "convex-test";
+import { describe, expect, it } from "vitest";
+import { api } from "./_generated/api";
+import schema from "./schema";
+import { modules } from "./test.setup";
+
+describe("backfillJobs", () => {
+  it("returns the latest backfill job for a connection", async () => {
+    const t = convexTest(schema, modules);
+
+    const connectionId = await t.run(async (ctx) => {
+      return await ctx.db.insert("connections", {
+        userId: "user-1",
+        provider: "garmin",
+        accessToken: "token",
+        status: "active",
+      });
+    });
+
+    await t.run(async (ctx) => {
+      await ctx.db.insert("backfillJobs", {
+        connectionId,
+        userId: "user-1",
+        provider: "garmin",
+        dataType: "full",
+        status: "failed",
+        startedAt: 1,
+        completedAt: 2,
+      });
+      await ctx.db.insert("backfillJobs", {
+        connectionId,
+        userId: "user-1",
+        provider: "garmin",
+        dataType: "full",
+        status: "running",
+        startedAt: 3,
+      });
+    });
+
+    const job = await t.query(api.backfillJobs.getLatestByConnection, {
+      connectionId,
+    });
+
+    expect(job?.status).toBe("running");
+    expect(job?.startedAt).toBe(3);
+  });
+});

package/src/component/backfillJobs.ts

@@ -0,0 +1,245 @@
+import { v } from "convex/values";
+import { internal } from "./_generated/api";
+import { internalMutation, internalQuery, query } from "./_generated/server";
+import { backfillStatus, providerName } from "./schema";
+import { durableWorkflow } from "./workflowManager";
+
+export const backfillSignal = v.object({
+  kind: v.union(v.literal("webhook"), v.literal("timeout")),
+  dataType: v.string(),
+  itemCount: v.optional(v.number()),
+});
+
+export const getActiveByConnection = internalQuery({
+  args: {
+    connectionId: v.id("connections"),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    const jobs = await ctx.db
+      .query("backfillJobs")
+      .withIndex("by_connection", (idx) => idx.eq("connectionId", args.connectionId))
+      .order("desc")
+      .take(10);
+
+    return jobs.find((job) => job.status === "queued" || job.status === "running") ?? null;
+  },
+});
+
+export const getById = internalQuery({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.backfillJobId);
+  },
+});
+
+export const getLatestByConnection = query({
+  args: {
+    connectionId: v.id("connections"),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("backfillJobs")
+      .withIndex("by_connection", (idx) => idx.eq("connectionId", args.connectionId))
+      .order("desc")
+      .first();
+  },
+});
+
+export const create = internalMutation({
+  args: {
+    connectionId: v.id("connections"),
+    userId: v.string(),
+    provider: providerName,
+    dataType: v.string(),
+    windowStart: v.number(),
+    windowEnd: v.number(),
+  },
+  returns: v.id("backfillJobs"),
+  handler: async (ctx, args) => {
+    return await ctx.db.insert("backfillJobs", {
+      connectionId: args.connectionId,
+      userId: args.userId,
+      provider: args.provider,
+      dataType: args.dataType,
+      status: "queued",
+      startedAt: Date.now(),
+      windowStart: args.windowStart,
+      windowEnd: args.windowEnd,
+      completedDataTypes: [],
+      currentAttempt: 0,
+    });
+  },
+});
+
+export const updateStatus = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    status: backfillStatus,
+    workflowId: v.optional(v.string()),
+    error: v.optional(v.string()),
+    currentDataType: v.optional(v.string()),
+    currentAttempt: v.optional(v.number()),
+    currentEventId: v.optional(v.string()),
+    completedDataTypes: v.optional(v.array(v.string())),
+    lastHeartbeatAt: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const updates: Record<string, unknown> = {
+      status: args.status,
+    };
+    if (args.workflowId !== undefined) updates.workflowId = args.workflowId;
+    if (args.error !== undefined) updates.error = args.error;
+    if (args.currentDataType !== undefined) updates.currentDataType = args.currentDataType;
+    if (args.currentAttempt !== undefined) updates.currentAttempt = args.currentAttempt;
+    if (args.currentEventId !== undefined) updates.currentEventId = args.currentEventId;
+    if (args.completedDataTypes !== undefined) updates.completedDataTypes = args.completedDataTypes;
+    if (args.lastHeartbeatAt !== undefined) updates.lastHeartbeatAt = args.lastHeartbeatAt;
+    if (args.status === "completed" || args.status === "failed" || args.status === "canceled") {
+      updates.completedAt = Date.now();
+      updates.currentEventId = undefined;
+    }
+    await ctx.db.patch(args.backfillJobId, updates);
+  },
+});
+
+export const beginAwaitingType = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    workflowId: v.string(),
+    dataType: v.string(),
+    attempt: v.number(),
+  },
+  returns: v.string(),
+  handler: async (ctx, args) => {
+    const eventId = await durableWorkflow.createEvent(ctx, {
+      workflowId: args.workflowId as never,
+      name: `garmin-backfill:${args.dataType}:${args.attempt}`,
+    });
+
+    await ctx.db.patch(args.backfillJobId, {
+      status: "running",
+      currentDataType: args.dataType,
+      currentAttempt: args.attempt,
+      currentEventId: eventId,
+      lastHeartbeatAt: Date.now(),
+    });
+
+    return eventId;
+  },
+});
+
+export const markTypeCompleted = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    dataType: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const job = await ctx.db.get(args.backfillJobId);
+    if (!job) return;
+
+    const completed = new Set(job.completedDataTypes ?? []);
+    completed.add(args.dataType);
+
+    await ctx.db.patch(args.backfillJobId, {
+      completedDataTypes: Array.from(completed),
+      currentDataType: undefined,
+      currentAttempt: undefined,
+      currentEventId: undefined,
+      lastHeartbeatAt: Date.now(),
+    });
+  },
+});
+
+export const scheduleTimeout = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    eventId: v.string(),
+    dataType: v.string(),
+    delayMs: v.number(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.scheduler.runAfter(args.delayMs, internal.backfillJobs.emitTimeout, {
+      backfillJobId: args.backfillJobId,
+      eventId: args.eventId,
+      dataType: args.dataType,
+    });
+  },
+});
+
+export const emitTimeout = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    eventId: v.string(),
+    dataType: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const job = await ctx.db.get(args.backfillJobId);
+    if (
+      !job ||
+      job.status !== "running" ||
+      job.currentEventId !== args.eventId ||
+      job.currentDataType !== args.dataType
+    ) {
+      return;
+    }
+
+    try {
+      await durableWorkflow.sendEvent(ctx, {
+        id: args.eventId as never,
+        value: {
+          kind: "timeout",
+          dataType: args.dataType,
+        },
+      });
+    } catch {
+      // Timeout events are best-effort. If the workflow already moved on,
+      // duplicate or stale sends should not fail the scheduler.
+    }
+  },
+});
+
+export const signalWebhookData = internalMutation({
+  args: {
+    connectionId: v.id("connections"),
+    dataType: v.string(),
+    itemCount: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const activeJob = await ctx.db
+      .query("backfillJobs")
+      .withIndex("by_connection", (idx) => idx.eq("connectionId", args.connectionId))
+      .order("desc")
+      .first();
+
+    if (
+      !activeJob ||
+      activeJob.status !== "running" ||
+      activeJob.currentDataType !== args.dataType ||
+      !activeJob.currentEventId
+    ) {
+      return;
+    }
+
+    try {
+      await durableWorkflow.sendEvent(ctx, {
+        id: activeJob.currentEventId as never,
+        value: {
+          kind: "webhook",
+          dataType: args.dataType,
+          itemCount: args.itemCount,
+        },
+      });
+      await ctx.db.patch(activeJob._id, {
+        currentEventId: undefined,
+        lastHeartbeatAt: Date.now(),
+      });
+    } catch {
+      // Duplicate Garmin webhook pushes should not fail ingestion.
+    }
+  },
+});