@tailor-platform/erp-kit 0.7.0 → 0.9.0

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" };

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   AccountNotFoundError,
@@ -16,7 +15,7 @@ import {
 } from "../lib/errors.generated";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateAccountInput {
+export type UpdateAccountInput = {
   id: string;
   name?: string;
   code?: string;
@@ -34,24 +33,7 @@ export interface UpdateAccountInput {
   defaultTaxCode?: string | null;
   tags?: string | null;
   accountGroupId?: 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 }>;
-}
+};
 
 interface GetCurrencyDep {
   getCurrency: (
@@ -80,10 +62,9 @@ const RECONCILIATION_REQUIRED_CLASSIFICATIONS = ["RECEIVABLE", "PAYABLE", "BANK_
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateAccountInput & CF,
+  input: UpdateAccountInput & Omit<Partial<CF>, "status">,
   ctx: CommandContext,
   deps?: GetCurrencyDep,
-  auditCommands?: AuditCommands,
 ) {
   const {
     id,
@@ -293,78 +274,5 @@ export async function run<CF extends Record<string, unknown>>(
     .returningAll()
     .executeTakeFirst();
 
-  // 12. Emit audit event
-  if (auditCommands) {
-    const changes: { fieldName: string; oldValue?: unknown; newValue?: unknown }[] = [];
-    if (name !== undefined && name !== account.name) {
-      changes.push({ fieldName: "name", oldValue: account.name, newValue: name });
-    }
-    if (code !== undefined && code !== account.code) {
-      changes.push({ fieldName: "code", oldValue: account.code, newValue: code });
-    }
-    if (accountType !== undefined && accountType !== account.accountType) {
-      changes.push({
-        fieldName: "accountType",
-        oldValue: account.accountType,
-        newValue: accountType,
-      });
-    }
-    if (classification !== undefined && classification !== account.classification) {
-      changes.push({
-        fieldName: "classification",
-        oldValue: account.classification,
-        newValue: classification,
-      });
-    }
-    if (reconciliation !== undefined && reconciliation !== account.reconciliation) {
-      changes.push({
-        fieldName: "reconciliation",
-        oldValue: account.reconciliation,
-        newValue: reconciliation,
-      });
-    }
-    if (currencyRestriction !== undefined && currencyRestriction !== account.currencyRestriction) {
-      changes.push({
-        fieldName: "currencyRestriction",
-        oldValue: account.currencyRestriction,
-        newValue: currencyRestriction,
-      });
-    }
-    if (defaultTaxCode !== undefined && defaultTaxCode !== account.defaultTaxCode) {
-      changes.push({
-        fieldName: "defaultTaxCode",
-        oldValue: account.defaultTaxCode,
-        newValue: defaultTaxCode,
-      });
-    }
-    if (tags !== undefined && tags !== account.tags) {
-      changes.push({ fieldName: "tags", oldValue: account.tags, newValue: tags });
-    }
-    if (accountGroupId !== undefined && accountGroupId !== account.accountGroupId) {
-      changes.push({
-        fieldName: "accountGroupId",
-        oldValue: account.accountGroupId,
-        newValue: accountGroupId,
-      });
-    }
-
-    if (changes.length > 0) {
-      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/updateAccountGroup.test.ts

@@ -52,6 +52,28 @@ describe("updateAccountGroup", () => {
     }
   });
 
+  it("looks up group by chartOfAccountsId and code and updates name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedGroup = { ...baseRootGroup, name: "Lookup Assets" };
+    spies.select.mockReturnValueOnce(baseRootGroup).mockReturnValueOnce(baseActiveCoa);
+    spies.update.mockReturnValue(updatedGroup);
+
+    const result = await run(
+      db,
+      {
+        chartOfAccountsId: baseRootGroup.chartOfAccountsId,
+        code: baseRootGroup.code,
+        name: "Lookup Assets",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.accountGroup.name).toBe("Lookup Assets");
+    }
+  });
+
   it("returns error when name is empty", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select
@@ -216,26 +238,6 @@ describe("updateAccountGroup", () => {
     }
   });
 
-  it("emits audit event recording previous and new field values", async () => {
-    const { db, spies } = createMockDb<Transaction>();
-    const updatedGroup = { ...baseRootGroup, name: "Renamed Assets", updatedAt: new Date() };
-    spies.select
-      .mockReturnValueOnce(baseRootGroup) // Group lookup
-      .mockReturnValueOnce(baseActiveCoa); // CoA lookup
-    spies.update.mockReturnValue(updatedGroup);
-
-    const result = await run(db, { id: baseRootGroup.id, name: "Renamed Assets" }, ctx);
-
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      // The returned value contains all updated fields for audit logging
-      expect(result.value.accountGroup.name).toBe("Renamed Assets");
-      expect(result.value.accountGroup.updatedAt).toBeDefined();
-    }
-    expect(spies.update).toHaveBeenCalled();
-    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ name: "Renamed Assets" }));
-  });
-
   it("passes custom fields through to update", async () => {
     const { db, spies } = createMockDb<Transaction>();
     const updatedGroup = { ...baseRootGroup, customField: "custom-value" };

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { Transaction } from "../generated/kysely-tailordb";
 import {
   AccountGroupNotFoundError,
@@ -9,30 +8,15 @@ import {
 } from "../lib/errors.generated";
 import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateAccountGroupInput {
-  id: string;
+export type UpdateAccountGroupInput = (
+  | { id: string }
+  | { chartOfAccountsId: string; code: string }
+) & {
   name?: string;
   sortOrder?: number | null;
   numberRangeStart?: number | null;
   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: updateAccountGroup
@@ -42,22 +26,32 @@ export interface AuditCommands {
  */
 export async function run<CF extends Record<string, unknown>>(
   db: Transaction,
-  input: UpdateAccountGroupInput & CF,
-  ctx: CommandContext,
-  auditCommands?: AuditCommands,
+  input: UpdateAccountGroupInput & Omit<Partial<CF>, "status">,
+  _ctx: CommandContext,
 ) {
-  const { id, name, sortOrder, numberRangeStart, numberRangeEnd, ...customFields } = input;
+  const { name, sortOrder, numberRangeStart, numberRangeEnd, ...customFields } = input;
+  delete (customFields as Record<string, unknown>).id;
+  delete (customFields as Record<string, unknown>).chartOfAccountsId;
+  delete (customFields as Record<string, unknown>).code;
 
   // 1. Find the group
-  const existing = await db
-    .selectFrom("AccountGroup")
-    .selectAll()
-    .where("id", "=", id)
-    .forUpdate()
-    .executeTakeFirst();
+  let existingQuery = db.selectFrom("AccountGroup").selectAll();
+  if ("id" in input) {
+    existingQuery = existingQuery.where("id", "=", (input as { id: string }).id);
+  } else {
+    const lookup = input as { chartOfAccountsId: string; code: string };
+    existingQuery = existingQuery
+      .where("chartOfAccountsId", "=", lookup.chartOfAccountsId)
+      .where("code", "=", lookup.code);
+  }
+  const existing = await existingQuery.forUpdate().executeTakeFirst();
 
   if (!existing) {
-    return err(new AccountGroupNotFoundError(id));
+    const key =
+      "id" in input
+        ? (input as { id: string }).id
+        : `${(input as { chartOfAccountsId: string; code: string }).chartOfAccountsId}:${(input as { chartOfAccountsId: string; code: string }).code}`;
+    return err(new AccountGroupNotFoundError(key));
   }
 
   // 2. Check parent CoA status
@@ -101,7 +95,7 @@ export async function run<CF extends Record<string, unknown>>(
         .execute();
 
       for (const group of existingGroups) {
-        if (group.id === id) continue;
+        if (group.id === existing.id) continue;
         if (group.numberRangeStart !== null && group.numberRangeEnd !== null) {
           if (newRangeStart <= group.numberRangeEnd && newRangeEnd >= group.numberRangeStart) {
             return err(new InvalidNumberRangeError(`${newRangeStart}-${newRangeEnd}`));
@@ -113,14 +107,14 @@ export async function run<CF extends Record<string, unknown>>(
       const assignedAccounts = await db
         .selectFrom("Account")
         .selectAll()
-        .where("accountGroupId", "=", id)
+        .where("accountGroupId", "=", existing.id)
         .execute();
 
       for (const account of assignedAccounts) {
         const accountCode = parseInt(account.code, 10);
         if (!isNaN(accountCode)) {
           if (accountCode < newRangeStart || accountCode > newRangeEnd) {
-            return err(new AccountsOutOfRangeError(id));
+            return err(new AccountsOutOfRangeError(existing.id));
           }
         }
       }
@@ -141,51 +135,9 @@ export async function run<CF extends Record<string, unknown>>(
   const accountGroup = await db
     .updateTable("AccountGroup")
     .set(updateData)
-    .where("id", "=", id)
+    .where("id", "=", existing.id)
     .returningAll()
     .executeTakeFirst();
 
-  // 7. Emit audit event
-  if (auditCommands) {
-    const changes: { fieldName: string; oldValue?: unknown; newValue?: unknown }[] = [];
-    if (name !== undefined && name !== existing.name) {
-      changes.push({ fieldName: "name", oldValue: existing.name, newValue: name });
-    }
-    if (sortOrder !== undefined && sortOrder !== existing.sortOrder) {
-      changes.push({ fieldName: "sortOrder", oldValue: existing.sortOrder, newValue: sortOrder });
-    }
-    if (numberRangeStart !== undefined && numberRangeStart !== existing.numberRangeStart) {
-      changes.push({
-        fieldName: "numberRangeStart",
-        oldValue: existing.numberRangeStart,
-        newValue: numberRangeStart,
-      });
-    }
-    if (numberRangeEnd !== undefined && numberRangeEnd !== existing.numberRangeEnd) {
-      changes.push({
-        fieldName: "numberRangeEnd",
-        oldValue: existing.numberRangeEnd,
-        newValue: numberRangeEnd,
-      });
-    }
-
-    if (changes.length > 0) {
-      await auditCommands.logAuditEvent(
-        db,
-        {
-          eventId: randomUUID(),
-          actorType: "USER",
-          actorId: ctx.actorId,
-          entityType: "AccountGroup",
-          entityId: id,
-          operationType: "UPDATE",
-          companyId: coa!.companyId,
-          changes,
-        },
-        ctx,
-      );
-    }
-  }
-
   return ok({ accountGroup: accountGroup! });
 }