@tailor-platform/erp-kit 0.6.0 → 0.7.0

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

@@ -0,0 +1,337 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  JournalEntryNotFoundError,
+  InvalidStatusForReversalError,
+  AlreadyReversedError,
+  InvalidPeriodStatusError,
+} from "../lib/errors.generated";
+import {
+  baseJournalEntry,
+  postedJournalEntry,
+  reversedJournalEntry,
+  baseJournalLine,
+  baseJournalLine2,
+  baseAccountingPeriod,
+  futureEnterablePeriod,
+  neverOpenedPeriod,
+  closedPeriod,
+  permanentlyClosedPeriod,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./reverseJournalEntry";
+
+const postedLines = [
+  { ...baseJournalLine, journalEntryId: postedJournalEntry.id },
+  { ...baseJournalLine2, journalEntryId: postedJournalEntry.id },
+];
+
+describe("reverseJournalEntry", () => {
+  it("returns error when journal entry does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, commandCtx);
+
+    expectErr(result, JournalEntryNotFoundError);
+  });
+
+  it("returns error when journal entry is in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseJournalEntry); // DRAFT entry
+
+    const result = await run(db, { id: baseJournalEntry.id }, commandCtx);
+
+    expectErr(result, InvalidStatusForReversalError);
+  });
+
+  it("returns error when journal entry is already REVERSED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(reversedJournalEntry);
+
+    const result = await run(db, { id: reversedJournalEntry.id }, commandCtx);
+
+    expectErr(result, AlreadyReversedError);
+  });
+
+  it("returns error when reversal period is in NEVER_OPENED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(neverOpenedPeriod); // period lookup
+
+    const result = await run(
+      db,
+      { id: postedJournalEntry.id, reversalPeriodId: neverOpenedPeriod.id },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidPeriodStatusError);
+  });
+
+  it("returns error when reversal period is in CLOSED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(closedPeriod); // period lookup
+
+    const result = await run(
+      db,
+      { id: postedJournalEntry.id, reversalPeriodId: closedPeriod.id },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidPeriodStatusError);
+  });
+
+  it("returns error when reversal period is in PERMANENTLY_CLOSED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(permanentlyClosedPeriod); // period lookup
+
+    const result = await run(
+      db,
+      { id: postedJournalEntry.id, reversalPeriodId: permanentlyClosedPeriod.id },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidPeriodStatusError);
+  });
+
+  it("creates mirror entry with all debit/credit amounts inverted", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reversalEntry = {
+      ...postedJournalEntry,
+      id: "reversal-entry-1",
+      status: "POSTED",
+      reversalOfId: postedJournalEntry.id,
+    };
+    const reversedOriginal = { ...postedJournalEntry, status: "REVERSED" };
+
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(baseAccountingPeriod); // period lookup (OPEN)
+    spies.insert
+      .mockReturnValueOnce(reversalEntry) // insert reversal entry
+      .mockImplementationOnce(() => [
+        // insert reversal lines
+        {
+          ...postedLines[0],
+          debitAmount: null,
+          creditAmount: 1000,
+          functionalDebitAmount: null,
+          functionalCreditAmount: 1000,
+        },
+        {
+          ...postedLines[1],
+          debitAmount: 1000,
+          creditAmount: null,
+          functionalDebitAmount: 1000,
+          functionalCreditAmount: null,
+        },
+      ]);
+    spies.update.mockReturnValueOnce(reversedOriginal); // update original entry
+
+    const result = await run(db, { id: postedJournalEntry.id }, commandCtx);
+
+    expectOk(result);
+    // Verify values were called with inverted amounts
+    expect(spies.values).toHaveBeenCalled();
+  });
+
+  it("reversal entry references the original entry", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reversalEntry = {
+      ...postedJournalEntry,
+      id: "reversal-entry-1",
+      status: "POSTED",
+      reversalOfId: postedJournalEntry.id,
+    };
+    const reversedOriginal = { ...postedJournalEntry, status: "REVERSED" };
+
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(baseAccountingPeriod); // period lookup (OPEN)
+    spies.insert
+      .mockReturnValueOnce(reversalEntry) // insert reversal entry
+      .mockImplementationOnce(() => []); // insert reversal lines
+    spies.update.mockReturnValueOnce(reversedOriginal); // update original entry
+
+    const result = await run(db, { id: postedJournalEntry.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.reversalEntry.reversalOfId).toBe(postedJournalEntry.id);
+  });
+
+  it("reversal entry is automatically posted", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reversalEntry = {
+      ...postedJournalEntry,
+      id: "reversal-entry-1",
+      status: "POSTED",
+      reversalOfId: postedJournalEntry.id,
+      postedAt: new Date(),
+    };
+    const reversedOriginal = { ...postedJournalEntry, status: "REVERSED" };
+
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(baseAccountingPeriod); // period lookup (OPEN)
+    spies.insert
+      .mockReturnValueOnce(reversalEntry) // insert reversal entry
+      .mockImplementationOnce(() => []); // insert reversal lines
+    spies.update.mockReturnValueOnce(reversedOriginal); // update original entry
+
+    const result = await run(db, { id: postedJournalEntry.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.reversalEntry.status).toBe("POSTED");
+    expect(value.reversalEntry.postedAt).toBeDefined();
+  });
+
+  it("original entry transitions from POSTED to REVERSED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reversalEntry = {
+      ...postedJournalEntry,
+      id: "reversal-entry-1",
+      status: "POSTED",
+      reversalOfId: postedJournalEntry.id,
+    };
+    const reversedOriginal = { ...postedJournalEntry, status: "REVERSED" };
+
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(baseAccountingPeriod); // period lookup (OPEN)
+    spies.insert
+      .mockReturnValueOnce(reversalEntry) // insert reversal entry
+      .mockImplementationOnce(() => []); // insert reversal lines
+    spies.update.mockReturnValueOnce(reversedOriginal); // update original entry
+
+    const result = await run(db, { id: postedJournalEntry.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.originalEntry.status).toBe("REVERSED");
+  });
+
+  it("reversal entry targets the specified accounting period", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reversalEntry = {
+      ...postedJournalEntry,
+      id: "reversal-entry-1",
+      status: "POSTED",
+      reversalOfId: postedJournalEntry.id,
+      accountingPeriodId: futureEnterablePeriod.id,
+    };
+    const reversedOriginal = { ...postedJournalEntry, status: "REVERSED" };
+
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(futureEnterablePeriod); // period lookup (FUTURE_ENTERABLE)
+    spies.insert
+      .mockReturnValueOnce(reversalEntry) // insert reversal entry
+      .mockImplementationOnce(() => []); // insert reversal lines
+    spies.update.mockReturnValueOnce(reversedOriginal); // update original entry
+
+    const result = await run(
+      db,
+      { id: postedJournalEntry.id, reversalPeriodId: futureEnterablePeriod.id },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.reversalEntry.accountingPeriodId).toBe(futureEnterablePeriod.id);
+  });
+
+  it("multi-currency lines are reversed with same currency and exchange rate", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const multiCurrencyLines = [
+      {
+        ...postedLines[0],
+        currencyCode: "currency-1",
+        exchangeRate: 1.5,
+        debitAmount: 1500,
+        functionalDebitAmount: 1000,
+      },
+      {
+        ...postedLines[1],
+        currencyCode: "currency-1",
+        exchangeRate: 1.5,
+        creditAmount: 1500,
+        functionalCreditAmount: 1000,
+      },
+    ];
+    const reversalEntry = {
+      ...postedJournalEntry,
+      id: "reversal-entry-1",
+      status: "POSTED",
+      reversalOfId: postedJournalEntry.id,
+    };
+    const reversedOriginal = { ...postedJournalEntry, status: "REVERSED" };
+
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => multiCurrencyLines) // journal lines
+      .mockReturnValueOnce(baseAccountingPeriod); // period lookup (OPEN)
+    spies.insert
+      .mockReturnValueOnce(reversalEntry) // insert reversal entry
+      .mockImplementationOnce(() => []); // insert reversal lines
+    spies.update.mockReturnValueOnce(reversedOriginal); // update original entry
+
+    const result = await run(db, { id: postedJournalEntry.id }, commandCtx);
+
+    expectOk(result);
+    // Verify that values() was called with reversed amounts preserving currency info
+    expect(spies.values).toHaveBeenCalled();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const insertedLines = spies.values.mock.calls[1]?.[0];
+    if (insertedLines) {
+      for (const line of insertedLines as { currencyCode: string; exchangeRate: number }[]) {
+        expect(line.currencyCode).toBe("currency-1");
+        expect(line.exchangeRate).toBe(1.5);
+      }
+    }
+  });
+
+  it("emits audit event recording status transition, reversal entry reference, and acting user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reversalEntry = {
+      ...postedJournalEntry,
+      id: "reversal-entry-1",
+      status: "POSTED",
+      reversalOfId: postedJournalEntry.id,
+    };
+    const reversedOriginal = { ...postedJournalEntry, status: "REVERSED" };
+
+    spies.select
+      .mockReturnValueOnce(postedJournalEntry) // entry lookup
+      .mockImplementationOnce(() => postedLines) // journal lines
+      .mockReturnValueOnce(baseAccountingPeriod); // period lookup (OPEN)
+    spies.insert
+      .mockReturnValueOnce(reversalEntry) // insert reversal entry
+      .mockImplementationOnce(() => []); // insert reversal lines
+    spies.update.mockReturnValueOnce(reversedOriginal); // update original entry
+
+    const result = await run(db, { id: postedJournalEntry.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.auditTrail).toBeDefined();
+    expect(value.auditTrail).toContainEqual(
+      expect.objectContaining({
+        type: "STATUS_TRANSITION",
+        from: "POSTED",
+        to: "REVERSED",
+        actorId: commandCtx.actorId,
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,140 @@
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  JournalEntryNotFoundError,
+  InvalidStatusForReversalError,
+  AlreadyReversedError,
+  InvalidPeriodStatusError,
+} from "../lib/errors.generated";
+
+export interface ReverseJournalEntryInput {
+  id: string;
+  reversalPeriodId?: string;
+}
+
+interface AuditEntry {
+  type: string;
+  from?: string;
+  to?: string;
+  actorId?: string;
+  reversalEntryId?: string;
+}
+
+const VALID_PERIOD_STATUSES = ["OPEN", "FUTURE_ENTERABLE"];
+
+/**
+ * Function: reverseJournalEntry
+ *
+ * Creates a mirror journal entry with all debit and credit amounts inverted
+ * from the original posted entry, and automatically posts the reversal entry.
+ * The original entry transitions from POSTED to REVERSED status.
+ */
+export async function run(db: Transaction, input: ReverseJournalEntryInput, ctx: CommandContext) {
+  const { id, reversalPeriodId } = input;
+  const auditTrail: AuditEntry[] = [];
+
+  // 1. Find journal entry
+  const journalEntry = await db
+    .selectFrom("JournalEntry")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!journalEntry) {
+    return err(new JournalEntryNotFoundError(id));
+  }
+
+  // 2. Validate status is POSTED
+  if (journalEntry.status === "REVERSED") {
+    return err(new AlreadyReversedError(id));
+  }
+
+  if (journalEntry.status !== "POSTED") {
+    return err(new InvalidStatusForReversalError(id));
+  }
+
+  // 3. Fetch original journal lines
+  const originalLines = await db
+    .selectFrom("JournalLine")
+    .selectAll()
+    .where("journalEntryId", "=", id)
+    .execute();
+
+  // 4. Determine target period and validate
+  const targetPeriodId = reversalPeriodId ?? journalEntry.accountingPeriodId;
+  const period = await db
+    .selectFrom("AccountingPeriod")
+    .selectAll()
+    .where("id", "=", targetPeriodId)
+    .executeTakeFirst();
+
+  if (!period || !VALID_PERIOD_STATUSES.includes(period.status)) {
+    return err(new InvalidPeriodStatusError(targetPeriodId));
+  }
+
+  // 5. Create reversal journal entry (auto-posted)
+  const now = new Date();
+  const reversalEntry = await db
+    .insertInto("JournalEntry")
+    .values({
+      companyId: journalEntry.companyId,
+      accountingPeriodId: targetPeriodId,
+      entryDate: now,
+      journalType: journalEntry.journalType,
+      referenceNumber: `REV-${journalEntry.referenceNumber}`,
+      status: "POSTED",
+      description: `Reversal of ${journalEntry.referenceNumber}`,
+      sourceDocumentReference: journalEntry.sourceDocumentReference,
+      adjustingEntryType: journalEntry.adjustingEntryType,
+      reversalOfId: journalEntry.id,
+      postedAt: now,
+      createdAt: now,
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  // 6. Create mirror journal lines with inverted amounts
+  const reversalLines = originalLines.map((line) => ({
+    journalEntryId: reversalEntry!.id,
+    accountId: line.accountId,
+    debitAmount: line.creditAmount,
+    creditAmount: line.debitAmount,
+    description: line.description,
+    currencyCode: line.currencyCode,
+    exchangeRate: line.exchangeRate,
+    functionalDebitAmount: line.functionalCreditAmount,
+    functionalCreditAmount: line.functionalDebitAmount,
+    createdAt: now,
+    updatedAt: null,
+  }));
+
+  await db.insertInto("JournalLine").values(reversalLines).returningAll().execute();
+
+  // 7. Transition original entry to REVERSED
+  const updatedOriginal = await db
+    .updateTable("JournalEntry")
+    .set({
+      status: "REVERSED",
+      updatedAt: now,
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 8. Record audit events
+  auditTrail.push({
+    type: "STATUS_TRANSITION",
+    from: "POSTED",
+    to: "REVERSED",
+    actorId: ctx.actorId,
+    reversalEntryId: reversalEntry!.id,
+  });
+
+  return ok({
+    reversalEntry: reversalEntry!,
+    originalEntry: updatedOriginal!,
+    auditTrail,
+  });
+}

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

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

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PeriodCloseNotFoundError,
+  InvalidStatusTransitionError,
+  PeriodPermanentlyClosedError,
+} from "../lib/errors.generated";
+import {
+  softLockedPeriodClose,
+  inProgressPeriodClose,
+  underReviewPeriodClose,
+  permanentlyClosedPeriodClose,
+  basePeriodClose,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./revertSoftLock";
+
+describe("revertSoftLock", () => {
+  it("returns error when PeriodClose record does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "non-existent" }, commandCtx);
+
+    expectErr(result, PeriodCloseNotFoundError);
+  });
+
+  it("returns error when PeriodClose is in NOT_STARTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePeriodClose);
+
+    const result = await run(db, { id: basePeriodClose.id }, commandCtx);
+
+    expectErr(result, InvalidStatusTransitionError);
+  });
+
+  it("returns error when PeriodClose is in IN_PROGRESS status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inProgressPeriodClose);
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    expectErr(result, InvalidStatusTransitionError);
+  });
+
+  it("returns error when PeriodClose is in UNDER_REVIEW status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(underReviewPeriodClose);
+
+    const result = await run(db, { id: underReviewPeriodClose.id }, commandCtx);
+
+    expectErr(result, InvalidStatusTransitionError);
+  });
+
+  it("returns error when PeriodClose is PERMANENTLY_CLOSED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(permanentlyClosedPeriodClose);
+
+    const result = await run(db, { id: permanentlyClosedPeriodClose.id }, commandCtx);
+
+    expectErr(result, PeriodPermanentlyClosedError);
+  });
+
+  it("transitions SOFT_LOCKED period close to IN_PROGRESS", async () => {
+    const updatedPeriodClose = { ...softLockedPeriodClose, status: "IN_PROGRESS" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(softLockedPeriodClose);
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: softLockedPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.periodClose.status).toBe("IN_PROGRESS");
+  });
+
+  it("emits audit event recording status transition and acting user", async () => {
+    const updatedPeriodClose = { ...softLockedPeriodClose, status: "IN_PROGRESS" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(softLockedPeriodClose);
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: softLockedPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.auditTrail).toEqual([
+      {
+        type: "STATUS_TRANSITION",
+        from: "SOFT_LOCKED",
+        to: "IN_PROGRESS",
+        actorId: commandCtx.actorId,
+      },
+    ]);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,67 @@
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PeriodCloseNotFoundError,
+  PeriodPermanentlyClosedError,
+  InvalidStatusTransitionError,
+} from "../lib/errors.generated";
+
+export interface RevertSoftLockInput {
+  id: string;
+}
+
+/**
+ * Function: revertSoftLock
+ *
+ * Transitions a PeriodClose record from SOFT_LOCKED back to IN_PROGRESS status,
+ * allowing the close workflow to be revisited when errors are discovered.
+ * Only permitted before permanent close.
+ */
+export async function run(db: Transaction, input: RevertSoftLockInput, ctx: CommandContext) {
+  const { id } = input;
+
+  // 1. Find PeriodClose record
+  const periodClose = await db
+    .selectFrom("PeriodClose")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!periodClose) {
+    return err(new PeriodCloseNotFoundError(id));
+  }
+
+  // 2. Reject permanently closed periods
+  if (periodClose.status === "PERMANENTLY_CLOSED") {
+    return err(new PeriodPermanentlyClosedError(id));
+  }
+
+  // 3. Validate status is SOFT_LOCKED
+  if (periodClose.status !== "SOFT_LOCKED") {
+    return err(new InvalidStatusTransitionError(id));
+  }
+
+  // 4. Transition back to IN_PROGRESS and record acting user
+  const updated = await db
+    .updateTable("PeriodClose")
+    .set({
+      status: "IN_PROGRESS",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  // 5. Emit audit event recording status transition
+  const auditTrail = [
+    {
+      type: "STATUS_TRANSITION",
+      from: "SOFT_LOCKED",
+      to: "IN_PROGRESS",
+      actorId: ctx.actorId,
+    },
+  ];
+
+  return ok({ periodClose: updated, auditTrail });
+}

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