@runflow-ai/sdk 1.1.11 → 1.1.13

package/dist/_runflow-shared/types/__tests__/dashboard-cards.normalize.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Snapshot tests for `normalizeCardConfig`. Each pair (input → canonical
+ * output) is one historical legacy shape we've seen in the wild plus an
+ * already-canonical case to confirm idempotency.
+ */
+export {};

package/dist/_runflow-shared/types/__tests__/dashboard-cards.normalize.test.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Snapshot tests for `normalizeCardConfig`. Each pair (input → canonical
+ * output) is one historical legacy shape we've seen in the wild plus an
+ * already-canonical case to confirm idempotency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const dashboard_cards_normalize_1 = require("../dashboard-cards.normalize");
+describe("normalizeCardConfig", () => {
+    describe("table", () => {
+        test("tableMode → mode", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("table", {
+                eventName: "sale",
+                tableMode: "raw",
+                columns: ["a", "b"],
+            });
+            expect(r.config).toMatchObject({ mode: "raw", columns: ["a", "b"] });
+            expect(r.config.tableMode).toBeUndefined();
+            expect(r.aliasesApplied).toContain("table.tableMode->mode");
+        });
+        test("already-canonical config is untouched", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("table", {
+                mode: "aggregate",
+                groupByKey: "status",
+            });
+            expect(r.config).toEqual({ mode: "aggregate", groupByKey: "status" });
+            expect(r.aliasesApplied).toEqual([]);
+        });
+    });
+    describe("funnel", () => {
+        test("funnelSteps → steps + defaults funnelMode to multi_event", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("funnel", {
+                funnelSteps: [
+                    { eventName: "a", label: "A" },
+                    { eventName: "b", label: "B" },
+                ],
+            });
+            expect(r.config).toMatchObject({
+                funnelMode: "multi_event",
+                steps: [
+                    { eventName: "a", label: "A" },
+                    { eventName: "b", label: "B" },
+                ],
+            });
+            expect(r.config.funnelSteps).toBeUndefined();
+            expect(r.aliasesApplied).toContain("funnel.funnelSteps->steps");
+            expect(r.aliasesApplied).toContain("funnel.missingFunnelMode->multi_event");
+        });
+        test("stepEvents → steps (older builds)", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("funnel", {
+                funnelMode: "multi_event",
+                stepEvents: [{ eventName: "x" }],
+            });
+            expect(r.config.steps).toEqual([{ eventName: "x" }]);
+            expect(r.aliasesApplied).toContain("funnel.stepEvents->steps");
+        });
+        test("single_event funnel passes through", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("funnel", {
+                funnelMode: "single_event",
+                eventName: "ticket",
+                propertyKey: "status",
+                stepValues: [{ value: "open" }, { value: "closed" }],
+            });
+            expect(r.config).toMatchObject({
+                funnelMode: "single_event",
+                eventName: "ticket",
+                propertyKey: "status",
+            });
+            expect(r.aliasesApplied).toEqual([]);
+        });
+    });
+    describe("gauge", () => {
+        test("thresholds [v1,v2] array → object", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("gauge", {
+                min: 0,
+                max: 100,
+                thresholds: [30, 70],
+            });
+            expect(r.config.thresholds).toEqual({ v1: 30, v2: 70 });
+            expect(r.aliasesApplied).toContain("gauge.thresholdsArray->object");
+        });
+        test("zoneColors [low,mid,high] array → object", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("gauge", {
+                min: 0,
+                max: 10,
+                thresholds: { v1: 3, v2: 7 },
+                zoneColors: ["#f00", "#ff0", "#0f0"],
+            });
+            expect(r.config.zoneColors).toEqual({
+                low: "#f00",
+                mid: "#ff0",
+                high: "#0f0",
+            });
+            expect(r.aliasesApplied).toContain("gauge.zoneColorsArray->object");
+        });
+        test("legacy `colors` field → zoneColors", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("gauge", {
+                min: 0,
+                max: 10,
+                thresholds: { v1: 3, v2: 7 },
+                colors: ["red", "yellow", "green"],
+            });
+            expect(r.config.zoneColors).toEqual({
+                low: "red",
+                mid: "yellow",
+                high: "green",
+            });
+            expect(r.config.colors).toBeUndefined();
+            expect(r.aliasesApplied).toContain("gauge.colorsArray->zoneColors");
+        });
+        test("range {from,to} → min/max", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("gauge", {
+                thresholds: { v1: 1, v2: 2 },
+                range: { from: 0, to: 5 },
+            });
+            expect(r.config.min).toBe(0);
+            expect(r.config.max).toBe(5);
+            expect(r.config.range).toBeUndefined();
+            expect(r.aliasesApplied).toContain("gauge.range->minMax");
+        });
+    });
+    describe("idempotency", () => {
+        test.each(["number", "rate", "line", "bar", "pie", "table", "funnel", "gauge"])("normalize is idempotent for %s", (cardType) => {
+            // Start with a legacy-ish input
+            const input = cardType === "table"
+                ? { tableMode: "raw" }
+                : cardType === "funnel"
+                    ? { funnelSteps: [{ eventName: "a" }, { eventName: "b" }] }
+                    : cardType === "gauge"
+                        ? { min: 0, max: 10, thresholds: [3, 7] }
+                        : { eventName: "x", aggregation: "count" };
+            const r1 = (0, dashboard_cards_normalize_1.normalizeCardConfig)(cardType, input);
+            const r2 = (0, dashboard_cards_normalize_1.normalizeCardConfig)(cardType, r1.config);
+            expect(r2.config).toEqual(r1.config);
+            // Second pass detects 0 aliases (already canonical)
+            expect(r2.aliasesApplied).toEqual([]);
+        });
+    });
+    describe("non-objects", () => {
+        test("null input → empty config", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("number", null);
+            expect(r.config).toEqual({});
+        });
+        test("undefined input → empty config", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("number", undefined);
+            expect(r.config).toEqual({});
+        });
+        test("primitive input → empty config", () => {
+            const r = (0, dashboard_cards_normalize_1.normalizeCardConfig)("number", "garbage");
+            expect(r.config).toEqual({});
+        });
+    });
+});

package/dist/_runflow-shared/types/__tests__/dashboard-cards.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for the grid-layout constraint helper and the zod schemas
+ * (discriminated union acceptance + per-card-type field validation).
+ */
+export {};

package/dist/_runflow-shared/types/__tests__/dashboard-cards.test.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Tests for the grid-layout constraint helper and the zod schemas
+ * (discriminated union acceptance + per-card-type field validation).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const dashboard_cards_1 = require("../dashboard-cards");
+const dashboard_cards_zod_1 = require("../dashboard-cards.zod");
+describe("GRID_CONSTRAINTS + isValidGridLayout", () => {
+    test("every card type has constraints", () => {
+        for (const t of dashboard_cards_1.ALL_CARD_TYPES) {
+            expect(dashboard_cards_1.GRID_CONSTRAINTS[t]).toBeDefined();
+            expect(dashboard_cards_1.GRID_CONSTRAINTS[t].minW).toBeGreaterThan(0);
+            expect(dashboard_cards_1.GRID_CONSTRAINTS[t].maxW).toBeGreaterThanOrEqual(dashboard_cards_1.GRID_CONSTRAINTS[t].minW);
+        }
+    });
+    test("minimum-sized layout passes for every type", () => {
+        for (const t of dashboard_cards_1.ALL_CARD_TYPES) {
+            const c = dashboard_cards_1.GRID_CONSTRAINTS[t];
+            const res = (0, dashboard_cards_1.isValidGridLayout)(t, { x: 0, y: 0, w: c.minW, h: c.minH });
+            expect(res.ok).toBe(true);
+        }
+    });
+    test("layout below minW is rejected with a useful reason", () => {
+        const res = (0, dashboard_cards_1.isValidGridLayout)("table", { x: 0, y: 0, w: 1, h: 5 });
+        expect(res.ok).toBe(false);
+        if (res.ok === false) {
+            expect(res.reason).toMatch(/w must be >= 4 for table/);
+        }
+    });
+    test("layout above maxW is rejected", () => {
+        const res = (0, dashboard_cards_1.isValidGridLayout)("number", { x: 0, y: 0, w: 99, h: 3 });
+        expect(res.ok).toBe(false);
+        if (res.ok === false) {
+            expect(res.reason).toMatch(/w must be <= 6 for number/);
+        }
+    });
+    test("negative x/y is rejected", () => {
+        const res = (0, dashboard_cards_1.isValidGridLayout)("number", { x: -1, y: 0, w: 3, h: 3 });
+        expect(res.ok).toBe(false);
+    });
+    test("unknown card type is rejected", () => {
+        const res = (0, dashboard_cards_1.isValidGridLayout)("bogus", {
+            x: 0,
+            y: 0,
+            w: 3,
+            h: 3,
+        });
+        expect(res.ok).toBe(false);
+    });
+});
+describe("GridLayoutItemSchema", () => {
+    test("accepts a valid 4-field object", () => {
+        expect(dashboard_cards_zod_1.GridLayoutItemSchema.safeParse({ x: 0, y: 0, w: 4, h: 3 }).success).toBe(true);
+    });
+    test("rejects missing fields", () => {
+        expect(dashboard_cards_zod_1.GridLayoutItemSchema.safeParse({ x: 0, y: 0, w: 4 }).success).toBe(false);
+    });
+    test("rejects extra fields (.strict())", () => {
+        expect(dashboard_cards_zod_1.GridLayoutItemSchema.safeParse({ x: 0, y: 0, w: 4, h: 3, span: 6 })
+            .success).toBe(false);
+    });
+    test("rejects non-integer values", () => {
+        expect(dashboard_cards_zod_1.GridLayoutItemSchema.safeParse({ x: 0, y: 0, w: 4.5, h: 3 }).success).toBe(false);
+    });
+});
+describe("DashboardCardInputSchema — happy paths per card type", () => {
+    test("number card with minimal config", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "number",
+            title: "Vendas",
+            config: { eventName: "sale", aggregation: "count" },
+        });
+        expect(r.success).toBe(true);
+    });
+    test("table card aggregate mode", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "table",
+            title: "Status",
+            config: {
+                mode: "aggregate",
+                groupByKey: "status",
+                metrics: [{ aggregation: "count" }],
+            },
+        });
+        expect(r.success).toBe(true);
+    });
+    test("funnel multi_event with 3 steps", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "funnel",
+            title: "Checkout",
+            config: {
+                funnelMode: "multi_event",
+                steps: [
+                    { eventName: "open" },
+                    { eventName: "started" },
+                    { eventName: "paid" },
+                ],
+            },
+        });
+        expect(r.success).toBe(true);
+    });
+    test("gauge with thresholds object", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "gauge",
+            title: "CSAT",
+            config: {
+                eventName: "csat",
+                aggregation: "avg",
+                propertyKey: "score",
+                min: 0,
+                max: 10,
+                thresholds: { v1: 3, v2: 7 },
+            },
+        });
+        expect(r.success).toBe(true);
+    });
+});
+describe("DashboardCardInputSchema — rejections", () => {
+    test("funnel multi_event requires >= 2 steps", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "funnel",
+            title: "x",
+            config: {
+                funnelMode: "multi_event",
+                steps: [{ eventName: "only-one" }],
+            },
+        });
+        expect(r.success).toBe(false);
+        if (!r.success) {
+            expect(r.error.issues.some((i) => i.message.includes("requires at least 2 steps"))).toBe(true);
+        }
+    });
+    test("gauge.min >= gauge.max is rejected", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "gauge",
+            title: "x",
+            config: {
+                min: 10,
+                max: 0,
+                thresholds: { v1: 1, v2: 5 },
+            },
+        });
+        expect(r.success).toBe(false);
+        if (!r.success) {
+            expect(r.error.issues.some((i) => i.message.includes("must be strictly less than gauge.max"))).toBe(true);
+        }
+    });
+    test("gauge.thresholds.v1 > v2 is rejected", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "gauge",
+            title: "x",
+            config: {
+                min: 0,
+                max: 100,
+                thresholds: { v1: 70, v2: 30 },
+            },
+        });
+        expect(r.success).toBe(false);
+    });
+    test("funnel single_event requires eventName + propertyKey + stepValues", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "funnel",
+            title: "x",
+            config: { funnelMode: "single_event" },
+        });
+        expect(r.success).toBe(false);
+        if (!r.success) {
+            const messages = r.error.issues.map((i) => i.message);
+            expect(messages.some((m) => m.includes("requires eventName"))).toBe(true);
+            expect(messages.some((m) => m.includes("requires propertyKey"))).toBe(true);
+        }
+    });
+    test("unknown cardType is rejected by the discriminator", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "bogus",
+            title: "x",
+            config: {},
+        });
+        expect(r.success).toBe(false);
+    });
+    test("gridLayout that violates cardType constraints is rejected", () => {
+        const r = dashboard_cards_zod_1.DashboardCardInputSchema.safeParse({
+            cardType: "number",
+            title: "small",
+            config: { eventName: "x", aggregation: "count" },
+            // number requires minW=2 minH=2, maxW=6 maxH=4 — this one is 8 wide
+            gridLayout: { x: 0, y: 0, w: 8, h: 3 },
+        });
+        expect(r.success).toBe(false);
+        if (!r.success) {
+            expect(r.error.issues.some((i) => i.message.includes("w must be <= 6"))).toBe(true);
+        }
+    });
+});