@tailor-platform/erp-kit 0.6.0 → 0.7.0

package/src/modules/finance-ledger/command/finalizeFinancialStatement.ts

@@ -0,0 +1,73 @@
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  FinancialStatementNotFoundError,
+  InvalidStatusTransitionError,
+} from "../lib/errors.generated";
+
+export interface FinalizeFinancialStatementInput {
+  id: string;
+}
+
+interface AuditEntry {
+  type: string;
+  from?: string;
+  to?: string;
+  actorId?: string;
+}
+
+/**
+ * Function: finalizeFinancialStatement
+ *
+ * Transitions a financial statement from DRAFT to FINALIZED status.
+ * Once finalized, the statement becomes immutable and cannot be
+ * modified or regenerated.
+ */
+export async function run(
+  db: Transaction,
+  input: FinalizeFinancialStatementInput,
+  ctx: CommandContext,
+) {
+  const { id } = input;
+  const auditTrail: AuditEntry[] = [];
+
+  // 1. Find FinancialStatement by id with forUpdate()
+  const financialStatement = await db
+    .selectFrom("FinancialStatement")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!financialStatement) {
+    return err(new FinancialStatementNotFoundError(id));
+  }
+
+  // 2. Validate status is DRAFT
+  if (financialStatement.status !== "DRAFT") {
+    return err(new InvalidStatusTransitionError(id));
+  }
+
+  // 3. Update to FINALIZED, set finalizedAt to now
+  const now = new Date();
+  const updatedStatement = await db
+    .updateTable("FinancialStatement")
+    .set({
+      status: "FINALIZED",
+      finalizedAt: now,
+      updatedAt: now,
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 4. Record audit event
+  auditTrail.push({
+    type: "STATUS_TRANSITION",
+    from: "DRAFT",
+    to: "FINALIZED",
+    actorId: ctx.actorId,
+  });
+
+  return ok({ financialStatement: updatedStatement!, auditTrail });
+}

package/src/modules/finance-ledger/command/generateFinancialStatement.generated.ts

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

package/src/modules/finance-ledger/command/generateFinancialStatement.test.ts

@@ -0,0 +1,311 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  ChartOfAccountsNotFoundError,
+  InvalidStatementTypeError,
+  InvalidReportingParametersError,
+  NoTrialBalanceDataError,
+  ComparativeDataUnavailableError,
+} from "../lib/errors.generated";
+import {
+  baseCompany,
+  baseChartOfAccounts,
+  baseTrialBalance,
+  baseTrialBalanceLine,
+  baseFinancialStatement,
+  baseAccount,
+  revenueAccount,
+  expenseAccount,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run, type GenerateFinancialStatementInput } from "./generateFinancialStatement";
+
+describe("generateFinancialStatement", () => {
+  const balanceSheetInput: GenerateFinancialStatementInput = {
+    companyId: baseCompany.id,
+    chartOfAccountsId: baseChartOfAccounts.id,
+    trialBalanceId: baseTrialBalance.id,
+    statementType: "BALANCE_SHEET",
+    reportingDate: new Date("2024-01-31"),
+  };
+
+  const profitAndLossInput: GenerateFinancialStatementInput = {
+    companyId: baseCompany.id,
+    chartOfAccountsId: baseChartOfAccounts.id,
+    trialBalanceId: baseTrialBalance.id,
+    statementType: "PROFIT_AND_LOSS",
+    startDate: new Date("2024-01-01"),
+    endDate: new Date("2024-01-31"),
+  };
+
+  it("returns error when company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...balanceSheetInput, companyId: "missing" }, commandCtx);
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when company is not ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseCompany, status: "INACTIVE" });
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    expectErr(result, CompanyNotFoundError);
+  });
+
+  it("returns error when CoA does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company lookup
+      .mockReturnValueOnce(undefined); // CoA lookup
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    expectErr(result, ChartOfAccountsNotFoundError);
+  });
+
+  it("returns error when CoA is not ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany)
+      .mockReturnValueOnce({ ...baseChartOfAccounts, status: "INACTIVE" });
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    expectErr(result, ChartOfAccountsNotFoundError);
+  });
+
+  it("returns error for invalid statement type", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(baseChartOfAccounts);
+
+    const result = await run(
+      db,
+      { ...balanceSheetInput, statementType: "INVALID_TYPE" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidStatementTypeError);
+  });
+
+  it("returns error when BALANCE_SHEET is missing reportingDate", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(baseChartOfAccounts);
+
+    const input: GenerateFinancialStatementInput = {
+      ...balanceSheetInput,
+      reportingDate: undefined,
+    };
+    const result = await run(db, input, commandCtx);
+
+    expectErr(result, InvalidReportingParametersError);
+  });
+
+  it("returns error when PROFIT_AND_LOSS is missing date range", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(baseChartOfAccounts);
+
+    const input: GenerateFinancialStatementInput = {
+      companyId: baseCompany.id,
+      chartOfAccountsId: baseChartOfAccounts.id,
+      trialBalanceId: baseTrialBalance.id,
+      statementType: "PROFIT_AND_LOSS",
+    };
+    const result = await run(db, input, commandCtx);
+
+    expectErr(result, InvalidReportingParametersError);
+  });
+
+  it("returns error when CASH_FLOW is missing cashFlowMethod", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompany).mockReturnValueOnce(baseChartOfAccounts);
+
+    const input: GenerateFinancialStatementInput = {
+      companyId: baseCompany.id,
+      chartOfAccountsId: baseChartOfAccounts.id,
+      trialBalanceId: baseTrialBalance.id,
+      statementType: "CASH_FLOW",
+      startDate: new Date("2024-01-01"),
+      endDate: new Date("2024-01-31"),
+    };
+    const result = await run(db, input, commandCtx);
+
+    expectErr(result, InvalidReportingParametersError);
+  });
+
+  it("returns error when trial balance does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company
+      .mockReturnValueOnce(baseChartOfAccounts) // CoA
+      .mockReturnValueOnce(undefined); // trial balance
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    expectErr(result, NoTrialBalanceDataError);
+  });
+
+  it("returns error when comparative trial balance does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company
+      .mockReturnValueOnce(baseChartOfAccounts) // CoA
+      .mockReturnValueOnce(baseTrialBalance) // trial balance
+      .mockReturnValueOnce(undefined); // comparative trial balance
+
+    const result = await run(
+      db,
+      { ...balanceSheetInput, comparativePeriodTrialBalanceId: "missing-comparative" },
+      commandCtx,
+    );
+
+    expectErr(result, ComparativeDataUnavailableError);
+  });
+
+  it("successfully generates a BALANCE_SHEET financial statement", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company
+      .mockReturnValueOnce(baseChartOfAccounts) // CoA
+      .mockReturnValueOnce(baseTrialBalance) // trial balance
+      .mockReturnValueOnce([baseTrialBalanceLine]) // trial balance lines (execute)
+      .mockReturnValueOnce(baseAccount); // account lookup for line
+    spies.insert
+      .mockReturnValueOnce(baseFinancialStatement) // FinancialStatement insert
+      .mockReturnValueOnce({
+        ...baseTrialBalanceLine,
+        id: "fs-line-1",
+        financialStatementId: baseFinancialStatement.id,
+      }) // DETAIL line item insert
+      .mockReturnValueOnce({
+        id: "fs-line-subtotal-1",
+        financialStatementId: baseFinancialStatement.id,
+        lineType: "SUBTOTAL",
+      }); // SUBTOTAL line item insert
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.financialStatement).toEqual(baseFinancialStatement);
+    expect(value.auditTrail).toBeDefined();
+    expect(value.auditTrail.length).toBeGreaterThan(0);
+  });
+
+  it("successfully generates a PROFIT_AND_LOSS financial statement", async () => {
+    const plTrialBalanceLine = {
+      ...baseTrialBalanceLine,
+      id: "tb-line-revenue",
+      accountId: revenueAccount.id,
+      accountCode: revenueAccount.code,
+      accountName: revenueAccount.name,
+      closingBalance: 8000,
+    };
+    const plExpenseLine = {
+      ...baseTrialBalanceLine,
+      id: "tb-line-expense",
+      accountId: expenseAccount.id,
+      accountCode: expenseAccount.code,
+      accountName: expenseAccount.name,
+      closingBalance: 3000,
+    };
+    const plFinancialStatement = {
+      ...baseFinancialStatement,
+      id: "financial-statement-pl",
+      statementType: "PROFIT_AND_LOSS",
+      reportingDate: null,
+      startDate: new Date("2024-01-01"),
+      endDate: new Date("2024-01-31"),
+    };
+
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company
+      .mockReturnValueOnce(baseChartOfAccounts) // CoA
+      .mockReturnValueOnce(baseTrialBalance) // trial balance
+      .mockReturnValueOnce([plTrialBalanceLine, plExpenseLine]) // trial balance lines
+      .mockReturnValueOnce(revenueAccount) // account lookup for revenue line
+      .mockReturnValueOnce(expenseAccount); // account lookup for expense line
+    spies.insert
+      .mockReturnValueOnce(plFinancialStatement) // FinancialStatement insert
+      .mockReturnValueOnce({}) // DETAIL line item 1 (revenue)
+      .mockReturnValueOnce({}) // DETAIL line item 2 (expense)
+      .mockReturnValueOnce({}) // SUBTOTAL line item for Revenue
+      .mockReturnValueOnce({}); // SUBTOTAL line item for Expenses
+
+    const result = await run(db, profitAndLossInput, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.financialStatement.statementType).toBe("PROFIT_AND_LOSS");
+  });
+
+  it("returns error when trial balance has no lines", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company
+      .mockReturnValueOnce(baseChartOfAccounts) // CoA
+      .mockReturnValueOnce(baseTrialBalance) // trial balance exists
+      .mockReturnValueOnce([]); // but has no lines
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    expectErr(result, NoTrialBalanceDataError);
+  });
+
+  it("emits audit event recording the generation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company
+      .mockReturnValueOnce(baseChartOfAccounts) // CoA
+      .mockReturnValueOnce(baseTrialBalance) // trial balance
+      .mockReturnValueOnce([baseTrialBalanceLine]) // trial balance lines
+      .mockReturnValueOnce(baseAccount); // account lookup for line
+    spies.insert
+      .mockReturnValueOnce(baseFinancialStatement) // FinancialStatement insert
+      .mockReturnValueOnce({}) // DETAIL line item
+      .mockReturnValueOnce({}); // SUBTOTAL line item
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.auditTrail).toEqual([
+      {
+        type: "FINANCIAL_STATEMENT_GENERATED",
+        statementType: "BALANCE_SHEET",
+        actorId: commandCtx.actorId,
+      },
+    ]);
+  });
+
+  it("generates subtotal lines for each section", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseCompany) // company
+      .mockReturnValueOnce(baseChartOfAccounts) // CoA
+      .mockReturnValueOnce(baseTrialBalance) // trial balance
+      .mockReturnValueOnce([baseTrialBalanceLine]) // trial balance lines
+      .mockReturnValueOnce(baseAccount); // account lookup for line
+    const subtotalLineItem = {
+      id: "fs-line-subtotal-1",
+      financialStatementId: baseFinancialStatement.id,
+      lineType: "SUBTOTAL",
+      label: "Total Assets",
+      amount: 3000,
+      sectionType: "Assets",
+    };
+    spies.insert
+      .mockReturnValueOnce(baseFinancialStatement) // FinancialStatement insert
+      .mockReturnValueOnce({}) // DETAIL line item
+      .mockReturnValueOnce(subtotalLineItem); // SUBTOTAL line item
+
+    const result = await run(db, balanceSheetInput, commandCtx);
+
+    expectOk(result);
+    // Verify insert was called for both DETAIL and SUBTOTAL lines (2 line item inserts)
+    expect(spies.insert).toHaveBeenCalledTimes(3); // 1 statement + 2 line items
+  });
+});

package/src/modules/finance-ledger/command/generateFinancialStatement.ts

@@ -0,0 +1,275 @@
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  ChartOfAccountsNotFoundError,
+  InvalidStatementTypeError,
+  InvalidReportingParametersError,
+  NoTrialBalanceDataError,
+  ComparativeDataUnavailableError,
+} from "../lib/errors.generated";
+
+export interface GenerateFinancialStatementInput {
+  companyId: string;
+  chartOfAccountsId: string;
+  trialBalanceId: string;
+  statementType: string;
+  reportingDate?: Date;
+  startDate?: Date;
+  endDate?: Date;
+  cashFlowMethod?: string;
+  comparativePeriodTrialBalanceId?: string;
+}
+
+const VALID_STATEMENT_TYPES = ["BALANCE_SHEET", "PROFIT_AND_LOSS", "CASH_FLOW"] as const;
+
+const BALANCE_SHEET_CLASSIFICATIONS = ["ASSET", "LIABILITY", "EQUITY", "RETAINED_EARNINGS"];
+const PROFIT_AND_LOSS_CLASSIFICATIONS = ["REVENUE", "EXPENSE"];
+const CASH_FLOW_CLASSIFICATIONS = ["ASSET", "LIABILITY", "REVENUE", "EXPENSE"];
+
+function getClassificationsForType(statementType: string): string[] {
+  switch (statementType) {
+    case "BALANCE_SHEET":
+      return BALANCE_SHEET_CLASSIFICATIONS;
+    case "PROFIT_AND_LOSS":
+      return PROFIT_AND_LOSS_CLASSIFICATIONS;
+    case "CASH_FLOW":
+      return CASH_FLOW_CLASSIFICATIONS;
+    default:
+      return [];
+  }
+}
+
+function getSectionType(classification: string, statementType: string): string {
+  if (statementType === "BALANCE_SHEET") {
+    if (classification === "ASSET") return "Assets";
+    if (classification === "LIABILITY") return "Liabilities";
+    return "Equity";
+  }
+  if (statementType === "PROFIT_AND_LOSS") {
+    if (classification === "REVENUE") return "Revenue";
+    return "Expenses";
+  }
+  // CASH_FLOW
+  if (classification === "REVENUE" || classification === "EXPENSE") return "Operating Activities";
+  if (classification === "ASSET") return "Investing Activities";
+  return "Financing Activities";
+}
+
+interface AuditEntry {
+  type: string;
+  statementType?: string;
+  actorId?: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: GenerateFinancialStatementInput,
+  ctx: CommandContext,
+) {
+  const auditTrail: AuditEntry[] = [];
+
+  // 1. Validate company exists and is ACTIVE
+  const company = await db
+    .selectFrom("Company" as never)
+    .where("id" as never, "=", input.companyId as never)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!company || (company as Record<string, unknown>).status !== "ACTIVE") {
+    return err(new CompanyNotFoundError(input.companyId));
+  }
+
+  // 2. Validate CoA exists and is ACTIVE
+  const coa = await db
+    .selectFrom("ChartOfAccounts" as never)
+    .where("id" as never, "=", input.chartOfAccountsId as never)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!coa || (coa as Record<string, unknown>).status !== "ACTIVE") {
+    return err(new ChartOfAccountsNotFoundError(input.chartOfAccountsId));
+  }
+
+  // 3. Validate statementType is valid
+  if (
+    !VALID_STATEMENT_TYPES.includes(input.statementType as (typeof VALID_STATEMENT_TYPES)[number])
+  ) {
+    return err(new InvalidStatementTypeError(input.statementType));
+  }
+
+  // 4. Validate reporting parameters
+  if (input.statementType === "BALANCE_SHEET") {
+    if (!input.reportingDate) {
+      return err(new InvalidReportingParametersError(input.statementType));
+    }
+  } else {
+    // PROFIT_AND_LOSS and CASH_FLOW need startDate + endDate
+    if (!input.startDate || !input.endDate) {
+      return err(new InvalidReportingParametersError(input.statementType));
+    }
+    if (input.statementType === "CASH_FLOW" && !input.cashFlowMethod) {
+      return err(new InvalidReportingParametersError(input.statementType));
+    }
+  }
+
+  // 5. Validate trial balance exists
+  const trialBalance = await db
+    .selectFrom("TrialBalance" as never)
+    .where("id" as never, "=", input.trialBalanceId as never)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!trialBalance) {
+    return err(new NoTrialBalanceDataError(input.trialBalanceId));
+  }
+
+  // 6. If comparativePeriodTrialBalanceId, validate it exists
+  if (input.comparativePeriodTrialBalanceId) {
+    const comparativeTb = await db
+      .selectFrom("TrialBalance" as never)
+      .where("id" as never, "=", input.comparativePeriodTrialBalanceId as never)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (!comparativeTb) {
+      return err(new ComparativeDataUnavailableError(input.comparativePeriodTrialBalanceId));
+    }
+  }
+
+  // 7. Fetch trial balance lines
+  const trialBalanceLines = (await db
+    .selectFrom("TrialBalanceLine" as never)
+    .where("trialBalanceId" as never, "=", input.trialBalanceId as never)
+    .selectAll()
+    .execute()) as Record<string, unknown>[];
+
+  if (trialBalanceLines.length === 0) {
+    return err(new NoTrialBalanceDataError(input.trialBalanceId));
+  }
+
+  // Fetch comparative lines if applicable
+  let comparativeLines: Record<string, unknown>[] = [];
+  if (input.comparativePeriodTrialBalanceId) {
+    comparativeLines = (await db
+      .selectFrom("TrialBalanceLine" as never)
+      .where("trialBalanceId" as never, "=", input.comparativePeriodTrialBalanceId as never)
+      .selectAll()
+      .execute()) as Record<string, unknown>[];
+  }
+
+  // Build a map of comparative amounts by accountId
+  const comparativeMap = new Map<string, number>();
+  for (const line of comparativeLines) {
+    comparativeMap.set(line.accountId as string, line.closingBalance as number);
+  }
+
+  // 8. Fetch accounts to get classification info
+  const classifications = getClassificationsForType(input.statementType);
+
+  // Build line items from trial balance lines, filtering by account classification
+  const now = new Date();
+  const lineItems: Record<string, unknown>[] = [];
+  let sortOrder = 0;
+
+  for (const tbLine of trialBalanceLines) {
+    // Look up the account to check classification
+    const account = await db
+      .selectFrom("Account" as never)
+      .where("id" as never, "=", tbLine.accountId as never)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (!account) continue;
+    const acct = account as Record<string, unknown>;
+    if (!classifications.includes(acct.classification as string)) continue;
+
+    sortOrder++;
+    lineItems.push({
+      accountId: tbLine.accountId,
+      accountGroupId: tbLine.accountGroupId ?? null,
+      label: tbLine.accountName as string,
+      amount: tbLine.closingBalance as number,
+      comparativeAmount: comparativeMap.get(tbLine.accountId as string) ?? null,
+      lineType: "DETAIL",
+      sectionType: tbLine.accountGroupId
+        ? getSectionType(acct.classification as string, input.statementType)
+        : "Unclassified",
+      sortOrder,
+    });
+  }
+
+  // Add SUBTOTAL lines for each section
+  const sectionTotals = new Map<string, number>();
+  for (const item of lineItems) {
+    const current = sectionTotals.get(item.sectionType as string) ?? 0;
+    sectionTotals.set(item.sectionType as string, current + (item.amount as number));
+  }
+
+  for (const [section, total] of sectionTotals) {
+    sortOrder++;
+    lineItems.push({
+      accountId: null,
+      accountGroupId: null,
+      label: `Total ${section}`,
+      amount: total,
+      comparativeAmount: null,
+      lineType: "SUBTOTAL",
+      sectionType: section,
+      sortOrder,
+    });
+  }
+
+  // 9. Insert FinancialStatement (DRAFT)
+  const financialStatement = await db
+    .insertInto("FinancialStatement")
+    .values({
+      companyId: input.companyId,
+      chartOfAccountsId: input.chartOfAccountsId,
+      trialBalanceId: input.trialBalanceId,
+      comparativePeriodTrialBalanceId: input.comparativePeriodTrialBalanceId ?? null,
+      statementType: input.statementType as never,
+      status: "DRAFT",
+      reportingDate: input.reportingDate ?? null,
+      startDate: input.startDate ?? null,
+      endDate: input.endDate ?? null,
+      cashFlowMethod: input.cashFlowMethod ?? null,
+      generatedAt: now,
+      finalizedAt: null,
+      createdAt: now,
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  // 10. Insert FinancialStatementLineItems
+  for (const item of lineItems) {
+    await db
+      .insertInto("FinancialStatementLineItem")
+      .values({
+        financialStatementId: financialStatement!.id,
+        accountId: item.accountId as string,
+        accountGroupId: item.accountGroupId as string | null,
+        label: item.label as string,
+        amount: item.amount as number,
+        comparativeAmount: item.comparativeAmount as number | null,
+        lineType: item.lineType as never,
+        sectionType: item.sectionType as string,
+        sortOrder: item.sortOrder as number,
+        createdAt: now,
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirst();
+  }
+
+  // Record audit event
+  auditTrail.push({
+    type: "FINANCIAL_STATEMENT_GENERATED",
+    statementType: input.statementType,
+    actorId: ctx.actorId,
+  });
+
+  // 11. Return financialStatement
+  return ok({ financialStatement: financialStatement!, auditTrail });
+}

package/src/modules/finance-ledger/command/generatePreliminaryStatements.generated.ts

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