@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/bizservice-config.js

@@ -0,0 +1,581 @@
+import { ToolRefusalError } from "./tool-types.js";
+/**
+ * Ticket 92 — business-integration write-face codec + preflight (pure functions,
+ * zero DSH/wire dependencies). Reused by service.register (92), service.update
+ * (93), method.get/update/delete (94/95/97).
+ *
+ * Evidence:
+ * - research/bizservice-integration-backend-face.md (8.6.26 source, file:line):
+ *   service configJson is PLAINTEXT (BizServiceController create path); method
+ *   configJson is AES-128-ECB/Base64 on entry and persisted as plaintext
+ *   (BizServiceMethodController.java:104-105,546-550; AESUtils.java:18-51) — a
+ *   plaintext payload silently decrypts to NULL and is stored NULL.
+ * - evidence/bizservice-rule-binding-fwb-20260914.md (fwb 8.6.39 readback):
+ *   adapterCode RESTFUL/DATA_SQL; service readback configJson plaintext;
+ *   method readback enum INTEGERS (httpType:0, requestBodyType:1, line 122/136).
+ * - CORRECTION (live 8.6.26 round19): the WIRE representation is the INTEGER
+ *   index on BOTH sides. `HttpType`/`RequestBodyType`/`BizServiceLocationType`
+ *   are `@JsonValue int getIndex()` + `@JsonCreator get(int)`; platform built-in
+ *   rows store `"httpType":0` and `"position":3`; `method/list_http_type`
+ *   returns `{name,index}`. Writing the NAME leaves the field unparseable and
+ *   the designer shows 接口类型 未配置. The tool takes names (tool-speak) but
+ *   ENCODES to the integer index on the wire, and DECODES both on readback.
+ * - RestProtocolAdapterRuntimeServiceImpl.java:185-200: URL_VARIABLE(1) has no
+ *   runtime branch (501007) — the preflight refuses it.
+ */
+/** Source-evidenced native write adapters. INTERNAL method creation remains extension-package import, not this tool face. */
+export const BIZSERVICE_WRITE_ADAPTERS = Object.freeze(["RESTFUL", "DATA_SQL", "DATA_TABLE", "SAP", "KAFKA", "SOAP"]);
+/**
+ * HttpType enum (HttpType.java:13-43). The platform enum is `@JsonValue int
+ * getIndex()` + `@JsonCreator get(int)` — i.e. the WIRE representation is the
+ * INTEGER index (platform built-in methods store `"httpType":0`; the designer
+ * dropdown endpoint `bizservice/method/list_http_type` returns `{name,index}`).
+ * The tool SPEAKS names to the caller but MUST write the integer index, or the
+ * platform stores an unparseable string and the UI shows 接口类型 未配置
+ * (live round19: `"httpType":"Get"` broke `method/get`).
+ */
+export const RESTFUL_HTTP_TYPES = Object.freeze({ 0: "Post", 1: "Get", 2: "Put", 3: "Patch", 4: "Delete" });
+/** RequestBodyType enum (RequestBodyType.java:13-40). Wire = integer index. */
+export const RESTFUL_REQUEST_BODY_TYPES = Object.freeze({ 0: "Form-urlencoded", 1: "JSON", 2: "Text" });
+/** BizServiceLocationType (BizServiceLocationType.java:13-43). Wire = integer index. */
+export const RESTFUL_PARAMETER_POSITIONS = Object.freeze({ 0: "QUERY_PARAMS", 1: "URL_VARIABLE", 2: "REQUEST_HEADER", 3: "REQUEST_BODY", 4: "PATH_PARAMS" });
+/**
+ * ExternalParameterType (platform `ParameterModel.externParameterType`): the
+ * wire is an integer index (1000/1001/1002), names are PROPERTY/LIST/OBJECT
+ * (`ExternalParameterType.java`). The rule designer emits it on EVERY
+ * parameter of a published BizMethod (leaf → 1000 PROPERTY; a parameter that
+ * carries `subParameters` → 1002 OBJECT, its children → 1001 LIST); a literal
+ * `deviceNo`-style BO leaf without it is the signature of a hand-rolled
+ * method face (params silently drop in the 绑定业务方法 dialog).
+ */
+export const EXTERN_PARAMETER_TYPES = Object.freeze({ 1000: "PROPERTY", 1001: "LIST", 1002: "OBJECT" });
+const EXTERN_PARAMETER_NAMES = Object.freeze({ PROPERTY: 1000, LIST: 1001, OBJECT: 1002 });
+/**
+ * BizPropertyType (platform `ParameterModel.bizPropertyType` / `MetadataPropertyType`):
+ * wire = the fourth constructor arg (`BizPropertyType.java`), NOT the enum
+ * ordinal. A published method parameter MUST carry this (designer's 参数类型);
+ * without it the parameter has no type and the 业务规则的绑定业务方法 dialog
+ * cannot match it to a target field (matching is by type — 短文本/下拉单选
+ * families interoperate, but a type-less or mismatched parameter cannot be
+ * mapped). Evidence: designer-written method faces always carry
+ * `bizPropertyType` (e.g. `{"code":"changeFormId",...,"bizPropertyType":0,...}`).
+ */
+export const BIZ_PROPERTY_TYPES = Object.freeze({
+    0: "SHORT_TEXT", 1: "LONG_TEXT", 2: "NUMERICAL", 3: "DATE", 4: "LOGICAL", 5: "SELECTION",
+    6: "ATTACHMENT", 7: "COMMENT", 8: "CHILD_TABLE", 9: "WORK_SHEET", 10: "ADDRESS", 11: "MULT_WORK_SHEET",
+    12: "RADIO", 13: "CHECKBOX", 14: "DROPDOWN_BOX", 15: "DROPDOWN_MULTI_BOX", 16: "RELEVANCE_DATA",
+    17: "HYPER_LINK", 20: "ID", 28: "TIME", 50: "STAFF_SELECTOR", 51: "STAFF_MULTI_SELECTOR",
+    60: "DEPARTMENT_SELECTOR", 61: "DEPARTMENT_MULTI_SELECTOR", 100: "FORMULA", 250: "OCR",
+    251: "ELECTRONIC_SIGN", 254: "APPROVAL_INFO",
+});
+const BIZ_PROPERTY_TYPE_NAMES = Object.freeze(Object.fromEntries(Object.entries(BIZ_PROPERTY_TYPES).map(([index, name]) => [name, Number(index)])));
+/** MethodReturnType (MethodReturnType.java:13-40). */
+export const DATA_RETURN_TYPES = Object.freeze({ 0: "Void", 1: "SingleObject", 2: "List" });
+export const RESTFUL_AUTH_PARAMETER_CODES = Object.freeze({
+    customer: Object.freeze([]),
+    basic: Object.freeze(["username", "password"]),
+    oauth_password: Object.freeze(["client_id", "client_secret", "username", "password", "oauth_path"]),
+    oauth_client: Object.freeze(["client_id", "client_secret", "oauth_path"]),
+});
+export const RESTFUL_AUTH_PARAMETER_DEFINITIONS = Object.freeze({
+    customer: Object.freeze([]),
+    basic: Object.freeze([
+        { code: "username", name: "用户名", description: "请输入用户名", required: true },
+        { code: "password", name: "密码", description: "请输入密码", required: true },
+    ]),
+    oauth_password: Object.freeze([
+        { code: "client_id", name: "客户端ID", description: "", required: true },
+        { code: "client_secret", name: "客户端凭证", description: "", required: true },
+        { code: "username", name: "用户名", description: "请输入用户名", required: true },
+        { code: "password", name: "密码", description: "请输入密码", required: true },
+        { code: "oauth_path", name: "获取token地址", description: "", required: true },
+    ]),
+    oauth_client: Object.freeze([
+        { code: "client_id", name: "客户端ID", description: "", required: true },
+        { code: "client_secret", name: "客户端凭证", description: "", required: true },
+        { code: "oauth_path", name: "获取token地址", description: "", required: true },
+    ]),
+});
+export function validateRestfulAuth(auth) {
+    if (!isRecord(auth))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, "RESTFUL 服务 auth 必须是对象", { key: "auth" });
+    if (typeof auth.code !== "string" || !auth.code || !(auth.code in RESTFUL_AUTH_PARAMETER_CODES))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth.code 必须是 customer/basic/oauth_password/oauth_client，动态扩展鉴权不在已证实写面`, { key: "auth.code" });
+    if (typeof auth.name !== "undefined" && typeof auth.name !== "string")
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, "RESTFUL auth.name 必须是字符串", { key: "auth.name" });
+    if (typeof auth.description !== "undefined" && typeof auth.description !== "string")
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, "RESTFUL auth.description 必须是字符串", { key: "auth.description" });
+    if (!Array.isArray(auth.parameterlist))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, "RESTFUL auth.parameterlist 必须是数组", { key: "auth.parameterlist" });
+    const expected = RESTFUL_AUTH_PARAMETER_CODES[auth.code];
+    const items = auth.parameterlist;
+    const seen = new Set();
+    for (const [index, item] of items.entries()) {
+        if (!isRecord(item) || typeof item.code !== "string" || !item.code || typeof item.value !== "string" || !item.value)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth.parameterlist[${index}] 必须含 code/name?/value 非空字符串；敏感 value 只透传不记录`, { key: `auth.parameterlist[${index}]` });
+        if (item.name !== undefined && typeof item.name !== "string")
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth.parameterlist[${index}].name 必须是字符串`, { key: `auth.parameterlist[${index}].name` });
+        if (item.description !== undefined && typeof item.description !== "string")
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth.parameterlist[${index}].description 必须是字符串`, { key: `auth.parameterlist[${index}].description` });
+        if (item.required !== undefined && item.required !== true)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth.parameterlist[${index}].required 必须为 true（前端 AdapterConfigParam.Param 定义）`, { key: `auth.parameterlist[${index}].required` });
+        if (seen.has(item.code))
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth.parameterlist 不允许重复参数 ${item.code}`, { key: "auth.parameterlist" });
+        seen.add(item.code);
+        if (!expected.includes(item.code))
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth=${auth.code} 不允许参数 ${item.code}；期望参数：${expected.join(",") || "无"}`, { key: `auth.parameterlist[${index}].code` });
+    }
+    const missing = expected.filter((code) => !seen.has(code));
+    if (missing.length > 0)
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `RESTFUL auth=${auth.code} 缺少参数：${missing.join(",")}`, { key: "auth.parameterlist" });
+}
+export const BIZSERVICE_CONFIG_BLOCKERS = Object.freeze({
+    adapterNotWhitelisted: "bizservice-adapter-not-whitelisted",
+    rawConfigJson: "bizservice-raw-config-json",
+    serviceConfigInvalid: "bizservice-service-config-invalid",
+    methodConfigInvalid: "bizservice-method-config-invalid",
+    parameterFaceInvalid: "bizservice-parameter-face-invalid",
+});
+function refuse(blocker, message, details) {
+    throw new ToolRefusalError({ status: "refused", blocker, message, ...(details ?? {}) });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Commonlist lookup: ServiceConfigVO reads commonlist[], not a top-level field (BizServiceController save path). */
+function commonlistValue(serviceConfig, code) {
+    const list = serviceConfig.commonlist;
+    if (!Array.isArray(list))
+        return undefined;
+    for (const item of list)
+        if (isRecord(item) && item.code === code && typeof item.value === "string" && item.value)
+            return item.value;
+    return undefined;
+}
+/**
+ * The adapter gate for every structured write. Non-whitelisted adapterCodes
+ * are refused at local dry-lint with the support face named (ADR 0001).
+ */
+export function assertBizServiceAdapterWhitelisted(adapterCode) {
+    if (typeof adapterCode !== "string" || !adapterCode)
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.adapterNotWhitelisted, "adapterCode 是必需的（结构化写面）", { adapterCode });
+    if (!BIZSERVICE_WRITE_ADAPTERS.includes(adapterCode))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.adapterNotWhitelisted, `adapterCode ${adapterCode} 不在写面支持范围内；本写面仅支持 ${BIZSERVICE_WRITE_ADAPTERS.join("/")}。` +
+            `**自定义 Java 方法体的常规做法是：在扩展模块写一个接口，然后用 RESTFUL 适配器注册一个服务指向它**（service.register，adapterCode:RESTFUL，methodConfig.url 指向扩展端点）；不要用 INTERNAL/custom_protocol 适配器（那是平台内部/自定义协议机制，不是二开接口的常规登记方式，也不是本工具的支持面）`, { adapterCode, supported: BIZSERVICE_WRITE_ADAPTERS });
+    return adapterCode;
+}
+/** The AES boundary is not bypassable: a raw configJson string is refused before any wire call. */
+export function assertStructuredConfig(value, label) {
+    if (typeof value === "string")
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.rawConfigJson, `拒绝原始 ${label} 字符串：传结构化对象，工具负责序列化/加密（方法 configJson 的 AES 边界唯一，不可绕过）`, { label });
+}
+/**
+ * r6-onlinejs 2026-10-10（全 0 悬案根因链的起点）——鉴权凭据的掩码/占位值。
+ * 平台 service/create 不校验凭据内容，掩码/占位值注册成功但运行时自调必败
+ * （401/500），且因"服务端不校验+读回掩码"极难排查。凭据值若匹配：
+ * 读回掩码 ***（读面按 ticket 115 掩码，不可抄写）、自造 RELEVANCE-xxx 占位、
+ * 全 0 串，则拒绝并要求从任务环境事实取真值。
+ */
+const MASKED_SECRET_RE = /^\*{3,}$/;
+const PLACEHOLDER_CORP_RE = /^RELEVANCE-[A-Za-z0-9]+$/;
+const ALL_ZERO_CREDENTIAL_RE = /^0{16,}$/;
+function scanAuthParameterlistForPlaceholders(parameterlist, adapterCode) {
+    for (const entry of parameterlist) {
+        if (!isRecord(entry))
+            continue;
+        const value = entry.value;
+        if (typeof value !== "string")
+            continue;
+        const t = value.trim();
+        let why = "";
+        if (MASKED_SECRET_RE.test(t))
+            why = "读回掩码 ***（读面按 ticket 115 掩码，不可抄写）";
+        else if (PLACEHOLDER_CORP_RE.test(t))
+            why = "自造 RELEVANCE-xxx 占位（沙盒真实 corpId 才是 RELEVANCE-<真实id>）";
+        else if (ALL_ZERO_CREDENTIAL_RE.test(t))
+            why = "全 0 串（脱敏显示值，非真实凭据）";
+        if (why)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `${adapterCode} 服务鉴权凭据包含${why}——平台 service/create 不校验凭据内容，注册成功但运行时自调必败（r6-onlinejs 真机：全 0 corpId 注册成功、自调 401/500）。凭据必须从任务环境事实取真值（如 doctor 显示的 corpId、任务提供的 client_secret）。`, { key: `auth.parameterlist.${String(entry.code ?? "")}`, value: t });
+    }
+}
+function requireAuthAndUrl(serviceConfig, adapterCode) {
+    const auth = serviceConfig.auth;
+    if (adapterCode === "RESTFUL" || adapterCode === "SOAP")
+        validateRestfulAuth(auth);
+    if (!isRecord(auth) || typeof auth.code !== "string" || !auth.code || !Array.isArray(auth.parameterlist))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `${adapterCode} 服务 configJson 需要 auth {code, parameterlist[]}`, { key: "auth" });
+    if (!commonlistValue(serviceConfig, "url"))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `${adapterCode} 服务 configJson 需要 commonlist [{code:"url", value}]`, { key: "commonlist.url" });
+    scanAuthParameterlistForPlaceholders(auth.parameterlist, adapterCode);
+}
+function requireCommonlist(serviceConfig, key, adapterCode) {
+    if (!commonlistValue(serviceConfig, key))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `${adapterCode} 服务 configJson 需要 commonlist [{code:"${key}", value}]`, { key: `commonlist.${key}` });
+}
+function requireEmptyAuth(serviceConfig, adapterCode) {
+    const auth = serviceConfig.auth;
+    if (auth !== undefined && (!isRecord(auth) || (auth.code !== undefined && auth.code !== "") || (auth.parameterlist !== undefined && (!Array.isArray(auth.parameterlist) || auth.parameterlist.length !== 0))))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, `${adapterCode} 服务不使用鉴权，auth 应为空对象或省略`, { key: "auth" });
+}
+function validateSapMethod(methodConfig) {
+    for (const key of ["functionName", "returnType"])
+        if (methodConfig[key] === undefined)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `SAP 方法 configJson 缺少必需键 ${key}`, { key });
+    if (typeof methodConfig.functionName !== "string" || !methodConfig.functionName)
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "SAP functionName 必须是非空字符串", { key: "functionName" });
+    methodConfig.returnType = encodeEnumIndex(methodConfig.returnType, DATA_RETURN_TYPES, "returnType");
+}
+/**
+ * Validate a structured service config against the adapter's source-evidenced
+ * required keys. Service configJson is plaintext on the wire for every adapter.
+ */
+export function compileServiceConfig(adapterCode, serviceConfig) {
+    assertStructuredConfig(serviceConfig, "serviceConfig");
+    if (!isRecord(serviceConfig))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.serviceConfigInvalid, "serviceConfig 必须是结构化对象", { adapterCode });
+    if (adapterCode === "RESTFUL" || adapterCode === "INTERNAL" || adapterCode === "SOAP")
+        requireAuthAndUrl(serviceConfig, adapterCode);
+    if (adapterCode === "DATA_SQL" || adapterCode === "DATA_TABLE") {
+        requireEmptyAuth(serviceConfig, adapterCode);
+        requireCommonlist(serviceConfig, "databaseConnectionPoolCode", adapterCode);
+    }
+    if (adapterCode === "SAP") {
+        requireEmptyAuth(serviceConfig, adapterCode);
+        requireCommonlist(serviceConfig, "sapConnectionPoolCode", adapterCode);
+    }
+    if (adapterCode === "KAFKA") {
+        requireEmptyAuth(serviceConfig, adapterCode);
+        requireCommonlist(serviceConfig, "kafkaConnectionPoolCode", adapterCode);
+    }
+    return JSON.stringify(serviceConfig);
+}
+/**
+ * Encode an enum to the platform WIRE INTEGER INDEX. The platform enums
+ * (`HttpType`/`RequestBodyType`/`BizServiceLocationType`) are `@JsonValue int
+ * getIndex()` + `@JsonCreator get(int)`, and the designer dropdown endpoint
+ * returns `{name,index}`; platform built-in rows store the integer
+ * (`"httpType":0`, `"position":3`). Accept either the name (tool-speak) or an
+ * index, and RETURN the index — writing the name leaves the platform field
+ * unparseable and the UI shows 接口类型 未配置 (live round19).
+ */
+function encodeEnumIndex(value, ints, label) {
+    const names = Object.values(ints);
+    if (typeof value === "number" && Number.isInteger(value)) {
+        if (!(value in ints))
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `${label} 枚举值 ${value} 不在已取证集合内`, { key: label });
+        return value;
+    }
+    if (typeof value === "string") {
+        const index = Object.entries(ints).find(([, name]) => name === value)?.[0];
+        if (index === undefined)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `${label} 枚举名 ${value} 不在已取证集合 ${names.join("|")} 内`, { key: label });
+        return Number(index);
+    }
+    refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `${label} 必须是已取证枚举名或整数索引`, { key: label });
+}
+/**
+ * Validate a structured method config against the adapter's required keys and
+ * return the plain JSON string (the caller encrypts it for the wire). The tool
+ * speaks enum NAMES to the caller but ENCODES them to the platform WIRE INTEGER
+ * index (never mutating the caller's object).
+ */
+export function compileMethodConfigPlain(adapterCode, methodConfig) {
+    assertStructuredConfig(methodConfig, "methodConfig");
+    if (!isRecord(methodConfig))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "methodConfig 必须是结构化对象", { adapterCode });
+    const config = { ...methodConfig };
+    if (adapterCode === "SOAP")
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "SOAP 方法由 WSDL 动态发现，没有固定 methodConfig；请使用平台原生 SOAP refresh/方法发现接口，不伪造方法体", { adapterCode });
+    if (adapterCode === "RESTFUL") {
+        for (const key of ["httpType", "requestBodyType", "url", "frontEndExtensionEnable"])
+            if (config[key] === undefined)
+                refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `RESTFUL 方法 configJson 缺少必需键 ${key}（BaseMethodConfigVO/HttpMethodConfigVO）`, { key });
+        config.httpType = encodeEnumIndex(config.httpType, RESTFUL_HTTP_TYPES, "httpType");
+        config.requestBodyType = encodeEnumIndex(config.requestBodyType, RESTFUL_REQUEST_BODY_TYPES, "requestBodyType");
+        if (typeof config.url !== "string" || !config.url)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "RESTFUL 方法 url 必须是非空字符串（相对路径与服务 commonlist.url 拼接）", { key: "url" });
+        // Designer parity: the rule designer's RESTFUL method config also carries
+        // `connectTime` / `retryTimes` (string seconds/count, designer defaults
+        // "10"/"3"); the 绑定业务方法 dialog and the runtime read them, so a
+        // hand-rolled config that omits them is normalized to the designer
+        // defaults. Caller values pass through (string or number).
+        if (config.connectTime === undefined)
+            config.connectTime = "10";
+        else if (typeof config.connectTime !== "string" && typeof config.connectTime !== "number")
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "RESTFUL connectTime 必须是字符串或数字（秒）", { key: "connectTime" });
+        if (config.retryTimes === undefined)
+            config.retryTimes = "3";
+        else if (typeof config.retryTimes !== "string" && typeof config.retryTimes !== "number")
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "RESTFUL retryTimes 必须是字符串或数字（次）", { key: "retryTimes" });
+    }
+    if (adapterCode === "DATA_SQL" || adapterCode === "DATA_TABLE") {
+        for (const key of ["sql", "returnType"])
+            if (config[key] === undefined)
+                refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `${adapterCode} 方法 configJson 缺少必需键 ${key}`, { key });
+        if (typeof config.sql !== "string" || !config.sql)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `${adapterCode} 方法 sql 必须是非空字符串`, { key: "sql" });
+        config.returnType = encodeEnumIndex(config.returnType, DATA_RETURN_TYPES, "returnType");
+        if (adapterCode === "DATA_TABLE") {
+            if (config.sqlType !== undefined && (typeof config.sqlType !== "string" || !["SELECT", "UPDATE", "DELETE", "INSERT", "UPSERT"].includes(config.sqlType)))
+                refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "DATA_TABLE sqlType 必须是 SELECT/UPDATE/DELETE/INSERT/UPSERT", { key: "sqlType" });
+            if (config.dataTable !== undefined && typeof config.dataTable !== "string")
+                refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "DATA_TABLE dataTable 必须是字符串", { key: "dataTable" });
+        }
+    }
+    if (adapterCode === "SAP") {
+        validateSapMethod(config);
+    }
+    if (adapterCode === "KAFKA") {
+        for (const key of ["sendMode", "connectTime", "retryTimes", "topic"])
+            if (config[key] === undefined)
+                refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, `KAFKA 方法 configJson 缺少必需键 ${key}`, { key });
+        if (!["SYNC_SEND", "ASYNC_SEND", "FORGOTTEN_SEND"].includes(String(config.sendMode)))
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "KAFKA sendMode 必须是 SYNC_SEND/ASYNC_SEND/FORGOTTEN_SEND", { key: "sendMode" });
+        if (typeof config.topic !== "string" || !config.topic)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "KAFKA topic 必须是非空字符串", { key: "topic" });
+        if (typeof config.connectTime !== "number" && typeof config.connectTime !== "string")
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "KAFKA connectTime 必须是数字或字符串", { key: "connectTime" });
+        if (typeof config.retryTimes !== "number" && typeof config.retryTimes !== "string")
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "KAFKA retryTimes 必须是数字或字符串", { key: "retryTimes" });
+    }
+    if (config.frontEndExtensionEnable !== undefined && typeof config.frontEndExtensionEnable !== "boolean")
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "frontEndExtensionEnable 必须是布尔值（/runtime/bizbus/invoke 的门槛，false → 500113）", { key: "frontEndExtensionEnable" });
+    return JSON.stringify(config);
+}
+function parameterPosition(parameter) {
+    const raw = parameter.configJson;
+    const parsed = typeof raw === "string" ? safeParse(raw) : raw;
+    return isRecord(parsed) ? parsed.position : undefined;
+}
+function safeParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Validate a structured parameter face and serialize it to
+ * input/outputParametersJson. `required` is PASSTHROUGH THREE-STATE: true /
+ * false / absent stay exactly as declared (an absent key is "必填未声明",
+ * never coerced to false — fwb §2 evidence).
+ *
+ * EXCEPTION (output face): RETURN parameters default to `required:false`
+ * when absent. Outputs are values the caller receives — marking them required
+ * buys nothing and, because the rule designer mirrors each method parameter's
+ * `required` onto the BIZ_ACTION mapping element, a required OUTPUT forces
+ * every output mapping to be required too, which is a common source of
+ * binding friction. Inputs keep the three-state passthrough: mark them
+ * required per actual need.
+ *
+ * For RESTFUL every parameter must carry configJson.position, and
+ * URL_VARIABLE is refused because the runtime has no branch for it (501007).
+ */
+export function compileParameterFace(adapterCode, parameters, label) {
+    if (!Array.isArray(parameters))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${label} 必须是结构化参数数组（ParameterModel[]）`, { label });
+    const defaultRequired = isOutputFace(label) ? false : undefined;
+    const normalized = parameters.map((parameter, index) => compileParameter(adapterCode, parameter, label, `${label}[${index}]`, index, defaultRequired));
+    return JSON.stringify(normalized);
+}
+/** True when `label` names the RETURN parameter face (outputParametersJson). */
+function isOutputFace(label) {
+    return /output/i.test(label);
+}
+/**
+ * Compile ONE parameter element (and recurse into `subParameters`). Platform
+ * canonical shape (designer-written BizMethod face): every element carries
+ * `bizPropertyType` (参数类型, int index) — mandatory, since the 业务规则的
+ * 绑定业务方法 dialog matches parameters to target fields BY TYPE and a
+ * type-less parameter cannot be mapped — plus `externParameterType` (int;
+ * leaf → 1000 PROPERTY, a node with subParameters → 1002 OBJECT) and
+ * `description`. RESTFUL additionally requires configJson.position.
+ */
+function compileParameter(adapterCode, parameter, label, path, index, defaultRequired) {
+    if (!isRecord(parameter))
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} 必须是对象`, { label, index });
+    if (typeof parameter.code !== "string" || !parameter.code)
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} 缺少 code（绑定校验按 code 对账）`, { label, index });
+    if (parameter.required !== undefined && typeof parameter.required !== "boolean")
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path}.required 必须是布尔（缺席=未声明必填，不会被补成 false）`, { label, index });
+    const position = parameterPosition(parameter);
+    if (adapterCode === "RESTFUL") {
+        if (position === undefined)
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) 缺 configJson.position —— RESTFUL 参数无 position 在 invoke 时 NPE（RestProtocolAdapterRuntimeServiceImpl.java:197）`, { label, index, code: parameter.code });
+        if (position === 1 || position === "URL_VARIABLE")
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) position=URL_VARIABLE 被运行时拒绝（501007，无对应分支）；用 QUERY_PARAMS/REQUEST_HEADER/REQUEST_BODY/PATH_PARAMS`, { label, index, code: parameter.code });
+    }
+    // Platform canonical: `ParameterModel.configJson` is a JSON STRING column
+    // whose content is the nested config OBJECT with the WIRE INTEGER position
+    // (platform built-ins: "configJson":{"position":3}). Encode the enum and
+    // emit the object form; a string input is parsed so we never double-encode.
+    const configInput = isRecord(parameter.configJson) ? parameter.configJson : typeof parameter.configJson === "string" ? safeParse(parameter.configJson) : undefined;
+    const configJson = adapterCode === "RESTFUL"
+        ? { ...(isRecord(configInput) ? configInput : {}), position: encodeEnumIndex(position, RESTFUL_PARAMETER_POSITIONS, "position") }
+        : parameter.configJson;
+    const bizPropertyType = resolveBizPropertyType(parameter, label, index, path);
+    const externParameterType = resolveExternParameterType(parameter, label, index);
+    const subParameters = Array.isArray(parameter.subParameters)
+        ? parameter.subParameters.map((sub, subIndex) => compileParameter(adapterCode, sub, label, `${path}.subParameters[${subIndex}]`, subIndex, defaultRequired))
+        : parameter.subParameters;
+    return {
+        ...parameter,
+        ...(configJson === undefined ? {} : { configJson }),
+        description: typeof parameter.description === "string" ? parameter.description : "",
+        bizPropertyType,
+        externParameterType,
+        // Output face defaults absent `required` to false (see compileParameterFace).
+        ...(parameter.required === undefined && defaultRequired !== undefined ? { required: defaultRequired } : {}),
+        ...(subParameters === undefined ? {} : { subParameters }),
+        ...(parameter.name === undefined ? { name: parameter.code } : {}),
+    };
+}
+/** Resolve/validate a parameter's `bizPropertyType` (int index or enum name). Absent → refuse (fail-closed). */
+function resolveBizPropertyType(parameter, label, index, path) {
+    const raw = parameter.bizPropertyType;
+    if (raw === undefined || raw === null)
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) 缺 bizPropertyType（参数类型）——业务集成参数必须有类型，否则业务规则按类型绑定失败、参数无法映射；用 BIZ_PROPERTY_TYPES 索引或枚举名（SHORT_TEXT/NUMERICAL/RADIO/DROPDOWN_BOX…）`, { label, index, code: parameter.code });
+    if (typeof raw === "number" && Number.isInteger(raw) && raw in BIZ_PROPERTY_TYPES)
+        return raw;
+    if (typeof raw === "string" && raw in BIZ_PROPERTY_TYPE_NAMES)
+        return BIZ_PROPERTY_TYPE_NAMES[raw];
+    refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) bizPropertyType 必须是合法字段类型（整数索引或枚举名，如 SHORT_TEXT/NUMERICAL/RADIO/DROPDOWN_BOX）——缺失或有误会破坏业务规则按类型绑定`, { label, index, code: parameter.code });
+}
+/** Resolve/validate a parameter's `externParameterType` (int index or name); default leaf=PROPERTY(1000)/parent=OBJECT(1002). */
+function resolveExternParameterType(parameter, label, index) {
+    const raw = parameter.externParameterType;
+    if (raw !== undefined) {
+        if (typeof raw === "number" && Number.isInteger(raw) && raw in EXTERN_PARAMETER_TYPES)
+            return raw;
+        if (typeof raw === "string" && raw in EXTERN_PARAMETER_NAMES)
+            return EXTERN_PARAMETER_NAMES[raw];
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${label}[${index}] (${parameter.code}) externParameterType 必须是 PROPERTY(1000)/LIST(1001)/OBJECT(1002) 的整数索引或枚举名`, { label, index, code: parameter.code });
+    }
+    const hasChildren = Array.isArray(parameter.subParameters) && parameter.subParameters.length > 0;
+    return hasChildren ? EXTERN_PARAMETER_NAMES.OBJECT : EXTERN_PARAMETER_NAMES.PROPERTY;
+}
+/**
+ * Read-side parameter-face normalization: the platform stores each parameter's
+ * `configJson.position` as the WIRE INTEGER index (platform built-ins:
+ * `{"position":3}`). Decode it back to the canonical NAME for a readable
+ * readback (mirrors `normalizeMethodConfigReadback`). Non-RESTFUL faces pass
+ * through untouched.
+ */
+export function normalizeParameterFaceReadback(adapterCode, parameters) {
+    if (adapterCode !== "RESTFUL" || !Array.isArray(parameters))
+        return parameters;
+    return parameters.map((parameter) => {
+        if (!isRecord(parameter))
+            return parameter;
+        const config = isRecord(parameter.configJson) ? parameter.configJson : typeof parameter.configJson === "string" ? safeParse(parameter.configJson) : undefined;
+        if (!isRecord(config) || !(typeof config.position === "number" && Number.isInteger(config.position) && config.position in RESTFUL_PARAMETER_POSITIONS))
+            return parameter;
+        return { ...parameter, configJson: { ...config, position: RESTFUL_PARAMETER_POSITIONS[config.position] } };
+    });
+}
+/**
+ * Read-side enum normalization: the wire stores INTEGER indexes (8.6.26 and
+ * fwb alike). Decode them to the canonical NAME form so a readback reads like a
+ * name; unknown values pass through untouched (never guessed). A name already
+ * present passes through unchanged, so the projection is idempotent.
+ */
+export function normalizeMethodConfigReadback(adapterCode, config) {
+    if (!isRecord(config))
+        return config;
+    if (adapterCode !== "RESTFUL" && adapterCode !== "DATA_SQL" && adapterCode !== "DATA_TABLE" && adapterCode !== "SAP" && adapterCode !== "KAFKA")
+        return config;
+    const normalized = { ...config };
+    const mapEntry = (key, ints) => {
+        if (typeof normalized[key] === "number" && Number.isInteger(normalized[key]) && normalized[key] in ints)
+            normalized[key] = ints[normalized[key]];
+    };
+    if (adapterCode === "RESTFUL") {
+        mapEntry("httpType", RESTFUL_HTTP_TYPES);
+        mapEntry("requestBodyType", RESTFUL_REQUEST_BODY_TYPES);
+    }
+    else if (adapterCode === "DATA_SQL" || adapterCode === "DATA_TABLE" || adapterCode === "SAP") {
+        mapEntry("returnType", DATA_RETURN_TYPES);
+    }
+    return normalized;
+}
+/**
+ * Ticket 115 — READ-face credential masking. A RESTFUL service config's
+ * `auth.parameterlist[].value` carries cleartext credentials (basic
+ * password, oauth client_secret…); handoff §5 says method-config secrets
+ * never echo. Applied ONLY to readback projections (service.get /
+ * method.get / method update readback): the VALUES become "***" while the
+ * code/name structure stays readable, so ticket 94's shape-readback
+ * semantics survive. NEVER apply this on a write/echo path — the update
+ * echo must carry the original config verbatim or the mask would be
+ * persisted over the stored credential.
+ */
+export function maskServiceConfigSecrets(config) {
+    if (!isRecord(config))
+        return config;
+    const auth = config.auth;
+    if (!isRecord(auth) || !Array.isArray(auth.parameterlist))
+        return config;
+    const maskedParameterlist = auth.parameterlist.map((entry) => {
+        if (!isRecord(entry))
+            return entry;
+        return { ...entry, ...(entry.value !== undefined ? { value: "***" } : {}) };
+    });
+    return { ...config, auth: { ...auth, parameterlist: maskedParameterlist } };
+}
+/** Decode a manifest.json payload; anything off-shape is an error (fail closed). */
+export function parseIeManifest(value) {
+    const record = value;
+    if (!record || typeof record !== "object" || Array.isArray(record))
+        throw new Error("manifest.json 不是对象");
+    const servicesRaw = record.services;
+    if (!Array.isArray(servicesRaw) || servicesRaw.length === 0)
+        throw new Error("manifest.services 缺失或为空");
+    const services = [];
+    const methodsByService = {};
+    for (const entry of servicesRaw) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            throw new Error("manifest.services 存在非对象元素");
+        const row = entry;
+        if (typeof row.code !== "string" || !row.code.trim())
+            throw new Error("manifest.services 存在为空的集成服务编码");
+        services.push({
+            code: row.code,
+            name: row.name,
+            adapterCode: row.adapterCode,
+            configJson: typeof row.configJson === "string" ? row.configJson : undefined,
+            raw: row,
+        });
+    }
+    const methodsMap = record.methodsMap;
+    if (methodsMap !== undefined) {
+        if (!methodsMap || typeof methodsMap !== "object" || Array.isArray(methodsMap))
+            throw new Error("manifest.methodsMap 不是对象");
+        for (const [serviceCode, list] of Object.entries(methodsMap)) {
+            if (!Array.isArray(list))
+                throw new Error(`manifest.methodsMap[${serviceCode}] 不是数组`);
+            methodsByService[serviceCode] = list.map((method) => {
+                if (!method || typeof method !== "object" || Array.isArray(method))
+                    throw new Error(`manifest.methodsMap[${serviceCode}] 存在非对象元素`);
+                const row = method;
+                if (typeof row.code !== "string" || !row.code.trim())
+                    throw new Error(`manifest.methodsMap[${serviceCode}] 存在为空的方法编码`);
+                return { code: row.code, raw: row };
+            });
+        }
+    }
+    return { systemVersion: typeof record.systemVersion === "string" ? record.systemVersion : undefined, services, methodsByService };
+}
+/** Secret-free package summary for tool responses (codes/faces only, never config bodies). */
+export function iePackageSummary(manifest) {
+    return {
+        systemVersion: manifest.systemVersion,
+        services: manifest.services.map((service) => ({
+            code: service.code,
+            name: service.name,
+            adapterCode: service.adapterCode,
+            methods: (manifest.methodsByService[service.code] ?? []).map((method) => method.code),
+        })),
+    };
+}
+//# sourceMappingURL=bizservice-config.js.map