@stellaris/metrics-shared 0.1.3 → 0.1.6

package/index.ts

@@ -1,3 +1,2 @@
-// export type * from "./bff-service.d.ts";
 export * from "./schemas";
-export type { AppType } from "../src/index";
+export type * from "./bff-service.d.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellaris/metrics-shared",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "type": "module",
   "main": "./index.ts",
   "types": "./index.ts",
@@ -11,6 +11,7 @@
     }
   },
   "dependencies": {
+    "@cubejs-client/core": "^1.6.4",
     "hono": "^4.11.4",
     "zod": "^4.0.0"
   }

package/schemas/filter.ts

@@ -1,84 +1,60 @@
-import { z } from "zod";
+import z from "zod";
 
-export const filterOperatorSchema = z.enum([
+const binaryOperatorSchema = z.enum([
   "equals",
   "notEquals",
   "contains",
+  "notContains",
+  "startsWith",
+  "notStartsWith",
+  "endsWith",
+  "notEndsWith",
   "gt",
-  "lt",
   "gte",
+  "lt",
   "lte",
-  "between",
   "inDateRange",
+  "notInDateRange",
+  "beforeDate",
+  "beforeOrOnDate",
+  "afterDate",
+  "afterOrOnDate",
 ]);
 
-export type FilterOperator = z.infer<typeof filterOperatorSchema>;
-
-export const FILTER_OPERATOR_LABELS: Record<FilterOperator, string> = {
-  equals: "等于",
-  notEquals: "不等于",
-  contains: "包含",
-  gt: "大于",
-  lt: "小于",
-  gte: "大于等于",
-  lte: "小于等于",
-  between: "范围内",
-  inDateRange: "在时间范围内",
-};
+const unaryOperatorSchema = z.enum(["set", "notSet"]);
 
-const baseFilterSchema = z.object({
+const baseFilterShape = {
   id: z.string(),
-  member: z.string(),
-});
-
-export const equalsFilterSchema = baseFilterSchema.extend({
-  operator: z.enum(["equals", "notEquals"]),
-  value: z.union([z.string(), z.number()]),
-});
-
-export type EqualsFilter = z.infer<typeof equalsFilterSchema>;
-
-export const compareFilterSchema = baseFilterSchema.extend({
-  operator: z.enum(["gt", "lt", "gte", "lte"]),
-  value: z.number(),
-});
-
-export type CompareFilter = z.infer<typeof compareFilterSchema>;
+  member: z.string().optional(),
+  dimension: z.string().optional(),
+};
 
-export const containsFilterSchema = baseFilterSchema.extend({
-  operator: z.literal("contains"),
+const binaryFilterSchema = z.object({
+  ...baseFilterShape,
+  operator: binaryOperatorSchema,
   values: z.array(z.string()),
 });
 
-export type ContainsFilter = z.infer<typeof containsFilterSchema>;
-
-export const betweenFilterSchema = baseFilterSchema.extend({
-  operator: z.literal("between"),
-  range: z.tuple([z.number(), z.number()]),
-});
-
-export type BetweenFilter = z.infer<typeof betweenFilterSchema>;
-
-export const dateRangeFilterSchema = baseFilterSchema.extend({
-  operator: z.literal("inDateRange"),
-  dateRange: z.tuple([z.string(), z.string()]),
+const unaryFilterSchema = z.object({
+  ...baseFilterShape,
+  operator: unaryOperatorSchema,
 });
 
-export type DateRangeFilter = z.infer<typeof dateRangeFilterSchema>;
-
-export const filterConditionSchema = z.discriminatedUnion("operator", [
-  equalsFilterSchema,
-  compareFilterSchema,
-  containsFilterSchema,
-  betweenFilterSchema,
-  dateRangeFilterSchema,
-]);
-
-export type FilterCondition = z.infer<typeof filterConditionSchema>;
-
-export const createEmptyFilter = (id: string): EqualsFilter => ({
-  id,
-  member: "",
-  operator: "equals",
-  value: "",
-});
+export type Filter =
+  | {
+      id: string;
+      member?: string;
+      dimension?: string;
+      operator: z.infer<typeof binaryOperatorSchema>;
+      values: string[];
+    }
+  | {
+      id: string;
+      member?: string;
+      dimension?: string;
+      operator: z.infer<typeof unaryOperatorSchema>;
+    };
+
+export const filterSchema: z.ZodType<Filter> = z.lazy(() =>
+  z.union([binaryFilterSchema, unaryFilterSchema]),
+);

package/schemas/index.ts

@@ -1,3 +1,4 @@
 export * from "./filter";
 export * from "./metric";
+export * from "./rpa-event";
 export * from "./time";

package/schemas/metric.ts

@@ -1,84 +1,15 @@
 import { z } from "zod";
-import { filterConditionSchema } from "./filter";
+import { filterSchema } from "./filter";
 import { timeGrainSchema } from "./time";
 
 export const metricQueryConfigSchema = z.object({
   table: z.string(),
-  distinctOn: z.string().optional(),
-  timeDimension: z.string().optional(),
+  value: z.string(),
+  timeDimension: z.string(),
   dimensions: z.array(z.string()),
-  filters: z.array(filterConditionSchema),
-  timeGrain: timeGrainSchema,
+  filters: z.array(filterSchema),
+  timeGrain: z.array(timeGrainSchema),
+  format: z.enum(["number", "currency", "percent"]),
 });
 
 export type MetricQueryConfig = z.infer<typeof metricQueryConfigSchema>;
-
-export const DEFAULT_QUERY_CONFIG: MetricQueryConfig = {
-  table: "",
-  distinctOn: "",
-  timeDimension: "",
-  dimensions: [],
-  filters: [],
-  timeGrain: "all",
-};
-
-export const metricVisualConfigSchema = z.object({
-  chartType: z.enum([
-    "line",
-    "bar",
-    "area",
-    "pie",
-    "donut",
-    "stacked-bar",
-    "combo",
-    "radar",
-    "funnel",
-    "gauge",
-  ]),
-  colors: z.array(z.string()).optional(),
-  showLegend: z.boolean().default(true),
-  showGrid: z.boolean().default(true),
-  xAxis: z
-    .object({
-      label: z.string().optional(),
-      dataKey: z.string().optional(),
-    })
-    .optional(),
-  yAxis: z
-    .object({
-      label: z.string().optional(),
-      unit: z.string().optional(),
-      min: z.number().optional(),
-      max: z.number().optional(),
-    })
-    .optional(),
-  tooltip: z
-    .object({
-      show: z.boolean().default(true),
-    })
-    .optional(),
-});
-
-export type MetricVisualConfig = z.infer<typeof metricVisualConfigSchema>;
-
-export const DEFAULT_VISUAL_CONFIG: MetricVisualConfig = {
-  chartType: "line",
-  showLegend: true,
-  showGrid: true,
-};
-
-export function parseMetricQueryConfig(
-  data: unknown,
-): MetricQueryConfig | null {
-  const result = metricQueryConfigSchema.safeParse(data);
-  if (result.success) {
-    return result.data;
-  }
-  return null;
-}
-
-export function parseMetricQueryConfigOrDefault(
-  data: unknown,
-): MetricQueryConfig {
-  return parseMetricQueryConfig(data) ?? DEFAULT_QUERY_CONFIG;
-}

package/schemas/rpa-event.ts

@@ -0,0 +1,41 @@
+import z from "zod";
+
+// RPA 事件基础字段
+export const rpaEventBaseSchema = z.object({
+  shopId: z.string(),
+  agentConfigId: z.string(),
+  stage: z.enum(["queued", "executing", "success", "failed"]),
+  message: z.string().nullable().optional(),
+  timestamp: z.number().optional(),
+});
+
+// 回复消息事件
+export const replyMessageEventSchema = rpaEventBaseSchema.extend({
+  eventType: z.literal("reply-message"),
+  payload: z.record(z.string(), z.unknown()),
+});
+
+// 变更客服状态事件
+export const changeCsStatusEventSchema = rpaEventBaseSchema.extend({
+  eventType: z.literal("change-cs-status"),
+  payload: z.record(z.string(), z.unknown()),
+});
+
+// 用户消息事件
+export const userMessageEventSchema = rpaEventBaseSchema.extend({
+  eventType: z.literal("user-message"),
+  payload: z.object({
+    platform: z.string(),
+    userId: z.string(),
+    uid: z.string(),
+  }),
+});
+
+// RPA 事件 Schema (Discriminated Union)
+export const rpaEventSchema = z.discriminatedUnion("eventType", [
+  replyMessageEventSchema,
+  changeCsStatusEventSchema,
+  userMessageEventSchema,
+]);
+
+export type RpaEvent = z.infer<typeof rpaEventSchema>;

package/schemas/time.ts

@@ -1,64 +1,11 @@
+import type { TimeDimensionPredefinedGranularity } from "@cubejs-client/core";
 import { z } from "zod";
 
-export const timeGrainSchema = z.enum([
-  "all",
-  "day",
-  "week",
-  "month",
-  "quarter",
-  "year",
-]);
+const predefinedGrins: [
+  TimeDimensionPredefinedGranularity,
+  ...TimeDimensionPredefinedGranularity[],
+] = ["minute", "hour", "day", "week", "month", "quarter", "year"] as const;
 
-export type TimeGrain = z.infer<typeof timeGrainSchema>;
-
-export const TIME_GRAIN_OPTIONS: { value: TimeGrain; label: string }[] = [
-  { value: "all", label: "全部" },
-  { value: "day", label: "天" },
-  { value: "week", label: "周" },
-  { value: "month", label: "月" },
-  { value: "quarter", label: "季" },
-  { value: "year", label: "年" },
-];
-
-export const timeRangePresetSchema = z.enum([
-  "today",
-  "yesterday",
-  "last7days",
-  "last30days",
-  "last90days",
-  "last180days",
-  "last365days",
-  "last730days",
-  "last1825days",
-  "thisMonth",
-  "lastMonth",
-  "thisQuarter",
-  "thisYear",
-]);
-
-export type TimeRangePreset = z.infer<typeof timeRangePresetSchema>;
+export const timeGrainSchema = z.enum(predefinedGrins);
 
-export const dateRangeSchema = z.object({
-  preset: timeRangePresetSchema.optional(),
-  startDate: z.string().optional(),
-  endDate: z.string().optional(),
-});
-
-export type DateRange = z.infer<typeof dateRangeSchema>;
-
-export const TIME_RANGE_OPTIONS: {
-  value: TimeRangePreset;
-  label: string;
-  days: number;
-}[] = [
-  { value: "last7days", label: "近 7 天", days: 7 },
-  { value: "last30days", label: "近 30 天", days: 30 },
-  { value: "last90days", label: "近 90 天", days: 90 },
-  { value: "last180days", label: "近半年", days: 180 },
-  { value: "last365days", label: "近 1 年", days: 365 },
-  { value: "last730days", label: "近 2 年", days: 730 },
-  { value: "last1825days", label: "近 5 年", days: 1825 },
-  { value: "thisMonth", label: "本月", days: 30 },
-  { value: "thisQuarter", label: "本季度", days: 90 },
-  { value: "thisYear", label: "本年", days: 365 },
-];
+export type TimeGrain = z.infer<typeof timeGrainSchema>;