digitalsee-ai-flow-cli 0.2.1 → 0.6.15-beta

package/dist/commands/flow/mapping.js

@@ -0,0 +1,734 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMappingSupported = isMappingSupported;
+exports.getDirectionFromBusinessType = getDirectionFromBusinessType;
+exports.getAvailableSides = getAvailableSides;
+exports.findMappingByName = findMappingByName;
+exports.getDirectionLabel = getDirectionLabel;
+exports.getMappingSubPath = getMappingSubPath;
+exports.buildMappingEntry = buildMappingEntry;
+exports.formatMappingMethod = formatMappingMethod;
+exports.filterProfileMappingData = filterProfileMappingData;
+exports.filterBySide = filterBySide;
+exports.registerFlowMapping = registerFlowMapping;
+const output_1 = require("@/utils/output");
+const flow_1 = require("@/api/flow");
+const mapping_1 = require("@/api/mapping");
+const MAPPING_BUSINESS_TYPES = [5, 6];
+function isMappingSupported(flow) {
+    return flow.business_type !== undefined && MAPPING_BUSINESS_TYPES.includes(flow.business_type);
+}
+async function validateFlowSupportsMapping(flowId) {
+    const flow = await (0, flow_1.getFlowDetail)(flowId);
+    if (!isMappingSupported(flow)) {
+        const msg = `该连接流不支持属性映射（business_type=${flow.business_type ?? '未知'}），仅通讯录集成（business_type=5）和通讯录同步（business_type=6）支持`;
+        throw new Error(msg);
+    }
+    return flow.business_type;
+}
+const ENTITY_FIELD_MAP = {
+    user: {
+        label: '用户',
+        digParams: 'digUserSubParams',
+        digName: 'digUserName',
+        otherParams: 'otherUserSubParams',
+        otherName: 'otherUserName',
+        mappingToIam: 'otherUserMappingToIam',
+        mappingToApp: 'otherUserMappingToApp',
+    },
+    org: {
+        label: '部门',
+        digParams: 'digOrgSubParams',
+        digName: 'digOrgName',
+        otherParams: 'otherOrgSubParams',
+        otherName: 'otherOrgName',
+        mappingToIam: 'otherOrgMappingToIam',
+        mappingToApp: 'otherOrgMappingToApp',
+    },
+    role: {
+        label: '角色',
+        digParams: 'digRoleSubParams',
+        digName: 'digRoleName',
+        otherParams: 'otherRoleSubParams',
+        otherName: 'otherRoleName',
+        mappingToIam: 'otherRoleMappingToIam',
+        mappingToApp: 'otherRoleMappingToApp',
+    },
+};
+// ── Validation helpers ──────────────────────────────────────
+const VALID_ENTITIES = ['user', 'org', 'role'];
+function validateEntity(entity) {
+    if (entity !== undefined && !VALID_ENTITIES.includes(entity)) {
+        throw new Error(`无效的实体类型: ${entity}，可选值: user | org | role`);
+    }
+}
+const VALID_SIDES = ['upstream', 'idaas', 'downstream'];
+function validateSide(side) {
+    if (side !== undefined && !VALID_SIDES.includes(side)) {
+        throw new Error(`无效的端: ${side}，可选值: upstream | idaas | downstream`);
+    }
+}
+const VALID_DIRECTIONS = ['all', 'upstream', 'downstream'];
+function validateDirection(direction) {
+    if (!VALID_DIRECTIONS.includes(direction)) {
+        throw new Error(`无效的方向: ${direction}，可选值: upstream | downstream | all`);
+    }
+}
+// ── Business type / direction utilities ─────────────────────
+function getDirectionFromBusinessType(businessType) {
+    if (businessType === 5)
+        return 'upstream';
+    if (businessType === 6)
+        return 'downstream';
+    throw new Error(`不支持的 business_type: ${businessType}`);
+}
+function getAvailableSides(businessType) {
+    if (businessType === 5)
+        return ['upstream', 'idaas'];
+    if (businessType === 6)
+        return ['idaas', 'downstream'];
+    return ['upstream', 'idaas', 'downstream'];
+}
+function findMappingByName(subParams, name, direction) {
+    if (direction === 'upstream') {
+        return subParams.findIndex((item) => item.name === name);
+    }
+    return subParams.findIndex((item) => item.value === name);
+}
+function getDirectionLabel(direction) {
+    return direction === 'upstream' ? '上游 → IDAAS' : 'IDAAS → 下游';
+}
+function getMappingSubPath(entity, direction) {
+    const mappingKey = `${entity}_mapping`;
+    const directionKey = direction === 'upstream' ? 'to_iam' : 'to_app';
+    return [mappingKey, directionKey, 'sub_params'];
+}
+function ensureSubParams(data, entity, direction) {
+    const [mappingKey, directionKey] = getMappingSubPath(entity, direction);
+    let mapping = data[mappingKey];
+    if (!mapping) {
+        mapping = {};
+        data[mappingKey] = mapping;
+    }
+    let dirData = mapping[directionKey];
+    if (!dirData) {
+        dirData = {};
+        mapping[directionKey] = dirData;
+    }
+    let arr = dirData.sub_params;
+    if (!arr) {
+        arr = [];
+        dirData.sub_params = arr;
+    }
+    return arr;
+}
+function getSubParams(data, entity, direction) {
+    const [mappingKey, directionKey] = getMappingSubPath(entity, direction);
+    const mapping = data[mappingKey];
+    const dirData = mapping?.[directionKey];
+    return dirData?.sub_params || [];
+}
+function buildMappingEntry(sourceField, targetField, method, direction, expression, targetExpression) {
+    const update = method === 'update';
+    const base = direction === 'upstream'
+        ? { name: targetField, value: sourceField, update }
+        : { name: sourceField, value: targetField, update };
+    if (expression) {
+        base.source_exp = expression;
+        base.exp_type = 'JS_EXP';
+    }
+    if (targetExpression) {
+        base.target_exp = targetExpression;
+        base.exp_type = 'JS_EXP';
+    }
+    return base;
+}
+function formatMappingMethod(item) {
+    return item.update ? 'update' : 'create';
+}
+function filterProfileMappingData(data, entity, direction) {
+    const result = { ...data };
+    if (entity && entity !== 'user') {
+        result.digUserSubParams = [];
+        result.otherUserSubParams = [];
+        result.otherUserMappingToIam = [];
+        result.otherUserMappingToApp = [];
+    }
+    if (entity && entity !== 'org') {
+        result.digOrgSubParams = [];
+        result.otherOrgSubParams = [];
+        result.otherOrgMappingToIam = [];
+        result.otherOrgMappingToApp = [];
+    }
+    if (entity && entity !== 'role') {
+        result.digRoleSubParams = [];
+        result.otherRoleSubParams = [];
+        result.otherRoleMappingToIam = [];
+        result.otherRoleMappingToApp = [];
+    }
+    if (direction === 'upstream') {
+        result.otherUserMappingToApp = [];
+        result.otherOrgMappingToApp = [];
+        result.otherRoleMappingToApp = [];
+    }
+    else if (direction === 'downstream') {
+        result.otherUserMappingToIam = [];
+        result.otherOrgMappingToIam = [];
+        result.otherRoleMappingToIam = [];
+    }
+    return result;
+}
+function filterBySide(data, side, entity) {
+    const result = filterProfileMappingData(data, entity);
+    if (side === 'idaas') {
+        result.otherUserSubParams = [];
+        result.otherOrgSubParams = [];
+        result.otherRoleSubParams = [];
+        result.otherUserMappingToIam = [];
+        result.otherUserMappingToApp = [];
+        result.otherOrgMappingToIam = [];
+        result.otherOrgMappingToApp = [];
+        result.otherRoleMappingToIam = [];
+        result.otherRoleMappingToApp = [];
+    }
+    else if (side === 'upstream') {
+        result.otherUserMappingToApp = [];
+        result.otherOrgMappingToApp = [];
+        result.otherRoleMappingToApp = [];
+        result.digUserSubParams = [];
+        result.digOrgSubParams = [];
+        result.digRoleSubParams = [];
+    }
+    else if (side === 'downstream') {
+        result.otherUserMappingToIam = [];
+        result.otherOrgMappingToIam = [];
+        result.otherRoleMappingToIam = [];
+        result.otherUserSubParams = [];
+        result.otherOrgSubParams = [];
+        result.otherRoleSubParams = [];
+    }
+    return result;
+}
+// ── JSON / rendering utilities ──────────────────────────────
+const JSON_FIELD_WHITELIST = new Set([
+    'name',
+    'display_name',
+    'type',
+    'value_type',
+    'value',
+    'update',
+    'source_exp',
+    'target_exp',
+    'exp_type',
+]);
+function stripMappingItem(item) {
+    const out = { name: item.name };
+    for (const key of JSON_FIELD_WHITELIST) {
+        if (key !== 'name' && item[key] !== undefined && item[key] !== null) {
+            out[key] = item[key];
+        }
+    }
+    return out;
+}
+function stripMappingArray(items) {
+    return items.map(stripMappingItem);
+}
+function formatSourceValue(item) {
+    if (item.exp_type === 'JS_EXP' && item.source_exp) {
+        return `JS: ${item.source_exp}`;
+    }
+    return String(item.value || '-');
+}
+function renderMappingTable(mappings, title, direction) {
+    if (mappings.length === 0) {
+        (0, output_1.printWarning)(`${title}: 无映射`);
+        return;
+    }
+    (0, output_1.printSubHeader)(title);
+    const headers = direction === 'upstream'
+        ? ['上游字段', 'IDAAS 字段', '显示名', '类型', '方式']
+        : ['下游字段', '显示名', 'IDAAS 字段', '类型', '方式'];
+    const rows = mappings.map((m) => {
+        const idaasLabel = m.exp_type === 'JS_EXP' && m.target_exp
+            ? `JS: ${m.target_exp}`
+            : direction === 'upstream'
+                ? String(m.name || '-')
+                : String(m.value || '-');
+        if (direction === 'upstream') {
+            return [
+                formatSourceValue(m),
+                idaasLabel,
+                String(m.display_name || '-'),
+                String(m.value_type || m.type || '-'),
+                formatMappingMethod(m),
+            ];
+        }
+        return [
+            formatSourceValue(m),
+            String(m.display_name || '-'),
+            idaasLabel,
+            String(m.value_type || m.type || '-'),
+            formatMappingMethod(m),
+        ];
+    });
+    (0, output_1.printTable)(headers, rows);
+}
+function renderFieldOptions(fields, title) {
+    if (fields.length === 0) {
+        (0, output_1.printWarning)(`${title}: 无可用字段`);
+        return;
+    }
+    (0, output_1.printSubHeader)(`${title} (${fields.length} 个字段)`);
+    const headers = ['字段名', '显示名', '类型'];
+    const rows = fields.map((f) => [
+        f.name || '-',
+        f.display_name || f.name || '-',
+        String(f.value_type || f.type || '-'),
+    ]);
+    (0, output_1.printTable)(headers, rows);
+}
+function resolveRefType(explicitType, businessType) {
+    if (explicitType)
+        return explicitType;
+    return businessType === 6 ? 'PUSHCONNECTOR' : 'CONNECTOR';
+}
+function wrapAction(errorLabel) {
+    return (fn) => async (flowId, options) => {
+        try {
+            if (options.json)
+                (0, output_1.setJsonMode)(true);
+            await fn(flowId, options);
+        }
+        catch (error) {
+            if (options.json) {
+                (0, output_1.printStructuredResult)({ ok: false, message: error.message });
+            }
+            else {
+                (0, output_1.printError)(`${errorLabel}失败: ${error.message}`);
+            }
+        }
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseShowOptions(options) {
+    const refType = options.type;
+    const mode = options.mode || 'all';
+    const entity = options.entity;
+    const side = options.side;
+    const direction = side ? 'all' : (options.direction || 'all');
+    if (side && options.direction && options.direction !== 'all') {
+        throw new Error('--side 与 --direction 互斥，不能同时使用');
+    }
+    validateEntity(entity);
+    validateSide(side);
+    validateDirection(direction);
+    return { refType, mode, entity, side, direction };
+}
+async function prepareShowData(flowId, params) {
+    const businessType = await validateFlowSupportsMapping(flowId);
+    const refType = resolveRefType(params.refType, businessType);
+    const availableSides = getAvailableSides(businessType);
+    if (params.side && !availableSides.includes(params.side)) {
+        const btLabel = businessType === 5 ? '通讯录集成' : '通讯录同步';
+        throw new Error(`该流为${btLabel}，不支持 --side ${params.side}，可用: ${availableSides.join(' | ')}`);
+    }
+    // 按需获取：避免请求不需要的数据
+    const needsDig = params.mode !== 'configured' || params.side === 'idaas';
+    const needsConnector = params.side !== 'idaas';
+    const [dig, raw] = await Promise.all([
+        needsDig ? (0, mapping_1.getDigProfileTemplates)(refType) : null,
+        needsConnector ? (0, mapping_1.fetchProfileData)(flowId, refType) : null,
+    ]);
+    const data = (0, mapping_1.buildProfileMappingData)(dig, raw);
+    // Auto-filter based on flow type when no --side specified
+    if (!params.side) {
+        if (businessType === 5) {
+            data.otherUserMappingToApp = [];
+            data.otherOrgMappingToApp = [];
+            data.otherRoleMappingToApp = [];
+        }
+        else if (businessType === 6) {
+            data.otherUserMappingToIam = [];
+            data.otherOrgMappingToIam = [];
+            data.otherRoleMappingToIam = [];
+            data.otherUserSubParams = [];
+            data.otherOrgSubParams = [];
+            data.otherRoleSubParams = [];
+        }
+    }
+    const filtered = params.side
+        ? filterBySide(data, params.side, params.entity)
+        : filterProfileMappingData(data, params.entity, params.direction);
+    return { filtered, businessType };
+}
+function printShowJsonOutput(filtered, mode) {
+    const jsonData = {};
+    const showAvailable = mode === 'all' || mode === 'available';
+    const showConfigured = mode === 'all' || mode === 'configured';
+    if (showAvailable) {
+        for (const fm of Object.values(ENTITY_FIELD_MAP)) {
+            const dig = filtered[fm.digParams];
+            const other = filtered[fm.otherParams];
+            if (dig.length > 0) {
+                jsonData[fm.digParams] = stripMappingArray(dig);
+                jsonData[fm.digName] = filtered[fm.digName];
+            }
+            if (other.length > 0) {
+                jsonData[fm.otherParams] = stripMappingArray(other);
+                jsonData[fm.otherName] = filtered[fm.otherName];
+            }
+        }
+    }
+    if (showConfigured) {
+        for (const fm of Object.values(ENTITY_FIELD_MAP)) {
+            for (const key of [fm.mappingToIam, fm.mappingToApp]) {
+                const arr = filtered[key];
+                if (arr.length > 0)
+                    jsonData[key] = stripMappingArray(arr);
+            }
+        }
+    }
+    (0, output_1.printJson)(jsonData);
+}
+// ── Show command rendering helpers ──────────────────────────
+function entityMatches(filter, entityType) {
+    return !filter || filter === entityType;
+}
+function renderIdaaAvailableFields(filtered, entity) {
+    for (const [et, fm] of Object.entries(ENTITY_FIELD_MAP)) {
+        if (!entityMatches(entity, et))
+            continue;
+        renderFieldOptions(filtered[fm.digParams], `IDAAS ${fm.label}字段: ${filtered[fm.digName]}`);
+    }
+}
+function renderConfiguredMappings(filtered, side, entity, direction) {
+    if (side === 'idaas') {
+        (0, output_1.printWarning)('IDAAS 端无已配置映射（IDAAS 端仅包含字段模板，使用 --mode available 查看）');
+        return;
+    }
+    if (side === 'upstream') {
+        for (const [et, fm] of Object.entries(ENTITY_FIELD_MAP)) {
+            if (!entityMatches(entity, et))
+                continue;
+            const items = filtered[fm.mappingToIam];
+            if (items.length > 0)
+                renderMappingTable(items, `${fm.label}字段映射`, 'upstream');
+        }
+        return;
+    }
+    if (side === 'downstream') {
+        for (const [et, fm] of Object.entries(ENTITY_FIELD_MAP)) {
+            if (!entityMatches(entity, et))
+                continue;
+            const items = filtered[fm.mappingToApp];
+            if (items.length > 0)
+                renderMappingTable(items, `${fm.label}字段映射`, 'downstream');
+        }
+        return;
+    }
+    // No side filter: render both upstream and downstream sections
+    const showUpstream = direction === 'all' || direction === 'upstream';
+    const showDownstream = direction === 'all' || direction === 'downstream';
+    const hasUpstream = showUpstream &&
+        Object.entries(ENTITY_FIELD_MAP).some(([et, fm]) => entityMatches(entity, et) &&
+            filtered[fm.mappingToIam].length > 0);
+    const hasDownstream = showDownstream &&
+        Object.entries(ENTITY_FIELD_MAP).some(([et, fm]) => entityMatches(entity, et) &&
+            filtered[fm.mappingToApp].length > 0);
+    if (!hasUpstream && !hasDownstream) {
+        (0, output_1.printWarning)('暂无已配置的映射');
+    }
+    if (hasUpstream) {
+        (0, output_1.printHeader)('上游 → IDAAS 映射');
+        for (const [et, fm] of Object.entries(ENTITY_FIELD_MAP)) {
+            if (!entityMatches(entity, et))
+                continue;
+            const items = filtered[fm.mappingToIam];
+            if (items.length > 0)
+                renderMappingTable(items, `${fm.label}字段映射`, 'upstream');
+        }
+    }
+    if (hasDownstream) {
+        (0, output_1.printHeader)('IDAAS → 下游 映射');
+        for (const [et, fm] of Object.entries(ENTITY_FIELD_MAP)) {
+            if (!entityMatches(entity, et))
+                continue;
+            const items = filtered[fm.mappingToApp];
+            if (items.length > 0)
+                renderMappingTable(items, `${fm.label}字段映射`, 'downstream');
+        }
+    }
+}
+function renderAvailableFields(filtered, entity, isFocused, mode, side) {
+    if (isFocused && mode === 'all')
+        return;
+    (0, output_1.printHeader)('可用字段');
+    const digLabel = side === 'downstream' ? '下游' : 'IDAAS';
+    for (const [et, fm] of Object.entries(ENTITY_FIELD_MAP)) {
+        if (!entityMatches(entity, et))
+            continue;
+        const digFields = filtered[fm.digParams];
+        const otherFields = filtered[fm.otherParams];
+        if (digFields.length > 0) {
+            renderFieldOptions(digFields, `${digLabel} ${fm.label}字段: ${filtered[fm.digName]}`);
+        }
+        if (otherFields.length > 0) {
+            renderFieldOptions(otherFields, `上游${fm.label}字段: ${filtered[fm.otherName]}`);
+        }
+    }
+}
+// ── Command registration ────────────────────────────────────
+function registerFlowMapping(flowCmd) {
+    const mappingCmd = flowCmd.command('mapping').description('属性映射管理（账号关联）');
+    // ── show ────────────────────────────────────────────────
+    mappingCmd
+        .command('show <flowId>')
+        .description('查看属性映射配置')
+        .option('--entity <entity>', '实体类型过滤: user | org | role')
+        .option('--side <side>', '聚焦端: upstream(上游端) | idaas(IDAAS端) | downstream(下游端)。与 --direction 互斥')
+        .option('--direction <direction>', '方向过滤: upstream(上游→IDAAS) | downstream(IDAAS→下游) | all(全部)', 'all')
+        .option('--mode <mode>', '显示模式: all(全部) | configured(仅已配置) | available(仅可配置项)', 'all')
+        .option('--json', '以 JSON 格式输出')
+        .action(wrapAction('获取映射配置')(async (flowId, options) => {
+        const params = parseShowOptions(options);
+        const { filtered } = await prepareShowData(flowId, params);
+        if (options.json) {
+            printShowJsonOutput(filtered, params.mode);
+            return;
+        }
+        // Title
+        const titleParts = [];
+        if (params.side) {
+            const sideLabels = {
+                upstream: '上游端',
+                idaas: 'IDAAS端',
+                downstream: '下游端',
+            };
+            titleParts.push(sideLabels[params.side]);
+        }
+        if (params.entity) {
+            const entityLabels = { user: '用户', org: '部门', role: '角色' };
+            titleParts.push(entityLabels[params.entity]);
+        }
+        const title = titleParts.length > 0
+            ? `${titleParts.join('')}映射配置 (Flow: ${flowId})`
+            : `属性映射配置 (Flow: ${flowId})`;
+        (0, output_1.printHeader)(title);
+        const isFocused = !!(params.entity && (params.side || params.direction !== 'all'));
+        if (params.side === 'idaas' && (params.mode === 'all' || params.mode === 'available')) {
+            renderIdaaAvailableFields(filtered, params.entity);
+            return;
+        }
+        if (params.mode === 'all' || params.mode === 'configured') {
+            renderConfiguredMappings(filtered, params.side, params.entity, params.direction);
+        }
+        if (params.mode === 'all' || params.mode === 'available') {
+            renderAvailableFields(filtered, params.entity, isFocused, params.mode, params.side);
+        }
+    }));
+    // ── add ─────────────────────────────────────────────────
+    mappingCmd
+        .command('add <flowId>')
+        .description('新增属性映射')
+        .requiredOption('--entity <entity>', '实体类型: user | org | role')
+        .option('--source-field <field>', '外部系统字段名（与 --expression 互斥）')
+        .option('--expression <expr>', 'source 侧 JS 表达式（与 --source-field 互斥）')
+        .option('--target-field <field>', 'IDAAS 字段名（与 --target-expression 互斥）')
+        .option('--target-expression <expr>', 'target 侧 JS 表达式（与 --target-field 互斥）')
+        .option('--method <method>', '映射方式: create | update', 'create')
+        .option('--type <refType>', '引用类型', 'CONNECTOR')
+        .option('--json', '以 JSON 格式输出')
+        .action(wrapAction('添加映射')(async (flowId, options) => {
+        const entity = options.entity;
+        validateEntity(entity);
+        if (options.sourceField && options.expression) {
+            throw new Error('--source-field 与 --expression 互斥，请只提供其中一个');
+        }
+        if (!options.sourceField && !options.expression) {
+            throw new Error('必须提供 --source-field 或 --expression');
+        }
+        if (options.targetField && options.targetExpression) {
+            throw new Error('--target-field 与 --target-expression 互斥，请只提供其中一个');
+        }
+        if (!options.targetField && !options.targetExpression) {
+            throw new Error('必须提供 --target-field 或 --target-expression');
+        }
+        const businessType = await validateFlowSupportsMapping(flowId);
+        const direction = getDirectionFromBusinessType(businessType);
+        const method = options.method === 'update' ? 'update' : 'create';
+        const refType = resolveRefType(options.type, businessType);
+        const profileData = await (0, mapping_1.fetchProfileData)(flowId, refType);
+        const subParams = ensureSubParams(profileData, entity, direction);
+        const idaasKey = options.targetField || options.targetExpression;
+        const existing = subParams.find((item) => direction === 'upstream' ? item.name === idaasKey : item.value === idaasKey);
+        if (existing && !options.targetExpression) {
+            throw new Error(`映射已存在: ${idaasKey}，如需修改请使用 flow mapping set 命令`);
+        }
+        const sourceField = options.sourceField || options.expression;
+        const targetField = options.targetField || options.targetExpression;
+        const entry = buildMappingEntry(sourceField, targetField, method, direction, options.expression, options.targetExpression);
+        subParams.push(entry);
+        await (0, mapping_1.editMapping)(flowId, refType, profileData);
+        if (options.json) {
+            (0, output_1.printJson)({ ok: true, message: '映射已添加', entry, flowId });
+        }
+        else {
+            const sourceLabel = options.expression
+                ? `JS: ${options.expression}`
+                : options.sourceField;
+            const targetLabel = options.targetExpression
+                ? `JS: ${options.targetExpression}`
+                : options.targetField;
+            (0, output_1.printSuccess)(`映射已添加 (${getDirectionLabel(direction)}): ${sourceLabel} → ${targetLabel} (${method})`);
+        }
+    }));
+    // ── set ─────────────────────────────────────────────────
+    mappingCmd
+        .command('set <flowId>')
+        .description('修改已有映射')
+        .requiredOption('--entity <entity>', '实体类型: user | org | role')
+        .requiredOption('--name <fieldName>', 'IDAAS 字段名，用于定位映射条目')
+        .option('--source-field <field>', '新的外部系统字段名（与 --expression 互斥）')
+        .option('--expression <expr>', '新的 source 侧 JS 表达式（与 --source-field 互斥）')
+        .option('--target-field <field>', '新的 IDAAS 字段名（与 --target-expression 互斥）')
+        .option('--target-expression <expr>', '新的 target 侧 JS 表达式（与 --target-field 互斥）')
+        .option('--method <method>', '映射方式: create | update')
+        .option('--type <refType>', '引用类型', 'CONNECTOR')
+        .option('--json', '以 JSON 格式输出')
+        .action(wrapAction('修改映射')(async (flowId, options) => {
+        const entity = options.entity;
+        validateEntity(entity);
+        if (options.sourceField && options.expression) {
+            throw new Error('--source-field 与 --expression 互斥，请只提供其中一个');
+        }
+        if (options.targetField && options.targetExpression) {
+            throw new Error('--target-field 与 --target-expression 互斥，请只提供其中一个');
+        }
+        if (!options.sourceField &&
+            !options.expression &&
+            !options.targetField &&
+            !options.targetExpression &&
+            !options.method) {
+            throw new Error('至少需要提供一个修改项');
+        }
+        const businessType = await validateFlowSupportsMapping(flowId);
+        const direction = getDirectionFromBusinessType(businessType);
+        const refType = resolveRefType(options.type, businessType);
+        const profileData = await (0, mapping_1.fetchProfileData)(flowId, refType);
+        const subParams = getSubParams(profileData, entity, direction);
+        const idx = findMappingByName(subParams, options.name, direction);
+        if (idx === -1) {
+            throw new Error(`未找到映射: ${options.name}`);
+        }
+        const entry = subParams[idx];
+        const oldEntry = { ...entry };
+        if (options.sourceField !== undefined) {
+            if (direction === 'upstream') {
+                entry.value = options.sourceField;
+            }
+            else {
+                entry.name = options.sourceField;
+            }
+            delete entry.source_exp;
+            if (!entry.target_exp)
+                delete entry.exp_type;
+        }
+        if (options.expression !== undefined) {
+            if (direction === 'upstream') {
+                entry.value = options.expression;
+            }
+            else {
+                entry.name = options.expression;
+            }
+            entry.source_exp = options.expression;
+            entry.exp_type = 'JS_EXP';
+        }
+        if (options.targetField !== undefined) {
+            if (direction === 'upstream') {
+                entry.name = options.targetField;
+            }
+            else {
+                entry.value = options.targetField;
+            }
+            delete entry.target_exp;
+            if (!entry.source_exp)
+                delete entry.exp_type;
+        }
+        if (options.targetExpression !== undefined) {
+            if (direction === 'upstream') {
+                entry.name = options.targetExpression;
+            }
+            else {
+                entry.value = options.targetExpression;
+            }
+            entry.target_exp = options.targetExpression;
+            entry.exp_type = 'JS_EXP';
+        }
+        if (options.method !== undefined) {
+            entry.update = options.method === 'update';
+        }
+        subParams[idx] = entry;
+        await (0, mapping_1.editMapping)(flowId, refType, profileData);
+        if (options.json) {
+            (0, output_1.printJson)({ ok: true, message: '映射已更新', old: oldEntry, updated: entry, flowId });
+        }
+        else {
+            (0, output_1.printSuccess)(`映射已更新: ${options.name}`);
+        }
+    }));
+    // ── delete ──────────────────────────────────────────────
+    mappingCmd
+        .command('delete <flowId>')
+        .description('删除属性映射')
+        .requiredOption('--entity <entity>', '实体类型: user | org | role')
+        .requiredOption('--name <fieldName>', 'IDAAS 字段名，用于定位映射条目')
+        .option('--type <refType>', '引用类型', 'CONNECTOR')
+        .option('--json', '以 JSON 格式输出')
+        .action(wrapAction('删除映射')(async (flowId, options) => {
+        const entity = options.entity;
+        validateEntity(entity);
+        const businessType = await validateFlowSupportsMapping(flowId);
+        const direction = getDirectionFromBusinessType(businessType);
+        const refType = resolveRefType(options.type, businessType);
+        const profileData = await (0, mapping_1.fetchProfileData)(flowId, refType);
+        const subParams = getSubParams(profileData, entity, direction);
+        const beforeLen = subParams.length;
+        const newSubParams = subParams.filter((item) => direction === 'upstream' ? item.name !== options.name : item.value !== options.name);
+        if (newSubParams.length === beforeLen) {
+            throw new Error(`未找到映射: ${options.name}`);
+        }
+        const [mappingKey, directionKey] = getMappingSubPath(entity, direction);
+        const mapping = profileData[mappingKey];
+        const dirData = mapping?.[directionKey];
+        if (dirData) {
+            dirData.sub_params = newSubParams;
+        }
+        await (0, mapping_1.editMapping)(flowId, refType, profileData);
+        if (options.json) {
+            (0, output_1.printJson)({ ok: true, message: '映射已删除', name: options.name, flowId });
+        }
+        else {
+            (0, output_1.printSuccess)(`映射已删除: ${options.name}`);
+        }
+    }));
+    // ── check ───────────────────────────────────────────────
+    mappingCmd
+        .command('check <flowId>')
+        .description('检查映射是否已配置')
+        .option('--json', '以 JSON 格式输出')
+        .action(wrapAction('检查映射状态')(async (flowId, options) => {
+        await validateFlowSupportsMapping(flowId);
+        const result = await (0, mapping_1.checkMappingStatus)(flowId);
+        if (options.json) {
+            (0, output_1.printJson)({ ok: true, configured: result, flowId });
+            return;
+        }
+        if (result) {
+            (0, output_1.printSuccess)(`Flow ${flowId}: 映射已配置`);
+        }
+        else {
+            (0, output_1.printWarning)(`Flow ${flowId}: 映射未配置`);
+        }
+    }));
+}
+//# sourceMappingURL=mapping.js.map