@stalfh233/omc-fake-platform 0.0.0-stage → 0.4.39

package/dist/model.js

@@ -0,0 +1,135 @@
+import { relationTargetOf } from "omc-core/relation-shape";
+import { MODEL_REFERENCED_DELETE_ERRCODE } from "omc-core/wire-facts";
+import { businessRefusal, NOT_HANDLED } from "./state.js";
+/** model-management lane: app tree, model CRUD, physical delete. Twin of src/lanes/model.ts. */
+export const modelRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/apppackage/trees": {
+            // Live fidelity (ticket 68): the tree row id is the AppFunction id, not
+            // the biz-model record id; appCode filters the tree, treeHidden models
+            // keep a record but no tree node. Ticket 83: rows carry parentId (live
+            // AppFunctionModel shape; bizmodels/update requires it) and the node
+            // display name comes from nodeName (the menu node is renamed
+            // independently of the schema record).
+            const appCode = q.appCode === undefined ? undefined : String(q.appCode);
+            // Live 8.6.26 fidelity (2026-09-17): the tree is NESTED — a Folder row
+            // carrying its BizModel children — not a flat list. The environment lane
+            // used a top-level map and silently dropped every model, so a live
+            // discover_environment with applicationCode returned no models. Consumers
+            // must flattenTreeRows (as resolveModelTreeNode already does); the fake
+            // must nest so a regression cannot pass.
+            const children = [...ctx.state.models.values()]
+                .filter((model) => !model.treeHidden && (appCode === undefined || (model.appCode ?? "test") === appCode))
+                .map((model) => ({ id: model.id, type: "BizModel", code: model.code, name: model.nodeName ?? model.name, parentId: "folder-1" }));
+            return [{ id: "folder-1", type: "FOLDER", code: "general", name: "General", children }];
+        }
+        case "/api/api/app/bizmodels/list_schema":
+            return [...ctx.state.models.values()].map((model) => ({ id: model.recordId, schemaCode: model.code, name: model.name }));
+        case "/api/api/app/bizmodels/create": {
+            const code = String(body.bizSchemaCode ?? body.code);
+            const n = ctx.state.models.size + 1;
+            ctx.state.models.set(code, {
+                id: `model-${n}-fn`,
+                recordId: `model-${n}-rec`,
+                code,
+                name: String(body.name ?? code),
+                appCode: String(body.applicationCode ?? body.appCode ?? "test"),
+            });
+            // Live fidelity (ticket 42): bizmodels/create seeds NO form — the model
+            // has no h_biz_sheet row until the form is created (bizsheet/create, or
+            // form.draft's scaffold-on-absent path). Do not pre-seed a sheet here.
+            return { schemaCode: code };
+        }
+        case "/api/api/app/apppackage/physically_delete": {
+            const rows = Array.isArray(input.body) ? input.body : [];
+            for (const row of rows) {
+                if (row.type === undefined || row.type === null || row.type === "") {
+                    ctx.state.apps.delete(String(row.code));
+                    continue;
+                }
+                const code = String(row.code);
+                // deleteFunctions semantics (ticket 23): a model referenced by
+                // another model's relation field cannot be deleted. Live: the sync
+                // face answers errcode 0 and the async dispatcher fails with
+                // ServiceException "xxx被模型 yyy 引用,不能删除"
+                // (AppIntegrationFacadeImpl.deleteFunctions:2201); the fake surfaces
+                // the check synchronously (MODEL_REFERENCED_DELETE_ERRCODE stands for
+                // the ServiceException envelope family) so the blocker and the
+                // referencing list are visible even when a caller bypasses the tool
+                // precheck. The live per-column async cascade (3-4s/column) is not
+                // simulated — the fake removes the model synchronously.
+                const referencers = [
+                    ...new Set([...ctx.state.fields.entries()]
+                        .filter(([key, field]) => !key.startsWith(`${code}#`) && relationTargetOf(field) === code)
+                        .map(([key]) => key.split("#")[0])),
+                ];
+                if (referencers.length > 0)
+                    return businessRefusal(MODEL_REFERENCED_DELETE_ERRCODE, `${code}被模型 ${referencers.join(",")} 引用,不能删除`);
+                // Ticket 68 live fidelity: physically_delete resolves each row id as an
+                // AppFunction id (removeBizModel → getAppFunction(id)); a biz-model
+                // record id is refused with 601003 业务模型不存在.
+                const model = ctx.state.models.get(code);
+                if (model && row.id !== model.id)
+                    return businessRefusal(601003, "业务模型不存在");
+                ctx.state.models.delete(code);
+                ctx.state.sheets.delete(code);
+                // The cascade drops the model's own bizproperty rows too — without
+                // this cleanup a deleted referencing model would keep blocking the
+                // referenced model's delete (dependency-inverted chains must pass).
+                for (const key of [...ctx.state.fields.keys()])
+                    if (key.startsWith(`${code}#`))
+                        ctx.state.fields.delete(key);
+            }
+            return null;
+        }
+        case "/api/api/app/bizmodels/exits_bizschema":
+            return ctx.state.models.has(q.schemaCode);
+        case "/api/api/app/bizmodels/get_summary":
+            // BizSchemaController.get_summary: an absent schema answers "" (ok), an
+            // existing one returns its summary string.
+            return ctx.state.models.get(q.schemaCode)?.summary ?? "";
+        case "/api/api/app/bizmodels/update_summary": {
+            // BizSchemaController.updateSummary: non-empty summary required
+            // (validateNotEmpty) and a missing schema answers the
+            // BIZ_SCHEMA_NOT_PUBLISHED errcode (ErrorCode.java:194 → 300014).
+            const schemaCode = String(body.schemaCode ?? "");
+            if (!ctx.state.models.has(schemaCode))
+                return businessRefusal(300014, "数据模型未发布");
+            const model = ctx.state.models.get(schemaCode);
+            model.summary = String(body.summary ?? "");
+            return null;
+        }
+        case "/api/api/app/bizmodels/get_all": {
+            const model = ctx.state.models.get(q.schemaCode);
+            return model ? { id: model.recordId, name: model.name, modelType: "LIST" } : null;
+        }
+        case "/api/api/app/bizmodels/update": {
+            // Ticket 83 (source-pinned BizSchemaController.update :266-305): the
+            // endpoint patches the AppFunction MENU NODE — bizSchemaCode, id, name,
+            // parentId are all validateNotEmpty-required; the schema RECORD is not
+            // migrated (get_all keeps the original name/type per probe evidence),
+            // so the rename lands on nodeName only.
+            const schemaCode = String(body.bizSchemaCode ?? body.schemaCode ?? "");
+            const model = ctx.state.models.get(schemaCode);
+            if (!model)
+                return businessRefusal(300014, "数据模型未发布");
+            const nodeId = String(body.id ?? "");
+            const name = String(body.name ?? "");
+            const parentId = String(body.parentId ?? "");
+            if (!nodeId)
+                return businessRefusal(10005, "id不能为空");
+            if (!name)
+                return businessRefusal(10005, "名称不能为空");
+            if (!parentId)
+                return businessRefusal(10005, "父id不可为空");
+            if (nodeId !== model.id)
+                return businessRefusal(10005, `id不是模型 ${schemaCode} 的应用树节点`);
+            model.nodeName = name;
+            return null;
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};

package/dist/online-js.d.ts

@@ -0,0 +1,3 @@
+import { type LaneRoute } from "./state.js";
+/** online-js lane: programming compile/get_source/publish. Twin of src/lanes/online-js.ts. */
+export declare const onlineJsRoute: LaneRoute;

package/dist/online-js.js

@@ -0,0 +1,17 @@
+import { NOT_HANDLED } from "./state.js";
+/** online-js lane: programming compile/get_source/publish. Twin of src/lanes/online-js.ts. */
+export const onlineJsRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/programming/compile":
+            return { compiled: true };
+        case "/api/api/programming/get_source":
+            return ctx.state.onlineJs.get(`${q.schemaCode}#${q.sheetCode}`) ?? null;
+        case "/api/api/programming/publish":
+            ctx.state.onlineJs.set(`${body.schemaCode}#${body.sheetCode}`, String(body.source));
+            return null;
+        default:
+            return NOT_HANDLED;
+    }
+};

package/dist/report.d.ts

@@ -0,0 +1,2 @@
+import { type LaneRoute } from "./state.js";
+export declare const reportRoute: LaneRoute;

package/dist/report.js

@@ -0,0 +1,252 @@
+import { businessRefusal, NOT_HANDLED, rawResponse } from "./state.js";
+/**
+ * R1-report fake. Twin of src/lanes/report.ts: the platform channel
+ * (`/api/api/report/*`, errcode envelope) owns the report page; the BI channel
+ * (`/dashboard/v1/*`, `{data}` / `{errorCode}` envelope) owns the dashboard and
+ * charts. Fidelity notes matching live (aozhe tenant):
+ *  - a BI call with no in-body `config` returns `{data:true}` but mutates
+ *    nothing (silent no-op);
+ *  - an absent dashboard answers `errorCode:"dashboard.not.exist"`;
+ *  - a report tree reports a page's charts from its BI dashboard.
+ */
+function reportTree(ctx, appCode) {
+    const pages = [...ctx.state.reportPages.values()].filter((page) => !appCode || page.appCode === appCode);
+    const byApp = new Map();
+    for (const page of pages) {
+        const list = byApp.get(page.appCode) ?? [];
+        list.push(page);
+        byApp.set(page.appCode, list);
+    }
+    return [...byApp.entries()].map(([app, appPages]) => ({
+        code: app,
+        appFunctionList: appPages.map((page) => ({
+            code: page.code,
+            name: page.name,
+            appCode: page.appCode,
+            type: "Report",
+            reportObjectId: page.id,
+            appReportChartList: (ctx.state.biDashboards.get(page.id)?.charts ?? []).map((chart) => ({
+                uuid: chart.uuid,
+                title: chart.title,
+                type: chart.type,
+                objectId: page.id,
+            })),
+        })),
+    }));
+}
+function hasConfig(body) {
+    const config = body.config;
+    return typeof config === "object" && config !== null;
+}
+/** BI error envelope (`{errorCode,...}`), returned verbatim with HTTP 200. */
+function biError(errorCode, errorMessage) {
+    return rawResponse({ errorCode, errorMessage, errorType: "BIZ" });
+}
+function biData(data) {
+    return rawResponse({ data });
+}
+function biNoop() {
+    return biData(true);
+}
+export const reportRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        // ---- platform channel ----
+        case "/api/api/app/folders/queryReportChartTree":
+            return reportTree(ctx);
+        case "/api/api/runtime/app/queryReportChartTreeByApp":
+            return reportTree(ctx, q.appCode);
+        case "/api/api/report/get": {
+            const page = ctx.state.reportPages.get(q.code);
+            if (!page)
+                return businessRefusal(302035, "报表不存在！");
+            // Live fidelity: report/get omits a top-level `parentId`; the immediate
+            // folder is the LAST folderList entry. The tool must derive parentId from
+            // it (report/update 500s without one).
+            const { parentId, ...rest } = page;
+            return { ...rest, reportObjectId: page.id, folderList: [{ id: parentId, type: "Folder" }] };
+        }
+        case "/api/api/report/create": {
+            const code = String(body.code ?? "");
+            if (!code)
+                return businessRefusal(50000, "code 不能为空");
+            if (ctx.state.reportPages.has(code))
+                return businessRefusal(50000, "编码重复");
+            const page = {
+                id: `report-${ctx.state.reportPages.size + 1}`,
+                code,
+                name: String(body.name ?? code),
+                appCode: String(body.appCode ?? ""),
+                parentId: String(body.parentId ?? ""),
+                icon: String(body.icon ?? "h-icon-all-Report"),
+                pcAble: body.pcAble !== false,
+                mobileAble: body.mobileAble !== false,
+                name_i18n: typeof body.name_i18n === "string" ? body.name_i18n : JSON.stringify(body.name_i18n ?? {}),
+            };
+            ctx.state.reportPages.set(code, page);
+            return { ...page, reportObjectId: page.id };
+        }
+        case "/api/api/report/update": {
+            const id = String(body.id ?? "");
+            const page = [...ctx.state.reportPages.values()].find((entry) => entry.id === id);
+            if (!page)
+                return businessRefusal(50000, "报表不存在");
+            // Live fidelity: a missing parentId answers 50000 服务异常 (the platform
+            // dereferences it), even though report/get never returns it directly.
+            if (body.parentId === undefined || body.parentId === null || body.parentId === "")
+                return businessRefusal(50000, "服务异常");
+            if (typeof body.name === "string")
+                page.name = body.name;
+            if (typeof body.icon === "string")
+                page.icon = body.icon;
+            if (typeof body.name_i18n === "string")
+                page.name_i18n = body.name_i18n;
+            if (typeof body.pcAble === "boolean")
+                page.pcAble = body.pcAble;
+            if (typeof body.mobileAble === "boolean")
+                page.mobileAble = body.mobileAble;
+            if (typeof body.parentId === "string")
+                page.parentId = body.parentId;
+            return page;
+        }
+        case "/api/api/report/logical_delete": {
+            const page = ctx.state.reportPages.get(q.code);
+            if (page) {
+                ctx.state.reportPages.delete(q.code);
+                ctx.state.biDashboards.delete(page.id);
+            }
+            return null;
+        }
+        // ---- BI channel ----
+        case "/dashboard/v1/report/v2/config": {
+            const objectId = String(body.objectId ?? "");
+            const dashboard = ctx.state.biDashboards.get(objectId);
+            if (!dashboard)
+                return biError("dashboard.not.exist", "The dashboard does not exist");
+            return biData({ corpId: "a", objectId, title: dashboard.title, global: dashboard.global, attributes: dashboard.attributes, charts: dashboard.charts });
+        }
+        case "/dashboard/v1/report/v2/reportpage": {
+            if (!hasConfig(body))
+                return biNoop();
+            const report = (body.report ?? {});
+            const objectId = String(report.objectId ?? "");
+            if (!objectId)
+                return biError("dashboard.save.fail", "objectId required");
+            const existing = ctx.state.biDashboards.get(objectId);
+            const dashboard = {
+                objectId,
+                title: String(report.title ?? existing?.title ?? ""),
+                global: typeof report.global === "string" ? report.global : JSON.stringify(report.global ?? {}),
+                attributes: typeof report.attributes === "string" ? report.attributes : JSON.stringify(report.attributes ?? {}),
+                charts: existing?.charts ?? [],
+            };
+            ctx.state.biDashboards.set(objectId, dashboard);
+            return biData(objectId);
+        }
+        case "/dashboard/v1/report/removeReport": {
+            if (!hasConfig(body))
+                return biNoop();
+            const objectId = String(body.objectId ?? "");
+            if (!ctx.state.biDashboards.has(objectId))
+                return biError("dashboard.not.exist", "The dashboard does not exist");
+            ctx.state.biDashboards.delete(objectId);
+            return biData(true);
+        }
+        case "/dashboard/v1/report/saveGlobal": {
+            if (!hasConfig(body))
+                return biNoop();
+            const dashboard = ctx.state.biDashboards.get(String(body.objectId ?? ""));
+            if (!dashboard)
+                return biError("dashboard.not.exist", "The dashboard does not exist");
+            dashboard.global = typeof body.global === "string" ? body.global : JSON.stringify(body.global ?? {});
+            return biData(true);
+        }
+        case "/dashboard/v1/report/saveAttributes": {
+            if (!hasConfig(body))
+                return biNoop();
+            const dashboard = ctx.state.biDashboards.get(String(body.objectId ?? ""));
+            if (!dashboard)
+                return biError("dashboard.not.exist", "The dashboard does not exist");
+            dashboard.attributes = typeof body.attributes === "string" ? body.attributes : JSON.stringify(body.attributes ?? {});
+            return biData(true);
+        }
+        case "/dashboard/v1/chart/addChart": {
+            if (!hasConfig(body))
+                return biNoop();
+            const charts = Array.isArray(body.charts) ? body.charts : [];
+            const objectId = String(charts[0]?.objectId ?? "");
+            const dashboard = ctx.state.biDashboards.get(objectId);
+            if (!dashboard)
+                return biError("dashboard.not.exist", "The dashboard does not exist");
+            for (const chart of charts) {
+                if (typeof chart.uuid !== "string" || !chart.uuid)
+                    return biError("chart.invalid", "chart uuid required");
+                if (dashboard.charts.some((entry) => entry.uuid === chart.uuid))
+                    return biError("chart.exist", "chart already exists");
+                dashboard.charts.push(chart);
+            }
+            return biData(true);
+        }
+        case "/dashboard/v1/chart/updateChart": {
+            if (!hasConfig(body))
+                return biNoop();
+            const charts = Array.isArray(body.charts) ? body.charts : [];
+            const objectId = String(charts[0]?.objectId ?? "");
+            const dashboard = ctx.state.biDashboards.get(objectId);
+            if (!dashboard)
+                return biError("dashboard.not.exist", "The dashboard does not exist");
+            for (const chart of charts) {
+                const index = dashboard.charts.findIndex((entry) => entry.uuid === chart.uuid);
+                if (index < 0)
+                    return biError("chart.not.exist", "chart does not exist");
+                dashboard.charts[index] = chart;
+            }
+            return biData(true);
+        }
+        case "/dashboard/v1/chart/removeChart": {
+            if (!hasConfig(body))
+                return biNoop();
+            const objectId = String(body.objectId ?? "");
+            for (const dashboard of ctx.state.biDashboards.values())
+                dashboard.charts = dashboard.charts.filter((chart) => chart.uuid !== objectId);
+            return biData(true);
+        }
+        case "/dashboard/v1/chart/removeCharts": {
+            if (!hasConfig(body))
+                return biNoop();
+            const ids = new Set(Array.isArray(body.objectIds) ? body.objectIds.map(String) : []);
+            for (const dashboard of ctx.state.biDashboards.values())
+                dashboard.charts = dashboard.charts.filter((chart) => !ids.has(String(chart.uuid)));
+            return biData(true);
+        }
+        case "/dashboard/v1/report/v3/datasourcelist":
+            return biData([
+                { dataSourceId: "model-1", displayName: "人员信息", nodeType: 0, useType: 1, objectId: "model-1", corpId: "a" },
+            ]);
+        case "/dashboard/datasource/advanced_list":
+            return biData([
+                { dataSourceId: "sql-1", displayName: "自定义查询", nodeType: 100, useType: 100, objectId: "sql-1", corpId: "a", status: 0, sort: 0, dwTableSyncFlag: false },
+            ]);
+        case "/dashboard/datasource/v2/datasource_list":
+            return biData([]);
+        case "/dashboard/v1/report/v3/datasource": {
+            if (!hasConfig(body))
+                return biNoop();
+            const infos = Array.isArray(body.dataSourceInfos) ? body.dataSourceInfos : [];
+            return biData(infos.map((info) => ({ nodeType: 1, displayName: String(info.dataSourceId), dataSourceId: info.dataSourceId, schema: { dataSourceId: info.dataSourceId, tableName: `t_${String(info.dataSourceId)}` } })));
+        }
+        case "/dashboard/v1/datalogic/v3/chartdata": {
+            // Live fidelity: the endpoint wants the flattened chart with an Integer
+            // (or null) `limit`; a raw stored chart (limit is an object) answers
+            // server.error. This locks the normalization in report.ts.
+            const chart = (body.chart ?? {});
+            if (chart.limit !== null && chart.limit !== undefined && typeof chart.limit === "object")
+                return biError("server.error", "A server error, please try again later");
+            const metric = Array.isArray(chart.metric) ? chart.metric : [];
+            return biData({ series: [], total: 0, metricFields: metric.map((entry) => entry.field) });
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};

package/dist/routes.d.ts

@@ -0,0 +1,2 @@
+import { type FakeRequestInput, type FakeRouteContext } from "./state.js";
+export declare function dispatchFakeRoute(ctx: FakeRouteContext, input: FakeRequestInput): unknown;

package/dist/routes.js

@@ -0,0 +1,46 @@
+import { appRoute } from "./app.js";
+import { b2Route } from "./b2-registration.js";
+import { businessRuleRoute } from "./businessrule.js";
+import { dataRuleRoute } from "./datarule.js";
+import { dictionaryRoute } from "./dictionary.js";
+import { environmentRoute } from "./environment.js";
+import { fieldRoute } from "./field.js";
+import { formRoute } from "./form.js";
+import { listViewRoute } from "./list-view.js";
+import { modelRoute } from "./model.js";
+import { onlineJsRoute } from "./online-js.js";
+import { reportRoute } from "./report.js";
+import { ruleLifecycleRoute } from "./rule-lifecycle.js";
+import { runtimeDataRoute } from "./runtime-data.js";
+import { NOT_HANDLED } from "./state.js";
+import { workflowRoute } from "./workflow.js";
+/**
+ * Composition root for the fake wire surface: one route module per lane,
+ * mirroring src/tools.ts. Every lane is tried in turn; the first that does
+ * not answer NOT_HANDLED owns the path.
+ */
+const LANE_ROUTES = [
+    environmentRoute,
+    appRoute,
+    dictionaryRoute,
+    modelRoute,
+    fieldRoute,
+    dataRuleRoute,
+    formRoute,
+    businessRuleRoute,
+    ruleLifecycleRoute,
+    runtimeDataRoute,
+    workflowRoute,
+    onlineJsRoute,
+    b2Route,
+    listViewRoute,
+    reportRoute,
+];
+export function dispatchFakeRoute(ctx, input) {
+    for (const route of LANE_ROUTES) {
+        const result = route(ctx, input);
+        if (result !== NOT_HANDLED)
+            return result;
+    }
+    return undefined;
+}

package/dist/rule-lifecycle.d.ts

@@ -0,0 +1,7 @@
+import { type LaneRoute } from "./state.js";
+/**
+ * S25-rule-lifecycle lane: enable/disable/delete mutations. Twin of
+ * src/lanes/rule-lifecycle.ts. The platform quirk stands: `enabled` is the
+ * truth; `status` may still read DISABLED.
+ */
+export declare const ruleLifecycleRoute: LaneRoute;

package/dist/rule-lifecycle.js

@@ -0,0 +1,36 @@
+import { NOT_HANDLED } from "./state.js";
+/**
+ * S25-rule-lifecycle lane: enable/disable/delete mutations. Twin of
+ * src/lanes/rule-lifecycle.ts. The platform quirk stands: `enabled` is the
+ * truth; `status` may still read DISABLED.
+ */
+export const ruleLifecycleRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/businessrule/publish": {
+            const targetId = q.id ?? body.id;
+            for (const rule of ctx.state.rules.values())
+                if (rule.id === targetId)
+                    rule.enabled = true;
+            return null;
+        }
+        case "/api/api/app/businessrule/enable": {
+            // BusinessRuleKeyRequest {schemaCode, ruleCode} flips the DRAFT row's
+            // enable switch — the face the runtime dispatcher reads
+            // (getExecutableBySchemaCodeAndCode). The platform quirk stands:
+            // enabled is the truth; status may still read DISABLED.
+            const target = [...ctx.state.rules.values()].find((rule) => rule.schemaCode === body.schemaCode && rule.code === body.ruleCode);
+            if (target)
+                target.enabled = true;
+            return null;
+        }
+        case "/api/api/app/businessrule/delete":
+            for (const [code, rule] of ctx.state.rules)
+                if (rule.id === q.id)
+                    ctx.state.rules.delete(code);
+            return null;
+        default:
+            return NOT_HANDLED;
+    }
+};

package/dist/runtime-data.d.ts

@@ -0,0 +1,2 @@
+import { type LaneRoute } from "./state.js";
+export declare const runtimeDataRoute: LaneRoute;