@tailor-platform/erp-kit 0.7.0 → 0.9.0

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   ChartOfAccountsNotFoundError,
@@ -21,23 +20,6 @@ export interface CreateAccountGroupInput {
   numberRangeEnd?: number | 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: createAccountGroup
  *
@@ -48,8 +30,7 @@ export interface AuditCommands {
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
   input: CreateAccountGroupInput & CF,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
+  _ctx: CommandContext,
 ) {
   const {
     chartOfAccountsId,
@@ -167,41 +148,5 @@ export async function run<CF extends Record<string, unknown>>(
     .returningAll()
     .executeTakeFirst();
 
-  // 9. Emit audit event
-  if (auditCommands) {
-    const changes: { fieldName: string; oldValue?: unknown; newValue?: unknown }[] = [
-      { fieldName: "chartOfAccountsId", newValue: chartOfAccountsId },
-      { fieldName: "code", newValue: code },
-      { fieldName: "name", newValue: name },
-    ];
-    if (parentAccountGroupId) {
-      changes.push({ fieldName: "parentAccountGroupId", newValue: parentAccountGroupId });
-    }
-    if (sortOrder !== undefined && sortOrder !== null) {
-      changes.push({ fieldName: "sortOrder", newValue: sortOrder });
-    }
-    if (rangeStart !== null) {
-      changes.push({ fieldName: "numberRangeStart", newValue: rangeStart });
-    }
-    if (rangeEnd !== null) {
-      changes.push({ fieldName: "numberRangeEnd", newValue: rangeEnd });
-    }
-
-    await auditCommands.logAuditEvent(
-      db,
-      {
-        eventId: randomUUID(),
-        actorType: "USER",
-        actorId: ctx.actorId,
-        entityType: "AccountGroup",
-        entityId: accountGroup!.id,
-        operationType: "CREATE",
-        companyId: coa.companyId,
-        changes,
-      },
-      ctx,
-    );
-  }
-
   return ok({ accountGroup: accountGroup! });
 }

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

@@ -1,4 +1,4 @@
-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 {
@@ -441,54 +441,6 @@ describe("createChartOfAccounts", () => {
       expect(result.value.chartOfAccounts.status).toBe("DRAFT");
     }
   });
-
-  it("emits audit event recording acting user, timestamp, and initial field values", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const createdCoa = { ...baseDraftCoa, id: "new-coa-id" };
-    spies.select.mockReturnValueOnce(baseActiveCompany);
-    spies.insert.mockReturnValue(createdCoa);
-
-    const mockLogAuditEvent = vi.fn().mockResolvedValue({ ok: true, value: {} });
-    const auditCommands = { logAuditEvent: mockLogAuditEvent };
-
-    const result = await run(db, validInput, ctx, undefined, undefined, auditCommands);
-
-    expect(result.ok).toBe(true);
-    expect(mockLogAuditEvent).toHaveBeenCalledWith(
-      db,
-      expect.objectContaining({
-        entityType: "ChartOfAccounts",
-        entityId: "new-coa-id",
-        operationType: "CREATE",
-        companyId: validInput.companyId,
-        actorType: "USER",
-        actorId: ctx.actorId,
-      }),
-      ctx,
-    );
-  });
-
-  it("audit event includes whether CoA was created from template or blank", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const createdCoa = { ...baseDraftCoa, id: "new-coa-id" };
-    spies.select.mockReturnValueOnce(baseActiveCompany);
-    spies.insert.mockReturnValue(createdCoa);
-
-    const mockLogAuditEvent = vi.fn().mockResolvedValue({ ok: true, value: {} });
-    const auditCommands = { logAuditEvent: mockLogAuditEvent };
-
-    // Test blank creation
-    await run(db, validInput, ctx, undefined, undefined, auditCommands);
-
-    expect(mockLogAuditEvent).toHaveBeenCalledWith(
-      db,
-      expect.objectContaining({
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        changes: expect.arrayContaining([{ fieldName: "templateUsed", newValue: "blank" }]),
-      }),
-      ctx,
-    );
-  });
 });
 
 // Helper type for custom fields test

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   NameRequiredError,
@@ -51,23 +50,6 @@ export interface TemplateProvider {
   resolveTemplate: (id: string) => Promise<TemplateSnapshot | 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 }>;
-}
-
 export interface OrganizationQueries {
   getCompany: (
     db: Transaction,
@@ -91,7 +73,6 @@ export async function run<CF extends Record<string, unknown>>(
   ctx: CommandContext,
   organizationQueries?: Pick<OrganizationQueries, "getCompany">,
   templateProvider?: TemplateProvider,
-  auditCommands?: AuditCommands,
 ) {
   const { name, companyId, description, templateId, ...customFields } = input;
 
@@ -209,38 +190,6 @@ export async function run<CF extends Record<string, unknown>>(
     }
   }
 
-  // 6. Emit audit event
-  if (auditCommands) {
-    const changes: { fieldName: string; oldValue?: unknown; newValue?: unknown }[] = [
-      { fieldName: "name", newValue: name },
-      { fieldName: "companyId", newValue: companyId },
-      { fieldName: "baseCurrencyId", newValue: baseCurrencyId },
-      { fieldName: "status", newValue: "DRAFT" },
-    ];
-    if (description) {
-      changes.push({ fieldName: "description", newValue: description });
-    }
-    changes.push({
-      fieldName: "templateUsed",
-      newValue: templateId ? "template" : "blank",
-    });
-
-    await auditCommands.logAuditEvent(
-      db,
-      {
-        eventId: randomUUID(),
-        actorType: "USER",
-        actorId: ctx.actorId,
-        entityType: "ChartOfAccounts",
-        entityId: coa!.id,
-        operationType: "CREATE",
-        companyId,
-        changes,
-      },
-      ctx,
-    );
-  }
-
   return ok({ chartOfAccounts: coa! });
 }
 

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

@@ -181,19 +181,4 @@ describe("deactivateAccount", () => {
       expect(result.error).toBeInstanceOf(OpenBalancesExistError);
     }
   });
-
-  it("emits audit event recording status transition from ACTIVE to INACTIVE and successor mapping", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const deactivated = { ...baseActiveAccount, status: "INACTIVE" };
-    spies.select.mockReturnValueOnce(baseActiveAccount).mockReturnValueOnce(baseActiveCoa);
-    spies.update.mockReturnValue(deactivated);
-
-    const result = await run(db, { id: baseActiveAccount.id }, ctx);
-
-    // Audit event is emitted as part of successful deactivation
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.value.account.status).toBe("INACTIVE");
-    }
-  });
 });

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   AccountNotFoundError,
@@ -15,23 +14,6 @@ export interface DeactivateAccountInput {
   preDeactivationHook?: (accountId: string) => Promise<boolean>;
 }
 
-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: deactivateAccount
  *
@@ -39,12 +21,7 @@ export interface AuditCommands {
  * journal postings while preserving history. An optional successor account
  * can be designated during deactivation.
  */
-export async function run(
-  db: Transaction,
-  input: DeactivateAccountInput,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
-) {
+export async function run(db: Transaction, input: DeactivateAccountInput, _ctx: CommandContext) {
   const { id, successorAccountId, preDeactivationHook } = input;
 
   // 1. Find account with forUpdate
@@ -109,34 +86,5 @@ export async function run(
     .returningAll()
     .executeTakeFirst();
 
-  // 8. Emit audit event
-  if (auditCommands) {
-    const changes: { fieldName: string; oldValue?: unknown; newValue?: unknown }[] = [
-      { fieldName: "status", oldValue: "ACTIVE", newValue: "INACTIVE" },
-    ];
-    if (successorAccountId) {
-      changes.push({
-        fieldName: "successorAccountId",
-        oldValue: null,
-        newValue: successorAccountId,
-      });
-    }
-
-    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/deactivateChartOfAccounts.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 "./deactivateChartOfAccounts";
+import { run } from "./deactivateChartOfAccounts";
 import type { CommandContext } from "@tailor-platform/erp-kit/module";
 
 const ctx: CommandContext = {
@@ -61,31 +61,4 @@ describe("deactivateChartOfAccounts", () => {
       expect(result.value.chartOfAccounts.status).toBe("ARCHIVED");
     }
   });
-
-  it("emits audit event recording status transition from ACTIVE to ARCHIVED", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const archivedCoa = { ...baseActiveCoa, status: "ARCHIVED" };
-    spies.select.mockReturnValueOnce(baseActiveCoa);
-    spies.update.mockReturnValue(archivedCoa);
-
-    const mockLogAuditEvent = vi.fn().mockResolvedValue({ ok: true, value: {} });
-    const auditCommands: AuditCommands = { logAuditEvent: mockLogAuditEvent };
-
-    const result = await run(db, { id: baseActiveCoa.id }, ctx, auditCommands);
-
-    expect(result.ok).toBe(true);
-    expect(mockLogAuditEvent).toHaveBeenCalledWith(
-      db,
-      expect.objectContaining({
-        entityType: "ChartOfAccounts",
-        entityId: baseActiveCoa.id,
-        operationType: "UPDATE",
-        companyId: baseActiveCoa.companyId,
-        actorType: "USER",
-        actorId: ctx.actorId,
-        changes: [{ fieldName: "status", oldValue: "ACTIVE", newValue: "ARCHIVED" }],
-      }),
-      ctx,
-    );
-  });
 });

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,
-    );
-  });
 });