@rawdash/core 0.1.1 → 0.3.0

package/dist/index.js

@@ -133,32 +133,108 @@ function defineConnector() {
 
 // src/widget-schemas.ts
 import { z } from "zod";
-var widgetSchemas = {
-  stat: z.object({
-    title: z.string().meta({ label: "Title", description: "Widget title." }),
-    metric: z.string().meta({ label: "Metric", description: "Metric reference." }),
-    window: z.string().optional().meta({ label: "Window", description: "Time window, e.g. '7d'." }),
-    compare: z.enum(["none", "previous-period"]).default("none").meta({ label: "Compare", description: "Comparison mode." })
+var shapeSchema = z.enum([
+  "event",
+  "entity",
+  "metric",
+  "edge",
+  "distribution"
+]);
+var aggFnSchema = z.enum([
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "latest",
+  "first"
+]);
+var filterOperatorSchema = z.enum([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "contains"
+]);
+var filterConditionSchema = z.object({
+  field: z.string(),
+  op: filterOperatorSchema,
+  value: z.union([z.string(), z.number(), z.boolean()])
+});
+var filterClauseSchema = z.union([
+  filterConditionSchema,
+  z.object({ or: z.array(filterConditionSchema) })
+]);
+var groupBySchema = z.object({
+  field: z.string(),
+  granularity: z.enum(["hour", "day", "week", "month"])
+});
+var resolvedMetricSchema = z.object({
+  connectorId: z.string(),
+  shape: shapeSchema,
+  name: z.string().optional(),
+  entityType: z.string().optional(),
+  field: z.string().optional(),
+  fn: aggFnSchema,
+  window: z.string().optional(),
+  filter: z.array(filterClauseSchema).optional(),
+  groupBy: groupBySchema.optional()
+}).refine((m) => m.fn === "count" || m.field !== void 0, {
+  message: 'field is required unless fn is "count"',
+  path: ["field"]
+});
+var titleField = z.string().meta({ label: "Title", description: "Widget title." });
+var statWidgetSchema = z.object({
+  kind: z.literal("stat"),
+  title: titleField,
+  metric: resolvedMetricSchema.meta({
+    label: "Metric",
+    description: "Resolved metric definition."
   }),
-  status: z.object({
-    title: z.string().meta({ label: "Title", description: "Widget title." }),
-    source: z.string().meta({
-      label: "Source",
-      description: "Connector or data source reference."
-    })
+  window: z.string().optional().meta({ label: "Window", description: "Time window, e.g. '7d'." }),
+  compare: z.enum(["none", "previous-period"]).default("none").meta({ label: "Compare", description: "Comparison mode." })
+});
+var statusWidgetSchema = z.object({
+  kind: z.literal("status"),
+  title: titleField,
+  source: z.string().meta({
+    label: "Source",
+    description: "Connector or data source reference."
+  })
+});
+var timeseriesWidgetSchema = z.object({
+  kind: z.literal("timeseries"),
+  title: titleField,
+  metric: resolvedMetricSchema.meta({
+    label: "Metric",
+    description: "Resolved metric definition."
   }),
-  timeseries: z.object({
-    title: z.string().meta({ label: "Title", description: "Widget title." }),
-    metric: z.string().meta({ label: "Metric", description: "Metric reference." }),
-    window: z.string().meta({ label: "Window", description: "Time window, e.g. '30d'." }),
-    granularity: z.enum(["hour", "day", "week"]).default("day").meta({ label: "Granularity", description: "Time bucket size." })
+  window: z.string().meta({ label: "Window", description: "Time window, e.g. '30d'." }),
+  granularity: z.enum(["hour", "day", "week"]).default("day").meta({ label: "Granularity", description: "Time bucket size." })
+});
+var distributionWidgetSchema = z.object({
+  kind: z.literal("distribution"),
+  title: titleField,
+  metric: resolvedMetricSchema.meta({
+    label: "Metric",
+    description: "Resolved metric definition."
   }),
-  distribution: z.object({
-    title: z.string().meta({ label: "Title", description: "Widget title." }),
-    metric: z.string().meta({ label: "Metric", description: "Metric reference." }),
-    window: z.string().meta({ label: "Window", description: "Time window, e.g. '7d'." })
-  })
+  window: z.string().meta({ label: "Window", description: "Time window, e.g. '7d'." })
+});
+var widgetSchemas = {
+  stat: statWidgetSchema,
+  status: statusWidgetSchema,
+  timeseries: timeseriesWidgetSchema,
+  distribution: distributionWidgetSchema
 };
+var widgetSchema = z.discriminatedUnion("kind", [
+  statWidgetSchema,
+  statusWidgetSchema,
+  timeseriesWidgetSchema,
+  distributionWidgetSchema
+]);
 function getWidgetSchema(kind) {
   return widgetSchemas[kind];
 }
@@ -173,17 +249,7 @@ function defineDashboard(options) {
       );
     }
     const schema = getWidgetSchema(widget.kind);
-    const parseInput = { ...widget };
-    if (widget.kind !== "status") {
-      const m = widget.metric;
-      if (typeof m !== "object" || m === null) {
-        throw new Error(
-          `Widget "${key}" (kind "${widget.kind}"): metric is required`
-        );
-      }
-      parseInput.metric = "placeholder";
-    }
-    const result = schema.safeParse(parseInput);
+    const result = schema.safeParse(widget);
     if (!result.success) {
       throw new Error(
         `Widget "${key}" (kind "${widget.kind}"): ${result.error.issues.map((i) => i.message).join("; ")}`
@@ -336,20 +402,556 @@ function defineConfigFields(schema) {
   }
   return schema;
 }
+
+// src/compute.ts
+function matchesCondition(record, cond) {
+  const val = record[cond.field];
+  switch (cond.op) {
+    case "eq":
+      return val === cond.value;
+    case "neq":
+      return val !== cond.value;
+    case "gt":
+      if (typeof val !== "number" || typeof cond.value !== "number") {
+        return false;
+      }
+      return val > cond.value;
+    case "gte":
+      if (typeof val !== "number" || typeof cond.value !== "number") {
+        return false;
+      }
+      return val >= cond.value;
+    case "lt":
+      if (typeof val !== "number" || typeof cond.value !== "number") {
+        return false;
+      }
+      return val < cond.value;
+    case "lte":
+      if (typeof val !== "number" || typeof cond.value !== "number") {
+        return false;
+      }
+      return val <= cond.value;
+    case "contains":
+      return String(val).includes(String(cond.value));
+    default:
+      return false;
+  }
+}
+function applyFilter(record, filter) {
+  if (!filter) {
+    return true;
+  }
+  for (const clause of filter) {
+    if ("or" in clause) {
+      if (!clause.or.some((cond) => matchesCondition(record, cond))) {
+        return false;
+      }
+    } else {
+      if (!matchesCondition(record, clause)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var WINDOW_MS = {
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5,
+  m: 2592e6
+};
+function parseWindowMs(window) {
+  const match = /^(\d+)(h|d|w|m)$/.exec(window);
+  if (!match) {
+    return null;
+  }
+  const unitMs = WINDOW_MS[match[2]];
+  if (unitMs === void 0) {
+    return null;
+  }
+  return parseInt(match[1]) * unitMs;
+}
+function truncateToGranularity(ts, granularity) {
+  const d = new Date(ts);
+  switch (granularity) {
+    case "hour":
+      d.setUTCMinutes(0, 0, 0);
+      return d.toISOString();
+    case "day":
+      d.setUTCHours(0, 0, 0, 0);
+      return d.toISOString().slice(0, 10);
+    case "week": {
+      d.setUTCDate(d.getUTCDate() - d.getUTCDay());
+      d.setUTCHours(0, 0, 0, 0);
+      return d.toISOString().slice(0, 10);
+    }
+    case "month":
+      d.setUTCDate(1);
+      d.setUTCHours(0, 0, 0, 0);
+      return d.toISOString().slice(0, 7);
+    default:
+      return d.toISOString().slice(0, 10);
+  }
+}
+function computeAgg(records, field, fn) {
+  if (fn === "count") {
+    return records.length;
+  }
+  if (field === void 0) {
+    throw new Error(`computeAgg: fn "${fn}" requires a field`);
+  }
+  if (fn === "latest") {
+    return records.at(-1)?.[field] ?? null;
+  }
+  if (fn === "first") {
+    return records[0]?.[field] ?? null;
+  }
+  const values = records.map((r) => r[field]).filter((v) => v !== void 0 && v !== null);
+  const nonNumeric = values.find((v) => typeof v !== "number");
+  if (nonNumeric !== void 0) {
+    throw new Error(
+      `computeAgg: fn "${fn}" requires numeric values for field "${field}", got ${typeof nonNumeric} (${String(nonNumeric)})`
+    );
+  }
+  const numbers = values;
+  if (fn === "sum") {
+    return numbers.reduce((a, b) => a + b, 0);
+  }
+  if (fn === "avg") {
+    return numbers.length > 0 ? numbers.reduce((a, b) => a + b, 0) / numbers.length : null;
+  }
+  if (fn === "min") {
+    return numbers.length > 0 ? numbers.reduce((a, b) => a < b ? a : b) : null;
+  }
+  if (fn === "max") {
+    return numbers.length > 0 ? numbers.reduce((a, b) => a > b ? a : b) : null;
+  }
+  return null;
+}
+function sortByTs(records, tsField) {
+  return [...records].sort((a, b) => {
+    return a[tsField] - b[tsField];
+  });
+}
+function computeGroupBy(records, metric, tsField) {
+  const { field, granularity } = metric.groupBy;
+  const groups = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const ts = record[field];
+    if (ts === void 0 || typeof ts !== "number") {
+      continue;
+    }
+    const key = truncateToGranularity(ts, granularity);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key).push(record);
+  }
+  return [...groups.entries()].map(([key, groupRecords]) => ({
+    date: key,
+    value: computeAgg(
+      sortByTs(groupRecords, tsField),
+      metric.field,
+      metric.fn
+    )
+  })).sort((a, b) => a.date < b.date ? -1 : 1);
+}
+function getTimestampField(shape) {
+  switch (shape) {
+    case "event":
+      return "start_ts";
+    case "metric":
+    case "distribution":
+      return "ts";
+    case "entity":
+    case "edge":
+      return "updated_at";
+    default:
+      return "start_ts";
+  }
+}
+async function computeMetric(storage, metric) {
+  const tsField = getTimestampField(metric.shape);
+  const windowMs = metric.window ? parseWindowMs(metric.window) : null;
+  const windowStart = windowMs !== null ? Date.now() - windowMs : void 0;
+  let records;
+  switch (metric.shape) {
+    case "event": {
+      const events = await storage.queryEvents({
+        name: metric.name,
+        start: windowStart
+      });
+      records = events.map((e) => ({
+        ...e.attributes,
+        name: e.name,
+        start_ts: e.start_ts,
+        end_ts: e.end_ts
+      }));
+      break;
+    }
+    case "entity": {
+      const type = metric.entityType ?? metric.name ?? "";
+      const entities = await storage.queryEntities({ type });
+      records = entities.map((e) => ({
+        ...e.attributes,
+        type: e.type,
+        id: e.id,
+        updated_at: e.updated_at
+      }));
+      if (windowStart !== void 0) {
+        records = records.filter((r) => r[tsField] >= windowStart);
+      }
+      break;
+    }
+    case "metric": {
+      const metrics = await storage.queryMetrics({
+        name: metric.name,
+        start: windowStart
+      });
+      records = metrics.map((m) => ({
+        ...m.attributes,
+        name: m.name,
+        ts: m.ts,
+        value: m.value
+      }));
+      break;
+    }
+    case "edge": {
+      const edges = await storage.traverse({ kind: metric.name });
+      records = edges.map((e) => ({
+        ...e.attributes,
+        from_type: e.from_type,
+        from_id: e.from_id,
+        kind: e.kind,
+        to_type: e.to_type,
+        to_id: e.to_id,
+        updated_at: e.updated_at
+      }));
+      if (windowStart !== void 0) {
+        records = records.filter((r) => r[tsField] >= windowStart);
+      }
+      break;
+    }
+    case "distribution": {
+      const distributions = await storage.queryDistributions({
+        name: metric.name,
+        start: windowStart
+      });
+      records = distributions.map((d) => ({
+        ...d.attributes,
+        name: d.name,
+        ts: d.ts,
+        kind: d.kind,
+        data: d.data
+      }));
+      break;
+    }
+    default:
+      return null;
+  }
+  const filtered = records.filter((r) => applyFilter(r, metric.filter));
+  const sorted = sortByTs(filtered, tsField);
+  if (metric.groupBy) {
+    return computeGroupBy(sorted, metric, tsField);
+  }
+  return computeAgg(sorted, metric.field, metric.fn);
+}
+
+// src/resolve-widget.ts
+async function resolveWidget(id, widget, connectors, storage) {
+  if (widget.kind === "status") {
+    return {
+      id,
+      widgetId: id,
+      connectorId: widget.source,
+      data: null,
+      cachedAt: null
+    };
+  }
+  const { connectorId } = widget.metric;
+  if (connectors !== void 0 && !isAllowedConnector(connectors, connectorId)) {
+    return void 0;
+  }
+  const handle = storage.getStorageHandle(connectorId);
+  const data = await computeMetric(handle, widget.metric);
+  return {
+    id,
+    widgetId: id,
+    connectorId,
+    data,
+    cachedAt: (await storage.getSyncState()).lastSyncAt
+  };
+}
+function isAllowedConnector(connectors, connectorId) {
+  if (connectors.length === 0) {
+    return false;
+  }
+  if (typeof connectors[0] === "string") {
+    return connectors.includes(connectorId);
+  }
+  return connectors.some(
+    (e) => e.connector.id === connectorId
+  );
+}
+
+// src/in-memory-storage.ts
+var InMemoryStorage = class {
+  eventStore = /* @__PURE__ */ new Map();
+  entityStore = /* @__PURE__ */ new Map();
+  metricStore = /* @__PURE__ */ new Map();
+  edgeStore = /* @__PURE__ */ new Map();
+  distributionStore = /* @__PURE__ */ new Map();
+  syncState = {
+    status: "idle",
+    lastSyncAt: null,
+    lastError: null
+  };
+  getStorageHandle(connectorId) {
+    const getEntityMap = () => {
+      if (!this.entityStore.has(connectorId)) {
+        this.entityStore.set(connectorId, /* @__PURE__ */ new Map());
+      }
+      return this.entityStore.get(connectorId);
+    };
+    const upsertEntities = (es) => {
+      const byType = getEntityMap();
+      for (const e of es) {
+        if (!byType.has(e.type)) {
+          byType.set(e.type, /* @__PURE__ */ new Map());
+        }
+        byType.get(e.type).set(e.id, e);
+      }
+    };
+    const upsertEdges = (es) => {
+      const existing = this.edgeStore.get(connectorId) ?? [];
+      const index = /* @__PURE__ */ new Map();
+      for (let i = 0; i < existing.length; i++) {
+        const e = existing[i];
+        index.set(
+          `${e.from_type}:${e.from_id}:${e.kind}:${e.to_type}:${e.to_id}`,
+          i
+        );
+      }
+      for (const e of es) {
+        const key = `${e.from_type}:${e.from_id}:${e.kind}:${e.to_type}:${e.to_id}`;
+        const idx = index.get(key);
+        if (idx !== void 0) {
+          existing[idx] = e;
+        } else {
+          index.set(key, existing.length);
+          existing.push(e);
+        }
+      }
+      this.edgeStore.set(connectorId, existing);
+    };
+    return {
+      event: async (e) => {
+        if (!this.eventStore.has(connectorId)) {
+          this.eventStore.set(connectorId, []);
+        }
+        this.eventStore.get(connectorId).push(e);
+      },
+      entity: async (e) => {
+        upsertEntities([e]);
+      },
+      metric: async (m) => {
+        if (!this.metricStore.has(connectorId)) {
+          this.metricStore.set(connectorId, []);
+        }
+        this.metricStore.get(connectorId).push(m);
+      },
+      edge: async (e) => {
+        upsertEdges([e]);
+      },
+      distribution: async (d) => {
+        if (!this.distributionStore.has(connectorId)) {
+          this.distributionStore.set(connectorId, []);
+        }
+        this.distributionStore.get(connectorId).push(d);
+      },
+      events: async (es, scope) => {
+        const names = new Set(scope?.names ?? es.map((e) => e.name));
+        const kept = (this.eventStore.get(connectorId) ?? []).filter(
+          (e) => !names.has(e.name)
+        );
+        this.eventStore.set(connectorId, [...kept, ...es]);
+      },
+      entities: async (es, scope) => {
+        const byType = getEntityMap();
+        const types = new Set(scope?.types ?? es.map((e) => e.type));
+        for (const type of types) {
+          byType.set(type, /* @__PURE__ */ new Map());
+        }
+        upsertEntities(es);
+      },
+      metrics: async (ms, scope) => {
+        const names = new Set(scope?.names ?? ms.map((m) => m.name));
+        const kept = (this.metricStore.get(connectorId) ?? []).filter(
+          (m) => !names.has(m.name)
+        );
+        this.metricStore.set(connectorId, [...kept, ...ms]);
+      },
+      edges: async (es, scope) => {
+        const kinds = new Set(scope?.kinds ?? es.map((e) => e.kind));
+        const kept = (this.edgeStore.get(connectorId) ?? []).filter(
+          (e) => !kinds.has(e.kind)
+        );
+        this.edgeStore.set(connectorId, kept);
+        upsertEdges(es);
+      },
+      distributions: async (ds, scope) => {
+        const names = new Set(scope?.names ?? ds.map((d) => d.name));
+        const kept = (this.distributionStore.get(connectorId) ?? []).filter(
+          (d) => !names.has(d.name)
+        );
+        this.distributionStore.set(connectorId, [...kept, ...ds]);
+      },
+      queryEvents: async (q) => {
+        let results = this.eventStore.get(connectorId) ?? [];
+        if (q.name !== void 0) {
+          results = results.filter((e) => e.name === q.name);
+        }
+        if (q.start !== void 0) {
+          results = results.filter((e) => e.start_ts >= q.start);
+        }
+        if (q.end !== void 0) {
+          results = results.filter((e) => e.start_ts <= q.end);
+        }
+        return results;
+      },
+      getEntity: async (type, id) => {
+        return getEntityMap().get(type)?.get(id) ?? null;
+      },
+      queryEntities: async (q) => {
+        const byType = getEntityMap().get(q.type);
+        if (!byType) {
+          return [];
+        }
+        return Array.from(byType.values());
+      },
+      queryMetrics: async (q) => {
+        let results = this.metricStore.get(connectorId) ?? [];
+        if (q.name !== void 0) {
+          results = results.filter((m) => m.name === q.name);
+        }
+        if (q.start !== void 0) {
+          results = results.filter((m) => m.ts >= q.start);
+        }
+        if (q.end !== void 0) {
+          results = results.filter((m) => m.ts <= q.end);
+        }
+        return results;
+      },
+      traverse: async (q) => {
+        let results = this.edgeStore.get(connectorId) ?? [];
+        if (q.fromType !== void 0) {
+          results = results.filter((e) => e.from_type === q.fromType);
+        }
+        if (q.fromId !== void 0) {
+          results = results.filter((e) => e.from_id === q.fromId);
+        }
+        if (q.kind !== void 0) {
+          results = results.filter((e) => e.kind === q.kind);
+        }
+        if (q.toType !== void 0) {
+          results = results.filter((e) => e.to_type === q.toType);
+        }
+        if (q.toId !== void 0) {
+          results = results.filter((e) => e.to_id === q.toId);
+        }
+        return results;
+      },
+      queryDistributions: async (q) => {
+        let results = this.distributionStore.get(connectorId) ?? [];
+        if (q.name !== void 0) {
+          results = results.filter((d) => d.name === q.name);
+        }
+        if (q.start !== void 0) {
+          results = results.filter((d) => d.ts >= q.start);
+        }
+        if (q.end !== void 0) {
+          results = results.filter((d) => d.ts <= q.end);
+        }
+        return results;
+      },
+      deleteOlderThan: async (shape, tsUnixMs) => {
+        if (shape === "events") {
+          const before = this.eventStore.get(connectorId) ?? [];
+          const after = before.filter((e) => e.start_ts >= tsUnixMs);
+          this.eventStore.set(connectorId, after);
+          return { rowsDeleted: before.length - after.length };
+        } else if (shape === "metrics") {
+          const before = this.metricStore.get(connectorId) ?? [];
+          const after = before.filter((m) => m.ts >= tsUnixMs);
+          this.metricStore.set(connectorId, after);
+          return { rowsDeleted: before.length - after.length };
+        } else if (shape === "distributions") {
+          const before = this.distributionStore.get(connectorId) ?? [];
+          const after = before.filter((d) => d.ts >= tsUnixMs);
+          this.distributionStore.set(connectorId, after);
+          return { rowsDeleted: before.length - after.length };
+        } else {
+          throw new Error(
+            `Unsupported shape for deleteOlderThan: ${String(shape)}`
+          );
+        }
+      }
+    };
+  }
+  async getSyncState() {
+    return { ...this.syncState };
+  }
+  async setSyncing() {
+    if (this.syncState.status === "syncing") {
+      return false;
+    }
+    this.syncState = { ...this.syncState, status: "syncing" };
+    return true;
+  }
+  async setSyncSuccess() {
+    this.syncState = {
+      status: "idle",
+      lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastError: null
+    };
+  }
+  async setSyncError(error) {
+    this.syncState = {
+      status: "error",
+      lastSyncAt: this.syncState.lastSyncAt,
+      lastError: error
+    };
+  }
+};
 export {
   BaseConnector,
   EnvSecretsResolver,
+  InMemoryStorage,
+  aggFnSchema,
+  computeMetric,
   computeRetention,
   defineConfig,
   defineConfigFields,
   defineConnector,
   defineDashboard,
   defineMetric,
+  distributionWidgetSchema,
+  filterClauseSchema,
+  filterConditionSchema,
+  filterOperatorSchema,
   getWidgetSchema,
+  groupBySchema,
   isSecretRef,
   resolveSecretRefs,
+  resolveWidget,
+  resolvedMetricSchema,
   secret,
   selectForDeletion,
+  shapeSchema,
+  statWidgetSchema,
+  statusWidgetSchema,
+  timeseriesWidgetSchema,
+  widgetSchema,
   widgetSchemas
 };
 //# sourceMappingURL=index.js.map