@tailor-platform/erp-kit 0.7.0 → 0.9.0

package/skills/erp-kit-module-shared/references/commands.md

@@ -179,10 +179,80 @@ const units = await db
 
 - **Error handling**: Use `ok()` / `err()` from `@tailor-platform/erp-kit/module` — do not throw
 - **Validation**: Check referenced entities exist before operating, return `err()` if not found
+- **Return property naming**: Use the full model name in camelCase as the return property key — never abbreviate. This keeps property names unambiguous across modules.
+  - `return ok({ stockMovement: ... })` — not `movement`
+  - `return ok({ inventoryAdjustment: ... })` — not `adjustment`
+
+## Update Command Input Type
+
+Update commands use a structured type that separates lookup keys from mutable fields, and explicitly excludes status-controlled fields.
+
+### Input type shape
+
+```typescript
+export type UpdateXInput = ({
+  id: string;
+} | {
+  naturalKey: string; // e.g. sku, code
+}) & {
+  mutableField1?: string;
+  mutableField2?: string | null;
+}
+```
+
+### Run signature with custom fields
+
+```typescript
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateXInput & Omit<Partial<CF>, "status">,
+  ctx: CommandContext,
+)
+```
+
+### Rules
+
+| Field kind | Examples | How to handle |
+|---|---|---|
+| Lookup key (primary) | `id` | One branch of the union |
+| Lookup key (natural) | `sku`, `code` | Another branch of the union — used to look up the record, not to update it |
+| Mutable fields | `name`, `barcode` | Listed in the `&` intersection as optional fields |
+| Status-controlled | `status` | **Never in the input type.** Managed by dedicated commands (`activateX`, `deactivateX`). Excluded from `CF` via `Omit`. |
+| System fields | `createdAt`, `updatedAt` | Never in the input type. Set automatically. |
+
+### Lookup implementation
+
+Use `"id" in input` to branch between lookup strategies:
+
+```typescript
+let query = db.selectFrom("Item").selectAll();
+if ("id" in input) {
+  query = query.where("id", "=", input.id);
+} else {
+  query = query.where("sku", "=", (input as { sku: string }).sku);
+}
+const item = await query.forUpdate().executeTakeFirst();
+```
+
+### Custom field extraction
+
+Destructure known fields and treat the rest as custom fields:
+
+```typescript
+const { name, barcode, unitId, ...rest } = input as any;
+const { id: _id, sku: _sku, ...customFields } = rest;
+```
+
+### Why not throw immutable errors
+
+Natural keys like `sku` or `code` are **lookup keys**, not updatable fields. They do not belong in the mutable section of the input type — the type system prevents callers from passing them as update targets. There is no need for a `SkuImmutableError` or `CodeImmutableError` in an update command.
+
+> Exception: conditionally-mutable fields (e.g., `baseCurrencyId` that can only change in DRAFT status) belong in the mutable section and use a business-rule error when the condition is not met.
 
 ## Conventions
 
-- Input types: exported interfaces (`export interface MyFunctionInput`)
+- Input types for create commands: exported interfaces (`export interface CreateXInput`)
+- Input types for update commands: exported type aliases (`export type UpdateXInput = ...`)
 - Use `.executeTakeFirst()` for single results
 - Include JSDoc: `/** Function: name \n Description */`
 

package/skills/erp-kit-update/SKILL.md

@@ -1,12 +1,18 @@
 ---
 name: erp-kit-update
 description: Route requirements changes to the correct erp-kit skill. Use when requirements change midway — adding features, modifying business flows, updating screens, changing module specs, or when unsure which erp-kit skill to re-run after a change.
+metadata:
+  erp-kit-version: "0.9.0"
 ---
 
 # Requirements Update Router
 
 Route mid-workflow changes to the correct erp-kit skill. Dynamically discovers available skills — no hardcoded routing tables.
 
+## Version Check
+
+Run `npx erp-kit --version` and compare against this skill's `metadata.erp-kit-version`. If they differ, the local skills are outdated — tell the user to run `pnpm erp-kit update skills` and stop.
+
 ## Workflow
 
 ```

package/src/commands/index.ts

@@ -19,9 +19,15 @@ const cwd = process.cwd();
 export const initCommand = defineCommand({
   name: "init",
   description: "First-time setup for a consumer repo",
-  run: () => {
+  args: z.object({
+    name: arg(z.string(), {
+      positional: true,
+      description: "Project name",
+    }),
+  }),
+  run: (args) => {
     return executeCommand(() => {
-      const exitCode = runInit(cwd);
+      const exitCode = runInit(args.name, cwd);
       return exitCode === 0 ? success() : silentFailure(exitCode);
     });
   },

package/src/commands/init.test.ts

@@ -15,8 +15,8 @@ describe("runInit", () => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
-  it("copies skills, workflows, config, and symlink on fresh repo", () => {
-    const exitCode = runInit(tmpDir);
+  it("copies skills, workflows, symlink, and scaffolds project on fresh repo", () => {
+    const exitCode = runInit("test-project", tmpDir);
     expect(exitCode).toBe(0);
 
     // Skills
@@ -37,14 +37,30 @@ describe("runInit", () => {
     const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
     expect(fs.existsSync(wfPath)).toBe(true);
 
-    // Config
-    const configPath = path.join(tmpDir, "license.config.json");
-    expect(fs.existsSync(configPath)).toBe(true);
+    // Scaffold: package.json
+    const pkgPath = path.join(tmpDir, "package.json");
+    expect(fs.existsSync(pkgPath)).toBe(true);
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as { name: string; private: boolean };
+    expect(pkg.name).toBe("test-project");
+    expect(pkg.private).toBe(true);
+
+    // Scaffold: pnpm-workspace.yaml
+    expect(fs.existsSync(path.join(tmpDir, "pnpm-workspace.yaml"))).toBe(true);
+
+    // Scaffold: .gitignore
+    expect(fs.existsSync(path.join(tmpDir, ".gitignore"))).toBe(true);
+
+    // Scaffold: license.config.json
+    expect(fs.existsSync(path.join(tmpDir, "license.config.json"))).toBe(true);
+
+    // Scaffold: apps/ and modules/
+    expect(fs.existsSync(path.join(tmpDir, "apps", ".gitkeep"))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, "modules", ".gitkeep"))).toBe(true);
   });
 
   it("refuses to run if already initialized", () => {
-    runInit(tmpDir);
-    const exitCode = runInit(tmpDir);
+    runInit("test-project", tmpDir);
+    const exitCode = runInit("test-project", tmpDir);
     expect(exitCode).toBe(1);
   });
 
@@ -52,7 +68,7 @@ describe("runInit", () => {
     const customDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
     fs.mkdirSync(customDir, { recursive: true });
     fs.writeFileSync(path.join(customDir, "SKILL.md"), "# Custom");
-    runInit(tmpDir);
+    runInit("test-project", tmpDir);
     expect(fs.readFileSync(path.join(customDir, "SKILL.md"), "utf-8")).toBe("# Custom");
   });
 });

package/src/commands/init.ts

@@ -1,13 +1,8 @@
 import chalk from "chalk";
-import {
-  copySkills,
-  copyWorkflows,
-  copyConfigs,
-  setupSymlink,
-  isAlreadyInitialized,
-} from "./lib/distribute";
+import { scaffoldProjectBoilerplate } from "../generator/scaffold";
+import { copySkills, copyWorkflows, setupSymlink, isAlreadyInitialized } from "./lib/distribute";
 
-export function runInit(cwd: string): number {
+export function runInit(name: string, cwd: string): number {
   console.log(chalk.bold("erp-kit init\n"));
 
   if (isAlreadyInitialized(cwd)) {
@@ -36,10 +31,8 @@ export function runInit(cwd: string): number {
     console.log(chalk.green(`  Copied ${workflows.copied} workflow(s) to .github/workflows/`));
   }
 
-  const configs = copyConfigs(cwd);
-  if (configs.copied > 0) {
-    console.log(chalk.green(`  Copied ${configs.copied} config file(s)`));
-  }
+  scaffoldProjectBoilerplate(cwd, name);
+  console.log(chalk.green("  Scaffolded project structure"));
 
   console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
   return 0;

package/src/commands/lib/distribute.test.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { copySkills, copyWorkflows, copyConfigs, setupSymlink } from "./distribute";
+import { copySkills, copyWorkflows, setupSymlink } from "./distribute";
 
 describe("copySkills", () => {
   let tmpDir: string;
@@ -74,25 +74,6 @@ describe("copyWorkflows", () => {
   });
 });
 
-describe("copyConfigs", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("copies config files to repo root", () => {
-    const result = copyConfigs(tmpDir);
-    const configPath = path.join(tmpDir, "license.config.json");
-    expect(fs.existsSync(configPath)).toBe(true);
-    expect(result.copied).toBeGreaterThan(0);
-  });
-});
-
 describe("setupSymlink", () => {
   let tmpDir: string;
 

package/src/commands/lib/distribute.ts

@@ -4,7 +4,6 @@ import { PACKAGE_ROOT } from "../../util";
 
 const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
 const WORKFLOWS_SRC = path.join(PACKAGE_ROOT, "templates", "workflows");
-const CONFIG_SRC = path.join(PACKAGE_ROOT, "templates", "config");
 
 export interface CopyResult {
   copied: number;
@@ -77,19 +76,6 @@ export function copyWorkflows(cwd: string): CopyResult {
   return { copied, removed: 0 };
 }
 
-export function copyConfigs(cwd: string): CopyResult {
-  if (!fs.existsSync(CONFIG_SRC)) return { copied: 0, removed: 0 };
-
-  let copied = 0;
-  for (const entry of fs.readdirSync(CONFIG_SRC)) {
-    const destPath = path.join(cwd, entry);
-    fs.copyFileSync(path.join(CONFIG_SRC, entry), destPath);
-    copied++;
-  }
-
-  return { copied, removed: 0 };
-}
-
 export type SymlinkResult = "linked" | "already_linked" | "skipped_directory" | "copied";
 
 function createSymlink(target: string, linkPath: string): void {

package/src/commands/update.test.ts

@@ -74,7 +74,7 @@ describe("runUpdate", () => {
     fs.writeFileSync(path.join(wfDir, "erp-kit-check.yml"), "# Old");
     runUpdate(tmpDir, ["workflows"]);
     const content = fs.readFileSync(path.join(wfDir, "erp-kit-check.yml"), "utf-8");
-    expect(content).toContain("@tailor-platform/erp-kit");
+    expect(content).toContain("erp-kit Check");
   });
 
   it("refreshes .claude/skills when it is a copied directory (not a symlink)", () => {

package/src/generator/scaffold.ts

@@ -2,24 +2,33 @@ import fs from "node:fs";
 import path from "node:path";
 import { PACKAGE_ROOT, readErpKitVersion } from "../util";
 
+// Files that need renaming because they cause issues in the repo/pack.
 // npm renames .gitignore during pack (npm/cli#5756).
-// prepack copies .gitignore to __dot__gitignore to preserve it.
+// pnpm-workspace.yaml causes the template dir to be treated as a workspace member.
+// prepack copies these to their safe names; scaffold time restores the originals.
+const RENAME_MAP: Record<string, string> = {
+  __dot__gitignore: ".gitignore",
+  "__pnpm-workspace.yaml": "pnpm-workspace.yaml",
+};
+
 export function copyTemplateDir(
   srcDir: string,
   destDir: string,
   replacements: Record<string, string>,
   placeholderFiles: Set<string>,
+  excludeDirs = new Set<string>(),
 ): void {
   for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
     const srcPath = path.join(srcDir, entry.name);
-    const destName = entry.name === "__dot__gitignore" ? ".gitignore" : entry.name;
+    const destName = RENAME_MAP[entry.name] ?? entry.name;
     const destPath = path.join(destDir, destName);
 
     if (entry.name === "node_modules") continue;
+    if (excludeDirs.has(entry.name)) continue;
 
     if (entry.isDirectory()) {
       fs.mkdirSync(destPath, { recursive: true });
-      copyTemplateDir(srcPath, destPath, replacements, placeholderFiles);
+      copyTemplateDir(srcPath, destPath, replacements, placeholderFiles, excludeDirs);
     } else {
       if (fs.existsSync(destPath)) continue;
       fs.mkdirSync(path.dirname(destPath), { recursive: true });
@@ -57,5 +66,17 @@ export function scaffoldAppBoilerplate(appDir: string, appName: string): void {
     '"workspace:*"': `"${erpKitVersion}"`,
   };
   const placeholderFiles = new Set(["package.json", "tailor.config.ts", "index.html"]);
-  copyTemplateDir(templateDir, appDir, replacements, placeholderFiles);
+  // docs are authored by skills (app-1 through app-4), not scaffolded.
+  copyTemplateDir(templateDir, appDir, replacements, placeholderFiles, new Set(["docs"]));
+}
+
+export function scaffoldProjectBoilerplate(projectDir: string, projectName: string): void {
+  const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "project");
+  const erpKitVersion = readErpKitVersion();
+  const replacements = {
+    "template-project": projectName,
+    '"workspace:*"': `"${erpKitVersion}"`,
+  };
+  const placeholderFiles = new Set(["package.json"]);
+  copyTemplateDir(templateDir, projectDir, replacements, placeholderFiles);
 }

package/src/module.ts

@@ -44,7 +44,10 @@ export {
   all as itemManagementAll,
 } from "./modules/item-management/lib/permissions.generated";
 // audit
-export { defineModule as defineAuditModule } from "./modules/audit/module";
+export {
+  defineModule as defineAuditModule,
+  companyStub as auditCompanyStub,
+} from "./modules/audit/module";
 export {
   permissions as auditPermissions,
   own as auditOwn,

package/src/modules/accounting/README.md

@@ -0,0 +1,63 @@
+# README
+
+## Overview
+
+The accounting module provides management (internal) accounting capabilities for budgeting, cost allocation, profit center reporting, and variance analysis. It enables organizations to track, allocate, and analyze costs for internal decision-making, complementing the financial accounting capabilities provided by `finance-ledger` and `coa-management`.
+
+This module owns cost centers, profit centers, cost elements, budgets, internal orders, and allocation cycles — entities that exist solely for management accounting purposes and are distinct from the general ledger structure.
+
+## Key Features
+
+- **Cost Center Management** — Create and maintain cost centers with hierarchical grouping for overhead cost accumulation and reporting
+- **Cost Element Management** — Define primary cost elements (mapped to GL accounts) and secondary cost elements (internal allocation only)
+- **Profit Center Management** — Create and maintain profit centers with hierarchical grouping for internal P&L reporting
+- **Budget Management** — Create budgets with line items per cost element, manage approval workflows, track budget versions, and enforce budgetary control with commitment-aware availability checks
+- **Cost Allocation** — Execute allocation cycles (assessment/distribution) to distribute overhead costs from sender to receiver cost objects
+- **Internal Order Management** — Track costs for specific short-to-medium-term activities (projects, campaigns, events) with lifecycle management
+- **Variance Analysis** — Compare planned vs. actual costs by cost object and period, categorize variances, and generate management reports
+
+## Module Scope
+
+### In Scope
+
+- Cost center CRUD and hierarchy management
+- Profit center CRUD and hierarchy management
+- Primary and secondary cost element definition
+- Budget creation, approval workflow, and line item entry per cost element
+- Budgetary control with commitment-aware availability checks (Budget - Actual - Commitments - Encumbrances)
+- Commitment tracking via purchase module event consumption (PO confirmed, received, invoiced, cancelled)
+- Budget vs. actual comparison
+- Cost allocation cycles (assessment and distribution methods)
+- Allocation rule definition and execution
+- Internal order lifecycle (created → released → technically completed → closed)
+- Variance calculation and categorization (plan vs. actual) with cost-element-level detail lines
+- Multi-version planning (budget, forecast)
+- Audit trail for budget changes, allocation runs, and variance postings
+
+### Out of Scope
+
+- Financial (external) accounting — owned by `finance-ledger`
+- Chart of accounts and GL account management — owned by `coa-management`
+- Fiscal year and accounting period management — owned by `finance-ledger`
+- Activity-based costing (activity types, rate calculation) — future extension
+- Statistical key figures as allocation drivers — future extension
+- Multi-dimensional profitability analysis (CO-PA style) — future extension
+- What-if scenario modeling and simulation — future extension
+- Internal order settlement to receivers — future extension
+- Rolling forecasts beyond fiscal year boundaries — future extension
+- Manufacturing variance calculation — owned by `manufacturing`; this module consumes results
+- Transfer pricing between legal entities — future extension
+
+### Scope Decision Rationale
+
+The initial scope focuses on the six core entities identified in the roadmap (Budget, BudgetLine, ProfitCenter, CostAllocation, InternalOrder, Variance) plus foundational entities (CostCenter, CostElement) required by all management accounting features. Comprehensive features like activity-based costing and multi-dimensional profitability analysis are deferred as they add significant complexity without being prerequisites for the core budgeting-allocation-variance workflow. The module explicitly does not recreate entities already owned by other modules (fiscal calendar from finance-ledger, GL accounts from coa-management, manufacturing variances from manufacturing).
+
+## Module Dependencies
+
+- `primitives` — Currency definitions for multi-currency budget amounts and variance values
+- `organization` — Company scoping for all management accounting entities; Department/Site as optional mapping targets for cost centers and profit centers
+- `coa-management` — GL account references for primary cost elements, budget line items, and allocation target accounts
+- `finance-ledger` — Fiscal year/period alignment for budget periods; journal entry data as source of actuals; subledger integration pattern for posting allocation journal entries
+- `purchase` — Commitment event consumption for budgetary control: PO confirmation creates commitments, goods receipt and invoice match consume commitments, PO cancellation releases commitments
+- `user-management` — Permission definitions for budget creation, allocation execution, and report access
+- `audit` — Audit trail for budget lifecycle transitions, allocation runs, and variance postings

package/src/modules/accounting/command/activateBudget.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateBudget";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateBudget = defineCommand(permissions.activateBudget, run);

package/src/modules/accounting/command/activateBudget.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BudgetNotFoundError,
+  InvalidStateError,
+  DuplicateActiveBudgetError,
+} from "../lib/errors.generated";
+import { approvedBudget, baseBudget, activeBudget, basePlanVersion } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./activateBudget";
+
+const forecastPlanVersion = { ...basePlanVersion, id: "plan-version-forecast", type: "FORECAST" };
+const simulationPlanVersion = { ...basePlanVersion, id: "plan-version-sim", type: "SIMULATION" };
+
+describe("activateBudget", () => {
+  it("activates an APPROVED budget transitioning it to ACTIVE status", async () => {
+    const activatedBudget = { ...approvedBudget, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion) // plan version type BUDGET
+      .mockReturnValueOnce(undefined); // no existing active
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("enables funds checking upon activation", async () => {
+    const activatedBudget = { ...approvedBudget, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion)
+      .mockReturnValueOnce(undefined);
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("returns error when budget does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { budgetId: "missing" }, commandCtx);
+
+    expectErr(result, BudgetNotFoundError);
+  });
+
+  it("returns error when budget is not in APPROVED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBudget); // DRAFT
+
+    const result = await run(db, { budgetId: baseBudget.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when another ACTIVE BUDGET exists for the same cost object and fiscal year", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion) // type BUDGET
+      .mockReturnValueOnce(activeBudget) // existing active
+      .mockReturnValueOnce(basePlanVersion); // existing active's plan version is also BUDGET
+    // no update mock needed — should return error
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    expectErr(result, DuplicateActiveBudgetError);
+  });
+
+  it("allows multiple ACTIVE FORECAST versions for the same cost object and fiscal year", async () => {
+    const forecastApproved = { ...approvedBudget, planVersionId: forecastPlanVersion.id };
+    const activatedBudget = { ...forecastApproved, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(forecastApproved).mockReturnValueOnce(forecastPlanVersion); // type FORECAST — skip uniqueness check
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("allows multiple ACTIVE SIMULATION versions for the same cost object and fiscal year", async () => {
+    const simApproved = { ...approvedBudget, planVersionId: simulationPlanVersion.id };
+    const activatedBudget = { ...simApproved, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(simApproved).mockReturnValueOnce(simulationPlanVersion); // type SIMULATION — skip uniqueness check
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.budget.status).toBe("ACTIVE");
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const activatedBudget = { ...approvedBudget, status: "ACTIVE" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(approvedBudget)
+      .mockReturnValueOnce(basePlanVersion)
+      .mockReturnValueOnce(undefined);
+    spies.update.mockReturnValueOnce(activatedBudget);
+
+    const result = await run(db, { budgetId: approvedBudget.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/accounting/command/activateBudget.ts

@@ -0,0 +1,77 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BudgetNotFoundError,
+  InvalidStateError,
+  DuplicateActiveBudgetError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ActivateBudgetInput {
+  budgetId: string;
+}
+
+export async function run(db: Transaction, input: ActivateBudgetInput, ctx: CommandContext) {
+  void ctx;
+
+  // Fetch budget with lock
+  const budget = await db
+    .selectFrom("Budget")
+    .where("id", "=", input.budgetId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!budget) {
+    return err(new BudgetNotFoundError(input.budgetId));
+  }
+
+  if (budget.status !== "APPROVED") {
+    return err(new InvalidStateError(input.budgetId));
+  }
+
+  // Check plan version type — only BUDGET type needs uniqueness check
+  const planVersion = await db
+    .selectFrom("PlanVersion")
+    .where("id", "=", budget.planVersionId)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (planVersion?.type === "BUDGET") {
+    // Check no other ACTIVE budget of type BUDGET exists for same cost object and fiscal year
+    const existingActive = await db
+      .selectFrom("Budget")
+      .where("costObjectType", "=", budget.costObjectType)
+      .where("costObjectId", "=", budget.costObjectId)
+      .where("fiscalYearId", "=", budget.fiscalYearId)
+      .where("status", "=", "ACTIVE")
+      .where("id", "!=", input.budgetId)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (existingActive) {
+      // Verify the existing active budget is also of type BUDGET
+      const existingPlanVersion = await db
+        .selectFrom("PlanVersion")
+        .where("id", "=", existingActive.planVersionId)
+        .selectAll()
+        .executeTakeFirst();
+
+      if (existingPlanVersion?.type === "BUDGET") {
+        return err(new DuplicateActiveBudgetError(input.budgetId));
+      }
+    }
+  }
+
+  // Transition to ACTIVE (which enables funds checking)
+  const updated = await db
+    .updateTable("Budget")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.budgetId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ budget: updated! });
+}

package/src/modules/accounting/command/activateCostElement.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateCostElement";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateCostElement = defineCommand(permissions.activateCostElement, run);