@tailor-platform/erp-kit 0.2.2 → 0.4.0

package/src/modules/coa-management/command/reactivateAccount.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AccountNotFoundError,
+  ChartOfAccountsArchivedError,
+  InvalidStateTransitionError,
+} from "../lib/errors.generated";
+import {
+  baseInactiveAccount,
+  baseDraftAccount,
+  baseActiveAccount,
+  baseActiveCoa,
+  baseArchivedCoa,
+} from "../testing/fixtures";
+import { run } from "./reactivateAccount";
+
+const ctx: CommandContext = {
+  actorId: "test-actor",
+  permissions: ["coa-management:reactivateAccount"],
+};
+
+describe("reactivateAccount", () => {
+  it("returns error when account does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AccountNotFoundError);
+    }
+  });
+
+  it("returns error when parent CoA is ARCHIVED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const accountInArchivedCoa = { ...baseInactiveAccount, chartOfAccountsId: baseArchivedCoa.id };
+    spies.select
+      .mockReturnValueOnce(accountInArchivedCoa) // account lookup
+      .mockReturnValueOnce(baseArchivedCoa); // CoA lookup
+
+    const result = await run(db, { id: accountInArchivedCoa.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ChartOfAccountsArchivedError);
+    }
+  });
+
+  it("returns error when account is DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseDraftAccount) // account lookup
+      .mockReturnValueOnce(baseActiveCoa); // CoA lookup
+
+    const result = await run(db, { id: baseDraftAccount.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("returns error when account is already ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseActiveAccount) // account lookup
+      .mockReturnValueOnce(baseActiveCoa); // CoA lookup
+
+    const result = await run(db, { id: baseActiveAccount.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("reactivates an INACTIVE account", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivated = { ...baseInactiveAccount, status: "ACTIVE", successorAccountId: null };
+    spies.select
+      .mockReturnValueOnce(baseInactiveAccount) // account lookup
+      .mockReturnValueOnce(baseActiveCoa); // CoA lookup
+    spies.update.mockReturnValue(reactivated);
+
+    const result = await run(db, { id: baseInactiveAccount.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.account.status).toBe("ACTIVE");
+    }
+  });
+
+  it("clears successor mapping on reactivation", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivated = { ...baseInactiveAccount, status: "ACTIVE", successorAccountId: null };
+    spies.select
+      .mockReturnValueOnce(baseInactiveAccount) // has successorAccountId
+      .mockReturnValueOnce(baseActiveCoa);
+    spies.update.mockReturnValue(reactivated);
+
+    const result = await run(db, { id: baseInactiveAccount.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.account.successorAccountId).toBeNull();
+    }
+  });
+
+  it("emits audit event recording status transition from INACTIVE to ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivated = { ...baseInactiveAccount, status: "ACTIVE", successorAccountId: null };
+    spies.select.mockReturnValueOnce(baseInactiveAccount).mockReturnValueOnce(baseActiveCoa);
+    spies.update.mockReturnValue(reactivated);
+
+    const result = await run(db, { id: baseInactiveAccount.id }, ctx);
+
+    // Audit event is emitted as part of successful reactivation
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.account.status).toBe("ACTIVE");
+    }
+  });
+});

package/src/modules/coa-management/command/reactivateAccount.ts

@@ -0,0 +1,123 @@
+import { randomUUID } from "node:crypto";
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AccountNotFoundError,
+  ChartOfAccountsNotActiveError,
+  ChartOfAccountsArchivedError,
+  InvalidStateTransitionError,
+} from "../lib/errors.generated";
+
+export interface ReactivateAccountInput {
+  id: string;
+  from?: string[];
+}
+
+export interface AuditCommands {
+  logAuditEvent: (
+    db: Transaction,
+    input: {
+      eventId: string;
+      actorType: string;
+      actorId: string;
+      entityType: string;
+      entityId: string;
+      operationType: string;
+      companyId?: string;
+      changes: { fieldName: string; oldValue?: unknown; newValue?: unknown }[];
+    },
+    ctx: CommandContext,
+  ) => Promise<{ ok: true; value: unknown }>;
+}
+
+/**
+ * Function: reactivateAccount
+ *
+ * Transitions a GL account from INACTIVE back to ACTIVE status, making it
+ * eligible to receive journal postings again. Clears any previously mapped
+ * successor account.
+ */
+export async function run(
+  db: Transaction,
+  input: ReactivateAccountInput,
+  ctx: CommandContext,
+  auditCommands?: AuditCommands,
+) {
+  const { id, from = ["INACTIVE"] } = input;
+
+  // 1. Find account with forUpdate
+  const account = await db
+    .selectFrom("Account")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!account) {
+    return err(new AccountNotFoundError(id));
+  }
+
+  // 2. Look up parent CoA
+  const coa = await db
+    .selectFrom("ChartOfAccounts")
+    .selectAll()
+    .where("id", "=", account.chartOfAccountsId)
+    .executeTakeFirst();
+
+  // 3. CoA must be ACTIVE
+  if (!coa || coa.status === "ARCHIVED") {
+    return err(new ChartOfAccountsArchivedError(account.chartOfAccountsId));
+  }
+
+  if (coa.status !== "ACTIVE") {
+    return err(new ChartOfAccountsNotActiveError(account.chartOfAccountsId));
+  }
+
+  // 4. Account must be in expected from status
+  if (!from.includes(account.status)) {
+    return err(new InvalidStateTransitionError(id));
+  }
+
+  // 5. Update status to ACTIVE and clear successor
+  const updated = await db
+    .updateTable("Account")
+    .set({
+      status: "ACTIVE",
+      successorAccountId: null,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 6. Emit audit event
+  if (auditCommands) {
+    const changes: { fieldName: string; oldValue?: unknown; newValue?: unknown }[] = [
+      { fieldName: "status", oldValue: account.status, newValue: "ACTIVE" },
+    ];
+    if (account.successorAccountId) {
+      changes.push({
+        fieldName: "successorAccountId",
+        oldValue: account.successorAccountId,
+        newValue: null,
+      });
+    }
+
+    await auditCommands.logAuditEvent(
+      db,
+      {
+        eventId: randomUUID(),
+        actorType: "USER",
+        actorId: ctx.actorId,
+        entityType: "Account",
+        entityId: id,
+        operationType: "UPDATE",
+        companyId: coa.companyId,
+        changes,
+      },
+      ctx,
+    );
+  }
+
+  return ok({ account: updated! });
+}

package/src/modules/coa-management/command/updateAccount.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../../shared";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./updateAccount";
+
+export const updateAccount = defineCommand(permissions.updateAccount, run);