@tailor-platform/erp-kit 0.7.0 → 0.8.0

package/src/modules/accounting/testing/commandTestUtils.ts

@@ -0,0 +1,35 @@
+import { expect } from "vitest";
+import { type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export const commandCtx: CommandContext = {
+  actorId: "test-actor",
+  permissions: ["accounting:*"],
+};
+
+interface OkResult<T> {
+  ok: true;
+  value: T;
+}
+
+interface ErrResult {
+  ok: false;
+  error: unknown;
+}
+
+export function expectErr(
+  result: OkResult<unknown> | ErrResult,
+  errorClass: abstract new (...args: never[]) => Error,
+) {
+  expect(result.ok).toBe(false);
+  if (!result.ok) {
+    expect(result.error).toBeInstanceOf(errorClass);
+  }
+}
+
+export function expectOk<T>(result: OkResult<T> | ErrResult) {
+  expect(result.ok).toBe(true);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.value;
+}

package/src/modules/accounting/testing/fixtures.ts

@@ -0,0 +1,502 @@
+import type {
+  CostElement,
+  CostCenter,
+  CostCenterHierarchy,
+  CostCenterHierarchyNode,
+  ProfitCenter,
+  ProfitCenterHierarchy,
+  ProfitCenterHierarchyNode,
+  ProfitCenterHierarchyAssignment,
+  InternalOrder,
+  AllocationCycle,
+  AllocationRule,
+  AllocationResult,
+  PlanVersion,
+  Budget,
+  BudgetLineItem,
+  Commitment,
+  VarianceReport,
+  VarianceReportLine,
+  Schema,
+} from "../lib/types";
+
+const createdAt = new Date("2024-01-01T00:00:00.000Z");
+
+// Cross-module fixtures (minimal shape for validation)
+export const baseCompany = {
+  id: "company-1",
+  status: "ACTIVE",
+};
+
+export const baseAccount = {
+  id: "account-1",
+  code: "5000",
+  name: "Material Costs",
+  classification: "EXPENSE",
+  status: "ACTIVE",
+  chartOfAccountsId: "coa-1",
+};
+
+export const baseAccount2 = {
+  id: "account-2",
+  code: "5100",
+  name: "Labor Costs",
+  classification: "EXPENSE",
+  status: "ACTIVE",
+  chartOfAccountsId: "coa-1",
+};
+
+export const inactiveAccount = {
+  ...baseAccount,
+  id: "account-inactive",
+  status: "INACTIVE",
+};
+
+export const baseChartOfAccounts = {
+  id: "coa-1",
+  companyId: baseCompany.id,
+  status: "ACTIVE",
+};
+
+export const inactiveChartOfAccounts = {
+  ...baseChartOfAccounts,
+  id: "coa-inactive",
+  status: "INACTIVE",
+};
+
+export const baseUser = {
+  id: "user-1",
+  status: "ACTIVE",
+};
+
+export const baseUser2 = {
+  id: "user-2",
+  status: "ACTIVE",
+};
+
+export const baseDepartment = {
+  id: "department-1",
+  name: "IT Department",
+};
+
+export const baseAccountingPeriod = {
+  id: "period-1",
+  companyId: baseCompany.id,
+  fiscalYearId: "fiscal-year-1",
+  status: "OPEN",
+};
+
+export const closedAccountingPeriod = {
+  ...baseAccountingPeriod,
+  id: "period-closed",
+  status: "CLOSED",
+};
+
+export const baseFiscalYear = {
+  id: "fiscal-year-1",
+  companyId: baseCompany.id,
+};
+
+// CostElement fixtures
+export const baseCostElement = {
+  id: "cost-element-1",
+  code: "CE-001",
+  name: "Material Overhead",
+  type: "PRIMARY",
+  category: "overhead",
+  description: "Material overhead costs",
+  glAccountId: baseAccount.id,
+  companyId: baseCompany.id,
+  validFrom: null,
+  validTo: null,
+  status: "DRAFT",
+  createdAt,
+  updatedAt: null,
+} as const satisfies CostElement<Schema>;
+
+export const activeCostElement = {
+  ...baseCostElement,
+  id: "cost-element-active",
+  status: "ACTIVE",
+} as const satisfies CostElement<Schema>;
+
+export const inactiveCostElement = {
+  ...baseCostElement,
+  id: "cost-element-inactive",
+  status: "INACTIVE",
+} as const satisfies CostElement<Schema>;
+
+export const secondaryCostElement = {
+  ...baseCostElement,
+  id: "cost-element-secondary",
+  code: "CE-SEC-001",
+  name: "Assessment Overhead",
+  type: "SECONDARY",
+  category: "assessment",
+  glAccountId: null,
+  status: "ACTIVE",
+} as const satisfies CostElement<Schema>;
+
+// CostCenterHierarchy fixtures
+export const baseCostCenterHierarchy = {
+  id: "cc-hierarchy-1",
+  name: "Standard Hierarchy",
+  version: "V1",
+  companyId: baseCompany.id,
+  createdAt,
+  updatedAt: null,
+} as const satisfies CostCenterHierarchy<Schema>;
+
+// CostCenterHierarchyNode fixtures
+export const rootCostCenterNode = {
+  id: "cc-node-root",
+  name: "Root",
+  hierarchyId: baseCostCenterHierarchy.id,
+  parentNodeId: null,
+  sortOrder: 1,
+  level: 0,
+  createdAt,
+  updatedAt: null,
+} as const satisfies CostCenterHierarchyNode<Schema>;
+
+export const childCostCenterNode = {
+  id: "cc-node-child-1",
+  name: "Administration",
+  hierarchyId: baseCostCenterHierarchy.id,
+  parentNodeId: rootCostCenterNode.id,
+  sortOrder: 1,
+  level: 1,
+  createdAt,
+  updatedAt: null,
+} as const satisfies CostCenterHierarchyNode<Schema>;
+
+export const childCostCenterNode2 = {
+  id: "cc-node-child-2",
+  name: "Production",
+  hierarchyId: baseCostCenterHierarchy.id,
+  parentNodeId: rootCostCenterNode.id,
+  sortOrder: 2,
+  level: 1,
+  createdAt,
+  updatedAt: null,
+} as const satisfies CostCenterHierarchyNode<Schema>;
+
+// CostCenter fixtures
+export const baseCostCenter = {
+  id: "cost-center-1",
+  code: "CC-001",
+  name: "IT Department",
+  description: "Information Technology",
+  category: "overhead",
+  responsiblePersonId: baseUser.id,
+  departmentId: baseDepartment.id,
+  companyId: baseCompany.id,
+  hierarchyNodeId: childCostCenterNode.id,
+  validFrom: new Date("2024-01-01"),
+  validTo: null,
+  createdAt,
+  updatedAt: null,
+} as const satisfies CostCenter<Schema>;
+
+export const baseCostCenter2 = {
+  ...baseCostCenter,
+  id: "cost-center-2",
+  code: "CC-002",
+  name: "Finance Department",
+  hierarchyNodeId: childCostCenterNode2.id,
+} as const satisfies CostCenter<Schema>;
+
+// ProfitCenterHierarchy fixtures
+export const baseProfitCenterHierarchy = {
+  id: "pc-hierarchy-1",
+  name: "Product Lines",
+  companyId: baseCompany.id,
+  createdAt,
+  updatedAt: null,
+} as const satisfies ProfitCenterHierarchy<Schema>;
+
+// ProfitCenterHierarchyNode fixtures
+export const rootProfitCenterNode = {
+  id: "pc-node-root",
+  name: "Root",
+  hierarchyId: baseProfitCenterHierarchy.id,
+  parentNodeId: null,
+  sortOrder: 1,
+  level: 0,
+  createdAt,
+  updatedAt: null,
+} as const satisfies ProfitCenterHierarchyNode<Schema>;
+
+export const childProfitCenterNode = {
+  id: "pc-node-child-1",
+  name: "Product Line A",
+  hierarchyId: baseProfitCenterHierarchy.id,
+  parentNodeId: rootProfitCenterNode.id,
+  sortOrder: 1,
+  level: 1,
+  createdAt,
+  updatedAt: null,
+} as const satisfies ProfitCenterHierarchyNode<Schema>;
+
+// ProfitCenter fixtures
+export const baseProfitCenter = {
+  id: "profit-center-1",
+  code: "PC-001",
+  name: "Product Line Alpha",
+  description: "Alpha product line",
+  responsiblePersonId: baseUser.id,
+  companyId: baseCompany.id,
+  validFrom: new Date("2024-01-01"),
+  validTo: null,
+  status: "DRAFT",
+  createdAt,
+  updatedAt: null,
+} as const satisfies ProfitCenter<Schema>;
+
+export const activeProfitCenter = {
+  ...baseProfitCenter,
+  id: "profit-center-active",
+  status: "ACTIVE",
+} as const satisfies ProfitCenter<Schema>;
+
+export const inactiveProfitCenter = {
+  ...baseProfitCenter,
+  id: "profit-center-inactive",
+  status: "INACTIVE",
+} as const satisfies ProfitCenter<Schema>;
+
+// InternalOrder fixtures
+export const baseInternalOrder = {
+  id: "internal-order-1",
+  orderNumber: "IO-001",
+  orderType: "OVERHEAD",
+  description: "IT Infrastructure Upgrade",
+  responsiblePersonId: baseUser.id,
+  costCenterId: baseCostCenter.id,
+  companyId: baseCompany.id,
+  validFrom: null,
+  validTo: null,
+  status: "CREATED",
+  createdAt,
+  updatedAt: null,
+} as const satisfies InternalOrder<Schema>;
+
+export const releasedInternalOrder = {
+  ...baseInternalOrder,
+  id: "internal-order-released",
+  status: "RELEASED",
+} as const satisfies InternalOrder<Schema>;
+
+export const techCompletedInternalOrder = {
+  ...baseInternalOrder,
+  id: "internal-order-tech-completed",
+  status: "TECHNICALLY_COMPLETED",
+} as const satisfies InternalOrder<Schema>;
+
+export const closedInternalOrder = {
+  ...baseInternalOrder,
+  id: "internal-order-closed",
+  status: "CLOSED",
+} as const satisfies InternalOrder<Schema>;
+
+// AllocationCycle fixtures
+export const baseAllocationCycle = {
+  id: "allocation-cycle-1",
+  name: "Q1 2024 Overhead",
+  allocationType: "ASSESSMENT",
+  companyId: baseCompany.id,
+  accountingPeriodId: baseAccountingPeriod.id,
+  status: "DRAFT",
+  createdAt,
+  updatedAt: null,
+} as const satisfies AllocationCycle<Schema>;
+
+export const validatedAllocationCycle = {
+  ...baseAllocationCycle,
+  id: "allocation-cycle-validated",
+  status: "VALIDATED",
+} as const satisfies AllocationCycle<Schema>;
+
+export const executedAllocationCycle = {
+  ...baseAllocationCycle,
+  id: "allocation-cycle-executed",
+  status: "EXECUTED",
+} as const satisfies AllocationCycle<Schema>;
+
+export const postedAllocationCycle = {
+  ...baseAllocationCycle,
+  id: "allocation-cycle-posted",
+  status: "POSTED",
+} as const satisfies AllocationCycle<Schema>;
+
+export const reversedAllocationCycle = {
+  ...baseAllocationCycle,
+  id: "allocation-cycle-reversed",
+  status: "REVERSED",
+} as const satisfies AllocationCycle<Schema>;
+
+// AllocationRule fixtures
+export const baseAllocationRule = {
+  id: "allocation-rule-1",
+  allocationCycleId: baseAllocationCycle.id,
+  senderCostCenterId: baseCostCenter.id,
+  receiverType: "CostCenter",
+  receiverId: baseCostCenter2.id,
+  percentage: 100,
+  createdAt,
+  updatedAt: null,
+} as const satisfies AllocationRule<Schema>;
+
+// AllocationResult fixtures
+export const baseAllocationResult = {
+  id: "allocation-result-1",
+  allocationCycleId: baseAllocationCycle.id,
+  senderCostCenterId: baseCostCenter.id,
+  receiverType: "CostCenter",
+  receiverId: baseCostCenter2.id,
+  allocatedAmount: 5000,
+  costElementId: activeCostElement.id,
+  createdAt,
+  updatedAt: null,
+} as const satisfies AllocationResult<Schema>;
+
+// PlanVersion fixtures
+export const basePlanVersion = {
+  id: "plan-version-1",
+  name: "FY2024 Budget",
+  type: "BUDGET",
+  baseVersionId: null,
+  companyId: baseCompany.id,
+  createdAt,
+  updatedAt: null,
+} as const satisfies PlanVersion<Schema>;
+
+// Budget fixtures
+export const baseBudget = {
+  id: "budget-1",
+  name: "IT Budget 2024",
+  description: "Information Technology budget for FY2024",
+  budgetHolderId: baseUser.id,
+  fiscalYearId: baseFiscalYear.id,
+  companyId: baseCompany.id,
+  costObjectType: "CostCenter",
+  costObjectId: baseCostCenter.id,
+  planVersionId: basePlanVersion.id,
+  totalAmount: 100000,
+  status: "DRAFT",
+  rejectionReason: null,
+  createdByUserId: baseUser.id,
+  createdAt,
+  updatedAt: null,
+} as const satisfies Budget<Schema>;
+
+export const submittedBudget = {
+  ...baseBudget,
+  id: "budget-submitted",
+  status: "SUBMITTED",
+} as const satisfies Budget<Schema>;
+
+export const approvedBudget = {
+  ...baseBudget,
+  id: "budget-approved",
+  status: "APPROVED",
+} as const satisfies Budget<Schema>;
+
+export const activeBudget = {
+  ...baseBudget,
+  id: "budget-active",
+  status: "ACTIVE",
+} as const satisfies Budget<Schema>;
+
+export const closedBudget = {
+  ...baseBudget,
+  id: "budget-closed",
+  status: "CLOSED",
+} as const satisfies Budget<Schema>;
+
+// BudgetLineItem fixtures
+export const baseBudgetLineItem = {
+  id: "budget-line-item-1",
+  budgetId: baseBudget.id,
+  costElementId: activeCostElement.id,
+  glAccountId: null,
+  accountingPeriodId: baseAccountingPeriod.id,
+  plannedAmount: 10000,
+  createdAt,
+  updatedAt: null,
+} as const satisfies BudgetLineItem<Schema>;
+
+// Commitment fixtures
+export const baseCommitment = {
+  id: "commitment-1",
+  costElementId: activeCostElement.id,
+  costObjectType: "CostCenter",
+  costObjectId: baseCostCenter.id,
+  accountingPeriodId: baseAccountingPeriod.id,
+  amount: 5000,
+  consumedAmount: 0,
+  purchaseOrderId: "purchase-order-1",
+  companyId: baseCompany.id,
+  status: "OPEN",
+  createdAt,
+  updatedAt: null,
+} as const satisfies Commitment<Schema>;
+
+export const partiallyConsumedCommitment = {
+  ...baseCommitment,
+  id: "commitment-partially-consumed",
+  consumedAmount: 2000,
+} as const satisfies Commitment<Schema>;
+
+export const fullyConsumedCommitment = {
+  ...baseCommitment,
+  id: "commitment-fully-consumed",
+  consumedAmount: 5000,
+  status: "CONSUMED",
+} as const satisfies Commitment<Schema>;
+
+// VarianceReport fixtures
+export const baseVarianceReport = {
+  id: "variance-report-1",
+  costObjectType: "CostCenter",
+  costObjectId: baseCostCenter.id,
+  accountingPeriodId: baseAccountingPeriod.id,
+  companyId: baseCompany.id,
+  totalPlanned: 10000,
+  totalActual: 12000,
+  totalVariance: 2000,
+  status: "DRAFT",
+  createdAt,
+  updatedAt: null,
+} as const satisfies VarianceReport<Schema>;
+
+export const finalVarianceReport = {
+  ...baseVarianceReport,
+  id: "variance-report-final",
+  status: "FINAL",
+} as const satisfies VarianceReport<Schema>;
+
+// ProfitCenterHierarchyAssignment fixtures
+export const baseProfitCenterHierarchyAssignment = {
+  id: "pc-hierarchy-assignment-1",
+  profitCenterId: "profit-center-1",
+  hierarchyId: baseProfitCenterHierarchy.id,
+  hierarchyNodeId: childProfitCenterNode.id,
+  createdAt,
+  updatedAt: null,
+} as const satisfies ProfitCenterHierarchyAssignment<Schema>;
+
+// VarianceReportLine fixtures
+export const baseVarianceReportLine = {
+  id: "variance-report-line-1",
+  varianceReportId: baseVarianceReport.id,
+  costElementId: activeCostElement.id,
+  accountingPeriodId: baseAccountingPeriod.id,
+  plannedAmount: 10000,
+  actualAmount: 12000,
+  varianceAmount: 2000,
+  variancePercentage: 20,
+  varianceDirection: "UNFAVORABLE",
+  createdAt,
+  updatedAt: null,
+} as const satisfies VarianceReportLine<Schema>;

package/src/modules/audit/command/logAuditEvent.ts

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   EntityTypeNotRegisteredError,
@@ -52,8 +51,11 @@ function maskValue(value: string): string {
   return "*".repeat(value.length - 4) + value.slice(-4);
 }
 
-function hashValue(value: string): string {
-  return createHash("sha256").update(value).digest("hex");
+async function hashValue(value: string): Promise<string> {
+  const data = new TextEncoder().encode(value);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray, (b) => b.toString(16).padStart(2, "0")).join("");
 }
 
 function stripHtml(value: string): string {
@@ -99,7 +101,7 @@ function truncateValue(value: string | null): string | null {
   return value;
 }
 
-function applySensitivity(value: string | null, mode: string): string | null {
+async function applySensitivity(value: string | null, mode: string): Promise<string | null> {
   if (value === null) return null;
 
   let processed = value;
@@ -109,7 +111,7 @@ function applySensitivity(value: string | null, mode: string): string | null {
       processed = maskValue(processed);
       break;
     case "HASH":
-      processed = hashValue(processed);
+      processed = await hashValue(processed);
       break;
     case "EXCLUDE":
       return null;
@@ -253,39 +255,42 @@ export async function run(db: Transaction, input: LogAuditEventInput, _ctx: Comm
 
   // Filter and process changes
   const hasExplicitRules = fieldRules.length > 0;
-  const processedChanges = (input.changes || [])
-    .filter((change) => {
-      // Resolve fieldType: prefer registered type, fall back to input's fieldType
-      const effectiveFieldType = registeredFieldTypes.get(change.fieldName) ?? change.fieldType;
-      // Exclude binary and computed fields entirely
-      if (effectiveFieldType === "binary" || effectiveFieldType === "computed") return false;
-      // Drop fields not in entity's auditableFields
-      if (!auditableFieldNames.has(change.fieldName)) return false;
-      // If policy has explicit field rules, also drop fields not in policy's rules
-      if (hasExplicitRules && !fieldRuleMap.has(change.fieldName)) return false;
-      return true;
-    })
-    .map((change) => {
-      const mode = fieldRuleMap.get(change.fieldName) ?? "CAPTURE";
-      // Resolve fieldType: prefer registered type, fall back to input's fieldType
-      const effectiveFieldType = registeredFieldTypes.get(change.fieldName) ?? change.fieldType;
-      // Normalize values based on field type before sensitivity processing
-      const normalizedOld = normalizeFieldValue(change.oldValue, effectiveFieldType);
-      const normalizedNew = normalizeFieldValue(change.newValue, effectiveFieldType);
-
-      // Enforce stored invariants: CREATE → oldValue=null, DELETE → newValue=null
-      const effectiveOld = input.operationType === "CREATE" ? null : normalizedOld;
-      const effectiveNew = input.operationType === "DELETE" ? null : normalizedNew;
-
-      return {
-        fieldName: change.fieldName,
-        // Keep normalized values for unchanged-field detection
-        _normalizedOld: effectiveOld,
-        _normalizedNew: effectiveNew,
-        oldValue: applySensitivity(effectiveOld, mode),
-        newValue: applySensitivity(effectiveNew, mode),
-      };
-    })
+  const filteredChanges = (input.changes || []).filter((change) => {
+    // Resolve fieldType: prefer registered type, fall back to input's fieldType
+    const effectiveFieldType = registeredFieldTypes.get(change.fieldName) ?? change.fieldType;
+    // Exclude binary and computed fields entirely
+    if (effectiveFieldType === "binary" || effectiveFieldType === "computed") return false;
+    // Drop fields not in entity's auditableFields
+    if (!auditableFieldNames.has(change.fieldName)) return false;
+    // If policy has explicit field rules, also drop fields not in policy's rules
+    if (hasExplicitRules && !fieldRuleMap.has(change.fieldName)) return false;
+    return true;
+  });
+
+  const processedChanges = (
+    await Promise.all(
+      filteredChanges.map(async (change) => {
+        const mode = fieldRuleMap.get(change.fieldName) ?? "CAPTURE";
+        // Resolve fieldType: prefer registered type, fall back to input's fieldType
+        const effectiveFieldType = registeredFieldTypes.get(change.fieldName) ?? change.fieldType;
+        // Normalize values based on field type before sensitivity processing
+        const normalizedOld = normalizeFieldValue(change.oldValue, effectiveFieldType);
+        const normalizedNew = normalizeFieldValue(change.newValue, effectiveFieldType);
+
+        // Enforce stored invariants: CREATE → oldValue=null, DELETE → newValue=null
+        const effectiveOld = input.operationType === "CREATE" ? null : normalizedOld;
+        const effectiveNew = input.operationType === "DELETE" ? null : normalizedNew;
+
+        return {
+          fieldName: change.fieldName,
+          _normalizedOld: effectiveOld,
+          _normalizedNew: effectiveNew,
+          oldValue: await applySensitivity(effectiveOld, mode),
+          newValue: await applySensitivity(effectiveNew, mode),
+        };
+      }),
+    )
+  )
     .filter((change) => {
       // For UPDATE, drop fields where normalized old and new values are identical (no actual change)
       // Compare pre-sensitivity values so that EXCLUDE mode (both→null) still produces a record

package/src/modules/audit/command/updateAuditPolicy.ts

@@ -10,11 +10,11 @@ import {
 } from "../lib/errors.generated";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateAuditPolicyInput {
+export type UpdateAuditPolicyInput = {
   policyId: string;
   operationType?: string;
   fieldRules?: { fieldName: string; sensitivityMode?: string }[];
-}
+};
 
 const VALID_OPERATION_TYPES = ["CREATE", "UPDATE", "DELETE"] as const;
 const VALID_SENSITIVITY_MODES = ["CAPTURE", "MASK", "HASH", "EXCLUDE"] as const;

package/src/modules/audit/docs/commands/UpdateAuditPolicy.md

@@ -9,7 +9,7 @@ This command requires the `manageAuditPolicies` permission at the appropriate sc
 ## Business Rules
 
 - Only policies in DRAFT status can be updated
-- entityName and companyId cannot be changed after creation
+- entityName and companyId are fixed by the existing record and are not part of the update input
 - Operation type can be updated; must be one of CREATE, UPDATE, or DELETE
 - Field names in field-level rules must be non-empty strings
 - Field-level rules can be added, modified, or removed

package/src/modules/audit/module.ts

@@ -19,6 +19,9 @@ import { createAuditPolicyType } from "./db/auditPolicy";
 import { policyFieldRule } from "./db/policyFieldRule";
 import { createAuditEntryType } from "./db/auditEntry";
 import { changeDetail } from "./db/changeDetail";
+import { company as companyStub } from "./lib/_db_deps";
+
+export { companyStub };
 
 export interface DefineModuleParams {
   organization?: {
@@ -26,6 +29,7 @@ export interface DefineModuleParams {
   };
 }
 
+/* @__NO_SIDE_EFFECTS__ */
 export const defineModule = (params?: DefineModuleParams) => {
   const companyType = params?.organization?.db.company;