R47 A1-A8:完成薪资管理模块

这个提交包含在:
2026-03-29 19:05:55 +08:00
父节点 c0384b5bbf
当前提交 7ba72ca87d
共修改 25 个文件,包含 3598 行新增和 4 行删除
@@ -53,6 +53,18 @@ async function buildApp({ permissionCodes = ["system.users"], stats } = {}) {
{ overall_score: 4, _count: { _all: 3 } },
{ overall_score: 4.5, _count: { _all: 2 } },
]);
const payslipAggregate = vi
.fn()
.mockResolvedValueOnce({
_sum: { net_amount: 18800 },
_avg: { net_amount: 9400 },
_count: { _all: 2 },
})
.mockResolvedValueOnce({
_sum: { net_amount: 17600 },
_avg: { net_amount: 8800 },
_count: { _all: 2 },
});
app.decorate("prisma", {
employee: {
@@ -80,6 +92,9 @@ async function buildApp({ permissionCodes = ["system.users"], stats } = {}) {
aggregate: stats?.performanceReviewAggregate ?? performanceReviewAggregate,
groupBy: stats?.performanceReviewGroupBy ?? performanceReviewGroupBy,
},
payslip: {
aggregate: stats?.payslipAggregate ?? payslipAggregate,
},
});
app.decorate("authenticate", async (request) => {
request.employee = {
@@ -123,11 +138,12 @@ async function buildApp({ permissionCodes = ["system.users"], stats } = {}) {
performanceCycleFindFirst,
performanceReviewAggregate,
performanceReviewGroupBy,
payslipAggregate,
};
}
describe("employees stats route", () => {
it("returns aggregated employee stats for read-only viewers", async () => {
it("returns aggregated employee stats for read-only viewers without salary data", async () => {
const {
app,
employeeGroupBy,
@@ -139,6 +155,7 @@ describe("employees stats route", () => {
performanceCycleFindFirst,
performanceReviewAggregate,
performanceReviewGroupBy,
payslipAggregate,
} = await buildApp({
permissionCodes: ["report.dashboard.view"],
});
@@ -187,6 +204,7 @@ describe("employees stats route", () => {
{ score: 5, count: 0 },
],
});
expect(payload.data.salarySummary).toBeNull();
expect(employeeGroupBy).toHaveBeenCalledTimes(2);
expect(employeeCount).toHaveBeenCalledTimes(2);
expect(departmentFindMany).toHaveBeenCalledTimes(1);
@@ -196,6 +214,37 @@ describe("employees stats route", () => {
expect(performanceCycleFindFirst).toHaveBeenCalledTimes(2);
expect(performanceReviewAggregate).toHaveBeenCalledTimes(1);
expect(performanceReviewGroupBy).toHaveBeenCalledTimes(1);
expect(payslipAggregate).not.toHaveBeenCalled();
await app.close();
});
it("returns salary summary for system.users viewers", async () => {
const { app, payslipAggregate } = await buildApp({
permissionCodes: ["system.users"],
});
const response = await app.inject({
method: "GET",
url: "/api/employees/stats",
});
expect(response.statusCode).toBe(200);
expect(response.json().data.salarySummary).toEqual({
currentMonth: {
month: expect.any(String),
totalNetAmount: 18800,
averageNetAmount: 9400,
issuedCount: 2,
},
previousMonth: {
month: expect.any(String),
totalNetAmount: 17600,
averageNetAmount: 8800,
issuedCount: 2,
},
});
expect(payslipAggregate).toHaveBeenCalledTimes(2);
await app.close();
});
@@ -0,0 +1,168 @@
const ExcelJS = require("exceljs");
const Fastify = require("fastify");
const exportsRoutes = require("../../../src/routes/exports");
const { AppError } = require("../../../src/utils/AppError");
const ADMIN_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
function buildPayslipRow() {
return {
id: "payslip-1",
employee_id: "employee-1",
pay_month: new Date("2026-04-01T00:00:00.000Z"),
status: "issued",
gross_amount: "10000.00",
deduction_amount: "600.00",
net_amount: "9400.00",
issued_at: new Date("2026-04-30T09:00:00.000Z"),
created_at: new Date("2026-04-30T08:00:00.000Z"),
created_by: ADMIN_ID,
updated_at: new Date("2026-04-30T09:00:00.000Z"),
updated_by: ADMIN_ID,
};
}
async function buildApp({
actor = { id: ADMIN_ID, permissionCodes: ["system.users"] },
} = {}) {
const app = Fastify();
const salaryItems = [
{
id: "salary-item-1",
name: "基本工资",
item_type: "earning",
sort_order: 10,
enabled: true,
},
{
id: "salary-item-2",
name: "社保扣除",
item_type: "deduction",
sort_order: 20,
enabled: false,
},
];
const payslips = [buildPayslipRow()];
const payslipItems = [
{
id: "item-1",
payslip_id: "payslip-1",
salary_item_id: "salary-item-1",
amount: "10000.00",
salary_item: salaryItems[0],
},
{
id: "item-2",
payslip_id: "payslip-1",
salary_item_id: "salary-item-2",
amount: "600.00",
salary_item: salaryItems[1],
},
];
app.decorate("authenticate", async (request) => {
request.employee = actor;
});
app.decorate("requirePermission", (permissionCode) => async (request) => {
request.employee = actor;
const codes = actor.permissionCodes ?? [];
if (!codes.includes("*") && !codes.includes(permissionCode)) {
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403 });
}
});
app.decorate("hasPermission", (employee, permissionCode) => {
const codes = employee.permissionCodes ?? [];
return codes.includes("*") || codes.includes(permissionCode);
});
app.decorate("prisma", {
payslip: {
findMany: vi.fn(async () =>
payslips.map((item) => ({
...item,
employee: {
id: "employee-1",
employee_no: "E001",
name: "Alice",
title: "专员",
department: { id: "dept-1", name: "行政部" },
},
items: payslipItems.filter((row) => row.payslip_id === item.id),
})),
),
},
auditLog: {
create: vi.fn().mockResolvedValue({}),
},
});
app.setErrorHandler((error, request, reply) => {
reply.status(error.statusCode || 500).send({
requestId: request.id,
error: {
code: error.code || "SYS_001",
message: error.message,
details: error.details ?? null,
},
});
});
await app.register(exportsRoutes, { prefix: "/api" });
return { app };
}
describe("payroll export routes", () => {
it("exports monthly payslips in csv and xlsx formats", async () => {
const { app } = await buildApp();
const csvResponse = await app.inject({
method: "GET",
url: "/api/exports/payslips?month=2026-04&format=csv",
});
expect(csvResponse.statusCode).toBe(200);
expect(csvResponse.headers["content-type"]).toContain("text/csv");
const csvBody = csvResponse.body;
expect(csvBody).toContain("工号,姓名,部门,基本工资,社保扣除,应发合计,应扣合计,实发合计");
expect(csvBody).toContain("E001,Alice,行政部,10000,600,10000,600,9400");
const xlsxResponse = await app.inject({
method: "GET",
url: "/api/exports/payslips?month=2026-04&format=xlsx",
});
expect(xlsxResponse.statusCode).toBe(200);
const workbook = new ExcelJS.Workbook();
await workbook.xlsx.load(Buffer.from(xlsxResponse.rawPayload));
const sheet = workbook.getWorksheet("payslips");
expect(sheet.getRow(1).values.slice(1, 9)).toEqual([
"工号",
"姓名",
"部门",
"基本工资",
"社保扣除",
"应发合计",
"应扣合计",
"实发合计",
]);
await app.close();
});
it("rejects non-admin exports", async () => {
const { app } = await buildApp({
actor: {
id: "employee-1",
permissionCodes: ["employee"],
},
});
const response = await app.inject({
method: "GET",
url: "/api/exports/payslips?month=2026-04&format=csv",
});
expect(response.statusCode).toBe(403);
await app.close();
});
});
@@ -0,0 +1,160 @@
const Fastify = require("fastify");
const payrollRoutes = require("../../../src/routes/payroll");
const { AppError } = require("../../../src/utils/AppError");
const ADMIN_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
function buildSalaryItem(overrides = {}) {
return {
id: "11111111-1111-4111-8111-111111111111",
name: "基本工资",
item_type: "earning",
sort_order: 10,
enabled: true,
created_at: new Date("2026-03-29T08:00:00.000Z"),
created_by: ADMIN_ID,
updated_at: new Date("2026-03-29T08:00:00.000Z"),
updated_by: ADMIN_ID,
...overrides,
};
}
async function buildApp({
actor = { id: ADMIN_ID, permissionCodes: ["system.users"] },
} = {}) {
const app = Fastify();
const state = {
salaryItems: [buildSalaryItem()],
};
const salaryItem = {
findMany: vi.fn(async () => [...state.salaryItems].sort((left, right) => left.sort_order - right.sort_order)),
findUnique: vi.fn(async ({ where }) => state.salaryItems.find((item) => item.id === where.id) ?? null),
create: vi.fn(async ({ data }) => {
const item = buildSalaryItem({
id: "22222222-2222-4222-8222-222222222222",
name: data.name,
item_type: data.item_type,
sort_order: data.sort_order,
enabled: data.enabled,
created_by: data.created_by,
updated_by: data.updated_by,
});
state.salaryItems.push(item);
return item;
}),
update: vi.fn(async ({ where, data }) => {
const index = state.salaryItems.findIndex((item) => item.id === where.id);
state.salaryItems[index] = {
...state.salaryItems[index],
...data,
};
return state.salaryItems[index];
}),
};
app.decorate("authenticate", async (request) => {
request.employee = actor;
});
app.decorate("requirePermission", (permissionCode) => async (request) => {
request.employee = actor;
const codes = actor.permissionCodes ?? [];
if (!codes.includes("*") && !codes.includes(permissionCode)) {
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403 });
}
});
app.decorate("hasPermission", (employee, permissionCode) => {
const codes = employee.permissionCodes ?? [];
return codes.includes("*") || codes.includes(permissionCode);
});
app.decorate("prisma", {
salaryItem,
auditLog: {
create: vi.fn().mockResolvedValue({}),
},
});
app.setErrorHandler((error, request, reply) => {
reply.status(error.statusCode || 500).send({
requestId: request.id,
error: {
code: error.code || "SYS_001",
message: error.message,
details: error.details ?? null,
},
});
});
await app.register(payrollRoutes, { prefix: "/api" });
return { app, state, salaryItem };
}
describe("payroll salary item routes", () => {
it("allows admins to create, list and patch salary items", async () => {
const { app, state, salaryItem } = await buildApp();
const createResponse = await app.inject({
method: "POST",
url: "/api/payroll/items",
payload: {
name: "岗位津贴",
itemType: "earning",
sortOrder: 20,
},
});
expect(createResponse.statusCode).toBe(200);
expect(createResponse.json().data).toMatchObject({
name: "岗位津贴",
itemType: "earning",
sortOrder: 20,
enabled: true,
});
const patchResponse = await app.inject({
method: "PATCH",
url: `/api/payroll/items/${state.salaryItems[1].id}`,
payload: {
itemType: "deduction",
enabled: false,
},
});
expect(patchResponse.statusCode).toBe(200);
expect(patchResponse.json().data).toMatchObject({
name: "岗位津贴",
itemType: "deduction",
enabled: false,
});
const listResponse = await app.inject({
method: "GET",
url: "/api/payroll/items",
});
expect(listResponse.statusCode).toBe(200);
expect(listResponse.json().data.items).toHaveLength(2);
expect(salaryItem.create).toHaveBeenCalledTimes(1);
expect(salaryItem.update).toHaveBeenCalledTimes(1);
await app.close();
});
it("rejects non-admin users", async () => {
const { app } = await buildApp({
actor: {
id: "employee-1",
permissionCodes: ["employee"],
},
});
const response = await app.inject({
method: "GET",
url: "/api/payroll/items",
});
expect(response.statusCode).toBe(403);
await app.close();
});
});
@@ -0,0 +1,395 @@
const Fastify = require("fastify");
const payrollRoutes = require("../../../src/routes/payroll");
const { AppError } = require("../../../src/utils/AppError");
const ADMIN_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
const EMPLOYEE_ID = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
const OTHER_EMPLOYEE_ID = "cccccccc-cccc-4ccc-8ccc-cccccccccccc";
function buildEmployee(overrides = {}) {
return {
id: EMPLOYEE_ID,
employee_no: "E001",
name: "Alice",
title: "专员",
status: "active",
department: { id: "dept-1", name: "行政部" },
...overrides,
};
}
function buildSalaryItem(overrides = {}) {
return {
id: "11111111-1111-4111-8111-111111111111",
name: "基本工资",
item_type: "earning",
sort_order: 10,
enabled: true,
...overrides,
};
}
function buildSalaryRow(overrides = {}) {
return {
id: "salary-1",
employee_id: EMPLOYEE_ID,
salary_item_id: "11111111-1111-4111-8111-111111111111",
monthly_amount: "10000.00",
effective_date: new Date("2026-04-01T00:00:00.000Z"),
...overrides,
};
}
const PAYSLIP_IDS = [
"dddddddd-dddd-4ddd-8ddd-dddddddddddd",
"eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee",
"ffffffff-ffff-4fff-8fff-ffffffffffff",
];
async function buildApp({
actor = { id: ADMIN_ID, permissionCodes: ["system.users"] },
omitProfileFor = [],
} = {}) {
const app = Fastify();
const state = {
employees: [
buildEmployee(),
buildEmployee({
id: OTHER_EMPLOYEE_ID,
employee_no: "E002",
name: "Bob",
}),
],
salaryItems: [
buildSalaryItem(),
buildSalaryItem({
id: "22222222-2222-4222-8222-222222222222",
name: "社保扣除",
item_type: "deduction",
sort_order: 20,
}),
],
salaryRows: [
buildSalaryRow(),
buildSalaryRow({
id: "salary-2",
employee_id: EMPLOYEE_ID,
salary_item_id: "22222222-2222-4222-8222-222222222222",
monthly_amount: "600.00",
}),
buildSalaryRow({
id: "salary-3",
employee_id: OTHER_EMPLOYEE_ID,
monthly_amount: "9000.00",
}),
buildSalaryRow({
id: "salary-4",
employee_id: OTHER_EMPLOYEE_ID,
salary_item_id: "22222222-2222-4222-8222-222222222222",
monthly_amount: "500.00",
}),
].filter((item) => !omitProfileFor.includes(item.employee_id)),
payslips: [],
payslipItems: [],
};
function hydratePayslip(payslip) {
return {
...payslip,
employee: state.employees.find((item) => item.id === payslip.employee_id),
items: state.payslipItems
.filter((item) => item.payslip_id === payslip.id)
.map((item) => ({
...item,
salary_item: state.salaryItems.find((salaryItem) => salaryItem.id === item.salary_item_id),
})),
};
}
const payslip = {
count: vi.fn(async ({ where }) => state.payslips.filter((item) => item.pay_month.getTime() === where.pay_month.getTime()).length),
findMany: vi.fn(async ({ where, select, include }) => {
const filtered = state.payslips.filter((item) => {
if (where?.pay_month && item.pay_month.getTime() !== where.pay_month.getTime()) {
return false;
}
if (where?.employee_id && item.employee_id !== where.employee_id) {
return false;
}
if (where?.status && item.status !== where.status) {
return false;
}
if (where?.id?.in && !where.id.in.includes(item.id)) {
return false;
}
return true;
});
if (select) {
return filtered.map((item) => ({
id: item.id,
status: item.status,
}));
}
if (include) {
return filtered.map(hydratePayslip);
}
return filtered;
}),
findUnique: vi.fn(async ({ where }) => {
const payslipRow = state.payslips.find((item) => item.id === where.id);
return payslipRow ? hydratePayslip(payslipRow) : null;
}),
create: vi.fn(async ({ data }) => {
const row = {
id: PAYSLIP_IDS[state.payslips.length] ?? PAYSLIP_IDS[0],
employee_id: data.employee_id,
pay_month: data.pay_month,
status: data.status,
gross_amount: data.gross_amount,
deduction_amount: data.deduction_amount,
net_amount: data.net_amount,
issued_at: data.issued_at ?? null,
created_at: new Date("2026-04-30T08:00:00.000Z"),
created_by: data.created_by,
updated_at: new Date("2026-04-30T08:00:00.000Z"),
updated_by: data.updated_by,
};
state.payslips.push(row);
state.payslipItems.push(
...(data.items?.create ?? []).map((item, index) => ({
id: `payslip-item-${state.payslipItems.length + index + 1}`,
payslip_id: row.id,
salary_item_id: item.salary_item_id,
amount: item.amount,
})),
);
return row;
}),
update: vi.fn(async ({ where, data }) => {
const index = state.payslips.findIndex((item) => item.id === where.id);
state.payslips[index] = {
...state.payslips[index],
...data,
updated_at: new Date("2026-04-30T09:00:00.000Z"),
};
return state.payslips[index];
}),
updateMany: vi.fn(async ({ where, data }) => {
let count = 0;
state.payslips = state.payslips.map((item) => {
if (where.id?.in && where.id.in.includes(item.id)) {
count += 1;
return {
...item,
...data,
};
}
return item;
});
return { count };
}),
};
const payslipItem = {
deleteMany: vi.fn(async ({ where }) => {
state.payslipItems = state.payslipItems.filter((item) => item.payslip_id !== where.payslip_id);
return { count: 1 };
}),
createMany: vi.fn(async ({ data }) => {
state.payslipItems.push(
...data.map((item, index) => ({
id: `payslip-item-${state.payslipItems.length + index + 1}`,
payslip_id: item.payslip_id,
salary_item_id: item.salary_item_id,
amount: item.amount,
})),
);
return { count: data.length };
}),
};
app.decorate("authenticate", async (request) => {
request.employee = actor;
});
app.decorate("requirePermission", (permissionCode) => async (request) => {
request.employee = actor;
const codes = actor.permissionCodes ?? [];
if (!codes.includes("*") && !codes.includes(permissionCode)) {
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403 });
}
});
app.decorate("hasPermission", (employee, permissionCode) => {
const codes = employee.permissionCodes ?? [];
return codes.includes("*") || codes.includes(permissionCode);
});
app.decorate("prisma", {
employee: {
findMany: vi.fn(async ({ where }) => {
if (where?.status === "active") {
return state.employees.filter((item) => item.status === "active");
}
return [...state.employees];
}),
findUnique: vi.fn(async ({ where }) => state.employees.find((item) => item.id === where.id) ?? null),
},
salaryItem: {
findMany: vi.fn(async ({ where }) => {
if (where?.enabled === true) {
return state.salaryItems.filter((item) => item.enabled);
}
if (where?.id?.in) {
return state.salaryItems.filter((item) => where.id.in.includes(item.id));
}
return [...state.salaryItems];
}),
},
employeeSalary: {
findMany: vi.fn(async ({ where, select }) =>
state.salaryRows.filter((item) => {
if (where.employee_id?.in && !where.employee_id.in.includes(item.employee_id)) {
return false;
}
if (where.effective_date?.lte && item.effective_date > where.effective_date.lte) {
return false;
}
return true;
}).map((item) => (select ? { ...item } : item)),
),
},
payslip,
payslipItem,
auditLog: {
create: vi.fn().mockResolvedValue({}),
},
$transaction: vi.fn(async (callback) => callback(app.prisma)),
});
app.setErrorHandler((error, request, reply) => {
reply.status(error.statusCode || 500).send({
requestId: request.id,
error: {
code: error.code || "SYS_001",
message: error.message,
details: error.details ?? null,
},
});
});
await app.register(payrollRoutes, { prefix: "/api" });
return { app, state, payslip, payslipItem };
}
describe("payroll payslip routes", () => {
it("generates, edits and issues payslips and limits self view to issued records", async () => {
const { app, state, payslipItem } = await buildApp();
const generateResponse = await app.inject({
method: "POST",
url: "/api/payroll/payslips/generate",
payload: { month: "2026-04" },
});
expect(generateResponse.statusCode).toBe(200);
expect(generateResponse.json().data.summary).toEqual({
total: 2,
generated: 2,
});
expect(state.payslips).toHaveLength(2);
const patchResponse = await app.inject({
method: "PATCH",
url: `/api/payroll/payslips/${state.payslips[0].id}`,
payload: {
items: [
{
salaryItemId: state.salaryItems[0].id,
amount: 11000,
},
{
salaryItemId: state.salaryItems[1].id,
amount: 500,
},
],
},
});
expect(patchResponse.statusCode).toBe(200);
expect(patchResponse.json().data).toMatchObject({
grossAmount: 11000,
deductionAmount: 500,
netAmount: 10500,
status: "draft",
});
expect(payslipItem.createMany).toHaveBeenCalledTimes(1);
const issueResponse = await app.inject({
method: "POST",
url: "/api/payroll/payslips/issue",
payload: { month: "2026-04" },
});
expect(issueResponse.statusCode).toBe(200);
expect(issueResponse.json().data.summary).toEqual({
total: 2,
issued: 2,
});
const frozenResponse = await app.inject({
method: "PATCH",
url: `/api/payroll/payslips/${state.payslips[0].id}`,
payload: {
items: [
{
salaryItemId: state.salaryItems[0].id,
amount: 12000,
},
],
},
});
expect(frozenResponse.statusCode).toBe(409);
await app.close();
const selfApp = await buildApp({
actor: {
id: EMPLOYEE_ID,
permissionCodes: ["employee"],
},
});
selfApp.state.payslips = state.payslips;
selfApp.state.payslipItems = state.payslipItems;
const selfResponse = await selfApp.app.inject({
method: "GET",
url: `/api/payroll/employees/${EMPLOYEE_ID}/payslips`,
});
expect(selfResponse.statusCode).toBe(200);
expect(selfResponse.json().data.items).toHaveLength(1);
expect(selfResponse.json().data.items[0].status).toBe("issued");
await selfApp.app.close();
});
it("fails generation when an active employee has no effective salary profile", async () => {
const { app, state } = await buildApp({
omitProfileFor: [OTHER_EMPLOYEE_ID],
});
const response = await app.inject({
method: "POST",
url: "/api/payroll/payslips/generate",
payload: { month: "2026-04" },
});
expect(response.statusCode).toBe(409);
expect(response.json().error.details.month).toBe("salary_profile_missing");
expect(state.payslips).toHaveLength(0);
await app.close();
});
});
@@ -0,0 +1,236 @@
const Fastify = require("fastify");
const payrollRoutes = require("../../../src/routes/payroll");
const { AppError } = require("../../../src/utils/AppError");
const ADMIN_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
const EMPLOYEE_ID = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
function buildEmployee(overrides = {}) {
return {
id: EMPLOYEE_ID,
employee_no: "E001",
name: "Alice",
title: "专员",
status: "active",
department: { id: "dept-1", name: "行政部" },
...overrides,
};
}
function buildSalaryItem(overrides = {}) {
return {
id: "11111111-1111-4111-8111-111111111111",
name: "基本工资",
item_type: "earning",
sort_order: 10,
enabled: true,
created_at: new Date("2026-03-29T08:00:00.000Z"),
created_by: ADMIN_ID,
updated_at: new Date("2026-03-29T08:00:00.000Z"),
updated_by: ADMIN_ID,
...overrides,
};
}
function buildSalaryRow(overrides = {}) {
return {
id: "salary-1",
employee_id: EMPLOYEE_ID,
salary_item_id: "11111111-1111-4111-8111-111111111111",
monthly_amount: "10000.00",
effective_date: new Date("2026-01-01T00:00:00.000Z"),
created_at: new Date("2026-01-01T00:00:00.000Z"),
created_by: ADMIN_ID,
updated_at: new Date("2026-01-01T00:00:00.000Z"),
updated_by: ADMIN_ID,
salary_item: buildSalaryItem(),
...overrides,
};
}
async function buildApp({
actor = { id: ADMIN_ID, permissionCodes: ["system.users"] },
} = {}) {
const app = Fastify();
const state = {
employee: buildEmployee(),
salaryItems: [
buildSalaryItem(),
buildSalaryItem({
id: "22222222-2222-4222-8222-222222222222",
name: "社保扣除",
item_type: "deduction",
sort_order: 20,
}),
],
salaryRows: [buildSalaryRow()],
};
function attachSalaryItem(row) {
return {
...row,
salary_item: state.salaryItems.find((item) => item.id === row.salary_item_id),
};
}
const employeeSalary = {
findMany: vi.fn(async ({ where }) =>
state.salaryRows
.filter((item) => item.employee_id === where.employee_id)
.map(attachSalaryItem),
),
deleteMany: vi.fn(async ({ where }) => {
const effectiveDate = where.effective_date.toISOString().slice(0, 10);
state.salaryRows = state.salaryRows.filter(
(item) => !(item.employee_id === where.employee_id && item.effective_date.toISOString().slice(0, 10) === effectiveDate),
);
return { count: 1 };
}),
createMany: vi.fn(async ({ data }) => {
state.salaryRows.push(
...data.map((item, index) => ({
id: `salary-${state.salaryRows.length + index + 1}`,
employee_id: item.employee_id,
salary_item_id: item.salary_item_id,
monthly_amount: item.monthly_amount,
effective_date: item.effective_date,
created_at: new Date("2026-03-29T08:00:00.000Z"),
created_by: item.created_by,
updated_at: new Date("2026-03-29T08:00:00.000Z"),
updated_by: item.updated_by,
})),
);
return { count: data.length };
}),
};
app.decorate("authenticate", async (request) => {
request.employee = actor;
});
app.decorate("requirePermission", (permissionCode) => async (request) => {
request.employee = actor;
const codes = actor.permissionCodes ?? [];
if (!codes.includes("*") && !codes.includes(permissionCode)) {
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403 });
}
});
app.decorate("hasPermission", (employee, permissionCode) => {
const codes = employee.permissionCodes ?? [];
return codes.includes("*") || codes.includes(permissionCode);
});
app.decorate("prisma", {
employee: {
findUnique: vi.fn(async ({ where }) => (where.id === state.employee.id ? state.employee : null)),
},
salaryItem: {
findMany: vi.fn(async ({ where }) => state.salaryItems.filter((item) => where.id.in.includes(item.id))),
findUnique: vi.fn(async ({ where }) => state.salaryItems.find((item) => item.id === where.id) ?? null),
},
employeeSalary,
auditLog: {
create: vi.fn().mockResolvedValue({}),
},
$transaction: vi.fn(async (callback) => callback(app.prisma)),
});
app.setErrorHandler((error, request, reply) => {
reply.status(error.statusCode || 500).send({
requestId: request.id,
error: {
code: error.code || "SYS_001",
message: error.message,
details: error.details ?? null,
},
});
});
await app.register(payrollRoutes, { prefix: "/api" });
return { app, state, employeeSalary };
}
describe("payroll salary profile routes", () => {
it("replaces salary snapshots for the same effective date and preserves history", async () => {
const { app, state, employeeSalary } = await buildApp();
const putResponse = await app.inject({
method: "PUT",
url: `/api/payroll/employees/${EMPLOYEE_ID}/profile`,
payload: {
effectiveDate: "2026-04-01",
items: [
{
salaryItemId: state.salaryItems[0].id,
monthlyAmount: 12000,
},
{
salaryItemId: state.salaryItems[1].id,
monthlyAmount: 800,
},
],
},
});
expect(putResponse.statusCode).toBe(200);
expect(putResponse.json().data.snapshots[0]).toMatchObject({
effectiveDate: "2026-04-01",
items: [
{ salaryItemId: state.salaryItems[0].id, monthlyAmount: 12000 },
{ salaryItemId: state.salaryItems[1].id, monthlyAmount: 800 },
],
});
expect(putResponse.json().data.snapshots[1]).toMatchObject({
effectiveDate: "2026-01-01",
});
const replaceResponse = await app.inject({
method: "PUT",
url: `/api/payroll/employees/${EMPLOYEE_ID}/profile`,
payload: {
effectiveDate: "2026-04-01",
items: [
{
salaryItemId: state.salaryItems[0].id,
monthlyAmount: 12500,
},
],
},
});
expect(replaceResponse.statusCode).toBe(200);
expect(replaceResponse.json().data.snapshots[0]).toMatchObject({
effectiveDate: "2026-04-01",
items: [{ salaryItemId: state.salaryItems[0].id, monthlyAmount: 12500 }],
});
expect(replaceResponse.json().data.snapshots).toHaveLength(2);
const getResponse = await app.inject({
method: "GET",
url: `/api/payroll/employees/${EMPLOYEE_ID}/profile`,
});
expect(getResponse.statusCode).toBe(200);
expect(getResponse.json().data.snapshots).toHaveLength(2);
expect(employeeSalary.deleteMany).toHaveBeenCalledTimes(2);
expect(employeeSalary.createMany).toHaveBeenCalledTimes(2);
await app.close();
});
it("rejects non-admin users", async () => {
const { app } = await buildApp({
actor: {
id: EMPLOYEE_ID,
permissionCodes: ["employee"],
},
});
const response = await app.inject({
method: "GET",
url: `/api/payroll/employees/${EMPLOYEE_ID}/profile`,
});
expect(response.statusCode).toBe(403);
await app.close();
});
});