@tailor-platform/erp-kit 0.8.0 → 0.9.0

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import { ChartOfAccountsNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
@@ -8,23 +7,6 @@ export interface DeactivateChartOfAccountsInput {
   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: deactivateChartOfAccounts
  *
@@ -34,8 +16,7 @@ export interface AuditCommands {
 export async function run(
   db: Transaction,
   input: DeactivateChartOfAccountsInput,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
+  _ctx: CommandContext,
 ) {
   const { id, from = ["ACTIVE"] } = input;
 
@@ -67,22 +48,5 @@ export async function run(
     .returningAll()
     .executeTakeFirst();
 
-  if (auditCommands) {
-    await auditCommands.logAuditEvent(
-      db,
-      {
-        eventId: randomUUID(),
-        actorType: "USER",
-        actorId: ctx.actorId,
-        entityType: "ChartOfAccounts",
-        entityId: id,
-        operationType: "UPDATE",
-        companyId: existing.companyId,
-        changes: [{ fieldName: "status", oldValue: existing.status, newValue: "ARCHIVED" }],
-      },
-      ctx,
-    );
-  }
-
   return ok({ chartOfAccounts: chartOfAccounts! });
 }

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

@@ -106,17 +106,4 @@ describe("deleteAccount", () => {
       expect(result.value.success).toBe(true);
     }
   });
-
-  it("emits audit event recording deletion, acting user, and account code", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    spies.select.mockReturnValueOnce(baseDraftAccount).mockReturnValueOnce(baseActiveCoa);
-
-    const result = await run(db, { id: baseDraftAccount.id }, ctx);
-
-    // Audit event is emitted as part of successful deletion
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.value.success).toBe(true);
-    }
-  });
 });

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   AccountNotFoundError,
@@ -12,23 +11,6 @@ export interface DeleteAccountInput {
   id: 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: deleteAccount
  *
@@ -36,12 +18,7 @@ export interface AuditCommands {
  * transactions. ACTIVE/INACTIVE accounts and accounts with posted
  * transactions cannot be deleted.
  */
-export async function run(
-  db: Transaction,
-  input: DeleteAccountInput,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
-) {
+export async function run(db: Transaction, input: DeleteAccountInput, _ctx: CommandContext) {
   const { id } = input;
 
   // 1. Find account with forUpdate
@@ -81,23 +58,5 @@ export async function run(
   // 6. Delete account
   await db.deleteFrom("Account").where("id", "=", id).execute();
 
-  // 7. Emit audit event
-  if (auditCommands) {
-    await auditCommands.logAuditEvent(
-      db,
-      {
-        eventId: randomUUID(),
-        actorType: "USER",
-        actorId: ctx.actorId,
-        entityType: "Account",
-        entityId: id,
-        operationType: "DELETE",
-        companyId: coa.companyId,
-        changes: [{ fieldName: "id", oldValue: id }],
-      },
-      ctx,
-    );
-  }
-
   return ok({ success: true as const });
 }

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

@@ -98,23 +98,4 @@ describe("deleteAccountGroup", () => {
     }
     expect(spies.delete).toHaveBeenCalled();
   });
-
-  it("emits audit event recording deletion and acting user", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    spies.select
-      .mockReturnValueOnce(baseChildGroup) // Group lookup
-      .mockReturnValueOnce(baseActiveCoa) // CoA lookup
-      .mockReturnValueOnce([]) // No child groups
-      .mockReturnValueOnce([]); // No assigned accounts
-    spies.delete.mockReturnValue(undefined);
-
-    const result = await run(db, { id: baseChildGroup.id }, ctx);
-
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      // Success result indicates deletion completed; ctx.actorId available for audit
-      expect(result.value.success).toBe(true);
-    }
-    expect(spies.delete).toHaveBeenCalled();
-  });
 });

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   AccountGroupNotFoundError,
@@ -12,35 +11,13 @@ export interface DeleteAccountGroupInput {
   id: 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: deleteAccountGroup
  *
  * Permanently removes an account group that has no child groups and no assigned
  * accounts.
  */
-export async function run(
-  db: Transaction,
-  input: DeleteAccountGroupInput,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
-) {
+export async function run(db: Transaction, input: DeleteAccountGroupInput, _ctx: CommandContext) {
   const { id } = input;
 
   // 1. Find the group
@@ -91,23 +68,5 @@ export async function run(
   // 5. Delete the group
   await db.deleteFrom("AccountGroup").where("id", "=", id).execute();
 
-  // 6. Emit audit event
-  if (auditCommands) {
-    await auditCommands.logAuditEvent(
-      db,
-      {
-        eventId: randomUUID(),
-        actorType: "USER",
-        actorId: ctx.actorId,
-        entityType: "AccountGroup",
-        entityId: id,
-        operationType: "DELETE",
-        companyId: coa!.companyId,
-        changes: [{ fieldName: "id", oldValue: id }],
-      },
-      ctx,
-    );
-  }
-
   return ok({ success: true as const });
 }

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

@@ -1,9 +1,9 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../../testing/index";
 import type { Transaction } from "../generated/kysely-tailordb";
 import { ChartOfAccountsNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
 import { baseDraftCoa, baseActiveCoa, baseArchivedCoa } from "../testing/fixtures";
-import { run, type AuditCommands } from "./deleteChartOfAccounts";
+import { run } from "./deleteChartOfAccounts";
 import type { CommandContext } from "@tailor-platform/erp-kit/module";
 
 const ctx: CommandContext = {
@@ -95,60 +95,4 @@ describe("deleteChartOfAccounts", () => {
     // once for Account, once for AccountGroup, once for ChartOfAccounts
     expect(spies.delete).toHaveBeenCalledTimes(3);
   });
-
-  it("emits audit events for each cascade-deleted Account and AccountGroup", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const accounts = [{ id: "account-1", code: "1100", name: "Cash" }];
-    const groups = [{ id: "group-1", code: "1000", name: "Assets" }];
-    spies.select
-      .mockReturnValueOnce(baseDraftCoa) // CoA lookup
-      .mockReturnValueOnce(accounts) // accounts query
-      .mockReturnValueOnce(groups); // groups query
-
-    const mockLogAuditEvent = vi.fn().mockResolvedValue({ ok: true, value: {} });
-    const auditCommands: AuditCommands = { logAuditEvent: mockLogAuditEvent };
-
-    const result = await run(db, { id: baseDraftCoa.id }, ctx, auditCommands);
-
-    expect(result.ok).toBe(true);
-    // Should emit: 1 for account + 1 for group + 1 for CoA = 3 audit events
-    expect(mockLogAuditEvent).toHaveBeenCalledTimes(3);
-    expect(mockLogAuditEvent).toHaveBeenCalledWith(
-      db,
-      expect.objectContaining({ entityType: "Account", operationType: "DELETE" }),
-      ctx,
-    );
-    expect(mockLogAuditEvent).toHaveBeenCalledWith(
-      db,
-      expect.objectContaining({ entityType: "AccountGroup", operationType: "DELETE" }),
-      ctx,
-    );
-  });
-
-  it("emits audit event recording CoA deletion and acting user", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    spies.select
-      .mockReturnValueOnce(baseDraftCoa) // CoA lookup
-      .mockReturnValueOnce([]) // no accounts
-      .mockReturnValueOnce([]); // no groups
-
-    const mockLogAuditEvent = vi.fn().mockResolvedValue({ ok: true, value: {} });
-    const auditCommands: AuditCommands = { logAuditEvent: mockLogAuditEvent };
-
-    const result = await run(db, { id: baseDraftCoa.id }, ctx, auditCommands);
-
-    expect(result.ok).toBe(true);
-    expect(mockLogAuditEvent).toHaveBeenCalledWith(
-      db,
-      expect.objectContaining({
-        entityType: "ChartOfAccounts",
-        entityId: baseDraftCoa.id,
-        operationType: "DELETE",
-        companyId: baseDraftCoa.companyId,
-        actorType: "USER",
-        actorId: ctx.actorId,
-      }),
-      ctx,
-    );
-  });
 });

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import { ChartOfAccountsNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
@@ -7,23 +6,6 @@ export interface DeleteChartOfAccountsInput {
   id: 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: deleteChartOfAccounts
  *
@@ -33,8 +15,7 @@ export interface AuditCommands {
 export async function run(
   db: Transaction,
   input: DeleteChartOfAccountsInput,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
+  _ctx: CommandContext,
 ) {
   const { id } = input;
 
@@ -55,79 +36,14 @@ export async function run(
     return err(new InvalidStateTransitionError(id));
   }
 
-  // 3. Query child records before deleting (for audit)
-  const accounts = await db
-    .selectFrom("Account")
-    .selectAll()
-    .where("chartOfAccountsId", "=", id)
-    .execute();
-
-  const accountGroups = await db
-    .selectFrom("AccountGroup")
-    .selectAll()
-    .where("chartOfAccountsId", "=", id)
-    .execute();
-
-  // 4. Cascade-delete all child Accounts
+  // 3. Cascade-delete all child Accounts
   await db.deleteFrom("Account").where("chartOfAccountsId", "=", id).execute();
 
-  // 5. Cascade-delete all child AccountGroups
+  // 4. Cascade-delete all child AccountGroups
   await db.deleteFrom("AccountGroup").where("chartOfAccountsId", "=", id).execute();
 
-  // 6. Delete the CoA itself
+  // 5. Delete the CoA itself
   await db.deleteFrom("ChartOfAccounts").where("id", "=", id).execute();
 
-  // 7. Emit audit events
-  if (auditCommands) {
-    for (const account of accounts) {
-      await auditCommands.logAuditEvent(
-        db,
-        {
-          eventId: randomUUID(),
-          actorType: "USER",
-          actorId: ctx.actorId,
-          entityType: "Account",
-          entityId: account.id,
-          operationType: "DELETE",
-          companyId: existing.companyId,
-          changes: [{ fieldName: "id", oldValue: account.id }],
-        },
-        ctx,
-      );
-    }
-
-    for (const group of accountGroups) {
-      await auditCommands.logAuditEvent(
-        db,
-        {
-          eventId: randomUUID(),
-          actorType: "USER",
-          actorId: ctx.actorId,
-          entityType: "AccountGroup",
-          entityId: group.id,
-          operationType: "DELETE",
-          companyId: existing.companyId,
-          changes: [{ fieldName: "id", oldValue: group.id }],
-        },
-        ctx,
-      );
-    }
-
-    await auditCommands.logAuditEvent(
-      db,
-      {
-        eventId: randomUUID(),
-        actorType: "USER",
-        actorId: ctx.actorId,
-        entityType: "ChartOfAccounts",
-        entityId: id,
-        operationType: "DELETE",
-        companyId: existing.companyId,
-        changes: [{ fieldName: "id", oldValue: id }],
-      },
-      ctx,
-    );
-  }
-
   return ok({ success: true as const });
 }

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

@@ -169,31 +169,4 @@ describe("moveAccountGroup", () => {
       expect(result.value.previousParentAccountGroupId).toBe(baseRootGroup.id);
     }
   });
-
-  it("emits audit event recording previous and new parent references", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const movedGroup = { ...baseChildGroup, parentAccountGroupId: baseGroupNoRange.id };
-    spies.select
-      .mockReturnValueOnce(baseChildGroup) // Group lookup
-      .mockReturnValueOnce(baseActiveCoa) // CoA lookup
-      .mockReturnValueOnce(baseGroupNoRange); // New parent lookup
-    spies.update.mockReturnValue(movedGroup);
-
-    const result = await run(
-      db,
-      { id: baseChildGroup.id, newParentAccountGroupId: baseGroupNoRange.id },
-      ctx,
-    );
-
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      // Return value contains previous and new parent for audit logging
-      expect(result.value.previousParentAccountGroupId).toBe(baseRootGroup.id);
-      expect(result.value.accountGroup.parentAccountGroupId).toBe(baseGroupNoRange.id);
-    }
-    expect(spies.update).toHaveBeenCalled();
-    expect(spies.set).toHaveBeenCalledWith(
-      expect.objectContaining({ parentAccountGroupId: baseGroupNoRange.id }),
-    );
-  });
 });

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   AccountGroupNotFoundError,
@@ -13,35 +12,13 @@ export interface MoveAccountGroupInput {
   newParentAccountGroupId: string | null;
 }
 
-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: moveAccountGroup
  *
  * Reparents an account group by changing its parent reference within the same
  * CoA. Moving to a null parent promotes the group to a root group.
  */
-export async function run(
-  db: Transaction,
-  input: MoveAccountGroupInput,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
-) {
+export async function run(db: Transaction, input: MoveAccountGroupInput, _ctx: CommandContext) {
   const { id, newParentAccountGroupId } = input;
 
   // 1. Find the group
@@ -117,29 +94,5 @@ export async function run(
     .returningAll()
     .executeTakeFirst();
 
-  // 6. Emit audit event
-  if (auditCommands) {
-    await auditCommands.logAuditEvent(
-      db,
-      {
-        eventId: randomUUID(),
-        actorType: "USER",
-        actorId: ctx.actorId,
-        entityType: "AccountGroup",
-        entityId: id,
-        operationType: "UPDATE",
-        companyId: coa!.companyId,
-        changes: [
-          {
-            fieldName: "parentAccountGroupId",
-            oldValue: existing.parentAccountGroupId,
-            newValue: newParentAccountGroupId,
-          },
-        ],
-      },
-      ctx,
-    );
-  }
-
   return ok({ accountGroup: accountGroup!, previousParentAccountGroupId: previousParentId });
 }

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

@@ -108,19 +108,4 @@ describe("reactivateAccount", () => {
       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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   AccountNotFoundError,
@@ -13,23 +12,6 @@ export interface ReactivateAccountInput {
   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
  *
@@ -37,12 +19,7 @@ export interface AuditCommands {
  * eligible to receive journal postings again. Clears any previously mapped
  * successor account.
  */
-export async function run(
-  db: Transaction,
-  input: ReactivateAccountInput,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
-) {
+export async function run(db: Transaction, input: ReactivateAccountInput, _ctx: CommandContext) {
   const { id, from = ["INACTIVE"] } = input;
 
   // 1. Find account with forUpdate
@@ -90,34 +67,5 @@ export async function run(
     .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.test.ts

@@ -631,21 +631,6 @@ describe("updateAccount", () => {
     }
   });
 
-  it("emits audit event recording previous and new field values for all changed attributes", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const updated = { ...baseDraftAccount, name: "Audited Update" };
-    spies.select.mockReturnValueOnce(baseDraftAccount).mockReturnValueOnce(baseActiveCoa);
-    spies.update.mockReturnValue(updated);
-
-    const result = await run(db, { id: baseDraftAccount.id, name: "Audited Update" }, ctx);
-
-    // Audit event is emitted as part of successful update
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.value.account.name).toBe("Audited Update");
-    }
-  });
-
   it("passes custom fields through to update", async () => {
     const { db, spies } = createMockDb<Transaction>();
     const updated = { ...baseDraftAccount, customField: "custom-value" };