@okrlinkhub/okrhub 0.1.0

package/src/component/entities/indicatorValues.ts

@@ -0,0 +1,254 @@
+/**
+ * Indicator Values Entity for OKRHub Component
+ *
+ * CRUD operations and queries for Indicator Values.
+ */
+
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server.js";
+import type { Id } from "../_generated/dataModel.js";
+import { assertValidExternalId } from "../lib/validation.js";
+import { indicatorValuePayloadValidator, SyncStatusSchema } from "../schema.js";
+
+// ============================================================================
+// LOCAL CRUD MUTATIONS
+// ============================================================================
+
+/**
+ * Creates an indicator value locally and queues for sync
+ */
+export const createIndicatorValue = mutation({
+  args: {
+    sourceApp: v.string(),
+    sourceUrl: v.optional(v.string()),
+    indicatorExternalId: v.string(),
+    value: v.number(),
+    date: v.number(),
+  },
+  returns: v.object({
+    success: v.boolean(),
+    externalId: v.string(),
+    localId: v.id("indicatorValues"),
+    queueId: v.optional(v.id("syncQueue")),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const { sourceApp, sourceUrl, indicatorExternalId, value, date } = args;
+
+    try {
+      assertValidExternalId(indicatorExternalId, "indicatorExternalId");
+
+      const uuid = crypto.randomUUID();
+      const externalId = `${sourceApp}:indicatorValue:${uuid}`;
+      const now = Date.now();
+
+      const localId = await ctx.db.insert("indicatorValues", {
+        externalId,
+        indicatorExternalId,
+        value,
+        date,
+        syncStatus: "pending",
+        createdAt: now,
+      });
+
+      const payload = JSON.stringify({
+        externalId,
+        indicatorExternalId,
+        value,
+        date,
+        sourceUrl,
+        createdAt: now,
+      });
+
+      const queueId = await ctx.db.insert("syncQueue", {
+        entityType: "indicatorValue",
+        externalId,
+        payload,
+        status: "pending",
+        attempts: 0,
+        createdAt: now,
+      });
+
+      return {
+        success: true,
+        externalId,
+        localId,
+        queueId,
+      };
+    } catch (error) {
+      const errorMessage =
+        error && typeof error === "object" && "message" in error
+          ? (error.message as string)
+          : "Unknown error";
+
+      return {
+        success: false,
+        externalId: "",
+        localId: "" as Id<"indicatorValues">,
+        error: errorMessage,
+      };
+    }
+  },
+});
+
+// ============================================================================
+// LOCAL QUERY FUNCTIONS
+// ============================================================================
+
+/**
+ * Gets all local indicator values
+ */
+export const getAllIndicatorValues = query({
+  args: {},
+  returns: v.array(
+    v.object({
+      _id: v.id("indicatorValues"),
+      _creationTime: v.number(),
+      externalId: v.string(),
+      indicatorExternalId: v.string(),
+      value: v.number(),
+      date: v.number(),
+      syncStatus: SyncStatusSchema,
+      createdAt: v.number(),
+    })
+  ),
+  handler: async (ctx) => {
+    return await ctx.db.query("indicatorValues").collect();
+  },
+});
+
+// ============================================================================
+// UPDATE MUTATIONS
+// ============================================================================
+
+/**
+ * Updates an indicator value locally and queues for sync
+ * Resets syncStatus to "pending"
+ */
+export const updateIndicatorValue = mutation({
+  args: {
+    externalId: v.string(),
+    value: v.optional(v.number()),
+    date: v.optional(v.number()),
+  },
+  returns: v.object({
+    success: v.boolean(),
+    externalId: v.string(),
+    queueId: v.optional(v.id("syncQueue")),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const { externalId, value, date } = args;
+
+    try {
+      // Find the indicator value by externalId
+      const indicatorValue = await ctx.db
+        .query("indicatorValues")
+        .withIndex("by_external_id", (q) => q.eq("externalId", externalId))
+        .first();
+
+      if (!indicatorValue) {
+        return {
+          success: false,
+          externalId,
+          error: `Indicator value not found: ${externalId}`,
+        };
+      }
+
+      const now = Date.now();
+
+      // Update the indicator value
+      await ctx.db.patch(indicatorValue._id, {
+        ...(value !== undefined && { value }),
+        ...(date !== undefined && { date }),
+        syncStatus: "pending",
+      });
+
+      // Create payload for sync with updated values
+      const updatedIndicatorValue = {
+        externalId,
+        indicatorExternalId: indicatorValue.indicatorExternalId,
+        value: value ?? indicatorValue.value,
+        date: date ?? indicatorValue.date,
+      };
+
+      const payload = JSON.stringify(updatedIndicatorValue);
+
+      // Add to sync queue
+      const queueId = await ctx.db.insert("syncQueue", {
+        entityType: "indicatorValue",
+        externalId,
+        payload,
+        status: "pending",
+        attempts: 0,
+        createdAt: now,
+      });
+
+      return {
+        success: true,
+        externalId,
+        queueId,
+      };
+    } catch (error) {
+      const errorMessage =
+        error && typeof error === "object" && "message" in error
+          ? (error.message as string)
+          : "Unknown error";
+
+      return {
+        success: false,
+        externalId,
+        error: errorMessage,
+      };
+    }
+  },
+});
+
+// ============================================================================
+// PUBLIC MUTATIONS - Entry points for consumers
+// ============================================================================
+
+/**
+ * Insert an indicator value into LinkHub
+ */
+export const insertIndicatorValue = mutation({
+  args: {
+    indicatorValue: indicatorValuePayloadValidator,
+  },
+  returns: v.object({
+    success: v.boolean(),
+    externalId: v.string(),
+    queueId: v.optional(v.id("syncQueue")),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const { indicatorValue } = args;
+
+    // Validate external IDs
+    assertValidExternalId(
+      indicatorValue.externalId,
+      "indicatorValue.externalId"
+    );
+    assertValidExternalId(
+      indicatorValue.indicatorExternalId,
+      "indicatorValue.indicatorExternalId"
+    );
+
+    // Add to sync queue
+    const payload = JSON.stringify(indicatorValue);
+    const queueId = await ctx.db.insert("syncQueue", {
+      entityType: "indicatorValue",
+      externalId: indicatorValue.externalId,
+      payload,
+      status: "pending",
+      attempts: 0,
+      createdAt: Date.now(),
+    });
+
+    return {
+      success: true,
+      externalId: indicatorValue.externalId,
+      queueId,
+    };
+  },
+});

package/src/component/entities/indicators.ts

@@ -0,0 +1,290 @@
+/**
+ * Indicators Entity for OKRHub Component
+ *
+ * CRUD operations and queries for Indicators.
+ */
+
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server.js";
+import type { Id } from "../_generated/dataModel.js";
+import { generateExternalId } from "../externalId.js";
+import { assertValidExternalId, generateSlug } from "../lib/validation.js";
+import {
+  indicatorPayloadValidator,
+  PeriodicitySchema,
+  SyncStatusSchema,
+} from "../schema.js";
+
+// ============================================================================
+// LOCAL CRUD MUTATIONS
+// ============================================================================
+
+/**
+ * Creates an indicator locally and queues for sync
+ */
+export const createIndicator = mutation({
+  args: {
+    sourceApp: v.string(),
+    sourceUrl: v.optional(v.string()),
+    companyExternalId: v.string(),
+    description: v.string(),
+    symbol: v.string(),
+    periodicity: PeriodicitySchema,
+    isReverse: v.optional(v.boolean()),
+  },
+  returns: v.object({
+    success: v.boolean(),
+    externalId: v.string(),
+    localId: v.id("indicators"),
+    queueId: v.optional(v.id("syncQueue")),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const {
+      sourceApp,
+      sourceUrl,
+      companyExternalId,
+      description,
+      symbol,
+      periodicity,
+      isReverse,
+    } = args;
+
+    try {
+      assertValidExternalId(companyExternalId, "companyExternalId");
+
+      const externalId = generateExternalId(sourceApp, "indicator");
+      const slug = generateSlug(sourceApp, description);
+      const now = Date.now();
+
+      const localId = await ctx.db.insert("indicators", {
+        externalId,
+        companyExternalId,
+        description,
+        symbol,
+        periodicity,
+        isReverse,
+        slug,
+        syncStatus: "pending",
+        createdAt: now,
+      });
+
+      const payload = JSON.stringify({
+        externalId,
+        companyExternalId,
+        description,
+        symbol,
+        periodicity,
+        isReverse,
+        sourceUrl,
+        createdAt: now,
+      });
+
+      const queueId = await ctx.db.insert("syncQueue", {
+        entityType: "indicator",
+        externalId,
+        payload,
+        status: "pending",
+        attempts: 0,
+        createdAt: now,
+      });
+
+      return {
+        success: true,
+        externalId,
+        localId,
+        queueId,
+      };
+    } catch (error) {
+      const errorMessage =
+        error && typeof error === "object" && "message" in error
+          ? (error.message as string)
+          : "Unknown error";
+
+      return {
+        success: false,
+        externalId: "",
+        localId: "" as Id<"indicators">,
+        error: errorMessage,
+      };
+    }
+  },
+});
+
+// ============================================================================
+// LOCAL QUERY FUNCTIONS
+// ============================================================================
+
+/**
+ * Gets all local indicators
+ */
+export const getAllIndicators = query({
+  args: {},
+  returns: v.array(
+    v.object({
+      _id: v.id("indicators"),
+      _creationTime: v.number(),
+      externalId: v.string(),
+      companyExternalId: v.string(),
+      description: v.string(),
+      symbol: v.string(),
+      periodicity: PeriodicitySchema,
+      isReverse: v.optional(v.boolean()),
+      slug: v.string(),
+      syncStatus: SyncStatusSchema,
+      createdAt: v.number(),
+      deletedAt: v.optional(v.number()),
+    })
+  ),
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("indicators")
+      .filter((q) => q.eq(q.field("deletedAt"), undefined))
+      .collect();
+  },
+});
+
+// ============================================================================
+// UPDATE MUTATIONS
+// ============================================================================
+
+/**
+ * Updates an indicator locally and queues for sync
+ * Resets syncStatus to "pending"
+ */
+export const updateIndicator = mutation({
+  args: {
+    externalId: v.string(),
+    description: v.optional(v.string()),
+    symbol: v.optional(v.string()),
+    periodicity: v.optional(PeriodicitySchema),
+    isReverse: v.optional(v.boolean()),
+  },
+  returns: v.object({
+    success: v.boolean(),
+    externalId: v.string(),
+    queueId: v.optional(v.id("syncQueue")),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const {
+      externalId,
+      description,
+      symbol,
+      periodicity,
+      isReverse,
+    } = args;
+
+    try {
+      // Find the indicator by externalId
+      const indicator = await ctx.db
+        .query("indicators")
+        .withIndex("by_external_id", (q) => q.eq("externalId", externalId))
+        .first();
+
+      if (!indicator) {
+        return {
+          success: false,
+          externalId,
+          error: `Indicator not found: ${externalId}`,
+        };
+      }
+
+      const now = Date.now();
+
+      // Update the indicator
+      await ctx.db.patch(indicator._id, {
+        ...(description !== undefined && { description }),
+        ...(symbol !== undefined && { symbol }),
+        ...(periodicity !== undefined && { periodicity }),
+        ...(isReverse !== undefined && { isReverse }),
+        syncStatus: "pending",
+      });
+
+      // Create payload for sync with updated values
+      const updatedIndicator = {
+        externalId,
+        companyExternalId: indicator.companyExternalId,
+        description: description ?? indicator.description,
+        symbol: symbol ?? indicator.symbol,
+        periodicity: periodicity ?? indicator.periodicity,
+        isReverse: isReverse ?? indicator.isReverse,
+      };
+
+      const payload = JSON.stringify(updatedIndicator);
+
+      // Add to sync queue
+      const queueId = await ctx.db.insert("syncQueue", {
+        entityType: "indicator",
+        externalId,
+        payload,
+        status: "pending",
+        attempts: 0,
+        createdAt: now,
+      });
+
+      return {
+        success: true,
+        externalId,
+        queueId,
+      };
+    } catch (error) {
+      const errorMessage =
+        error && typeof error === "object" && "message" in error
+          ? (error.message as string)
+          : "Unknown error";
+
+      return {
+        success: false,
+        externalId,
+        error: errorMessage,
+      };
+    }
+  },
+});
+
+// ============================================================================
+// PUBLIC MUTATIONS - Entry points for consumers
+// ============================================================================
+
+/**
+ * Insert an indicator into LinkHub
+ */
+export const insertIndicator = mutation({
+  args: {
+    indicator: indicatorPayloadValidator,
+  },
+  returns: v.object({
+    success: v.boolean(),
+    externalId: v.string(),
+    queueId: v.optional(v.id("syncQueue")),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const { indicator } = args;
+
+    // Validate external IDs
+    assertValidExternalId(indicator.externalId, "indicator.externalId");
+    assertValidExternalId(
+      indicator.companyExternalId,
+      "indicator.companyExternalId"
+    );
+
+    // Add to sync queue
+    const payload = JSON.stringify(indicator);
+    const queueId = await ctx.db.insert("syncQueue", {
+      entityType: "indicator",
+      externalId: indicator.externalId,
+      payload,
+      status: "pending",
+      attempts: 0,
+      createdAt: Date.now(),
+    });
+
+    return {
+      success: true,
+      externalId: indicator.externalId,
+      queueId,
+    };
+  },
+});