@tailor-platform/erp-kit 0.3.0 → 0.4.0

package/src/modules/business-partner/command/deactivatePartner.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 DeactivatePartnerInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: deactivatePartner
+ *
+ * Transitions a business partner from ACTIVE to INACTIVE status,
+ * preserving it for audit trails while preventing new transactions.
+ */
+export async function run(db: Transaction, input: DeactivatePartnerInput) {
+  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 deactivation
+  const validFromStatuses = from ?? ["ACTIVE"];
+  if (!validFromStatuses.includes(partner.status)) {
+    return err(new InvalidStateTransitionError(`${partner.status} to INACTIVE`));
+  }
+
+  // 3. Update status to INACTIVE
+  const deactivatedPartner = await db
+    .updateTable("BusinessPartner")
+    .set({ status: "INACTIVE", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ partner: deactivatedPartner });
+}

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

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

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

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ContactPersonNotFoundError,
+  ContactNotActiveError,
+  ContactIsPrimaryError,
+} from "../lib/errors.generated";
+import { baseActiveContact, baseInactiveContact, baseNonPrimaryContact } from "../testing/fixtures";
+import { run } from "./deleteContactPerson";
+
+describe("deleteContactPerson", () => {
+  it("deletes a non-primary active contact person", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseNonPrimaryContact);
+
+    const result = await run(db, { id: baseNonPrimaryContact.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.id).toBe(baseNonPrimaryContact.id);
+    }
+    expect(spies.delete).toHaveBeenCalledTimes(1);
+  });
+
+  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 not active", 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(ContactNotActiveError);
+    }
+  });
+
+  it("returns error when contact is primary", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveContact); // isPrimary: true
+
+    const result = await run(db, { id: baseActiveContact.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ContactIsPrimaryError);
+    }
+  });
+});

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

@@ -0,0 +1,48 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ContactPersonNotFoundError,
+  ContactNotActiveError,
+  ContactIsPrimaryError,
+} from "../lib/errors.generated";
+
+export interface DeleteContactPersonInput {
+  id: string;
+}
+
+/**
+ * Function: deleteContactPerson
+ *
+ * Permanently deletes a contact person. Contact must be ACTIVE and must
+ * NOT be the primary contact.
+ */
+export async function run(db: Transaction, input: DeleteContactPersonInput) {
+  const { id } = 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. Contact must be ACTIVE
+  if (existing.status !== "ACTIVE") {
+    return err(new ContactNotActiveError(id));
+  }
+
+  // 3. Contact must NOT be primary
+  if (existing.isPrimary) {
+    return err(new ContactIsPrimaryError(id));
+  }
+
+  // 4. Delete the contact
+  await db.deleteFrom("ContactPerson").where("id", "=", id).execute();
+
+  return ok({ id });
+}

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

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

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

@@ -0,0 +1,58 @@
+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 "./deletePartner";
+
+describe("deletePartner", () => {
+  it("deletes a DRAFT partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftPartner);
+    spies.delete.mockReturnValue(undefined);
+
+    const result = await run(db, { id: baseDraftPartner.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.success).toBe(true);
+    }
+    expect(spies.delete).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 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);
+    }
+  });
+
+  it("returns error when partner is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInactivePartner);
+
+    const result = await run(db, { id: baseInactivePartner.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+});

package/src/modules/business-partner/command/deletePartner.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 DeletePartnerInput {
+  id: string;
+}
+
+/**
+ * Function: deletePartner
+ *
+ * Permanently removes a DRAFT business partner and all related records.
+ * Only DRAFT partners can be deleted; ACTIVE and INACTIVE are preserved for audit trails.
+ */
+export async function run(db: Transaction, input: DeletePartnerInput) {
+  const { id } = 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 DRAFT
+  if (partner.status !== "DRAFT") {
+    return err(new InvalidStateTransitionError(`${id} (status: ${partner.status})`));
+  }
+
+  // 3. Delete related records
+  await db.deleteFrom("PartnerRole").where("partnerId", "=", id).execute();
+  await db.deleteFrom("PartnerAddress").where("partnerId", "=", id).execute();
+  await db.deleteFrom("PartnerBankAccount").where("partnerId", "=", id).execute();
+  await db.deleteFrom("PartnerIdentification").where("partnerId", "=", id).execute();
+  await db.deleteFrom("ContactPerson").where("partnerId", "=", id).execute();
+
+  // 4. Delete partner
+  await db.deleteFrom("BusinessPartner").where("id", "=", id).execute();
+
+  return ok({ success: true as const });
+}

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

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

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

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AddressNotFoundError, AddressInUseError } from "../lib/errors.generated";
+import { baseBillingAddress } from "../testing/fixtures";
+import { run } from "./deletePartnerAddress";
+
+describe("deletePartnerAddress", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:deletePartnerAddress"],
+  };
+
+  it("deletes an address", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBillingAddress);
+
+    const result = await run(db, { id: "address-1" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.success).toBe(true);
+    }
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  it("returns error when address 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(AddressNotFoundError);
+    }
+  });
+
+  it("returns error when address is referenced on transactions", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseBillingAddress);
+
+    const referenceChecker = {
+      isAddressReferenced: () => Promise.resolve(true),
+    };
+
+    const result = await run(db, { id: "address-1" }, ctx, referenceChecker);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AddressInUseError);
+    }
+    // Should not have called delete
+    expect(spies.delete).not.toHaveBeenCalled();
+  });
+
+  it("deleting default does not promote another", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // baseBillingAddress has isDefault: true
+    spies.select.mockReturnValueOnce(baseBillingAddress);
+
+    const referenceChecker = {
+      isAddressReferenced: () => Promise.resolve(false),
+    };
+
+    const result = await run(db, { id: "address-1" }, ctx, referenceChecker);
+
+    expect(result.ok).toBe(true);
+    expect(spies.delete).toHaveBeenCalled();
+    // No update call to promote another address
+    expect(spies.update).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,52 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AddressNotFoundError, AddressInUseError } from "../lib/errors.generated";
+
+export interface DeletePartnerAddressInput {
+  id: string;
+}
+
+export interface AddressReferenceChecker {
+  isAddressReferenced: (db: Transaction, addressId: string) => Promise<boolean>;
+}
+
+/**
+ * Function: deletePartnerAddress
+ *
+ * Permanently removes a partner address. Addresses referenced on
+ * existing transactions cannot be deleted. Deleting a default address
+ * does not auto-promote another address to default.
+ */
+export async function run(
+  db: Transaction,
+  input: DeletePartnerAddressInput,
+  _ctx: CommandContext,
+  referenceChecker?: AddressReferenceChecker,
+) {
+  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. Check if address is referenced on transactions
+  if (referenceChecker) {
+    const inUse = await referenceChecker.isAddressReferenced(db, id);
+    if (inUse) {
+      return err(new AddressInUseError(id));
+    }
+  }
+
+  // 3. Delete address
+  await db.deleteFrom("PartnerAddress").where("id", "=", id).execute();
+
+  return ok({ success: true as const });
+}

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

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

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

@@ -0,0 +1,55 @@
+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 { baseDefaultBankAccount } from "../testing/fixtures";
+import { run } from "./deletePartnerBankAccount";
+
+describe("deletePartnerBankAccount", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:deletePartnerBankAccount"],
+  };
+
+  it("deletes an existing bank account", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+
+    const result = await run(db, { id: "bank-1" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.deleted).toBe(true);
+    }
+    expect(spies.delete).toHaveBeenCalled();
+  });
+
+  it("deletes default bank account without promoting another", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // The account being deleted is the default one
+    spies.select.mockReturnValueOnce({ ...baseDefaultBankAccount, isDefault: true });
+
+    const result = await run(db, { id: "bank-1" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.deleted).toBe(true);
+    }
+    expect(spies.delete).toHaveBeenCalled();
+    // No promotion logic — no additional update calls
+    expect(spies.update).not.toHaveBeenCalled();
+  });
+
+  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/deletePartnerBankAccount.ts

@@ -0,0 +1,36 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { BankAccountNotFoundError } from "../lib/errors.generated";
+
+export interface DeletePartnerBankAccountInput {
+  id: string;
+}
+
+/**
+ * Function: deletePartnerBankAccount
+ *
+ * Permanently removes a bank account from a partner.
+ */
+export async function run(
+  db: Transaction,
+  input: DeletePartnerBankAccountInput,
+  _ctx: CommandContext,
+) {
+  const { id } = input;
+
+  // 1. Check account exists
+  const account = await db
+    .selectFrom("PartnerBankAccount")
+    .selectAll()
+    .where("id", "=", id)
+    .executeTakeFirst();
+
+  if (!account) {
+    return err(new BankAccountNotFoundError(id));
+  }
+
+  // 2. Delete the account
+  await db.deleteFrom("PartnerBankAccount").where("id", "=", id).execute();
+
+  return ok({ deleted: true });
+}

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

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

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

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { IdentificationNotFoundError } from "../lib/errors.generated";
+import { baseTaxIdIdentification } from "../testing/fixtures";
+import { run, type DeletePartnerIdentificationInput } from "./deletePartnerIdentification";
+
+describe("deletePartnerIdentification", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:deletePartnerIdentification"],
+  };
+
+  it("deletes an existing identification", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Select: identification found
+    spies.select.mockReturnValueOnce(baseTaxIdIdentification);
+    // Delete: succeeds
+    spies.delete.mockReturnValueOnce(undefined);
+
+    const input: DeletePartnerIdentificationInput = {
+      id: baseTaxIdIdentification.id,
+    };
+
+    const result = await run(db, input, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.id).toBe(baseTaxIdIdentification.id);
+    }
+  });
+
+  it("returns error when identification not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const input: DeletePartnerIdentificationInput = {
+      id: "non-existent",
+    };
+
+    const result = await run(db, input, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(IdentificationNotFoundError);
+    }
+  });
+});

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

@@ -0,0 +1,37 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { IdentificationNotFoundError } from "../lib/errors.generated";
+
+export interface DeletePartnerIdentificationInput {
+  id: string;
+}
+
+/**
+ * Function: deletePartnerIdentification
+ *
+ * Deletes a partner identification record.
+ * Validates the identification exists before deletion.
+ */
+export async function run(
+  db: Transaction,
+  input: DeletePartnerIdentificationInput,
+  _ctx: CommandContext,
+) {
+  const { id } = input;
+
+  // 1. Check identification exists
+  const existing = await db
+    .selectFrom("PartnerIdentification")
+    .selectAll()
+    .where("id", "=", id)
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new IdentificationNotFoundError(id));
+  }
+
+  // 2. Delete the record
+  await db.deleteFrom("PartnerIdentification").where("id", "=", id).execute();
+
+  return ok({ id });
+}

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

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

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

@@ -0,0 +1,48 @@
+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 { baseActiveContact, baseInactiveContact } from "../testing/fixtures";
+import { run } from "./reactivateContactPerson";
+
+describe("reactivateContactPerson", () => {
+  it("reactivates an inactive contact person", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInactiveContact);
+    spies.update.mockReturnValue({
+      ...baseInactiveContact,
+      status: "ACTIVE",
+    });
+
+    const result = await run(db, { id: baseInactiveContact.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contact.status).toBe("ACTIVE");
+    }
+  });
+
+  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 already active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveContact);
+
+    const result = await run(db, { id: baseActiveContact.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+});