weaver-work-cli 0.1.2 → 0.1.5

package/dist/shortcuts/ehr/operations/registry.js

@@ -0,0 +1,43 @@
+import { ehrValidationError } from '../errors.js';
+import { attendReadOperations } from './attend-read.js';
+import { attendWriteOperations } from './attend-write.js';
+import { hrContactOperations } from './hr-contact.js';
+import { hrDataSourceOperations } from './hr-ds.js';
+import { hrReportOperations } from './hr-report.js';
+import { recruitOperations } from './recruit.js';
+import { recruitWriteOperations } from './recruit-write.js';
+import { salaryOperations } from './salary.js';
+function buildRegistry() {
+    const registry = new Map();
+    const definitions = [
+        ...salaryOperations,
+        ...attendReadOperations,
+        ...attendWriteOperations,
+        ...hrContactOperations,
+        ...hrDataSourceOperations,
+        ...hrReportOperations,
+        ...recruitOperations,
+        ...recruitWriteOperations,
+    ];
+    for (const definition of definitions) {
+        if (registry.has(definition.name)) {
+            throw new Error(`duplicate ehr operation: ${definition.name}`);
+        }
+        registry.set(definition.name, definition);
+    }
+    return registry;
+}
+const ehrOperationRegistry = buildRegistry();
+export function ehrOperationDefinitions() {
+    return [...ehrOperationRegistry.values()];
+}
+export function getEhrOperation(operation) {
+    const definition = ehrOperationRegistry.get(operation);
+    if (!definition) {
+        throw ehrValidationError('operation_unknown', `聚才林不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasEhrOperation(operation) {
+    return ehrOperationRegistry.has(operation);
+}

package/dist/shortcuts/ehr/operations/salary.js

@@ -0,0 +1,319 @@
+import { ehrValidationError } from '../errors.js';
+import { READ, SCHEMA_DATE, SCHEMA_ID, SCHEMA_ID_LIST, SCHEMA_MONTH, SCHEMA_STRING_LIST, ehrSuccess, schemaOf, } from './types.js';
+import { assertEnum, assertMonth, assertMonthRange, compact, normalizePaged, pickDefined, resolveSecondAuthToken, toIdList, toNumber, toPageQuery, } from './shared.js';
+/**
+ * 薪资所属月范围。页面实际传 2 个元素 [开始月, 结束月]。
+ * salaryMonth 超过 2 项时服务端仅保留第 1 项，因此在入口侧直接拒绝。
+ */
+function requireMonthRange(value, field) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw ehrValidationError('month_range_invalid', `${field} 必须是 1-2 个 YYYY-MM 月份`);
+    }
+    if (value.length > 2) {
+        throw ehrValidationError('month_range_invalid', `${field} 最多支持 2 个月份（开始月、结束月）`);
+    }
+    const months = value.map((item, index) => assertMonth(item, `${field}[${index}]`));
+    if (months.length === 2 && months[0] > months[1]) {
+        throw ehrValidationError('month_range_invalid', `${field} 的开始月不得晚于结束月`);
+    }
+    return months;
+}
+function requireYearRange(args) {
+    const startYear = toNumber(args.startYear, 'startYear');
+    const endYear = toNumber(args.endYear, 'endYear');
+    // 文档明确：startYear 与 endYear 必须成对提供，只提供一个时服务端不会应用年份范围。
+    if ((startYear === undefined) !== (endYear === undefined)) {
+        throw ehrValidationError('year_range_incomplete', 'startYear 与 endYear 必须成对提供');
+    }
+    if (startYear !== undefined && endYear !== undefined) {
+        if (!Number.isInteger(startYear) || !Number.isInteger(endYear) || startYear < 1000 || startYear > 9999) {
+            throw ehrValidationError('year_range_invalid', 'startYear 与 endYear 必须是合法四位年份');
+        }
+        if (endYear < startYear) {
+            throw ehrValidationError('year_range_invalid', 'endYear 不得小于 startYear');
+        }
+    }
+    return { startYear, endYear };
+}
+const salaryBillList = {
+    name: 'ehr.salary.bill.list',
+    resource: 'salary',
+    method: 'bill.list',
+    action: 'ehr.salary.bill.list',
+    summary: '分页查询当前登录人的工资单，可按薪资所属月范围筛选；也用于取得详情接口的 salaryInfoId',
+    capability: 'salary',
+    risk: READ,
+    inputSchema: schemaOf({
+        current: SCHEMA_ID,
+        pageSize: SCHEMA_ID,
+        salaryYearMonth: { type: 'array', items: SCHEMA_MONTH, maxItems: 2, description: '[开始月, 结束月]，格式 YYYY-MM' },
+        terminalType: { type: 'string' },
+        token: { type: 'string', description: '二次身份验证 token（SalaryBillQueryParam.token）；未提供时不传，CLI 自动补 DONT_NEED' },
+    }),
+    handler: async (args, { host }) => {
+        const body = { ...toPageQuery(args) };
+        // 默认按 PC 终端查询，避免服务端按未知终端类型返回不同列集合。
+        body.terminalType = args.terminalType || 'PC';
+        // 工资单列表也走二次身份验证，token 缺失会返回 checkSecondFailNoToken。
+        body.token = resolveSecondAuthToken(args.token);
+        if (args.salaryYearMonth !== undefined) {
+            body.salaryYearMonth = requireMonthRange(args.salaryYearMonth, 'salaryYearMonth');
+        }
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/bs/hrmsalary/salaryBill/mySalaryBillList',
+            body: compact(body),
+        });
+        const { data, page } = normalizePaged(response);
+        return ehrSuccess('ehr.salary.bill.list', data, { page });
+    },
+};
+const salaryBillGet = {
+    name: 'ehr.salary.bill.get',
+    resource: 'salary',
+    method: 'bill.get',
+    action: 'ehr.salary.bill.get',
+    summary: '查看当前登录人某一张已发放工资单的完整展示数据；会记录首次查看时间，不是完全无痕查询',
+    capability: 'salary',
+    risk: READ,
+    inputSchema: schemaOf({
+        salaryInfoId: { type: 'string', pattern: '^\\d+$', description: '工资单发放信息 ID，来自 bill.list 的 id' },
+        token: { type: 'string', description: '二次身份验证 token；用户主动提供时用原值，未提供时不传（CLI 自动补 DONT_NEED）' },
+        viewMac: { type: 'string' },
+    }, { required: ['salaryInfoId'] }),
+    handler: async (args, { host }) => {
+        const salaryInfoId = args.salaryInfoId;
+        if (salaryInfoId === undefined || salaryInfoId === null || salaryInfoId === '') {
+            throw ehrValidationError('salary_info_id_required', 'salaryInfoId 必填');
+        }
+        if (!/^\d+$/.test(String(salaryInfoId))) {
+            throw ehrValidationError('salary_info_id_invalid', 'salaryInfoId 必须是数字 ID 字符串');
+        }
+        const query = {
+            salaryInfoId: String(salaryInfoId),
+            // Controller 用 @RequestParam 声明 token 为必传，缺失会触发 HTTP 参数校验失败。
+            token: resolveSecondAuthToken(args.token),
+        };
+        if (args.viewMac !== undefined)
+            query.viewMac = args.viewMac;
+        const response = await host.request({
+            method: 'GET',
+            path: '/api/bs/hrmsalary/salaryBill/mySalaryBill',
+            query,
+        });
+        return ehrSuccess('ehr.salary.bill.get', normalizePaged(response).data);
+    },
+};
+const salaryWelfareList = {
+    name: 'ehr.salary.welfare.list',
+    resource: 'salary',
+    method: 'welfare.list',
+    action: 'ehr.salary.welfare.list',
+    summary: '按月份范围查询当前登录人的社保、公积金及其他福利缴费汇总和动态明细',
+    capability: 'salary',
+    risk: READ,
+    inputSchema: schemaOf({
+        startMonth: SCHEMA_MONTH,
+        endMonth: SCHEMA_MONTH,
+        terminalType: { type: 'string' },
+        token: { type: 'string', description: '二次身份验证 token；源码为空时返回 checkSecondFailNoToken。未提供时不传，CLI 自动补 DONT_NEED' },
+    }),
+    handler: async (args, { host }) => {
+        const query = {
+            terminalType: args.terminalType || 'PC',
+            token: resolveSecondAuthToken(args.token),
+        };
+        if (args.startMonth !== undefined)
+            query.startMonth = assertMonth(args.startMonth, 'startMonth');
+        if (args.endMonth !== undefined)
+            query.endMonth = assertMonth(args.endMonth, 'endMonth');
+        if (typeof query.startMonth === 'string' && typeof query.endMonth === 'string'
+            && query.startMonth > query.endMonth) {
+            throw ehrValidationError('month_range_invalid', 'startMonth 不得晚于 endMonth');
+        }
+        const response = await host.request({
+            method: 'GET',
+            path: '/api/bs/hrmsalary/report/welfare/list',
+            query,
+        });
+        const { data, page } = normalizePaged(response);
+        return ehrSuccess('ehr.salary.welfare.list', data, { page });
+    },
+};
+const salaryAdjustmentList = {
+    name: 'ehr.salary.adjustment.list',
+    resource: 'salary',
+    method: 'adjustment.list',
+    action: 'ehr.salary.adjustment.list',
+    summary: '按年份范围查询当前登录人的薪资项目调整记录；startYear 与 endYear 必须成对提供',
+    capability: 'salary',
+    risk: READ,
+    inputSchema: schemaOf({
+        startYear: { type: 'integer', minimum: 1000, maximum: 9999 },
+        endYear: { type: 'integer', minimum: 1000, maximum: 9999 },
+        terminalType: { type: 'string' },
+        token: { type: 'string', description: '二次身份验证 token；源码为空时返回 checkSecondFailNoToken。未提供时不传，CLI 自动补 DONT_NEED' },
+    }),
+    handler: async (args, { host }) => {
+        const { startYear, endYear } = requireYearRange(args);
+        const query = {
+            terminalType: args.terminalType || 'PC',
+            token: resolveSecondAuthToken(args.token),
+        };
+        if (startYear !== undefined)
+            query.startYear = startYear;
+        if (endYear !== undefined)
+            query.endYear = endYear;
+        const response = await host.request({
+            method: 'GET',
+            path: '/api/bs/hrmsalary/report/record/list',
+            query,
+        });
+        const { data, page } = normalizePaged(response);
+        return ehrSuccess('ehr.salary.adjustment.list', data, { page });
+    },
+};
+const salarySiaccountQuery = {
+    name: 'ehr.salary.siaccount.query',
+    resource: 'salary',
+    method: 'siaccount.query',
+    action: 'ehr.salary.siaccount.query',
+    summary: '社保台账详情查询（需薪酬社保台账权限）；接口不分页且返回高度敏感数据，必须提供范围条件',
+    capability: 'salary',
+    risk: READ,
+    inputSchema: schemaOf({
+        startBillMonth: SCHEMA_MONTH,
+        endBillMonth: SCHEMA_MONTH,
+        paymentOrganizationIds: SCHEMA_ID_LIST,
+        paymentAgencyIds: SCHEMA_ID_LIST,
+        salaryAcctOrgIds: SCHEMA_ID_LIST,
+        employeeIds: SCHEMA_ID_LIST,
+        billStatus: { type: 'integer', enum: [0, 1], description: '0 未归档，1 已归档' },
+        paymentStatusList: {
+            type: 'array',
+            items: { type: 'integer', enum: [0, 1, 2, 3, 4] },
+            description: '0 正常缴纳，1 补缴，2 代缴，3 退差，4 补差',
+        },
+    }),
+    handler: async (args, { host }) => {
+        // 注意：这是月份区间（YYYY-MM），必须用 assertMonthRange；
+        // 误用 assertDateRange 会按 YYYY-MM-DD 校验而报 date_invalid。
+        assertMonthRange(args, 'startBillMonth', 'endBillMonth');
+        const employeeIds = toIdList(args.employeeIds, 'employeeIds');
+        const paymentOrganizationIds = toIdList(args.paymentOrganizationIds, 'paymentOrganizationIds');
+        const paymentAgencyIds = toIdList(args.paymentAgencyIds, 'paymentAgencyIds');
+        const salaryAcctOrgIds = toIdList(args.salaryAcctOrgIds, 'salaryAcctOrgIds');
+        // 接口不分页且返回高度敏感数据，缺少任何范围条件都可能造成大范围敏感数据返回。
+        const hasScope = Boolean((args.startBillMonth && args.endBillMonth)
+            || employeeIds?.length
+            || paymentOrganizationIds?.length
+            || paymentAgencyIds?.length
+            || salaryAcctOrgIds?.length);
+        if (!hasScope) {
+            throw ehrValidationError('siaccount_scope_required', '社保台账查询不分页且返回敏感数据，必须至少提供月份范围或人员/组织 ID 之一以收窄范围');
+        }
+        // 枚举必须在运行时校验：inputSchema 只是文档。
+        // 否则非法值（如 billStatus=9）会被服务端静默忽略并返回空数组，
+        // 调用方会误判为"没有数据"，比直接报错更危险。
+        const BILL_STATUS = ['0', '1'];
+        const PAYMENT_STATUS = ['0', '1', '2', '3', '4'];
+        const billStatus = args.billStatus === undefined
+            ? undefined
+            : Number(assertEnum(args.billStatus, BILL_STATUS, 'billStatus'));
+        let paymentStatusList;
+        if (args.paymentStatusList !== undefined) {
+            if (!Array.isArray(args.paymentStatusList)) {
+                throw ehrValidationError('enum_invalid', 'paymentStatusList 必须是数组');
+            }
+            paymentStatusList = args.paymentStatusList.map((item, index) => Number(assertEnum(item, PAYMENT_STATUS, `paymentStatusList[${index}]`)));
+        }
+        const body = {
+            startBillMonth: args.startBillMonth,
+            endBillMonth: args.endBillMonth,
+            billStatus,
+            paymentStatusList,
+            paymentOrganizationIds,
+            paymentAgencyIds,
+            salaryAcctOrgIds,
+            employeeIds,
+        };
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/bs/hrmsalary/siaccount/detail/query',
+            body: compact(body),
+        });
+        return ehrSuccess('ehr.salary.siaccount.query', normalizePaged(response).data);
+    },
+};
+const salaryEmployeeList = {
+    name: 'ehr.salary.employee.list',
+    resource: 'salary',
+    method: 'employee.list',
+    action: 'ehr.salary.employee.list',
+    summary: '员工薪资明细列表（需薪酬统计权限）；按薪资所属月、人员、组织等条件分页查询',
+    capability: 'salary',
+    risk: READ,
+    inputSchema: schemaOf({
+        current: SCHEMA_ID,
+        pageSize: SCHEMA_ID,
+        keyword: { type: 'string' },
+        username: { type: 'string' },
+        jobNum: { type: 'string' },
+        idNo: { type: 'string', description: '身份证号，敏感字段' },
+        year: { type: 'integer', minimum: 1000, maximum: 9999 },
+        salaryMonth: { type: 'array', items: SCHEMA_MONTH, maxItems: 2, description: '1 项单月，2 项闭区间；超过 2 项服务端仅保留第 1 项' },
+        employeeType: { type: 'string', enum: ['ORGANIZATION', 'EXT_EMPLOYEE'] },
+        salarySendType: { type: 'string', enum: ['normal', 'import'] },
+        sortField: { type: 'string' },
+        departmentIds: SCHEMA_ID_LIST,
+        positionIds: SCHEMA_ID_LIST,
+        ids: SCHEMA_ID_LIST,
+        taxAgentIds: SCHEMA_ID_LIST,
+        salarySobIds: SCHEMA_ID_LIST,
+        personnelStatuss: SCHEMA_STRING_LIST,
+        incomeCategories: SCHEMA_STRING_LIST,
+        hiredate: { type: 'array', items: SCHEMA_DATE, minItems: 2, maxItems: 2, description: '入职日期闭区间，必须正好 2 项' },
+    }),
+    handler: async (args, { host }) => {
+        const body = {
+            ...toPageQuery(args),
+            ...pickDefined(args, [
+                'keyword',
+                'username',
+                'jobNum',
+                'idNo',
+                'employeeType',
+                'salarySendType',
+                'sortField',
+                'personnelStatuss',
+                'incomeCategories',
+                'hiredate',
+            ]),
+            departmentIds: toIdList(args.departmentIds, 'departmentIds'),
+            positionIds: toIdList(args.positionIds, 'positionIds'),
+            ids: toIdList(args.ids, 'ids'),
+            taxAgentIds: toIdList(args.taxAgentIds, 'taxAgentIds'),
+            salarySobIds: toIdList(args.salarySobIds, 'salarySobIds'),
+        };
+        if (args.year !== undefined)
+            body.year = toNumber(args.year, 'year');
+        if (args.salaryMonth !== undefined) {
+            body.salaryMonth = requireMonthRange(args.salaryMonth, 'salaryMonth');
+        }
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/bs/salaryreport/salary/statistics/employee/salaryList',
+            body: compact(body),
+        });
+        const { data, page } = normalizePaged(response);
+        return ehrSuccess('ehr.salary.employee.list', data, { page });
+    },
+};
+export const salaryOperations = [
+    salaryBillList,
+    salaryBillGet,
+    salaryWelfareList,
+    salaryAdjustmentList,
+    salarySiaccountQuery,
+    salaryEmployeeList,
+];

package/dist/shortcuts/ehr/operations/shared.js

@@ -0,0 +1,246 @@
+import { ehrValidationError } from '../errors.js';
+/** 原型污染防护：禁止出现在输入对象中的键。 */
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+export function asObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw ehrValidationError('input_not_object', '输入必须是 JSON 对象');
+    }
+    return value;
+}
+export function assertNoForbiddenKeys(input) {
+    for (const key of Object.keys(input)) {
+        if (FORBIDDEN_KEYS.has(key)) {
+            throw ehrValidationError('forbidden_key', `输入包含非法字段：${key}`);
+        }
+    }
+}
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const MONTH_PATTERN = /^\d{4}-\d{2}$/;
+export function isDate(value) {
+    return typeof value === 'string' && DATE_PATTERN.test(value);
+}
+export function isMonth(value) {
+    return typeof value === 'string' && MONTH_PATTERN.test(value);
+}
+/**
+ * 语义校验：正则只能保证形如 YYYY-MM-DD，无法拒绝 2026-13-01 这类不存在的日期。
+ * 缺少这层校验时，非法日期会被当成合法值参与字符串比较，
+ * 从而抛出误导性的 date_range_invalid（"开始日期不得晚于结束日期"）。
+ */
+function isRealDate(value) {
+    const [year, month, day] = value.split('-').map(Number);
+    if (month < 1 || month > 12)
+        return false;
+    // Date.UTC(year, month, 0) 取到该月最后一天，getUTCDate 即该月天数。
+    const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    return day >= 1 && day <= daysInMonth;
+}
+export function assertDate(value, field) {
+    if (!isDate(value))
+        throw ehrValidationError('date_invalid', `${field} 必须是 YYYY-MM-DD 格式`);
+    const text = value;
+    if (!isRealDate(text)) {
+        throw ehrValidationError('date_invalid', `${field} 不是合法日期（月份需 01-12，日期需在该月有效范围内）：${text}`);
+    }
+    return text;
+}
+export function assertMonth(value, field) {
+    if (!isMonth(value))
+        throw ehrValidationError('month_invalid', `${field} 必须是 YYYY-MM 格式`);
+    const text = value;
+    const month = Number(text.slice(5));
+    if (month < 1 || month > 12) {
+        throw ehrValidationError('month_invalid', `${field} 的月份必须在 01-12：${text}`);
+    }
+    return text;
+}
+/** 通用数值转换：Mock 模式下 integer 字段可能是字符串，需按字符串数值转换。 */
+export function toNumber(value, field) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        throw ehrValidationError('number_invalid', `${field} 必须是数字`);
+    }
+    return numeric;
+}
+export function toPositiveInt(value, field) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        throw ehrValidationError('number_invalid', `${field} 必须是数字`);
+    }
+    const truncated = Math.trunc(numeric);
+    if (truncated !== numeric || truncated <= 0) {
+        throw ehrValidationError('number_invalid', `${field} 必须是正整数`);
+    }
+    return truncated;
+}
+/** ID 数组归一化为 number[]；兼容字符串数字（Mock 模式）。 */
+export function toIdList(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value))
+        throw ehrValidationError('id_list_invalid', `${field} 必须是 ID 数组`);
+    return value.map((item, index) => {
+        if (item === undefined || item === null || item === '') {
+            throw ehrValidationError('id_list_invalid', `${field}[${index}] 不能为空`);
+        }
+        const numeric = Number(item);
+        if (!Number.isFinite(numeric)) {
+            throw ehrValidationError('id_list_invalid', `${field}[${index}] 必须是数字 ID`);
+        }
+        return numeric;
+    });
+}
+/** ID 数组归一化为 string[]（部分接口要求字符串 id）。 */
+export function toStringIdList(value, field) {
+    const list = toIdList(value, field);
+    return list === undefined ? undefined : list.map((item) => String(item));
+}
+export function pickDefined(value, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (value[key] !== undefined)
+            result[key] = value[key];
+    }
+    return result;
+}
+/** 移除值为 undefined 的键，避免把空值写进请求体。 */
+export function compact(body) {
+    for (const key of Object.keys(body)) {
+        if (body[key] === undefined)
+            delete body[key];
+    }
+    return body;
+}
+/** 校验日期区间成对提供且顺序正确。 */
+export function assertDateRange(args, startField, endField) {
+    const start = args[startField];
+    const end = args[endField];
+    if ((start === undefined || start === null) !== (end === undefined || end === null)) {
+        throw ehrValidationError('date_range_incomplete', `${startField} 与 ${endField} 必须成对提供`);
+    }
+    if (start === undefined || start === null)
+        return {};
+    const startDate = assertDate(start, startField);
+    const endDate = assertDate(end, endField);
+    if (startDate > endDate) {
+        throw ehrValidationError('date_range_invalid', `${startField} 不得晚于 ${endField}`);
+    }
+    return { start: startDate, end: endDate };
+}
+/**
+ * 校验「两个独立字段」形式的月份区间（如 startBillMonth/endBillMonth），
+ * 与数组形式的 requireMonthRange（如 salaryMonth: ["2026-01","2026-03"]）区分。
+ * 两者不可混用：月份是 YYYY-MM，误用 assertDateRange 会被当成 YYYY-MM-DD 而报 date_invalid。
+ */
+export function assertMonthRange(args, startField, endField) {
+    const start = args[startField];
+    const end = args[endField];
+    if ((start === undefined || start === null) !== (end === undefined || end === null)) {
+        throw ehrValidationError('month_range_incomplete', `${startField} 与 ${endField} 必须成对提供`);
+    }
+    if (start === undefined || start === null)
+        return {};
+    const startMonth = assertMonth(start, startField);
+    const endMonth = assertMonth(end, endField);
+    if (startMonth > endMonth) {
+        throw ehrValidationError('month_range_invalid', `${startField} 不得晚于 ${endField}`);
+    }
+    return { start: startMonth, end: endMonth };
+}
+export function requireDateRange(args, startField = 'beginDate', endField = 'endDate') {
+    const start = args[startField];
+    const end = args[endField];
+    if (start === undefined || start === null || start === '' || end === undefined || end === null || end === '') {
+        throw ehrValidationError('date_range_required', `${startField} 与 ${endField} 必填，格式 YYYY-MM-DD`);
+    }
+    const range = assertDateRange(args, startField, endField);
+    return { beginDate: range.start, endDate: range.end };
+}
+/** 取出响应中的业务数据。 */
+export function unwrapData(response) {
+    if (!response || typeof response !== 'object')
+        return response;
+    return response.data;
+}
+/**
+ * 归一化分页响应。聚才林各子系统分页结构不统一（以下均在真实 E10 环境实测确认）：
+ * - 出勤/人事档案/薪酬的表格类接口：data{ current, pageSize, total }，总数用 total
+ * - 数据源计数接口：totalCount/totalPage/pageSize/tableId
+ * - 出勤统计接口不分页，返回聚合对象
+ */
+export function normalizePaged(response) {
+    const data = unwrapData(response);
+    const page = {};
+    const candidates = [data?.page, response?.page, data, response];
+    for (const source of candidates) {
+        if (!source || typeof source !== 'object')
+            continue;
+        for (const key of ['pageNo', 'current', 'pageSize', 'total', 'totalCount', 'totalPage', 'tableId']) {
+            if (source[key] !== undefined && page[key] === undefined)
+                page[key] = source[key];
+        }
+    }
+    return { data, page };
+}
+/** 归一化列表响应：输出 { items, page }。 */
+export function normalizeList(response) {
+    const { data, page } = normalizePaged(response);
+    const payload = data;
+    const items = Array.isArray(payload?.data) ? payload.data
+        : Array.isArray(payload?.records) ? payload.records
+            : Array.isArray(payload?.list) ? payload.list
+                : Array.isArray(payload) ? payload
+                    : [];
+    return { data: items, page };
+}
+/** 分页入参：聚才林各子系统字段名不统一，此处统一收敛为 current/pageSize。 */
+export function toPageQuery(args) {
+    const page = {};
+    const current = toPositiveInt(args?.current, 'current');
+    const pageSize = toNumber(args?.pageSize, 'pageSize');
+    const pageNo = toNumber(args?.pageNo, 'pageNo');
+    if (current !== undefined)
+        page.current = current;
+    if (pageSize !== undefined)
+        page.pageSize = pageSize;
+    if (pageNo !== undefined)
+        page.pageNo = pageNo;
+    return page;
+}
+/**
+ * 二次身份验证 token 的缺省协议值。
+ * 三个薪酬接口（工资单列表/详情、社保福利、调薪记录）都要求携带 token：
+ * 源码为空时返回 `checkSecondFailNoToken`，Controller 用 @RequestParam 声明为必传。
+ * 该值与登录无关，也不由认证链路提供；用户未主动提供时固定传 DONT_NEED，
+ * 不得传空值或自行构造其他值。
+ */
+export const SECOND_AUTH_TOKEN_DEFAULT = 'DONT_NEED';
+/**
+ * 解析二次身份验证 token。
+ * - 用户显式传入时使用原值；
+ * - 未传或为空时回落到协议缺省值 DONT_NEED。
+ * 真实 token 属敏感信息，仅在此处短暂使用，不做缓存或日志输出。
+ */
+export function resolveSecondAuthToken(value) {
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    return SECOND_AUTH_TOKEN_DEFAULT;
+}
+/** 校验枚举取值。 */
+export function assertEnum(value, allowed, field) {
+    const text = typeof value === 'string' ? value : String(value);
+    if (!allowed.includes(text)) {
+        throw ehrValidationError('enum_invalid', `${field} 取值必须是 ${allowed.join(' / ')} 之一`);
+    }
+    return text;
+}
+/** 校验数组内每个元素都在枚举内。 */
+export function assertEnumArray(value, allowed, field) {
+    if (!Array.isArray(value))
+        throw ehrValidationError('enum_invalid', `${field} 必须是数组`);
+    return value.map((item) => assertEnum(item, allowed, field));
+}

package/dist/shortcuts/ehr/operations/types.js

@@ -0,0 +1,25 @@
+export const READ = 'read';
+export const WRITE = 'write';
+export function ehrSuccess(action, data, meta) {
+    const payload = { ok: true, action, data };
+    if (meta && Object.keys(meta).length > 0)
+        payload.meta = meta;
+    return payload;
+}
+/** 构造「对象类型 + 严格禁止额外字段」的 JSON Schema。 */
+export function schemaOf(properties, options = {}) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        ...(options.required?.length ? { required: options.required } : {}),
+        ...(options.description ? { description: options.description } : {}),
+    };
+}
+export const SCHEMA_INTEGER_POSITIVE = { type: 'integer', minimum: 1 };
+export const SCHEMA_NUMBER_POSITIVE = { type: 'number', exclusiveMinimum: 0 };
+export const SCHEMA_DATE = { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$' };
+export const SCHEMA_MONTH = { type: 'string', pattern: '^\\d{4}-\\d{2}$' };
+export const SCHEMA_ID = { oneOf: [{ type: 'integer' }, { type: 'string', pattern: '^\\d+$' }] };
+export const SCHEMA_ID_LIST = { type: 'array', items: SCHEMA_ID };
+export const SCHEMA_STRING_LIST = { type: 'array', items: { type: 'string' } };

package/dist/shortcuts/ehr/operations.js

@@ -0,0 +1,25 @@
+import { getEhrOperation } from './operations/registry.js';
+import { assertNoForbiddenKeys, asObject } from './operations/shared.js';
+import { createRecruitContextLoader } from './operations/recruit.js';
+export async function executeEhrOperation(operation, rawInput, context) {
+    const definition = getEhrOperation(operation);
+    const input = asObject(rawInput);
+    assertNoForbiddenKeys(input);
+    const host = {
+        request(request) {
+            return context.host.request({
+                ...request,
+                operation: request.operation || operation,
+            });
+        },
+        getSession() {
+            return context.host.getSession();
+        },
+        buildCardSign() {
+            return context.host.buildCardSign();
+        },
+    };
+    // 招聘域五层解析上下文：懒创建（首次 recruit operation 调用时才初始化），进程内复用
+    const recruitContext = context.recruitContext ?? createRecruitContextLoader();
+    return definition.handler(input, { ...context, host, recruitContext });
+}