@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/lanes/report.js

@@ -0,0 +1,476 @@
+import { z } from "zod";
+import { ENDPOINTS } from "../endpoints.js";
+import { capabilityArg, environmentArg } from "../args.js";
+import { governedRead } from "../read.js";
+import { writeTool } from "../write.js";
+import { defineTool, ToolRefusalError } from "../tool-types.js";
+import { wireCall, WireError } from "../wire.js";
+import { biCall, DEFAULT_BI_CORP_ID } from "../bi-wire.js";
+import { REPORT_LANE_CONTRACT } from "./report-contract.js";
+const LANE = REPORT_LANE_CONTRACT.lane;
+const TOOLS = REPORT_LANE_CONTRACT.tools;
+/**
+ * The default BI dashboard `global` (theme21). A brand-new report page has no
+ * BI dashboard record until it is saved, and the BI save requires a `global`
+ * JSON string; this is the live-captured default so a freshly created report
+ * renders instead of failing or coming up unstyled.
+ */
+export const DEFAULT_REPORT_GLOBAL = Object.freeze({
+    styles: {
+        theme: {
+            type: "theme21",
+            colors: ["#677EFF", "#FF794D", "#33C5E8", "#FFC836", "#66CA5A", "#FD787F", "#6FACED", "#FAAC3D", "#C178FE", "#D1F16D", "#FD787F", "#FFDA60", "#FF90A5", "#65E0E3", "#FA993D", "#46D399", "#8D6AFF", "#6FD0ED", "#A573FF", "#FD656D"],
+        },
+        paintCoatTheme: "default",
+        paintCoat: { type: "bgColor", value: "#F1F2F5", image: null, showMode: "draw" },
+        elementCoat: { type: "bgColor", value: "#FFFFFF" },
+        fontSetting: { titleColor: "#121933", fontColor: null },
+        globalGapSetting: { globalGapSetting: "dense", gridGapSetting: "dense", innerGapSetting: "dense" },
+        gridLayout: { rowHeight: 32, colNumber: 32 },
+        roundedCornerSetting: { roundedCornerSetting: "default", isCustom: false, customCorner: "" },
+        globalTimer: { autoRefreshEnabled: false, refreshInterval: 5 },
+        arrangementMode: "multiRow",
+    },
+});
+const chartObject = z.record(z.string(), z.unknown());
+function authOf(corpId, reportCode, appCode) {
+    return { corpId: corpId ?? DEFAULT_BI_CORP_ID, reportCode, appCode };
+}
+/** Parse a JSON string, returning the raw text when it is not JSON. */
+function parseJsonText(value) {
+    if (typeof value !== "string")
+        return value;
+    const text = value.trim();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return value;
+    }
+}
+function isMissingDashboard(error) {
+    return error instanceof WireError && /dashboard\.not\.exist|The dashboard does not exist/i.test(error.message);
+}
+/** Recursively collect report functions from a report tree (queryReportChartTree[*]). */
+function collectReports(node, out) {
+    if (Array.isArray(node)) {
+        for (const item of node)
+            collectReports(item, out);
+        return;
+    }
+    if (!node || typeof node !== "object")
+        return;
+    const record = node;
+    if (Array.isArray(record.appReportChartList)) {
+        const charts = record.appReportChartList.map((chart) => ({
+            uuid: chart.uuid,
+            title: chart.title,
+            type: chart.type,
+            objectId: chart.objectId,
+        }));
+        out.push({
+            code: record.code,
+            name: record.name,
+            appCode: record.appCode,
+            objectId: charts.length > 0 ? charts[0].objectId : record.reportObjectId,
+            charts,
+        });
+    }
+    for (const key of ["children", "appFunctionList", "appReportChartList"]) {
+        if (record[key] !== undefined)
+            collectReports(record[key], out);
+    }
+}
+/**
+ * The report page's parent folder id. `report/get` does NOT return `parentId`
+ * directly — live it must come from the last `folderList` entry (app → … →
+ * immediate folder). /api/report/update 500s ("服务异常") when parentId is
+ * absent, so this is required rather than cosmetic. The fake seeds a plain
+ * `parentId`, which is preferred when present.
+ */
+function pageParentId(page) {
+    if (typeof page.parentId === "string" && page.parentId)
+        return page.parentId;
+    const list = Array.isArray(page.folderList) ? page.folderList : [];
+    const last = list[list.length - 1];
+    return last && typeof last.id === "string" ? last.id : undefined;
+}
+function reportPageView(page) {
+    return {
+        id: page.id,
+        reportObjectId: page.reportObjectId ?? page.id,
+        code: page.code,
+        name: page.name,
+        nameI18n: parseJsonText(page.name_i18n),
+        i18nMessage: page.i18nMessage,
+        appCode: page.appCode,
+        icon: page.icon,
+        description: page.description,
+        pcAble: page.pcAble,
+        mobileAble: page.mobileAble,
+        parentId: pageParentId(page),
+    };
+}
+function chartView(chart) {
+    return {
+        uuid: chart.uuid,
+        title: chart.title,
+        type: chart.type,
+        dataSourceId: chart.dataSourceId,
+        mainTable: chart.mainTable,
+        position: parseJsonText(chart.position),
+    };
+}
+/** Read the BI config, treating a missing dashboard as present:false rather than an error. */
+async function readBiConfig(session, auth, objectId) {
+    try {
+        const data = (await biCall(session, {
+            path: ENDPOINTS.biReportConfig,
+            body: { objectId },
+            query: { lang: "cn" },
+            auth,
+        }));
+        if (!data || typeof data !== "object")
+            return { present: false, charts: [] };
+        return {
+            present: true,
+            corpId: data.corpId,
+            title: data.title,
+            charts: Array.isArray(data.charts) ? data.charts : [],
+            global: parseJsonText(data.global),
+            attributes: parseJsonText(data.attributes),
+        };
+    }
+    catch (error) {
+        if (isMissingDashboard(error))
+            return { present: false, charts: [] };
+        throw error;
+    }
+}
+function requireCode(code) {
+    const value = code.trim();
+    if (!/^[A-Za-z][A-Za-z0-9_]{0,59}$/.test(value))
+        throw new ToolRefusalError({ status: "refused", blocker: "report-code-invalid", message: "报表页 code 必须字母开头、≤60、仅字母数字下划线" });
+    return value;
+}
+function jsonString(value, fallback) {
+    if (value === undefined)
+        return JSON.stringify(fallback);
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+/**
+ * The chart query model the BI `chartdata` endpoint expects. The stored chart
+ * (from report/v2/config) keeps its query definition in `data` as a JSON string
+ * and models `limit` as `{ value, showOthers }`; the API wants the flattened
+ * `dimension`/`metric`/… at the top level with `limit` as an Integer. Verified
+ * by replaying the viewer's own request (live 2026-09-30): sending the raw chart
+ * answers server.error; this normalization answers with the series.
+ */
+function chartParamModel(chart) {
+    const decoded = typeof chart.data === "string" ? parseJsonText(chart.data) : chart.data;
+    const d = decoded && typeof decoded === "object" && !Array.isArray(decoded) ? decoded : {};
+    const rawLimit = d.limit;
+    const limit = rawLimit && typeof rawLimit === "object" ? (rawLimit.value ?? null) : (rawLimit ?? null);
+    const relations = typeof chart.relations === "string" ? parseJsonText(chart.relations) : chart.relations;
+    return {
+        title: chart.title,
+        id: chart.id ?? chart.uuid,
+        authorization: chart.authorization,
+        dataSourceId: chart.dataSourceId,
+        useType: chart.useType,
+        type: chart.type,
+        dimension: d.dimension ?? [],
+        dynamicParams: d.dynamicParams ?? [],
+        metric: d.metric ?? [],
+        filter: d.filter ?? [],
+        sort: d.sort ?? [],
+        limit,
+        relations: relations ?? [],
+        mainTable: chart.mainTable,
+        options: d.options ?? {},
+        filterNone: d.filterNone,
+    };
+}
+export function registerReportLane(tools) {
+    tools.push(defineTool({
+        name: "report.tree",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["report.tree"].scope,
+        description: TOOLS["report.tree"].description,
+        inputSchema: { environment: environmentArg, capability: capabilityArg, appCode: z.string().optional() },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const data = args.appCode
+                ? (await wireCall(session, { path: ENDPOINTS.reportTreeByApp, query: { appCode: args.appCode } })).data
+                : (await wireCall(session, { path: ENDPOINTS.reportTreeAll, method: "POST", body: {} })).data;
+            const reports = [];
+            collectReports(data, reports);
+            return { appCode: args.appCode ?? null, reportCount: reports.length, reports };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "report.get",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["report.get"].scope,
+        description: TOOLS["report.get"].description,
+        inputSchema: { environment: environmentArg, capability: capabilityArg, code: z.string().min(1), corpId: z.string().optional(), full: z.boolean().default(false) },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const page = (await wireCall(session, { path: ENDPOINTS.reportGet, query: { code: args.code } })).data;
+            const objectId = String(page.id ?? page.reportObjectId ?? "");
+            const auth = authOf(args.corpId, String(page.code ?? args.code), String(page.appCode ?? ""));
+            const bi = objectId ? await readBiConfig(session, auth, objectId) : { present: false, charts: [], title: undefined, global: undefined, attributes: undefined };
+            const biView = {
+                present: bi.present,
+                corpId: bi.corpId ?? args.corpId ?? DEFAULT_BI_CORP_ID,
+                title: bi.title,
+                chartCount: bi.charts.length,
+                charts: bi.charts.map(chartView),
+                globalPresent: bi.global !== undefined && JSON.stringify(bi.global) !== "{}",
+                attributesPresent: bi.attributes !== undefined && JSON.stringify(bi.attributes) !== "{}",
+            };
+            return {
+                report: reportPageView(page),
+                bi: biView,
+                global: bi.global,
+                attributes: bi.attributes,
+                charts: bi.charts,
+                ...(args.full ? { rawPage: page } : {}),
+            };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "report.chartdata",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["report.chartdata"].scope,
+        description: TOOLS["report.chartdata"].description,
+        inputSchema: {
+            environment: environmentArg,
+            capability: capabilityArg,
+            reportCode: z.string().min(1),
+            appCode: z.string().min(1),
+            chart: chartObject,
+            dataSourceId: z.string().optional(),
+            corpId: z.string().optional(),
+            lang: z.string().default("en-US"),
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const raw = args.chart;
+            const chart = chartParamModel(raw);
+            const data = await biCall(session, {
+                path: ENDPOINTS.biChartData,
+                query: { lang: args.lang },
+                body: { chart, dataSourceId: args.dataSourceId ?? raw.dataSourceId, corpId: args.corpId ?? DEFAULT_BI_CORP_ID },
+                auth: authOf(args.corpId, args.reportCode, args.appCode),
+            });
+            return { data };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "report.datasource.list",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["report.datasource.list"].scope,
+        description: TOOLS["report.datasource.list"].description,
+        inputSchema: {
+            environment: environmentArg,
+            capability: capabilityArg,
+            kind: z.enum(["model", "advanced", "all"]).default("all"),
+            reportCode: z.string().min(1),
+            appCode: z.string().min(1),
+            corpId: z.string().optional(),
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const auth = authOf(args.corpId, args.reportCode, args.appCode);
+            const fetchOne = (path) => biCall(session, { path, body: {}, query: { lang: "cn" }, auth }).then((data) => (Array.isArray(data) ? data : []));
+            const model = args.kind === "advanced" ? [] : await fetchOne(ENDPOINTS.biDatasourceModelList);
+            const advanced = args.kind === "model" ? [] : await fetchOne(ENDPOINTS.biDatasourceAdvancedList);
+            const seen = new Set();
+            const merged = [...model, ...advanced].filter((entry) => {
+                const id = String(entry.dataSourceId ?? entry.objectId ?? "");
+                if (!id || seen.has(id))
+                    return false;
+                seen.add(id);
+                return true;
+            });
+            return { kind: args.kind, count: merged.length, datasources: merged };
+        }),
+    }));
+    writeTool(tools, "report.datasource.link", LANE, TOOLS["report.datasource.link"].scope, TOOLS["report.datasource.link"].description, {
+        reportCode: z.string().min(1),
+        appCode: z.string().min(1),
+        dataSourceInfos: z.array(z.object({ dataSourceId: z.string().min(1), useType: z.number().int().optional() })).min(1),
+        corpId: z.string().optional(),
+    }, async (session, args) => {
+        const auth = authOf(args.corpId, args.reportCode, args.appCode);
+        const infos = args.dataSourceInfos.map((info) => ({ dataSourceId: info.dataSourceId, useType: info.useType ?? 1 }));
+        const linked = (await biCall(session, { path: ENDPOINTS.biDatasourceModelLink, body: { dataSourceInfos: infos }, query: { lang: "cn" }, auth }));
+        const models = Array.isArray(linked) ? linked : [];
+        return {
+            performed: { errcode: 0, linked: infos.map((info) => info.dataSourceId) },
+            readback: { linkedCount: models.length, models: models.map((model) => ({ dataSourceId: model.dataSourceId, displayName: model.displayName, tableName: model.schema?.tableName })) },
+        };
+    });
+    writeTool(tools, "report.create", LANE, TOOLS["report.create"].scope, TOOLS["report.create"].description, {
+        code: z.string().min(1),
+        name: z.string().min(1).max(60),
+        appCode: z.string().min(1),
+        parentId: z.string().min(1),
+        icon: z.string().default("h-icon-all-Report"),
+        nameI18n: z.union([z.record(z.string(), z.string()), z.string()]).optional(),
+        pcAble: z.boolean().default(true),
+        mobileAble: z.boolean().default(true),
+        corpId: z.string().optional(),
+    }, async (session, args) => {
+        const code = requireCode(args.code);
+        const created = (await wireCall(session, {
+            path: ENDPOINTS.reportCreate,
+            method: "POST",
+            body: {
+                code,
+                name: args.name,
+                parentId: args.parentId,
+                icon: args.icon,
+                name_i18n: typeof args.nameI18n === "string" ? args.nameI18n : JSON.stringify(args.nameI18n ?? { zh: args.name }),
+                pcAble: args.pcAble,
+                mobileAble: args.mobileAble,
+                appCode: args.appCode,
+            },
+        })).data;
+        const page = (await wireCall(session, { path: ENDPOINTS.reportGet, query: { code } })).data;
+        const objectId = String(page.id ?? page.reportObjectId ?? "");
+        if (objectId) {
+            await biCall(session, {
+                path: ENDPOINTS.biReportPageSave,
+                body: { report: { objectId, title: args.name, attributes: "{}", global: JSON.stringify(DEFAULT_REPORT_GLOBAL) } },
+                auth: authOf(args.corpId, code, args.appCode),
+            });
+        }
+        void created;
+        return {
+            performed: { errcode: 0, code, appCode: args.appCode, objectId },
+            readback: { present: page.code === code, report: reportPageView(page), biInitialized: objectId !== "" },
+        };
+    }, (args) => requireCode(args.code));
+    writeTool(tools, "report.update", LANE, TOOLS["report.update"].scope, TOOLS["report.update"].description, {
+        code: z.string().min(1),
+        name: z.string().min(1).max(60).optional(),
+        icon: z.string().optional(),
+        nameI18n: z.union([z.record(z.string(), z.string()), z.string()]).optional(),
+        pcAble: z.boolean().optional(),
+        mobileAble: z.boolean().optional(),
+        parentId: z.string().optional(),
+    }, async (session, args) => {
+        const page = (await wireCall(session, { path: ENDPOINTS.reportGet, query: { code: args.code } })).data;
+        if (!page || !page.id)
+            throw new ToolRefusalError({ status: "refused", blocker: "report-not-found", message: `报表页 ${args.code} 不存在` });
+        const name = args.name ?? String(page.name ?? "");
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.reportUpdate,
+            method: "POST",
+            body: {
+                id: page.id,
+                code: page.code ?? args.code,
+                appCode: page.appCode,
+                name,
+                parentId: args.parentId ?? pageParentId(page),
+                icon: args.icon ?? page.icon,
+                name_i18n: typeof args.nameI18n === "string" ? args.nameI18n : JSON.stringify(args.nameI18n ?? parseJsonText(page.name_i18n) ?? { zh: name }),
+                pcAble: args.pcAble ?? page.pcAble,
+                mobileAble: args.mobileAble ?? page.mobileAble,
+            },
+        });
+        const after = (await wireCall(session, { path: ENDPOINTS.reportGet, query: { code: args.code } })).data;
+        return { performed: { errcode: performed.errcode }, readback: { present: Boolean(after && after.code), report: reportPageView(after) } };
+    });
+    writeTool(tools, "report.delete", LANE, TOOLS["report.delete"].scope, TOOLS["report.delete"].description, {
+        code: z.string().min(1),
+        corpId: z.string().optional(),
+    }, async (session, args) => {
+        const page = (await wireCall(session, { path: ENDPOINTS.reportGet, query: { code: args.code } })).data;
+        let dashboardRemoved = false;
+        if (page && page.id) {
+            try {
+                await biCall(session, {
+                    path: ENDPOINTS.biReportRemove,
+                    body: { objectId: page.id },
+                    auth: authOf(args.corpId, String(page.code ?? args.code), String(page.appCode ?? "")),
+                });
+                dashboardRemoved = true;
+            }
+            catch (error) {
+                if (!isMissingDashboard(error))
+                    throw error;
+            }
+        }
+        const performed = await wireCall(session, { path: ENDPOINTS.reportDelete, method: "POST", query: { code: args.code } });
+        const tree = (await wireCall(session, { path: ENDPOINTS.reportTreeByApp, query: { appCode: String(page?.appCode ?? "") } })).data;
+        const remaining = [];
+        collectReports(tree, remaining);
+        const stillListed = remaining.some((report) => report.code === args.code);
+        return { performed: { errcode: performed.errcode, code: args.code, dashboardRemoved }, readback: { absent: !stillListed, remainingInTree: stillListed } };
+    });
+    writeTool(tools, "report.configure", LANE, TOOLS["report.configure"].scope, TOOLS["report.configure"].description, {
+        reportCode: z.string().min(1),
+        appCode: z.string().min(1),
+        global: z.union([z.record(z.string(), z.unknown()), z.string()]).optional(),
+        attributes: z.union([z.record(z.string(), z.unknown()), z.string()]).optional(),
+        charts: z.array(chartObject).optional(),
+        removeUnlistedCharts: z.boolean().default(false),
+        corpId: z.string().optional(),
+    }, async (session, args) => {
+        const auth = authOf(args.corpId, args.reportCode, args.appCode);
+        const page = (await wireCall(session, { path: ENDPOINTS.reportGet, query: { code: args.reportCode } })).data;
+        const objectId = String(page?.id ?? page?.reportObjectId ?? "");
+        if (!objectId)
+            throw new ToolRefusalError({ status: "refused", blocker: "report-not-found", message: `报表页 ${args.reportCode} 不存在` });
+        const current = await readBiConfig(session, auth, objectId);
+        if (!current.present)
+            throw new ToolRefusalError({ status: "refused", blocker: "report-dashboard-absent", message: `报表页 ${args.reportCode} 的 BI dashboard 不存在；先 report.create 初始化或用 report.get 确认 present` });
+        const existing = new Map(current.charts.map((chart) => [String(chart.uuid), chart]));
+        const declared = args.charts ?? [];
+        const toAdd = [];
+        const toUpdate = [];
+        const kept = new Set();
+        for (const chart of declared) {
+            const uuid = chart.uuid;
+            if (typeof uuid !== "string" || !uuid)
+                throw new ToolRefusalError({ status: "refused", blocker: "report-chart-uuid-required", message: "report.configure 的每个图表必须带 uuid（既有=更新，新图表自带 uuid）" });
+            kept.add(uuid);
+            // The BI write face scopes charts by their parent report objectId; stamp
+            // it so callers (and the intent compiler) need not know it.
+            const stamped = { ...chart, objectId };
+            (existing.has(uuid) ? toUpdate : toAdd).push(stamped);
+        }
+        const toRemove = args.removeUnlistedCharts ? [...existing.keys()].filter((uuid) => !kept.has(uuid)) : [];
+        const performed = {};
+        if (toAdd.length)
+            performed.added = (await biCall(session, { path: ENDPOINTS.biChartAdd, body: { charts: toAdd }, auth }));
+        if (toUpdate.length)
+            performed.updated = (await biCall(session, { path: ENDPOINTS.biChartUpdate, body: { charts: toUpdate }, auth }));
+        if (toRemove.length)
+            performed.removed = (await biCall(session, { path: ENDPOINTS.biChartRemoveMany, body: { objectIds: toRemove }, auth }));
+        if (args.global !== undefined)
+            performed.global = (await biCall(session, { path: ENDPOINTS.biReportSaveGlobal, body: { objectId, global: jsonString(args.global, {}) }, auth }));
+        if (args.attributes !== undefined)
+            performed.attributes = (await biCall(session, { path: ENDPOINTS.biReportSaveAttributes, body: { objectId, attributes: jsonString(args.attributes, {}) }, auth }));
+        const after = await readBiConfig(session, auth, objectId);
+        return {
+            performed: { ...performed, added: toAdd.length, updated: toUpdate.length, removed: toRemove.length },
+            readback: {
+                chartCount: after.charts.length,
+                charts: after.charts.map(chartView),
+                globalPresent: after.global !== undefined && JSON.stringify(after.global) !== "{}",
+                attributesPresent: after.attributes !== undefined && JSON.stringify(after.attributes) !== "{}",
+            },
+        };
+    });
+}
+//# sourceMappingURL=report.js.map