@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/fake/businessrule.js

@@ -0,0 +1,242 @@
+import { RULE_STATUS } from "../lanes/businessrule-contract.js";
+import { DYNAMIC_ACTION_SOURCE_KEY, DYNAMIC_CONDITION_SOURCE_KEY } from "../lanes/rule-graph.js";
+import { NOT_HANDLED } from "./state.js";
+/**
+ * B1-businessrule lane: rule listing/read + save (upsert). Twin of
+ * src/lanes/businessrule.ts. Both list faces share one serializer: the app
+ * face is driven by the rule-lifecycle lane, the runtime face by this lane.
+ */
+/**
+ * Ticket 97: scan a saved rule node graph for methodMapping bindings and flag
+ * the bound biz-service methods referenced (the platform derives the same
+ * flag from its mapping tables; a referenced method refuses method/delete
+ * with 500108).
+ */
+function markReferencedMethods(ctx, nodeJson) {
+    if (typeof nodeJson !== "string")
+        return;
+    let nodes;
+    try {
+        nodes = JSON.parse(nodeJson);
+    }
+    catch {
+        return;
+    }
+    if (!Array.isArray(nodes))
+        return;
+    for (const entry of nodes) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const mapping = entry.methodMapping;
+        if (!mapping || typeof mapping !== "object" || Array.isArray(mapping))
+            continue;
+        const m = mapping;
+        const serviceCode = typeof m.serviceCode === "string" ? m.serviceCode : "";
+        const serviceMethodCode = typeof m.serviceMethodCode === "string" ? m.serviceMethodCode : "";
+        if (!serviceCode || !serviceMethodCode)
+            continue;
+        const method = ctx.state.services.get(serviceCode)?.methods.find((candidate) => candidate.code === serviceMethodCode);
+        if (method)
+            method.referenced = true;
+    }
+}
+export const businessRuleRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/businessrule/list_by_schemacode":
+        case "/api/api/runtime/business_rule/list_by_schemacode":
+            return [...ctx.state.rules.values()].filter((rule) => rule.schemaCode === q.schemaCode).map((rule) => ({
+                id: rule.id,
+                schemaCode: rule.schemaCode,
+                code: rule.code,
+                ruleCode: rule.code,
+                name: rule.name,
+                enabled: rule.enabled,
+                status: rule.status ?? (rule.enabled ? RULE_STATUS.enabled : RULE_STATUS.disabled),
+                priority: rule.priority ?? 0,
+                createdTime: rule.createdTime ?? 1730000000000,
+                creator: rule.creator ?? "fake-user",
+                // latestPublished must read the COMPUTED status, not the raw optional
+                // field: a rule enabled by businessrule/publish has no explicit
+                // publishStatus and previously reported latestPublished:false here.
+                publishStatus: rule.publishStatus ?? (rule.enabled ? "PUBLISHED" : "DRAFT"),
+                developmentMode: rule.developmentMode ?? "CODING",
+                ruleVersion: rule.ruleVersion ?? 1,
+                latestPublished: (rule.publishStatus ?? (rule.enabled ? "PUBLISHED" : "DRAFT")) === "PUBLISHED",
+            }));
+        case "/api/api/app/businessrule/get": {
+            // Ticket 109 fidelity: superseded rows stay readable by their OLD id
+            // (historical versions) — the current rows map only holds the newest.
+            const rule = [...ctx.state.rules.values()].find((row) => row.id === q.id) ?? ctx.state.ruleHistory.find((row) => row.id === q.id);
+            if (!rule)
+                return null;
+            return {
+                id: rule.id,
+                code: rule.code,
+                name: rule.name,
+                schemaCode: rule.schemaCode,
+                bizRuleType: rule.bizRuleType ?? 0,
+                enabled: rule.enabled,
+                status: rule.status ?? "DISABLED",
+                defaultRule: false,
+                developmentMode: 0,
+                ruleVersion: rule.ruleVersion ?? 1,
+                node: rule.node ?? JSON.stringify([{ nodeCode: "Start", nodeType: "START" }]),
+                route: rule.route ?? JSON.stringify([]),
+                schedulerSetting: rule.schedulerSetting ?? null,
+            };
+        }
+        case "/api/api/app/businessrule/create":
+        case "/api/api/app/businessrule/update": {
+            const code = String(body.code ?? q.code ?? "");
+            const schemaCode = String(body.schemaCode ?? q.schemaCode ?? "");
+            const existing = [...ctx.state.rules.values()].find((rule) => rule.code === code && rule.schemaCode === schemaCode);
+            // Ticket 109 platform fidelity: every save (create OR update of the
+            // same code) mints a NEW record id and bumps ruleVersion; the
+            // superseded row moves to ruleHistory where get?id= still reads it —
+            // reading a stale id shows the OLD graph (live: 6509ed… → 8a8313… →
+            // 8f850e…, ruleVersion 1→4→5).
+            if (existing)
+                ctx.state.ruleHistory.push(existing);
+            ctx.state.ruleSeq = (ctx.state.ruleSeq ?? 0) + 1;
+            const id = `rule-${ctx.state.ruleSeq}`;
+            ctx.state.rules.set(`${schemaCode}#${code}`, {
+                ...existing,
+                id,
+                schemaCode,
+                code,
+                name: String(body.name ?? code),
+                enabled: body.enabled === true,
+                bizRuleType: typeof body.bizRuleType === "number" ? body.bizRuleType : existing?.bizRuleType,
+                node: typeof body.node === "string" ? body.node : existing?.node,
+                route: typeof body.route === "string" ? body.route : existing?.route,
+                schedulerSetting: typeof body.schedulerSetting === "string" ? body.schedulerSetting : body.schedulerSetting === null ? null : existing?.schedulerSetting,
+                priority: typeof body.priority === "number" ? body.priority : existing?.priority,
+                createdTime: typeof body.createdTime === "number" ? body.createdTime : existing?.createdTime,
+                creator: typeof body.creator === "string" ? body.creator : existing?.creator,
+                publishStatus: typeof body.publishStatus === "string" ? body.publishStatus : existing?.publishStatus,
+                developmentMode: typeof body.developmentMode === "string" ? body.developmentMode : existing?.developmentMode,
+                status: typeof body.status === "string" ? body.status : RULE_STATUS.disabled,
+                ruleVersion: (existing?.ruleVersion ?? 0) + 1,
+            });
+            // Ticket 97 fidelity: a saved methodMapping (serviceCode+serviceMethodCode
+            // inside the node graph) marks the bound method referenced — the
+            // platform derives the same flag from the mapping tables, and a
+            // referenced method refuses method/delete with 500108.
+            markReferencedMethods(ctx, typeof body.node === "string" ? body.node : existing?.node);
+            return null;
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};
+export function applyBusinessRules(state, event, source) {
+    for (const rule of state.rules.values()) {
+        if (!rule.enabled || rule.schemaCode !== String(source.schemaCode ?? "") || rule.code !== event)
+            continue;
+        for (const node of parseJsonArray(rule.node)) {
+            if (node.nodeType !== "UPDATE" || typeof node.targetObjectCode !== "string")
+                continue;
+            const conditions = readConditionGroups(node.filterCondition);
+            for (const target of state.dataRows.values()) {
+                if (target.schemaCode !== node.targetObjectCode || !conditions.every((group) => group.some((andGroup) => andGroup.every((leaf) => matchesRuleCondition(leaf, target, source)))))
+                    continue;
+                applyActions(target, node.dataActions, source);
+            }
+        }
+    }
+}
+function parseJsonArray(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function readConditionGroups(filterCondition) {
+    if (!isRecord(filterCondition) || !Array.isArray(filterCondition.mainConditions))
+        return [];
+    return filterCondition.mainConditions.map((group) => {
+        if (!Array.isArray(group))
+            return [];
+        if (group.every(isRecord))
+            return [group];
+        return group.map((andGroup) => (Array.isArray(andGroup) ? andGroup.filter(isRecord) : []));
+    });
+}
+function matchesRuleCondition(condition, target, source) {
+    const targetField = condition.targetSchemaDataItem;
+    if (typeof targetField !== "string")
+        return false;
+    if (condition.ruleValueType === "DYNAMIC") {
+        // Shared wire key (rule-graph.ts): the DYNAMIC filter source lives in
+        // currentSchemaDataItem and value must not carry it (ticket 09).
+        const sourceField = condition[DYNAMIC_CONDITION_SOURCE_KEY];
+        if (typeof sourceField !== "string" || !sourceField || condition.value !== undefined)
+            return false;
+        return compareRuleValues(readRuleField(target, targetField), source[sourceField], String(condition.ruleConditionType ?? "EQ"));
+    }
+    if (condition.ruleValueType === "FIXED")
+        return compareRuleValues(readRuleField(target, targetField), condition.value, String(condition.ruleConditionType ?? "EQ"));
+    return false;
+}
+function readRuleField(target, field) {
+    const value = field === "id" ? target.id ?? target.bizObjectId : target[field];
+    if (value && typeof value === "object" && !Array.isArray(value) && typeof value.id === "string")
+        return value.id;
+    return value;
+}
+function compareRuleValues(actual, expected, operator) {
+    switch (operator) {
+        case "EQ": return fixedValueEqual(actual, expected);
+        case "NEQ": return !fixedValueEqual(actual, expected);
+        case "GT": return Number(actual) > Number(expected);
+        case "LT": return Number(actual) < Number(expected);
+        case "GTEQ": return Number(actual) >= Number(expected);
+        case "LTEQ": return Number(actual) <= Number(expected);
+        case "CT": return String(actual ?? "").includes(String(expected ?? ""));
+        case "NCT": return !String(actual ?? "").includes(String(expected ?? ""));
+        case "EP": return actual === null || actual === undefined || actual === "";
+        case "NEP": return actual !== null && actual !== undefined && actual !== "";
+        default: return false;
+    }
+}
+function applyActions(target, actions, source) {
+    if (!Array.isArray(actions))
+        return;
+    for (const action of actions) {
+        if (!isRecord(action) || action.ruleActionType !== "EQUALS" || typeof action.targetDataItem !== "string")
+            continue;
+        if (action.ruleValueType === "DYNAMIC") {
+            // Shared wire key (rule-graph.ts): the DYNAMIC action source lives in
+            // currentDataItemValue with value pinned to the empty string.
+            const sourceField = action[DYNAMIC_ACTION_SOURCE_KEY];
+            if (typeof sourceField === "string" && sourceField && action.value === "")
+                target[action.targetDataItem] = source[sourceField];
+        }
+        else if (action.ruleValueType === "FIXED") {
+            target[action.targetDataItem] = action.value;
+        }
+    }
+}
+function fixedValueEqual(actual, expected) {
+    const actualId = relationId(actual) ?? actual;
+    const expectedId = relationId(expected) ?? expected;
+    if (Array.isArray(actualId) || Array.isArray(expectedId))
+        return JSON.stringify(actualId) === JSON.stringify(expectedId);
+    return actualId === expectedId || String(actualId ?? "") === String(expectedId ?? "");
+}
+function relationId(value) {
+    if (!isRecord(value) || typeof value.id !== "string")
+        return undefined;
+    return value.id;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=businessrule.js.map

package/dist/fake/datarule.js

@@ -0,0 +1,72 @@
+import { businessRefusal, NOT_HANDLED } from "./state.js";
+/** G1-datarule lane: 8.6.26 field-level data rules. Twin of src/lanes/datarule.ts. */
+function normalizeRule(id, body) {
+    const propertyCodes = Array.isArray(body.propertyCodes) ? body.propertyCodes.map((code) => String(code)) : [];
+    const propertyCode = body.propertyCode === null || body.propertyCode === undefined ? "" : String(body.propertyCode);
+    return {
+        id,
+        schemaCode: String(body.schemaCode),
+        propertyCode: propertyCode || (propertyCodes.length === 1 ? propertyCodes[0] : ""),
+        ...(propertyCodes.length > 0 ? { propertyCodes } : {}),
+        dataRuleType: Number(body.dataRuleType),
+        options: typeof body.options === "string" ? body.options : JSON.stringify(body.options ?? {}),
+        ...(body.checkType !== undefined ? { checkType: Number(body.checkType) } : {}),
+        ...(body.childRule !== undefined ? { childRule: Boolean(body.childRule) } : {}),
+        ...(body.name !== undefined ? { name: String(body.name) } : {}),
+        // Platform fidelity: the live engine stores a defaulted `sortKey: 0` on every
+        // row even when the caller omits it (bench56). The fake used to omit it, which
+        // hid a readback false-positive on an omitted sortKey.
+        sortKey: Number(body.sortKey ?? 0),
+    };
+}
+export const dataRuleRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/bizdatarule/list": {
+            const schemaCode = String(q.schemaCode ?? "");
+            const type = q.dataRuleType !== undefined && q.dataRuleType !== "" ? Number(q.dataRuleType) : undefined;
+            return [...ctx.state.dataRules.values()]
+                .filter((rule) => rule.schemaCode === schemaCode && (type === undefined || rule.dataRuleType === type))
+                .map((rule) => ({ ...rule }));
+        }
+        case "/api/api/app/bizdatarule/create": {
+            if (typeof body.schemaCode !== "string" || !body.schemaCode)
+                return businessRefusal(10005, "数据模型编码不能为空");
+            if (typeof body.dataRuleType !== "number")
+                return businessRefusal(10005, "规则类型不能为空");
+            // Ticket 78 live fidelity: on an UNPUBLISHED app, type2 CALCULATE answers
+            // a FALSE dead-cycle 305003 — checkCalculateRulesDeadCycle concatenates
+            // `schemaCode.propertyCode` when getAppFunctionByCode(schemaCode) is
+            // null, mismatching the assignment/parameter code口径. Types 3/4/5 are
+            // unaffected.
+            if (Number(body.dataRuleType) === 2) {
+                const model = ctx.state.models.get(String(body.schemaCode));
+                const app = ctx.state.apps.get(model?.appCode ?? "test");
+                if (app?.published === false)
+                    return businessRefusal(305003, "计算规则存在死循环");
+            }
+            ctx.state.dataRuleSeq += 1;
+            const id = `datarule-${ctx.state.dataRuleSeq}`;
+            ctx.state.dataRules.set(id, normalizeRule(id, body));
+            return null;
+        }
+        case "/api/api/app/bizdatarule/update": {
+            const id = String(body.id ?? "");
+            const existing = ctx.state.dataRules.get(id);
+            if (!existing)
+                return businessRefusal(304001, "数据规则不存在");
+            // The platform update is a full-row overwrite; callers must echo every
+            // persisted column or the omitted nullable columns are cleared.
+            ctx.state.dataRules.set(id, normalizeRule(id, body));
+            return null;
+        }
+        case "/api/api/app/bizdatarule/delete": {
+            ctx.state.dataRules.delete(String(q.id ?? ""));
+            return null;
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};
+//# sourceMappingURL=datarule.js.map

package/dist/fake/dictionary.js

@@ -0,0 +1,108 @@
+import { NOT_HANDLED } from "./state.js";
+function flatten(records) {
+    return records.flatMap((record) => [record, ...(record.children ? flatten(record.children) : [])]);
+}
+function classes(ctx) {
+    return [...ctx.state.dictionaryClasses.values()].map((item) => ({ ...item, dictionaryInfos: item.dictionaryIds.map((id) => ctx.state.dictionaries.get(id)).filter(Boolean) }));
+}
+function page(records, query) {
+    const searchWord = query?.searchWord ?? "";
+    const filtered = records.filter((record) => !searchWord || record.name.includes(searchWord) || record.code.includes(searchWord));
+    const pageNumber = Math.max(1, Number(query?.page ?? 1));
+    const size = Math.max(1, Number(query?.size ?? 20));
+    const content = filtered.slice((pageNumber - 1) * size, pageNumber * size);
+    return { totalElements: filtered.length, totalPages: Math.ceil(filtered.length / size), content };
+}
+export function dictionaryRoute(ctx, input) {
+    const dictionaries = ctx.state.dictionaries;
+    switch (input.path) {
+        case "/api/api/data_dictionary/searchDictionary": {
+            const rows = [...dictionaries.values()].filter((dictionary) => !input.query?.classificationId || dictionary.classificationId === input.query.classificationId).filter((dictionary) => !input.query?.searchWord || dictionary.name.includes(input.query.searchWord) || dictionary.code.includes(input.query.searchWord));
+            return { totalElements: rows.length, totalPages: rows.length ? 1 : 0, content: rows };
+        }
+        case "/api/api/data_dictionary/getDictionaryById":
+            return dictionaries.get(String(input.query?.id)) ?? {};
+        case "/api/api/data_dictionary/getDictionaryByCode":
+            return [...dictionaries.values()].find((dictionary) => dictionary.code === input.query?.code) ?? {};
+        case "/api/api/data_dictionary/searchDictionaryRecord": {
+            const dictionary = dictionaries.get(String(input.query?.id));
+            return page(dictionary ? flatten(dictionary.records) : [], input.query);
+        }
+        case "/api/api/data_dictionary/searchDictionaryRecordByCode": {
+            const dictionary = [...dictionaries.values()].find((item) => item.code === input.query?.code);
+            return page(dictionary ? flatten(dictionary.records) : [], input.query);
+        }
+        case "/api/api/data_dictionary/getEnableRecordsByDictionaryId": {
+            const dictionary = dictionaries.get(String(input.query?.dicId));
+            return dictionary?.status ? flatten(dictionary.records).filter((record) => record.status) : [];
+        }
+        case "/api/api/data_dictionary/getEnableRecordsByDictionaryCode": {
+            const dictionary = [...dictionaries.values()].find((item) => item.code === input.query?.code);
+            return dictionary?.status ? flatten(dictionary.records).filter((record) => record.status) : [];
+        }
+        case "/api/api/data_dictionary/getDictionaryRecordByParentId": {
+            const records = [...dictionaries.values()].flatMap((dictionary) => flatten(dictionary.records)).filter((record) => record.parentId === input.query?.parentId);
+            return records;
+        }
+        case "/api/api/data_dictionary/getDictionaryClass":
+            return classes(ctx);
+        case "/api/api/data_dictionary/getDictionaryClassDetail":
+            return classes(ctx);
+        case "/api/api/data_dictionary/saveDictionaryClass": {
+            const body = input.body;
+            const id = String(body.id ?? `class-${ctx.state.dictionaryClasses.size + 1}`);
+            ctx.state.dictionaryClasses.set(id, { id, name: String(body.name), sortKey: Number(body.sortKey ?? 0), dictionaryIds: Array.isArray(body.dictionaryIds) ? body.dictionaryIds.map(String) : [] });
+            return null;
+        }
+        case "/api/api/data_dictionary/deleteDictionaryClass": {
+            const body = input.body;
+            ctx.state.dictionaryClasses.delete(String(body.id));
+            return 1;
+        }
+        case "/api/api/data_dictionary/deleteDictionaryClassBatch": {
+            const body = input.body;
+            for (const id of Array.isArray(body.ids) ? body.ids : [])
+                ctx.state.dictionaryClasses.delete(String(id));
+            return 1;
+        }
+        case "/api/api/data_dictionary/updateDictionaryRecordUsed": {
+            const body = input.body;
+            const ids = String(body.id ?? "").split(";");
+            for (const dictionary of dictionaries.values())
+                for (const record of flatten(dictionary.records))
+                    if (ids.includes(record.id))
+                        record.initialUsed = true;
+            return null;
+        }
+        case "/api/api/data_dictionary/saveDictionary": {
+            const body = input.body;
+            const id = String(body.id ?? `dictionary-${dictionaries.size + 1}`);
+            const records = Array.isArray(body.records) ? body.records : [];
+            const normalize = (items, parentId = null) => items.map((item, index) => {
+                const recordId = String(item.id ?? `${id}-record-${index + 1}`);
+                return { id: recordId, code: String(item.code), name: String(item.name), name_i18n: typeof item.name_i18n === "string" ? item.name_i18n : JSON.stringify(item.name_i18n ?? { "zh-CN": item.name }), parentId, status: item.status !== false, dictionaryId: id, sortKey: Number(item.sortKey ?? index + 1), initialUsed: item.initialUsed === true, ...(Array.isArray(item.children) ? { children: normalize(item.children, recordId) } : {}) };
+            });
+            const dictionary = { id, code: String(body.code), name: String(body.name), name_i18n: typeof body.name_i18n === "string" ? body.name_i18n : undefined, dictionaryType: Number(body.dictionaryType ?? 0), status: body.status !== false, sortKey: Number(body.sortKey ?? 0), classificationId: String(body.classificationId ?? ""), records: normalize(records) };
+            dictionaries.set(id, dictionary);
+            return null;
+        }
+        case "/api/api/data_dictionary/updateDictionaryStatus": {
+            const body = input.body;
+            const dictionary = dictionaries.get(String(body.id));
+            if (dictionary)
+                dictionary.status = body.status === true;
+            return 1;
+        }
+        case "/api/api/data_dictionary/updateDictionaryRecordStatus": {
+            const body = input.body;
+            for (const dictionary of dictionaries.values()) {
+                const record = flatten(dictionary.records).find((item) => item.id === String(body.id));
+                if (record)
+                    record.status = body.status === true;
+            }
+            return 1;
+        }
+        default: return NOT_HANDLED;
+    }
+}
+//# sourceMappingURL=dictionary.js.map

package/dist/fake/environment.js

@@ -0,0 +1,30 @@
+import { FAKE_RSA_PUBLIC_KEY, NOT_HANDLED } from "./state.js";
+/**
+ * environment-governance lane: the auth flow the session manager drives to
+ * reach the environment. Wire-contract twin of src/lanes/environment.ts.
+ */
+export const environmentRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    switch (input.path) {
+        case "/api/public/system/config":
+            return {
+                corpId: "fake-corp",
+                client_secret: "fake-client-secret",
+                pcServerUrl: ctx.options.baseUrl ?? "https://fake.cloudpivot.example",
+                version: ctx.options.version ?? "8.6.26",
+            };
+        case "/user/public/getKey":
+            return { key: FAKE_RSA_PUBLIC_KEY, index: "1" };
+        case "/user/login/Authentication/get_code":
+            return { code: "fake-auth-code" };
+        case "/user/login/Authentication/get_token":
+            return { access_token: q.code === "fake-auth-code" ? "fake-token" : "denied" };
+        case "/api/api/organization/user/info_login":
+            if ((input.headers ?? {}).Authorization !== "Bearer fake-token")
+                return undefined;
+            return { permissions: ["ADMIN"], name: "fake-admin" };
+        default:
+            return NOT_HANDLED;
+    }
+};
+//# sourceMappingURL=environment.js.map

package/dist/fake/field.js

@@ -0,0 +1,167 @@
+import { capabilityShapeError } from "../capability-shape.js";
+import { businessRefusal, NOT_HANDLED } from "./state.js";
+/** field-families lane: bizproperty CRUD + model-scoped publish. Twin of src/lanes/field.ts. */
+export const fieldRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/bizproperty/list": {
+            const rows = [...ctx.state.fields.entries()]
+                .filter(([key]) => key.startsWith(`${q.schemaCode}#`))
+                .map(([, field]) => ({
+                code: field.code,
+                name: field.name,
+                name_i18n: field.name_i18n ?? null,
+                type: field.type,
+                options: field.options ?? null,
+                ...(field.relativeCode ? { relativeCode: field.relativeCode } : {}),
+                ...(field.relativePropertyCode ? { relativePropertyCode: field.relativePropertyCode } : {}),
+                ...(field.subSchema ? { subSchema: field.subSchema } : {}),
+            }))
+                .filter((row) => (q.isPublish === "true" ? ctx.state.fields.get(`${q.schemaCode}#${row.code}`)?.published : !ctx.state.fields.get(`${q.schemaCode}#${row.code}`)?.published));
+            return rows;
+        }
+        case "/api/api/app/bizproperty/get": {
+            const key = `${q.schemaCode}#${q.propertyCode}`;
+            const field = ctx.state.fields.get(key);
+            if (!field)
+                return businessRefusal(50000, `属性不存在：${q.propertyCode}`);
+            const drift = ctx.state.fieldDetailDrift.get(key);
+            const propertyType = drift?.propertyType ?? Number(field.type);
+            return {
+                code: field.code,
+                name: drift?.name ?? field.name,
+                name_i18n: field.name_i18n ?? null,
+                propertyType,
+                type: propertyType,
+                options: field.options ?? null,
+                ...(field.relativeCode ? { relativeCode: field.relativeCode } : {}),
+            };
+        }
+        case "/api/api/app/bizproperty/create":
+        case "/api/api/app/bizproperty/update": {
+            const key = `${body.schemaCode}#${body.code}`;
+            const existing = ctx.state.fields.get(key);
+            const type = Number(body.propertyType ?? body.type ?? existing?.type);
+            let options = {};
+            if (typeof body.options === "string") {
+                try {
+                    options = JSON.parse(body.options);
+                }
+                catch {
+                    return businessRefusal(50000, "options 不是合法 JSON");
+                }
+            }
+            else if (body.options && typeof body.options === "object") {
+                options = body.options;
+            }
+            if (Number.isInteger(type)) {
+                const shapeError = capabilityShapeError(type, "field", options);
+                if (shapeError)
+                    return businessRefusal(50000, shapeError);
+            }
+            let subSchema;
+            if (body.subSchema && typeof body.subSchema === "object")
+                subSchema = body.subSchema;
+            else if (typeof body.subSchema === "string") {
+                try {
+                    subSchema = JSON.parse(body.subSchema);
+                }
+                catch {
+                    return businessRefusal(50000, "subSchema 不是合法 JSON");
+                }
+            }
+            else if (existing?.subSchema)
+                subSchema = existing.subSchema;
+            ctx.state.fields.set(key, {
+                code: String(body.code),
+                name: String(body.name ?? body.code),
+                type: String(body.propertyType ?? body.type ?? "TEXT"),
+                published: existing?.published ?? false,
+                ...(typeof body.name_i18n === "string" ? { name_i18n: body.name_i18n } : existing?.name_i18n !== undefined ? { name_i18n: existing.name_i18n } : {}),
+                ...(body.options !== undefined ? { options: String(body.options) } : existing?.options !== undefined ? { options: existing.options } : {}),
+                ...(body.relativeCode ? { relativeCode: String(body.relativeCode) } : existing?.relativeCode ? { relativeCode: existing.relativeCode } : {}),
+                ...(body.relativePropertyCode !== undefined ? { relativePropertyCode: String(body.relativePropertyCode) } : existing?.relativePropertyCode !== undefined ? { relativePropertyCode: existing.relativePropertyCode } : {}),
+                ...(subSchema ? { subSchema } : {}),
+            });
+            // Live 2026-09-18: creating/updating a field whose schemaCode IS a
+            // CHILD_TABLE field code adds/updates that column and syncs the parent
+            // field's subSchema.properties. Mirror it so the form scaffold sees new
+            // child columns.
+            const childSchema = String(body.schemaCode ?? "");
+            const childCode = String(body.code ?? "");
+            for (const parent of ctx.state.fields.values()) {
+                if (parent.type !== "8" || parent.code !== childSchema)
+                    continue;
+                const sub = parent.subSchema;
+                if (!sub || !Array.isArray(sub.properties))
+                    continue;
+                const row = {
+                    code: childCode,
+                    name: String(body.name ?? childCode),
+                    ...(typeof body.name_i18n === "string" ? { name_i18n: body.name_i18n } : {}),
+                    schemaCode: childSchema,
+                    propertyType: type,
+                    propertyEmpty: body.propertyEmpty === true,
+                    sortKey: null,
+                    ...(body.options !== undefined ? { options: String(body.options) } : {}),
+                    defaultProperty: false,
+                    published: false,
+                };
+                const at = sub.properties.findIndex((candidate) => candidate.code === childCode);
+                if (at >= 0)
+                    sub.properties[at] = { ...sub.properties[at], ...row };
+                else
+                    sub.properties.push(row);
+            }
+            return null;
+        }
+        case "/api/api/app/bizproperty/publish": {
+            const schemaCode = String(body.bizSchemaCode ?? body.schemaCode);
+            // Ticket 79 live-fidelity (docker log evidence, 2026-09-13 21:43-21:45):
+            // under DB connection-pool contention a publish can fail with
+            // `表单:<t>_<schema>不存在列:<col>` (BizSchemaDbManagerImpl addIndexes/
+            // updateColumns assert against the serializer view) while the DDL from
+            // the failed attempt auto-commits — the state SELF-HEALS across
+            // retries (live: attempt#2 failed on ownerDeptQueryCode, #3 on
+            // omc_mcp_wt_num, #4 succeeded). Tests seed the remaining count via
+            // state.transientPublishFailures.
+            const remaining = ctx.state.transientPublishFailures.get(schemaCode) ?? 0;
+            if (remaining > 0) {
+                ctx.state.transientPublishFailures.set(schemaCode, remaining - 1);
+                return businessRefusal(50000, `表单:ixtw3_${schemaCode}不存在列:ownerDeptQueryCode`);
+            }
+            for (const [key, field] of ctx.state.fields)
+                if (key.startsWith(`${schemaCode}#`))
+                    field.published = true;
+            // Publishing a model publishes its child tables' schemas too (their
+            // properties live under the CHILD_TABLE field's code on the same model).
+            for (const field of ctx.state.fields.values()) {
+                if (field.type !== "8" || !ctx.state.fields.get(`${schemaCode}#${field.code}`))
+                    continue;
+                for (const [key, child] of ctx.state.fields)
+                    if (key.startsWith(`${field.code}#`))
+                        child.published = true;
+            }
+            return null;
+        }
+        case "/api/api/app/bizproperty/force_delete":
+        case "/api/api/app/bizproperty/delete": {
+            const delSchema = String(q.bizSchemaCode ?? q.schemaCode ?? body.schemaCode ?? "");
+            const delCode = String(q.bizPropertyCode ?? q.code ?? body.code ?? "");
+            ctx.state.fields.delete(`${delSchema}#${delCode}`);
+            // Deleting a child column drops it from the parent child-table subSchema.
+            for (const parent of ctx.state.fields.values()) {
+                if (parent.type !== "8" || parent.code !== delSchema)
+                    continue;
+                const sub = parent.subSchema;
+                if (sub && Array.isArray(sub.properties))
+                    sub.properties = sub.properties.filter((candidate) => candidate.code !== delCode);
+            }
+            return null;
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};
+//# sourceMappingURL=field.js.map