@tailor-platform/erp-kit 0.3.0 → 0.4.0

package/src/modules/organization/command/updateCompany.generated.ts

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

package/src/modules/organization/command/updateCompany.test.ts

@@ -0,0 +1,239 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidLegalNameError,
+  CurrencyNotFoundError,
+  CurrencyImmutableError,
+} from "../lib/errors.generated";
+import { draftCompany, activeCompany, inactiveCompany } from "../testing/fixtures";
+import { getCurrency } from "../../primitives/query/getCurrency.generated";
+import { run } from "./updateCompany";
+
+const ctx: CommandContext = {
+  actorId: "test-actor",
+  permissions: ["organization:updateCompany"],
+};
+
+const deps = { getCurrency };
+
+describe("updateCompany", () => {
+  it("updates legal name on DRAFT company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedCompany = { ...draftCompany, legalName: "New Name" };
+    spies.select.mockReturnValueOnce(draftCompany);
+    spies.update.mockReturnValue(updatedCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: draftCompany.id,
+        legalName: "New Name",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.company.legalName).toBe("New Name");
+    }
+  });
+
+  it("updates address fields on ACTIVE company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedCompany = { ...activeCompany, street: "789 New Ave" };
+    spies.select.mockReturnValueOnce(activeCompany);
+    spies.update.mockReturnValue(updatedCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: activeCompany.id,
+        street: "789 New Ave",
+        city: "Kyoto",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.company.street).toBe("789 New Ave");
+    }
+  });
+
+  it("updates tax ID and registration number", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedCompany = { ...draftCompany, taxId: "NEW-TAX", registrationNumber: "NEW-REG" };
+    spies.select.mockReturnValueOnce(draftCompany);
+    spies.update.mockReturnValue(updatedCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: draftCompany.id,
+        taxId: "NEW-TAX",
+        registrationNumber: "NEW-REG",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.company.taxId).toBe("NEW-TAX");
+      expect(result.value.company.registrationNumber).toBe("NEW-REG");
+    }
+  });
+
+  it("throws when company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(
+      db,
+      {
+        companyId: "nonexistent",
+        legalName: "New Name",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CompanyNotFoundError);
+    }
+  });
+
+  it("throws when legal name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: draftCompany.id,
+        legalName: "",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidLegalNameError);
+    }
+  });
+
+  it("throws when changing base currency on ACTIVE company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: activeCompany.id,
+        baseCurrencyId: "new-currency",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyImmutableError);
+    }
+  });
+
+  it("throws when changing base currency on INACTIVE company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: inactiveCompany.id,
+        baseCurrencyId: "new-currency",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyImmutableError);
+    }
+  });
+
+  it("throws when new base currency does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(draftCompany) // company lookup
+      .mockReturnValueOnce(undefined); // getCurrency returns null
+
+    const result = await run(
+      db,
+      {
+        companyId: draftCompany.id,
+        baseCurrencyId: "nonexistent-currency",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
+  });
+
+  it("throws when new base currency is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(draftCompany) // company lookup
+      .mockReturnValueOnce({ id: "currency-inactive", isActive: false }); // getCurrency returns inactive
+
+    const result = await run(
+      db,
+      {
+        companyId: draftCompany.id,
+        baseCurrencyId: "currency-inactive",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
+  });
+
+  it("updates base currency on DRAFT company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedCompany = { ...draftCompany, baseCurrencyId: "currency-eur" };
+    spies.select
+      .mockReturnValueOnce(draftCompany) // company lookup
+      .mockReturnValueOnce({ id: "currency-eur", isActive: true }); // getCurrency
+    spies.update.mockReturnValue(updatedCompany);
+
+    const result = await run(
+      db,
+      {
+        companyId: draftCompany.id,
+        baseCurrencyId: "currency-eur",
+      },
+      ctx,
+      deps,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.company.baseCurrencyId).toBe("currency-eur");
+    }
+  });
+});

package/src/modules/organization/command/updateCompany.ts

@@ -0,0 +1,127 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidLegalNameError,
+  CurrencyNotFoundError,
+  CurrencyImmutableError,
+} from "../lib/errors.generated";
+import type { PrimitivesQueries } from "../module";
+
+export interface UpdateCompanyInput {
+  companyId: string;
+  legalName?: string;
+  taxId?: string;
+  registrationNumber?: string;
+  baseCurrencyId?: string;
+  street?: string;
+  city?: string;
+  state?: string;
+  postalCode?: string;
+  country?: string;
+}
+
+/**
+ * Function: updateCompany
+ *
+ * Modifies an existing company's attributes. Legal name validation applies when
+ * provided. Base currency can only be changed while the company is in DRAFT status.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateCompanyInput & CF,
+  ctx: CommandContext,
+  primitivesQueries?: Pick<PrimitivesQueries, "getCurrency">,
+) {
+  const {
+    companyId,
+    legalName,
+    taxId,
+    registrationNumber,
+    baseCurrencyId,
+    street,
+    city,
+    state,
+    postalCode,
+    country,
+    ...customFields
+  } = input;
+
+  // 1. Find company by id with forUpdate
+  const existing = await db
+    .selectFrom("Company")
+    .selectAll()
+    .where("id", "=", companyId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new CompanyNotFoundError(companyId));
+  }
+
+  // 2. If legalName provided and empty, error
+  if (legalName?.trim() === "") {
+    return err(new InvalidLegalNameError(legalName));
+  }
+
+  // 3. If baseCurrencyId provided, company must be DRAFT and currency must be valid
+  if (baseCurrencyId !== undefined) {
+    if (existing.status !== "DRAFT") {
+      return err(new CurrencyImmutableError(companyId));
+    }
+    if (primitivesQueries) {
+      const { currency } = (await primitivesQueries.getCurrency(db, { id: baseCurrencyId }, ctx))
+        .value;
+      if (!currency?.isActive) {
+        return err(new CurrencyNotFoundError(baseCurrencyId));
+      }
+    }
+  }
+
+  // 4. Build update object from provided fields — strip reserved model columns from customFields
+  const RESERVED_KEYS = new Set([
+    "id",
+    "status",
+    "legalName",
+    "taxId",
+    "registrationNumber",
+    "baseCurrencyId",
+    "street",
+    "city",
+    "state",
+    "postalCode",
+    "country",
+    "createdAt",
+    "updatedAt",
+  ]);
+  const safeCustomFields: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(customFields)) {
+    if (!RESERVED_KEYS.has(key)) {
+      safeCustomFields[key] = value;
+    }
+  }
+
+  const updateData: Record<string, unknown> = {
+    ...safeCustomFields,
+    updatedAt: new Date(),
+  };
+
+  if (legalName !== undefined) updateData.legalName = legalName;
+  if (taxId !== undefined) updateData.taxId = taxId;
+  if (registrationNumber !== undefined) updateData.registrationNumber = registrationNumber;
+  if (baseCurrencyId !== undefined) updateData.baseCurrencyId = baseCurrencyId;
+  if (street !== undefined) updateData.street = street;
+  if (city !== undefined) updateData.city = city;
+  if (state !== undefined) updateData.state = state;
+  if (postalCode !== undefined) updateData.postalCode = postalCode;
+  if (country !== undefined) updateData.country = country;
+
+  const company = await db
+    .updateTable("Company")
+    .set(updateData)
+    .where("id", "=", companyId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ company: company! });
+}

package/src/modules/organization/command/updateDepartment.generated.ts

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

package/src/modules/organization/command/updateDepartment.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  DepartmentNotFoundError,
+  InvalidNameError,
+  SelfReferenceError,
+  ParentNotFoundError,
+  CircularReferenceError,
+} from "../lib/errors.generated";
+import {
+  activeDepartment,
+  childDepartment,
+  grandchildDepartment,
+  inactiveDepartment,
+  otherCompanyDepartment,
+} from "../testing/fixtures";
+import { run } from "./updateDepartment";
+
+describe("updateDepartment", () => {
+  it("updates department name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...activeDepartment, name: "New Name", updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(activeDepartment); // find department
+    spies.update.mockReturnValue(updated);
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+      name: "New Name",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.department.name).toBe("New Name");
+    }
+  });
+
+  it("updates parent department", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const newParent = {
+      ...inactiveDepartment,
+      status: "ACTIVE",
+      companyId: activeDepartment.companyId,
+    };
+    const updated = {
+      ...childDepartment,
+      parentDepartmentId: newParent.id,
+      updatedAt: new Date(),
+    };
+
+    spies.select
+      .mockReturnValueOnce(childDepartment) // find department
+      .mockReturnValueOnce(newParent) // find new parent
+      .mockReturnValueOnce(newParent); // ancestor walk: newParent has no parent
+    spies.update.mockReturnValue(updated);
+
+    const result = await run(db, {
+      departmentId: childDepartment.id,
+      parentDepartmentId: newParent.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.department.parentDepartmentId).toBe(newParent.id);
+    }
+  });
+
+  it("removes parent department (promotes to top-level)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = {
+      ...childDepartment,
+      parentDepartmentId: null,
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValueOnce(childDepartment); // find department
+    spies.update.mockReturnValue(updated);
+
+    const result = await run(db, {
+      departmentId: childDepartment.id,
+      parentDepartmentId: null,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.department.parentDepartmentId).toBeNull();
+    }
+  });
+
+  it("throws when department does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, {
+      departmentId: "nonexistent-dept",
+      name: "New Name",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DepartmentNotFoundError);
+    }
+  });
+
+  it("throws when name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeDepartment);
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+      name: "",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("throws when name is whitespace-only", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeDepartment);
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+      name: "   ",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("throws when setting self as parent", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeDepartment);
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+      parentDepartmentId: activeDepartment.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SelfReferenceError);
+    }
+  });
+
+  it("throws when parent does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(activeDepartment) // find department
+      .mockReturnValueOnce(undefined); // parent not found
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+      parentDepartmentId: "nonexistent-dept",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNotFoundError);
+    }
+  });
+
+  it("throws when parent belongs to different company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(activeDepartment) // find department
+      .mockReturnValueOnce(otherCompanyDepartment); // parent in different company
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+      parentDepartmentId: otherCompanyDepartment.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNotFoundError);
+    }
+  });
+
+  it("throws when reparenting creates circular reference", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // activeDepartment -> childDepartment -> grandchildDepartment
+    // Try to set activeDepartment's parent to grandchildDepartment
+    // Ancestor walk: grandchildDepartment -> childDepartment (parentDepartmentId=dept-1) -> activeDepartment.id found!
+    spies.select
+      .mockReturnValueOnce(activeDepartment) // find department (activeDepartment)
+      .mockReturnValueOnce(grandchildDepartment) // find parent (grandchildDepartment)
+      .mockReturnValueOnce(grandchildDepartment) // ancestor walk: start at grandchildDepartment
+      .mockReturnValueOnce(childDepartment); // ancestor walk: grandchild's parent is childDepartment, whose parentDepartmentId is dept-1 === departmentId
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+      parentDepartmentId: grandchildDepartment.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CircularReferenceError);
+    }
+  });
+
+  it("updates parent on INACTIVE department", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const newParent = { ...activeDepartment };
+    const updated = {
+      ...inactiveDepartment,
+      parentDepartmentId: newParent.id,
+      updatedAt: new Date(),
+    };
+
+    spies.select
+      .mockReturnValueOnce(inactiveDepartment) // find department
+      .mockReturnValueOnce(newParent) // find new parent
+      .mockReturnValueOnce(newParent); // ancestor walk: newParent has no parent
+    spies.update.mockReturnValue(updated);
+
+    const result = await run(db, {
+      departmentId: inactiveDepartment.id,
+      parentDepartmentId: newParent.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.department.parentDepartmentId).toBe(newParent.id);
+    }
+  });
+});