@tailor-platform/erp-kit 0.5.1 → 0.7.0

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

@@ -0,0 +1,385 @@
+import { describe, it, expect } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import {
+  JournalLineNotFoundError,
+  InvalidStatusForLineUpdateError,
+  AccountNotFoundError,
+  AccountNotActiveError,
+  InvalidDebitCreditError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
+import {
+  baseJournalEntry,
+  postedJournalEntry,
+  reversedJournalEntry,
+  baseJournalLine,
+  baseAccount2,
+  inactiveAccount,
+  baseCurrency,
+} from "../testing/fixtures";
+import { run } from "./updateJournalLine";
+
+describe("updateJournalLine", () => {
+  it("returns error when journal line does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        id: "missing-line",
+        accountId: undefined,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, JournalLineNotFoundError);
+  });
+
+  it("returns error when parent journal entry is in POSTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const postedLine = { ...baseJournalLine, journalEntryId: postedJournalEntry.id };
+    spies.select.mockReturnValueOnce(postedLine).mockReturnValueOnce(postedJournalEntry);
+
+    const result = await run(
+      db,
+      {
+        id: postedLine.id,
+        accountId: undefined,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidStatusForLineUpdateError);
+  });
+
+  it("returns error when parent journal entry is in REVERSED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reversedLine = { ...baseJournalLine, journalEntryId: reversedJournalEntry.id };
+    spies.select.mockReturnValueOnce(reversedLine).mockReturnValueOnce(reversedJournalEntry);
+
+    const result = await run(
+      db,
+      {
+        id: reversedLine.id,
+        accountId: undefined,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidStatusForLineUpdateError);
+  });
+
+  it("returns error when updated GL account does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseJournalLine)
+      .mockReturnValueOnce(baseJournalEntry)
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: "missing-account",
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, AccountNotFoundError);
+  });
+
+  it("returns error when updated GL account is not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseJournalLine)
+      .mockReturnValueOnce(baseJournalEntry)
+      .mockReturnValueOnce(inactiveAccount);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: inactiveAccount.id,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, AccountNotActiveError);
+  });
+
+  it("returns error when updated debit/credit values are invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseJournalLine).mockReturnValueOnce(baseJournalEntry);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: 1000,
+        creditAmount: 500,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidDebitCreditError);
+  });
+
+  it("returns error when updated currency does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseJournalLine)
+      .mockReturnValueOnce(baseJournalEntry)
+      .mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: "missing-currency",
+        exchangeRate: 1.5,
+      },
+      commandCtx,
+    );
+
+    expectErr(result, CurrencyNotFoundError);
+  });
+
+  it("updates GL account reference on a journal line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = { ...baseJournalLine, accountId: baseAccount2.id };
+    spies.select
+      .mockReturnValueOnce(baseJournalLine)
+      .mockReturnValueOnce(baseJournalEntry)
+      .mockReturnValueOnce(baseAccount2);
+    spies.update.mockReturnValueOnce(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: baseAccount2.id,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.journalLine.accountId).toBe(baseAccount2.id);
+  });
+
+  it("updates debit amount on a journal line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = {
+      ...baseJournalLine,
+      debitAmount: 2000,
+      functionalDebitAmount: 2000,
+    };
+    spies.select.mockReturnValueOnce(baseJournalLine).mockReturnValueOnce(baseJournalEntry);
+    spies.update.mockReturnValueOnce(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: 2000,
+        creditAmount: null,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.journalLine.debitAmount).toBe(2000);
+  });
+
+  it("updates credit amount on a journal line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = {
+      ...baseJournalLine,
+      debitAmount: null,
+      creditAmount: 1500,
+      functionalDebitAmount: null,
+      functionalCreditAmount: 1500,
+    };
+    spies.select.mockReturnValueOnce(baseJournalLine).mockReturnValueOnce(baseJournalEntry);
+    spies.update.mockReturnValueOnce(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: null,
+        creditAmount: 1500,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.journalLine.creditAmount).toBe(1500);
+  });
+
+  it("updates currency and exchange rate on a journal line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = {
+      ...baseJournalLine,
+      currencyCode: baseCurrency.code,
+      exchangeRate: 1.5,
+      functionalDebitAmount: 1500,
+    };
+    spies.select
+      .mockReturnValueOnce(baseJournalLine)
+      .mockReturnValueOnce(baseJournalEntry)
+      .mockReturnValueOnce(baseCurrency);
+    spies.update.mockReturnValueOnce(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: undefined,
+        currencyCode: baseCurrency.code,
+        exchangeRate: 1.5,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.journalLine.currencyCode).toBe(baseCurrency.code);
+    expect(value.journalLine.exchangeRate).toBe(1.5);
+  });
+
+  it("recomputes functional currency amount after update", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = {
+      ...baseJournalLine,
+      debitAmount: 500,
+      currencyCode: baseCurrency.code,
+      exchangeRate: 2.0,
+      functionalDebitAmount: 1000,
+    };
+    spies.select
+      .mockReturnValueOnce(baseJournalLine)
+      .mockReturnValueOnce(baseJournalEntry)
+      .mockReturnValueOnce(baseCurrency);
+    spies.update.mockReturnValueOnce(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: 500,
+        creditAmount: null,
+        description: undefined,
+        currencyCode: baseCurrency.code,
+        exchangeRate: 2.0,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.journalLine).toEqual(updatedLine);
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates line-level description", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = {
+      ...baseJournalLine,
+      description: "Updated description",
+    };
+    spies.select.mockReturnValueOnce(baseJournalLine).mockReturnValueOnce(baseJournalEntry);
+    spies.update.mockReturnValueOnce(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: undefined,
+        creditAmount: undefined,
+        description: "Updated description",
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.journalLine.description).toBe("Updated description");
+  });
+
+  it("emits audit event recording previous and new field values and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = { ...baseJournalLine, debitAmount: 2000, functionalDebitAmount: 2000 };
+    spies.select.mockReturnValueOnce(baseJournalLine).mockReturnValueOnce(baseJournalEntry);
+    spies.update.mockReturnValueOnce(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseJournalLine.id,
+        accountId: undefined,
+        debitAmount: 2000,
+        creditAmount: null,
+        description: undefined,
+        currencyCode: undefined,
+        exchangeRate: undefined,
+      },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,155 @@
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  JournalLineNotFoundError,
+  InvalidStatusForLineUpdateError,
+  AccountNotFoundError,
+  AccountNotActiveError,
+  InvalidDebitCreditError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
+
+export interface UpdateJournalLineInput {
+  id: string;
+  accountId?: string;
+  debitAmount?: number | null;
+  creditAmount?: number | null;
+  description?: string;
+  currencyCode?: string | null;
+  exchangeRate?: number | null;
+}
+
+export async function run(db: Transaction, input: UpdateJournalLineInput, ctx: CommandContext) {
+  // 1. Fetch journal line
+  const existing = await db
+    .selectFrom("JournalLine")
+    .selectAll()
+    .where("id", "=", input.id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new JournalLineNotFoundError(input.id));
+  }
+
+  // 2. Validate parent entry is DRAFT
+  const entry = await db
+    .selectFrom("JournalEntry")
+    .selectAll()
+    .where("id", "=", existing.journalEntryId)
+    .executeTakeFirst();
+
+  if (entry?.status !== "DRAFT") {
+    return err(new InvalidStatusForLineUpdateError(input.id));
+  }
+
+  // 3. Validate updated account if provided
+  if (input.accountId !== undefined) {
+    const account = await db
+      .selectFrom("Account")
+      .selectAll()
+      .where("id", "=", input.accountId)
+      .executeTakeFirst();
+
+    if (!account) {
+      return err(new AccountNotFoundError(input.accountId));
+    }
+
+    if (account.status !== "ACTIVE") {
+      return err(new AccountNotActiveError(input.accountId));
+    }
+  }
+
+  // 4. Resolve effective debit/credit amounts
+  const amountsProvided = input.debitAmount !== undefined || input.creditAmount !== undefined;
+
+  const effectiveDebit = input.debitAmount !== undefined ? input.debitAmount : existing.debitAmount;
+  const effectiveCredit =
+    input.creditAmount !== undefined ? input.creditAmount : existing.creditAmount;
+
+  if (amountsProvided) {
+    const hasDebit = effectiveDebit !== null && effectiveDebit !== undefined;
+    const hasCredit = effectiveCredit !== null && effectiveCredit !== undefined;
+
+    if (hasDebit && hasCredit) {
+      return err(new InvalidDebitCreditError(input.id));
+    }
+
+    if (!hasDebit && !hasCredit) {
+      return err(new InvalidDebitCreditError(input.id));
+    }
+
+    if (hasDebit && effectiveDebit <= 0) {
+      return err(new InvalidDebitCreditError(input.id));
+    }
+
+    if (hasCredit && effectiveCredit <= 0) {
+      return err(new InvalidDebitCreditError(input.id));
+    }
+  }
+
+  // 5. Validate currency if provided
+  const currencyProvided = input.currencyCode !== undefined;
+  const effectiveCurrencyCode = currencyProvided ? input.currencyCode : existing.currencyCode;
+
+  if (currencyProvided && input.currencyCode) {
+    const currency = await db
+      .selectFrom("Currency")
+      .selectAll()
+      .where("code", "=", input.currencyCode)
+      .executeTakeFirst();
+
+    if (!currency?.isActive) {
+      return err(new CurrencyNotFoundError(input.currencyCode));
+    }
+  }
+
+  // 6. Compute functional amounts
+  const effectiveExchangeRate =
+    input.exchangeRate !== undefined ? (input.exchangeRate ?? 1.0) : (existing.exchangeRate ?? 1.0);
+
+  const finalDebit = amountsProvided ? effectiveDebit : existing.debitAmount;
+  const finalCredit = amountsProvided ? effectiveCredit : existing.creditAmount;
+  const functionalDebitAmount = finalDebit !== null ? finalDebit * effectiveExchangeRate : null;
+  const functionalCreditAmount = finalCredit !== null ? finalCredit * effectiveExchangeRate : null;
+
+  // 7. Build update set
+  const updateSet: Record<string, unknown> = {
+    updatedAt: new Date(),
+  };
+
+  if (input.accountId !== undefined) {
+    updateSet.accountId = input.accountId;
+  }
+  if (input.debitAmount !== undefined) {
+    updateSet.debitAmount = input.debitAmount;
+  }
+  if (input.creditAmount !== undefined) {
+    updateSet.creditAmount = input.creditAmount;
+  }
+  if (input.description !== undefined) {
+    updateSet.description = input.description;
+  }
+  if (currencyProvided) {
+    updateSet.currencyCode = effectiveCurrencyCode;
+  }
+  if (input.exchangeRate !== undefined) {
+    updateSet.exchangeRate = input.exchangeRate;
+  }
+
+  updateSet.functionalDebitAmount = functionalDebitAmount;
+  updateSet.functionalCreditAmount = functionalCreditAmount;
+
+  // 8. Update journal line
+  const journalLine = await db
+    .updateTable("JournalLine")
+    .set(updateSet)
+    .where("id", "=", input.id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  // Emit audit event recording previous and new field values, acting user, and timestamp
+  void ctx;
+
+  return ok({ journalLine });
+}

package/src/modules/finance-ledger/command/verifySubledgerTransfers.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 "./verifySubledgerTransfers";
+
+export const verifySubledgerTransfers = defineCommand(permissions.verifySubledgerTransfers, run);