metrickit 0.1.2

package/dist/helpers.js

@@ -0,0 +1,668 @@
+// src/time.ts
+function getPreviousPeriod(range) {
+  if (!range.from || !range.to)
+    return null;
+  const durationMs = range.to.getTime() - range.from.getTime();
+  return {
+    from: new Date(range.from.getTime() - durationMs),
+    to: new Date(range.from.getTime())
+  };
+}
+function getBucketStart(date, granularity) {
+  const d = new Date(date);
+  switch (granularity) {
+    case "hour":
+      d.setUTCMinutes(0, 0, 0);
+      break;
+    case "day":
+      d.setUTCHours(0, 0, 0, 0);
+      break;
+    case "week": {
+      const day = d.getUTCDay();
+      const diff = d.getUTCDate() - day + (day === 0 ? -6 : 1);
+      d.setUTCDate(diff);
+      d.setUTCHours(0, 0, 0, 0);
+      break;
+    }
+    case "month":
+      d.setUTCDate(1);
+      d.setUTCHours(0, 0, 0, 0);
+      break;
+    case "quarter": {
+      const month = d.getUTCMonth();
+      const quarterStart = month - month % 3;
+      d.setUTCMonth(quarterStart, 1);
+      d.setUTCHours(0, 0, 0, 0);
+      break;
+    }
+    case "year":
+      d.setUTCMonth(0, 1);
+      d.setUTCHours(0, 0, 0, 0);
+      break;
+  }
+  return d;
+}
+function normalizeUserDate(date) {
+  const d = new Date(date);
+  const hours = d.getUTCHours();
+  if (hours >= 20) {
+    d.setUTCDate(d.getUTCDate() + 1);
+  }
+  d.setUTCHours(0, 0, 0, 0);
+  return d;
+}
+function generateBuckets(from, to, granularity) {
+  const buckets = [];
+  const normalizedFrom = granularity === "hour" ? from : normalizeUserDate(from);
+  const normalizedTo = granularity === "hour" ? to : normalizeUserDate(to);
+  let current = getBucketStart(normalizedFrom, granularity);
+  while (current <= normalizedTo) {
+    buckets.push(new Date(current));
+    current = getNextBucket(current, granularity);
+  }
+  return buckets;
+}
+function getNextBucket(date, granularity) {
+  const d = new Date(date);
+  switch (granularity) {
+    case "hour":
+      d.setUTCHours(d.getUTCHours() + 1);
+      break;
+    case "day":
+      d.setUTCDate(d.getUTCDate() + 1);
+      break;
+    case "week":
+      d.setUTCDate(d.getUTCDate() + 7);
+      break;
+    case "month":
+      d.setUTCMonth(d.getUTCMonth() + 1);
+      break;
+    case "quarter":
+      d.setUTCMonth(d.getUTCMonth() + 3);
+      break;
+    case "year":
+      d.setUTCFullYear(d.getUTCFullYear() + 1);
+      break;
+  }
+  return d;
+}
+function inferGranularity(range) {
+  if (!range.from || !range.to)
+    return "day";
+  const diffMs = range.to.getTime() - range.from.getTime();
+  const diffDays = diffMs / (1000 * 60 * 60 * 24);
+  if (diffDays <= 2)
+    return "hour";
+  if (diffDays <= 31)
+    return "day";
+  if (diffDays <= 90)
+    return "week";
+  if (diffDays <= 365)
+    return "month";
+  if (diffDays <= 730)
+    return "quarter";
+  return "year";
+}
+
+// src/helpers/clickhouse.ts
+var CLICKHOUSE_GRANULARITY_FUNCTIONS = {
+  hour: "toStartOfHour",
+  day: "toStartOfDay",
+  week: "toStartOfWeek",
+  month: "toStartOfMonth",
+  quarter: "toStartOfQuarter",
+  year: "toStartOfYear"
+};
+function getClickhouseGranularity(granularity) {
+  return CLICKHOUSE_GRANULARITY_FUNCTIONS[granularity];
+}
+function buildClickhouseBucketExpr(columnName, granularity) {
+  const fn = CLICKHOUSE_GRANULARITY_FUNCTIONS[granularity];
+  if (granularity === "week") {
+    return `${fn}(${columnName}, 1)`;
+  }
+  return `${fn}(${columnName})`;
+}
+function toClickhouseDatetime(date, boundary) {
+  let d = date;
+  if (boundary === "start") {
+    d = normalizeUserDate(date);
+  } else if (boundary === "end") {
+    d = new Date(date.getTime() + 24 * 60 * 60 * 1000 - 1000);
+  }
+  return d.toISOString().slice(0, 19).replace("T", " ");
+}
+function buildClickhouseTimeParams(filters) {
+  return {
+    ...filters.from ? { from: toClickhouseDatetime(filters.from) } : {},
+    ...filters.to ? { to: toClickhouseDatetime(filters.to) } : {}
+  };
+}
+function buildClickhouseTimeWhere(columnName, options) {
+  const parts = [];
+  if (options.from) {
+    parts.push(`${columnName} >= {from:DateTime}`);
+  }
+  if (options.to) {
+    parts.push(`${columnName} <= {to:DateTime}`);
+  }
+  return parts.join(" AND ");
+}
+function parseClickhouseBucketToTimestamp(bucket) {
+  const isoString = `${bucket.replace(" ", "T")}Z`;
+  return new Date(isoString).getTime();
+}
+// src/helpers/prisma.ts
+function buildTimeRangeWhere(filters) {
+  if (!filters.from && !filters.to) {
+    return;
+  }
+  return {
+    ...filters.from ? { gte: filters.from } : {},
+    ...filters.to ? { lte: filters.to } : {}
+  };
+}
+function buildTimeRangeWhereObject(columnName, filters) {
+  const timeRange = buildTimeRangeWhere(filters);
+  if (!timeRange) {
+    return {};
+  }
+  return { [columnName]: timeRange };
+}
+function buildScopedTimeWhere(idColumn, timeColumn, filters) {
+  const idWhere = filters.scopeIds?.length ? { [idColumn]: { in: filters.scopeIds } } : filters.scopeId ? { [idColumn]: filters.scopeId } : {};
+  return {
+    ...idWhere,
+    ...buildTimeRangeWhereObject(timeColumn, filters)
+  };
+}
+// src/helpers/distribution.ts
+function calculateDistribution(segments, options) {
+  const total = segments.reduce((sum, s) => sum + s.value, 0);
+  return {
+    kind: "distribution",
+    total,
+    segments: segments.map((s) => ({
+      key: s.key,
+      label: s.label,
+      value: s.value,
+      percent: total > 0 ? s.value / total * 100 : 0
+    })),
+    chartType: options?.chartType
+  };
+}
+function calculateDistributionFromGroups(groups, keyField, labelMap = {}, options) {
+  return calculateDistribution(groups.map((g) => ({
+    key: g[keyField],
+    label: labelMap[g[keyField]] ?? g[keyField],
+    value: g._count._all
+  })), options);
+}
+// src/helpers/timeseries.ts
+function mapBucketsToPoints(buckets, rows, valueExtractor) {
+  const dataMap = new Map;
+  for (const row of rows) {
+    if (row.bucket) {
+      const ts = parseClickhouseBucketToTimestamp(row.bucket);
+      dataMap.set(ts, row);
+    }
+  }
+  return buckets.map((ts) => ({
+    ts,
+    value: dataMap.has(ts.getTime()) ? valueExtractor(dataMap.get(ts.getTime())) : 0
+  }));
+}
+function createEmptyPoints(from, to, granularity) {
+  const buckets = generateBuckets(from, to, granularity);
+  return buckets.map((ts) => ({ ts, value: 0 }));
+}
+// src/helpers/metric-type.ts
+import { typedSwitch } from "typedswitch";
+function resolveMetricType(metric, defaultMetric) {
+  return metric ?? defaultMetric;
+}
+function calculateMetricModeValue(args) {
+  const value = typedSwitch(resolveMetricType(args.metric, args.defaultMetric), {
+    TOTAL: () => args.total,
+    AVG: () => args.averageDivisor > 0 ? args.total / args.averageDivisor : 0,
+    PER_BUCKET: () => args.bucketCount && args.bucketCount > 0 ? args.total / args.bucketCount : 0
+  });
+  return args.postProcess ? args.postProcess(value) : value;
+}
+function getMetricModeLabel(args) {
+  return args.labels[resolveMetricType(args.metric, args.defaultMetric)];
+}
+function getBucketCountForMetricMode(args) {
+  if (resolveMetricType(args.metric, args.defaultMetric) !== "PER_BUCKET") {
+    return;
+  }
+  return Math.max(1, generateBuckets(args.from, args.to, inferGranularity({ from: args.from, to: args.to })).length);
+}
+// src/schemas/time.ts
+import { z } from "zod";
+var TimeGranularitySchema = z.enum([
+  "hour",
+  "day",
+  "week",
+  "month",
+  "quarter",
+  "year"
+]);
+var TimeRangeSchema = z.object({
+  from: z.date().optional(),
+  to: z.date().optional()
+});
+var RequiredTimeRangeSchema = z.object({
+  from: z.date(),
+  to: z.date()
+});
+var CompareSchema = z.object({
+  compareToPrevious: z.boolean().optional().default(false)
+});
+// src/schemas/output.ts
+import { z as z2 } from "zod";
+var OutputKindSchema = z2.enum([
+  "kpi",
+  "timeseries",
+  "distribution",
+  "table",
+  "leaderboard",
+  "pivot"
+]);
+var MetricUnitSchema = z2.enum([
+  "DKK",
+  "EUR",
+  "USD",
+  "GBP",
+  "SEK",
+  "NOK",
+  "PERCENTAGE"
+]);
+var KpiOutputSchema = z2.object({
+  kind: z2.literal("kpi"),
+  value: z2.number(),
+  label: z2.string().optional(),
+  unit: MetricUnitSchema.optional(),
+  prefix: z2.string().optional(),
+  suffix: z2.string().optional(),
+  trend: z2.enum(["up", "down", "flat"]).optional()
+});
+function defineKpiOutput(output) {
+  return {
+    kind: "kpi",
+    ...output
+  };
+}
+var TimeSeriesPointSchema = z2.object({
+  ts: z2.date(),
+  value: z2.number(),
+  label: z2.string().optional()
+});
+var TimeSeriesSeriesSchema = z2.object({
+  key: z2.string(),
+  label: z2.string().optional(),
+  points: z2.array(TimeSeriesPointSchema),
+  chartType: z2.enum(["line", "bar"]).optional(),
+  axis: z2.enum(["left", "right"]).optional(),
+  meta: z2.record(z2.string(), z2.unknown()).optional()
+});
+var TimeSeriesOutputSchema = z2.object({
+  kind: z2.literal("timeseries"),
+  granularity: TimeGranularitySchema,
+  series: z2.array(TimeSeriesSeriesSchema)
+});
+function defineTimeSeriesOutput(output) {
+  if (Array.isArray(output.series)) {
+    return {
+      kind: "timeseries",
+      ...output,
+      series: [...output.series]
+    };
+  }
+  return {
+    kind: "timeseries",
+    ...output,
+    series: Object.entries(output.series).map(([key, series]) => ({
+      key,
+      ...series
+    }))
+  };
+}
+var DistributionSegmentSchema = z2.object({
+  key: z2.string(),
+  label: z2.string(),
+  value: z2.number(),
+  percent: z2.number().optional()
+});
+var DistributionChartTypeSchema = z2.enum([
+  "bar",
+  "donut",
+  "pie",
+  "funnel"
+]);
+var DistributionOutputSchema = z2.object({
+  kind: z2.literal("distribution"),
+  total: z2.number(),
+  segments: z2.array(DistributionSegmentSchema),
+  chartType: DistributionChartTypeSchema.optional()
+});
+function defineDistributionOutput(output) {
+  return {
+    kind: "distribution",
+    ...output,
+    segments: [...output.segments]
+  };
+}
+var TableColumnSchema = z2.object({
+  key: z2.string(),
+  label: z2.string(),
+  type: z2.enum(["string", "number", "date", "boolean"]).optional(),
+  nullable: z2.boolean().optional()
+});
+var TableOutputSchema = z2.object({
+  kind: z2.literal("table"),
+  columns: z2.array(TableColumnSchema),
+  rows: z2.array(z2.record(z2.string(), z2.unknown())),
+  total: z2.number().optional()
+});
+function defineTableOutput(output) {
+  return {
+    kind: "table",
+    ...output,
+    columns: [...output.columns],
+    rows: [...output.rows]
+  };
+}
+var PivotDimensionSchema = z2.object({
+  key: z2.string(),
+  label: z2.string()
+});
+var PivotTotalsSchema = z2.object({
+  rowTotals: z2.array(z2.number()).optional(),
+  columnTotals: z2.array(z2.number()).optional(),
+  grandTotal: z2.number().optional()
+});
+function addGrandTotalMismatchIssue(ctx, totalsName, totals, grandTotal) {
+  const totalsSum = totals?.reduce((total, value) => total + value, 0);
+  if (totalsSum === undefined)
+    return;
+  if (Math.abs(totalsSum - grandTotal) <= Number.EPSILON)
+    return;
+  ctx.addIssue({
+    code: z2.ZodIssueCode.custom,
+    path: ["totals", "grandTotal"],
+    message: `grandTotal must equal the sum of ${totalsName}`
+  });
+}
+function clonePivotTotals(totals) {
+  if (!totals)
+    return;
+  return {
+    rowTotals: totals.rowTotals ? [...totals.rowTotals] : undefined,
+    columnTotals: totals.columnTotals ? [...totals.columnTotals] : undefined,
+    grandTotal: totals.grandTotal
+  };
+}
+function clonePivotCellTooltips(cellTooltips) {
+  if (!cellTooltips)
+    return;
+  return cellTooltips.map((row) => [...row]);
+}
+var PivotOutputSchema = z2.object({
+  kind: z2.literal("pivot"),
+  rowDimension: PivotDimensionSchema,
+  columnDimension: PivotDimensionSchema,
+  rows: z2.array(z2.string()),
+  columns: z2.array(z2.string()),
+  values: z2.array(z2.array(z2.number())),
+  cellTooltips: z2.array(z2.array(z2.string())).optional(),
+  totals: PivotTotalsSchema.optional()
+}).superRefine((pivot, ctx) => {
+  const rowCount = pivot.rows.length;
+  const columnCount = pivot.columns.length;
+  if (pivot.values.length !== rowCount) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["values"],
+      message: `Pivot values must have ${rowCount} rows`
+    });
+  }
+  for (const [rowIndex, row] of pivot.values.entries()) {
+    if (row.length !== columnCount) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["values", rowIndex],
+        message: `Pivot row ${rowIndex} must have ${columnCount} columns`
+      });
+    }
+  }
+  if (pivot.cellTooltips !== undefined) {
+    if (pivot.cellTooltips.length !== rowCount) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["cellTooltips"],
+        message: `cellTooltips must have ${rowCount} rows`
+      });
+    }
+    for (const [rowIndex, row] of pivot.cellTooltips.entries()) {
+      if (row.length !== columnCount) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          path: ["cellTooltips", rowIndex],
+          message: `cellTooltips row ${rowIndex} must have ${columnCount} columns`
+        });
+      }
+    }
+  }
+  if (pivot.totals?.rowTotals && pivot.totals.rowTotals.length !== rowCount) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["totals", "rowTotals"],
+      message: `rowTotals must have ${rowCount} entries`
+    });
+  }
+  if (pivot.totals?.columnTotals && pivot.totals.columnTotals.length !== columnCount) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["totals", "columnTotals"],
+      message: `columnTotals must have ${columnCount} entries`
+    });
+  }
+  if (pivot.totals?.grandTotal !== undefined) {
+    addGrandTotalMismatchIssue(ctx, "rowTotals", pivot.totals.rowTotals, pivot.totals.grandTotal);
+    addGrandTotalMismatchIssue(ctx, "columnTotals", pivot.totals.columnTotals, pivot.totals.grandTotal);
+  }
+});
+function definePivotOutput(output) {
+  return {
+    kind: "pivot",
+    ...output,
+    rows: [...output.rows],
+    columns: [...output.columns],
+    values: output.values.map((row) => [...row]),
+    cellTooltips: clonePivotCellTooltips(output.cellTooltips),
+    totals: clonePivotTotals(output.totals)
+  };
+}
+var LeaderboardItemSchema = z2.object({
+  rank: z2.number(),
+  id: z2.string(),
+  label: z2.string(),
+  value: z2.number(),
+  meta: z2.record(z2.string(), z2.unknown()).optional()
+});
+var LeaderboardOutputSchema = z2.object({
+  kind: z2.literal("leaderboard"),
+  items: z2.array(LeaderboardItemSchema),
+  total: z2.number().optional()
+});
+function defineLeaderboardOutput(output) {
+  return {
+    kind: "leaderboard",
+    ...output,
+    items: [...output.items]
+  };
+}
+function defineMetricOutput(kind, output) {
+  const handlers = {
+    kpi: () => defineKpiOutput(output),
+    timeseries: () => defineTimeSeriesOutput(output),
+    distribution: () => defineDistributionOutput(output),
+    table: () => defineTableOutput(output),
+    leaderboard: () => defineLeaderboardOutput(output),
+    pivot: () => definePivotOutput(output)
+  };
+  return handlers[kind]();
+}
+function validateOutput(kind, output) {
+  return OutputSchemaMap[kind].parse(output);
+}
+var MetricOutputSchema = z2.discriminatedUnion("kind", [
+  KpiOutputSchema,
+  TimeSeriesOutputSchema,
+  DistributionOutputSchema,
+  TableOutputSchema,
+  LeaderboardOutputSchema,
+  PivotOutputSchema
+]);
+var OutputSchemaMap = {
+  kpi: KpiOutputSchema,
+  timeseries: TimeSeriesOutputSchema,
+  distribution: DistributionOutputSchema,
+  table: TableOutputSchema,
+  leaderboard: LeaderboardOutputSchema,
+  pivot: PivotOutputSchema
+};
+var MetricExecutionCacheStatusSchema = z2.enum([
+  "hit",
+  "partialHit",
+  "miss",
+  "bypassed"
+]);
+var MetricExecutionSchema = z2.object({
+  cacheStatus: MetricExecutionCacheStatusSchema,
+  durationMs: z2.number().nonnegative(),
+  granularity: TimeGranularitySchema.optional()
+});
+var MetricResultSchema = z2.object({
+  current: MetricOutputSchema,
+  previous: MetricOutputSchema.optional(),
+  supportsTimeRange: z2.boolean(),
+  execution: MetricExecutionSchema.optional()
+});
+// src/schemas/inputs.ts
+import { z as z3 } from "zod";
+var BaseFiltersSchema = z3.object({
+  organizationIds: z3.array(z3.string()).optional()
+}).merge(TimeRangeSchema);
+var TimeSeriesFiltersSchema = z3.object({
+  organizationIds: z3.array(z3.string()).optional()
+}).merge(RequiredTimeRangeSchema);
+function extendBaseFilters(shape) {
+  const optionalShape = Object.fromEntries(Object.entries(shape).map(([key, schema]) => [
+    key,
+    schema.optional()
+  ]));
+  return BaseFiltersSchema.extend(optionalShape);
+}
+function extendTimeSeriesFilters(shape) {
+  const optionalShape = Object.fromEntries(Object.entries(shape).map(([key, schema]) => [
+    key,
+    schema.optional()
+  ]));
+  return TimeSeriesFiltersSchema.extend(optionalShape);
+}
+// src/schemas/metric-type.ts
+import { z as z4 } from "zod";
+var MetricTypeSchema = z4.enum(["TOTAL", "AVG", "PER_BUCKET"]);
+// src/helpers/pivot.ts
+function createPivotMatrix(rowCount, columnCount) {
+  return Array.from({ length: rowCount }, () => Array.from({ length: columnCount }, () => 0));
+}
+function addPivotCell(values, rowIndex, columnIndex, delta) {
+  const row = values[rowIndex];
+  if (!row)
+    return;
+  if (columnIndex < 0 || columnIndex >= row.length)
+    return;
+  row[columnIndex] = (row[columnIndex] ?? 0) + delta;
+}
+function computePivotTotals(values) {
+  const rowTotals = values.map((row) => row.reduce((acc, value) => acc + value, 0));
+  const columnCount = values[0]?.length ?? 0;
+  const columnTotals = Array.from({ length: columnCount }, (_, columnIndex) => values.reduce((acc, row) => acc + (row[columnIndex] ?? 0), 0));
+  const grandTotal = rowTotals.reduce((acc, value) => acc + value, 0);
+  return {
+    rowTotals,
+    columnTotals,
+    grandTotal
+  };
+}
+function formatPivotBucketLabel(bucket, granularity) {
+  const year = bucket.getUTCFullYear();
+  const month = String(bucket.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(bucket.getUTCDate()).padStart(2, "0");
+  const hour = String(bucket.getUTCHours()).padStart(2, "0");
+  switch (granularity) {
+    case "hour":
+      return `${year}-${month}-${day} ${hour}:00`;
+    case "day":
+      return `${year}-${month}-${day}`;
+    case "week": {
+      const { week, weekYear } = getIsoWeekAndYear(bucket);
+      return `Week ${week} ${weekYear}`;
+    }
+    case "month":
+      return `${year}-${month}`;
+    case "quarter": {
+      const quarter = Math.floor(bucket.getUTCMonth() / 3) + 1;
+      return `Q${quarter} ${year}`;
+    }
+    case "year":
+      return `${year}`;
+  }
+}
+function getIsoWeekAndYear(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  const day = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - day);
+  const weekYear = d.getUTCFullYear();
+  const yearStart = new Date(Date.UTC(weekYear, 0, 1));
+  const week = Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+  return { week, weekYear };
+}
+function buildPivotOutput(args) {
+  return definePivotOutput({
+    rowDimension: args.rowDimension,
+    columnDimension: args.columnDimension,
+    rows: args.rows,
+    columns: args.columns,
+    values: args.values,
+    cellTooltips: args.cellTooltips,
+    totals: args.totals ?? computePivotTotals(args.values)
+  });
+}
+export {
+  toClickhouseDatetime,
+  resolveMetricType,
+  parseClickhouseBucketToTimestamp,
+  mapBucketsToPoints,
+  getMetricModeLabel,
+  getClickhouseGranularity,
+  getBucketCountForMetricMode,
+  formatPivotBucketLabel,
+  createPivotMatrix,
+  createEmptyPoints,
+  computePivotTotals,
+  calculateMetricModeValue,
+  calculateDistributionFromGroups,
+  calculateDistribution,
+  buildTimeRangeWhereObject,
+  buildTimeRangeWhere,
+  buildScopedTimeWhere,
+  buildPivotOutput,
+  buildClickhouseTimeWhere,
+  buildClickhouseTimeParams,
+  buildClickhouseBucketExpr,
+  addPivotCell
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { createMetricsEngine, type MetricKindSchemaMap, type MetricsEngineConfig } from './engine.ts';
+export { createRegistry, getMetric, type AnyRegistry, type InferBaseFilters, type InferRegistryMetrics, type InferAvailableMetricKey, type GetMetricByKey, type MetricOutputFor, type MetricFiltersFor, type MetricKindFor, type MetricSeriesKeysFor, type MetricRequestFiltersFor, type MetricRequestFor, type MetricResultChunkFor, type MetricsExecutionResult, type MetricsRequestFor, type IsValidMetricKey, type MetricKeysOfKind } from './registry.ts';
+export { defineKpiMetric, defineTimeSeriesMetric, defineDistributionMetric, defineTableMetric, defineLeaderboardMetric, definePivotMetric, getOutputSchema, validateMetricOutput, defineMetricWithSchema, type MetricDefinition, type MetricDefinitionInput, type MetricFilterFieldMetadataMap, type AnyMetricDefinition, type MetricKey, type MetricOutput as MetricOutputFromDef } from './define-metric.ts';
+export { runMetrics, runMetricsStream, type MetricsRequest, type MetricsResult, type MetricResultChunk, type RunMetricsOptions } from './run-metrics.ts';
+export { noopCacheAdapter, parseCache, type CacheAdapter } from './cache.ts';
+export { redisCacheAdapter, type RedisLikeClient, type RedisPipeline } from './cache-redis.ts';
+export * from './schemas/index.ts';
+export { getPreviousPeriod, getBucketStart, normalizeUserDate, generateBuckets, inferGranularity } from './time.ts';
+export { isKpi, isTimeSeries, isDistribution, isTable, isLeaderboard, isPivot } from './type-guards.ts';
+export { defineMetricCatalogMetadata, type MetricCatalogMetadata, type MetricCatalogFreshness, type MetricCatalogSource } from './catalog.ts';
+export * from './filters/index.ts';