@tailor-platform/erp-kit 0.2.2 → 0.4.0

package/src/modules/business-partner/command/reactivateContactPerson.ts

@@ -0,0 +1,48 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ContactPersonNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
+
+export interface ReactivateContactPersonInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: reactivateContactPerson
+ *
+ * Reactivates an INACTIVE contact person by setting status to ACTIVE.
+ * Does NOT restore primary designation.
+ */
+export async function run(db: Transaction, input: ReactivateContactPersonInput) {
+  const { id, from = ["INACTIVE"] } = input;
+
+  // 1. Check contact exists
+  const existing = await db
+    .selectFrom("ContactPerson")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new ContactPersonNotFoundError(id));
+  }
+
+  // 2. Validate status transition
+  if (!from.includes(existing.status)) {
+    return err(new InvalidStateTransitionError(id));
+  }
+
+  // 3. Set status to ACTIVE
+  const contact = await db
+    .updateTable("ContactPerson")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ contact: contact! });
+}

package/src/modules/business-partner/command/reactivatePartner.generated.ts

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

package/src/modules/business-partner/command/reactivatePartner.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, PartnerNotFoundError } from "../lib/errors.generated";
+import { baseActivePartner, baseDraftPartner, baseInactivePartner } from "../testing/fixtures";
+import { run } from "./reactivatePartner";
+
+describe("reactivatePartner", () => {
+  it("reactivates an INACTIVE partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivatedPartner = { ...baseInactivePartner, status: "ACTIVE" };
+    spies.select.mockReturnValueOnce(baseInactivePartner);
+    spies.update.mockReturnValue(reactivatedPartner);
+
+    const result = await run(db, { id: baseInactivePartner.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partner.status).toBe("ACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when partner not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerNotFoundError);
+    }
+  });
+
+  it("returns error when partner is DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftPartner);
+
+    const result = await run(db, { id: baseDraftPartner.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("returns error when partner is ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, { id: baseActivePartner.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+});

package/src/modules/business-partner/command/reactivatePartner.ts

@@ -0,0 +1,46 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, PartnerNotFoundError } from "../lib/errors.generated";
+
+export interface ReactivatePartnerInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: reactivatePartner
+ *
+ * Transitions a business partner from INACTIVE back to ACTIVE status,
+ * restoring a previously deactivated partner for transactions.
+ */
+export async function run(db: Transaction, input: ReactivatePartnerInput) {
+  const { id, from } = input;
+
+  // 1. Check partner exists
+  const partner = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!partner) {
+    return err(new PartnerNotFoundError(id));
+  }
+
+  // 2. Check status is valid for reactivation
+  const validFromStatuses = from ?? ["INACTIVE"];
+  if (!validFromStatuses.includes(partner.status)) {
+    return err(new InvalidStateTransitionError(`${partner.status} to ACTIVE`));
+  }
+
+  // 3. Update status to ACTIVE
+  const reactivatedPartner = await db
+    .updateTable("BusinessPartner")
+    .set({ status: "ACTIVE", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ partner: reactivatedPartner });
+}

package/src/modules/business-partner/command/removeRoleFromPartner.generated.ts

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

package/src/modules/business-partner/command/removeRoleFromPartner.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidRoleError,
+  PartnerNotFoundError,
+  PartnerNotActiveError,
+} from "../lib/errors.generated";
+import { baseActivePartner, baseInactivePartner, baseCustomerRole } from "../testing/fixtures";
+import { run } from "./removeRoleFromPartner";
+
+const ctx: CommandContext = {
+  actorId: "test-actor",
+  permissions: ["business-partner:removeRoleFromPartner"],
+};
+
+describe("removeRoleFromPartner", () => {
+  it("removes CUSTOMER from partner holding both roles", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner); // partner lookup
+    spies.select.mockReturnValueOnce(baseCustomerRole); // existing role found
+    spies.delete.mockReturnValue(undefined);
+
+    const result = await run(db, { partnerId: "partner-2", role: "CUSTOMER" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.deleted).toBe(true);
+    }
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  it("idempotent when role not present", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner); // partner lookup
+    spies.select.mockReturnValueOnce(undefined); // no existing role
+
+    const result = await run(db, { partnerId: "partner-2", role: "SUPPLIER" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.deleted).toBe(true);
+    }
+    expect(spies.delete).not.toHaveBeenCalled();
+  });
+
+  it("returns error for invalid role value", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { partnerId: "partner-2", role: "INVALID_ROLE" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidRoleError);
+    }
+  });
+
+  it("returns error when partner not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // partner not found
+
+    const result = await run(db, { partnerId: "nonexistent", role: "CUSTOMER" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerNotFoundError);
+    }
+  });
+
+  it("returns error when partner is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInactivePartner); // partner in INACTIVE
+
+    const result = await run(db, { partnerId: "partner-3", role: "CUSTOMER" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerNotActiveError);
+    }
+  });
+});

package/src/modules/business-partner/command/removeRoleFromPartner.ts

@@ -0,0 +1,73 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidRoleError,
+  PartnerNotFoundError,
+  PartnerNotActiveError,
+} from "../lib/errors.generated";
+
+type ValidRole = "CUSTOMER" | "SUPPLIER";
+const VALID_ROLES: readonly ValidRole[] = ["CUSTOMER", "SUPPLIER"] as const;
+
+export interface RemoveRoleFromPartnerInput {
+  partnerId: string;
+  role: string;
+}
+
+/**
+ * Function: removeRoleFromPartner
+ *
+ * Removes a CUSTOMER or SUPPLIER role from an ACTIVE partner. Idempotent —
+ * returns success even if the role was not assigned.
+ */
+export async function run(
+  db: Transaction,
+  input: RemoveRoleFromPartnerInput,
+  _ctx: CommandContext,
+) {
+  const { partnerId, role } = input;
+
+  // 1. Validate role
+  if (!VALID_ROLES.includes(role as ValidRole)) {
+    return err(new InvalidRoleError(role ?? ""));
+  }
+  const validRole = role as ValidRole;
+
+  // 2. Check partner exists and is ACTIVE
+  const partner = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", partnerId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!partner) {
+    return err(new PartnerNotFoundError(partnerId));
+  }
+
+  if (partner.status !== "ACTIVE") {
+    return err(new PartnerNotActiveError(partnerId));
+  }
+
+  // 3. Check if role exists
+  const existingRole = await db
+    .selectFrom("PartnerRole")
+    .selectAll()
+    .where("partnerId", "=", partnerId)
+    .where("role", "=", validRole)
+    .executeTakeFirst();
+
+  // 4. Idempotent — return success even if not found
+  if (!existingRole) {
+    return ok({ deleted: true });
+  }
+
+  // 5. Delete the role
+  await db
+    .deleteFrom("PartnerRole")
+    .where("partnerId", "=", partnerId)
+    .where("role", "=", validRole)
+    .execute();
+
+  return ok({ deleted: true });
+}

package/src/modules/business-partner/command/setDefaultPartnerAddress.generated.ts

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

package/src/modules/business-partner/command/setDefaultPartnerAddress.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AddressNotFoundError } from "../lib/errors.generated";
+import { baseShippingAddress } from "../testing/fixtures";
+import { run } from "./setDefaultPartnerAddress";
+
+describe("setDefaultPartnerAddress", () => {
+  it("sets address as default", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedAddress = {
+      ...baseShippingAddress,
+      isDefault: true,
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValueOnce(baseShippingAddress); // Address lookup
+    spies.update.mockReturnValue(updatedAddress);
+
+    const result = await run(db, { id: "address-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.address.isDefault).toBe(true);
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("unsets previous default of same type", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const newDefault = {
+      ...baseShippingAddress,
+      isDefault: true,
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValueOnce(baseShippingAddress); // Address lookup
+    spies.update
+      .mockReturnValueOnce(undefined) // Unset previous defaults (execute)
+      .mockReturnValueOnce(newDefault); // Set new default
+
+    const result = await run(db, { id: "address-2" });
+
+    expect(result.ok).toBe(true);
+    // Two update calls: one to unset previous defaults, one to set new default
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when address not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // Address not found
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AddressNotFoundError);
+    }
+  });
+});

package/src/modules/business-partner/command/setDefaultPartnerAddress.ts

@@ -0,0 +1,48 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AddressNotFoundError } from "../lib/errors.generated";
+
+export interface SetDefaultPartnerAddressInput {
+  id: string;
+}
+
+/**
+ * Function: setDefaultPartnerAddress
+ *
+ * Sets the specified address as the default for its address type.
+ * Unsets isDefault on all other addresses of the same type and partner.
+ */
+export async function run(db: Transaction, input: SetDefaultPartnerAddressInput) {
+  const { id } = input;
+
+  // 1. Check address exists
+  const address = await db
+    .selectFrom("PartnerAddress")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!address) {
+    return err(new AddressNotFoundError(id));
+  }
+
+  // 2. Unset isDefault on all other addresses of same type and partner
+  await db
+    .updateTable("PartnerAddress")
+    .set({ isDefault: false, updatedAt: new Date() })
+    .where("partnerId", "=", address.partnerId)
+    .where("addressType", "=", address.addressType)
+    .where("isDefault", "=", true)
+    .execute();
+
+  // 3. Set isDefault on this address
+  const updatedAddress = await db
+    .updateTable("PartnerAddress")
+    .set({ isDefault: true, updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ address: updatedAddress });
+}

package/src/modules/business-partner/command/setDefaultPartnerBankAccount.generated.ts

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

package/src/modules/business-partner/command/setDefaultPartnerBankAccount.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BankAccountNotFoundError } from "../lib/errors.generated";
+import { baseSecondBankAccount } from "../testing/fixtures";
+import { run } from "./setDefaultPartnerBankAccount";
+
+describe("setDefaultPartnerBankAccount", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:setDefaultPartnerBankAccount"],
+  };
+
+  it("sets account as default", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseSecondBankAccount);
+    // update unset others — no return needed
+    spies.update.mockReturnValueOnce(undefined);
+    // update set this one
+    spies.update.mockReturnValueOnce({ ...baseSecondBankAccount, isDefault: true });
+
+    const result = await run(db, { id: "bank-2" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.isDefault).toBe(true);
+    }
+  });
+
+  it("unsets previous default account", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseSecondBankAccount);
+    spies.update.mockReturnValueOnce(undefined);
+    spies.update.mockReturnValueOnce({ ...baseSecondBankAccount, isDefault: true });
+
+    await run(db, { id: "bank-2" }, ctx);
+
+    // First update call should set isDefault: false on other accounts
+    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ isDefault: false }));
+    // Second update call should set isDefault: true on this account
+    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ isDefault: true }));
+  });
+
+  it("returns error when account not found", 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(BankAccountNotFoundError);
+    }
+  });
+});

package/src/modules/business-partner/command/setDefaultPartnerBankAccount.ts

@@ -0,0 +1,51 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BankAccountNotFoundError } from "../lib/errors.generated";
+
+export interface SetDefaultPartnerBankAccountInput {
+  id: string;
+}
+
+/**
+ * Function: setDefaultPartnerBankAccount
+ *
+ * Sets a bank account as the default for a partner, unsetting the
+ * previous default.
+ */
+export async function run(
+  db: Transaction,
+  input: SetDefaultPartnerBankAccountInput,
+  _ctx: CommandContext,
+) {
+  const { id } = input;
+
+  // 1. Check account exists
+  const account = await db
+    .selectFrom("PartnerBankAccount")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!account) {
+    return err(new BankAccountNotFoundError(id));
+  }
+
+  // 2. Unset isDefault on all other accounts for same partner
+  await db
+    .updateTable("PartnerBankAccount")
+    .set({ isDefault: false, updatedAt: new Date() })
+    .where("partnerId", "=", account.partnerId)
+    .where("id", "!=", id)
+    .execute();
+
+  // 3. Set isDefault on this account
+  const updated = await db
+    .updateTable("PartnerBankAccount")
+    .set({ isDefault: true, updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ bankAccount: updated! });
+}

package/src/modules/business-partner/command/setPrimaryContactPerson.generated.ts

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

package/src/modules/business-partner/command/setPrimaryContactPerson.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ContactPersonNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
+import { baseNonPrimaryContact, baseInactiveContact } from "../testing/fixtures";
+import { run } from "./setPrimaryContactPerson";
+
+describe("setPrimaryContactPerson", () => {
+  it("sets contact as primary", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseNonPrimaryContact);
+    spies.update.mockReturnValue({
+      ...baseNonPrimaryContact,
+      isPrimary: true,
+    });
+
+    const result = await run(db, { id: baseNonPrimaryContact.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contact.isPrimary).toBe(true);
+    }
+  });
+
+  it("unsets previous primary contact", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseNonPrimaryContact);
+    spies.update.mockReturnValue({
+      ...baseNonPrimaryContact,
+      isPrimary: true,
+    });
+
+    const result = await run(db, { id: baseNonPrimaryContact.id });
+
+    expect(result.ok).toBe(true);
+    // Two update calls: one to unset previous primary, one to set new primary
+    expect(spies.update).toHaveBeenCalledTimes(2);
+  });
+
+  it("returns error when contact not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ContactPersonNotFoundError);
+    }
+  });
+
+  it("returns error when contact is inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInactiveContact);
+
+    const result = await run(db, { id: baseInactiveContact.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+});