@tailor-platform/erp-kit 0.2.2 → 0.4.0

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

@@ -0,0 +1,64 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { AddressNotFoundError, InvalidCountryCodeError } from "../lib/errors.generated";
+
+export interface UpdatePartnerAddressInput {
+  id: string;
+  line1?: string;
+  line2?: string | null;
+  city?: string;
+  state?: string | null;
+  postalCode?: string;
+  country?: string;
+}
+
+/**
+ * Function: updatePartnerAddress
+ *
+ * Updates mutable fields of an existing partner address.
+ * addressType is immutable and not accepted as input.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdatePartnerAddressInput & Partial<CF>,
+) {
+  const { id, line1, line2, city, state, postalCode, country, ...customFields } = 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. Validate country if provided (ISO 3166-1 alpha-2: two uppercase letters)
+  if (country !== undefined && !/^[A-Z]{2}$/.test(country)) {
+    return err(new InvalidCountryCodeError(country));
+  }
+
+  // 3. Apply updates
+  const updates: Record<string, unknown> = {
+    ...(customFields as Record<string, unknown>),
+    updatedAt: new Date(),
+  };
+  if (line1 !== undefined) updates.line1 = line1;
+  if (line2 !== undefined) updates.line2 = line2;
+  if (city !== undefined) updates.city = city;
+  if (state !== undefined) updates.state = state;
+  if (postalCode !== undefined) updates.postalCode = postalCode;
+  if (country !== undefined) updates.country = country;
+
+  const updatedAddress = await db
+    .updateTable("PartnerAddress")
+    .set(updates)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ address: updatedAddress });
+}

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

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

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

@@ -0,0 +1,249 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { GetCurrencyInput } from "../../primitives/query/getCurrency";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BankAccountNotFoundError,
+  InvalidBankNameError,
+  InvalidAccountHolderNameError,
+  CurrencyNotFoundError,
+  MissingAccountIdentifierError,
+} from "../lib/errors.generated";
+import {
+  baseDefaultBankAccount,
+  baseSecondBankAccount,
+  baseDraftPartner,
+  baseActivePartner,
+  baseInactivePartner,
+} from "../testing/fixtures";
+import { run } from "./updatePartnerBankAccount";
+
+describe("updatePartnerBankAccount", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:updatePartnerBankAccount"],
+  };
+
+  const baseCurrency = {
+    id: "currency-usd",
+    code: "USD",
+    name: "US Dollar",
+    symbol: "$",
+    decimalPlaces: 2,
+    isActive: true,
+    isBaseCurrency: true,
+    createdAt: new Date("2024-01-01"),
+    updatedAt: null,
+  };
+
+  const mockGetCurrency = (_db: unknown, input: GetCurrencyInput, _ctx: unknown) =>
+    Promise.resolve({
+      ok: true as const,
+      value: {
+        currency: "id" in input && input.id === "currency-usd" ? baseCurrency : null,
+      },
+    });
+  const primitivesQueries = { getCurrency: mockGetCurrency };
+
+  it("updates bank account details", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedAccount = { ...baseDefaultBankAccount, bankName: "Updated Bank" };
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(
+      db,
+      { id: "bank-1", bankName: "Updated Bank" },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.bankName).toBe("Updated Bank");
+    }
+  });
+
+  it("updates routingNumber", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedAccount = { ...baseDefaultBankAccount, routingNumber: "021000089" };
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(
+      db,
+      { id: "bank-1", routingNumber: "021000089" },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.routingNumber).toBe("021000089");
+    }
+  });
+
+  it("updates swiftBic", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedAccount = { ...baseDefaultBankAccount, swiftBic: "BOFAUS3N" };
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(db, { id: "bank-1", swiftBic: "BOFAUS3N" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.swiftBic).toBe("BOFAUS3N");
+    }
+  });
+
+  it("clears routingNumber when null is passed", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedAccount = { ...baseDefaultBankAccount, routingNumber: null };
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(db, { id: "bank-1", routingNumber: null }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.routingNumber).toBeNull();
+    }
+  });
+
+  it("clears swiftBic when null is passed", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedAccount = { ...baseSecondBankAccount, swiftBic: null };
+    spies.select.mockReturnValueOnce(baseSecondBankAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(db, { id: "bank-2", swiftBic: null }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.swiftBic).toBeNull();
+    }
+  });
+
+  it("updates bank account for DRAFT partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const draftAccount = { ...baseDefaultBankAccount, partnerId: baseDraftPartner.id };
+    const updatedAccount = { ...draftAccount, bankName: "Draft Bank" };
+    spies.select.mockReturnValueOnce(draftAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(db, { id: "bank-1", bankName: "Draft Bank" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.bankName).toBe("Draft Bank");
+    }
+  });
+
+  it("updates bank account for ACTIVE partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const activeAccount = { ...baseDefaultBankAccount, partnerId: baseActivePartner.id };
+    const updatedAccount = { ...activeAccount, bankName: "Active Bank" };
+    spies.select.mockReturnValueOnce(activeAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(db, { id: "bank-1", bankName: "Active Bank" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.bankName).toBe("Active Bank");
+    }
+  });
+
+  it("updates bank account for INACTIVE partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const inactiveAccount = { ...baseDefaultBankAccount, partnerId: baseInactivePartner.id };
+    const updatedAccount = { ...inactiveAccount, bankName: "Inactive Bank" };
+    spies.select.mockReturnValueOnce(inactiveAccount);
+    spies.update.mockReturnValueOnce(updatedAccount);
+
+    const result = await run(
+      db,
+      { id: "bank-1", bankName: "Inactive Bank" },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.bankName).toBe("Inactive Bank");
+    }
+  });
+
+  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, primitivesQueries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(BankAccountNotFoundError);
+    }
+  });
+
+  it("returns error when bank name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+
+    const result = await run(db, { id: "bank-1", bankName: "" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidBankNameError);
+    }
+  });
+
+  it("returns error when account holder name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+
+    const result = await run(db, { id: "bank-1", accountHolderName: "" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAccountHolderNameError);
+    }
+  });
+
+  it("returns error when currency not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+
+    const result = await run(
+      db,
+      { id: "bank-1", currencyId: "currency-nonexistent" },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
+  });
+
+  it("returns error when update would remove all identifiers", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Account has accountNumber but no iban
+    spies.select.mockReturnValueOnce(baseDefaultBankAccount);
+
+    const result = await run(
+      db,
+      { id: "bank-1", accountNumber: "", iban: "" },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingAccountIdentifierError);
+    }
+  });
+});

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

@@ -0,0 +1,109 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  BankAccountNotFoundError,
+  InvalidBankNameError,
+  InvalidAccountHolderNameError,
+  CurrencyNotFoundError,
+  MissingAccountIdentifierError,
+} from "../lib/errors.generated";
+import type { defineModule as definePrimitivesModule } from "../../primitives";
+
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesQueries = PrimitivesModule["queries"];
+
+export interface UpdatePartnerBankAccountInput {
+  id: string;
+  bankName?: string;
+  accountHolderName?: string;
+  accountNumber?: string;
+  routingNumber?: string | null;
+  iban?: string;
+  swiftBic?: string | null;
+  currencyId?: string;
+}
+
+/**
+ * Function: updatePartnerBankAccount
+ *
+ * Updates mutable fields of an existing partner bank account. After
+ * update, at least one of accountNumber or iban must remain present.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdatePartnerBankAccountInput & CF,
+  ctx: CommandContext,
+  primitivesQueries?: Pick<PrimitivesQueries, "getCurrency">,
+) {
+  const {
+    id,
+    bankName,
+    accountHolderName,
+    accountNumber,
+    routingNumber,
+    iban,
+    swiftBic,
+    currencyId,
+    ...customFields
+  } = 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. Validate bankName non-empty if provided
+  if (bankName !== undefined && !bankName?.trim()) {
+    return err(new InvalidBankNameError(bankName ?? ""));
+  }
+
+  // 3. Validate accountHolderName non-empty if provided
+  if (accountHolderName !== undefined && !accountHolderName?.trim()) {
+    return err(new InvalidAccountHolderNameError(accountHolderName ?? ""));
+  }
+
+  // 4. Validate currency if provided
+  if (currencyId !== undefined && primitivesQueries?.getCurrency) {
+    const currencyResult = await primitivesQueries.getCurrency(db, { id: currencyId }, ctx);
+    if (!currencyResult.ok || !currencyResult.value.currency) {
+      return err(new CurrencyNotFoundError(currencyId));
+    }
+  }
+
+  // 5. After update, at least one of accountNumber or iban must remain
+  const mergedAccountNumber = accountNumber ?? account.accountNumber;
+  const mergedIban = iban ?? account.iban;
+
+  if (!mergedAccountNumber?.trim() && !mergedIban?.trim()) {
+    return err(new MissingAccountIdentifierError(id));
+  }
+
+  // 6. Build update payload
+  const updates: Record<string, unknown> = {
+    ...(customFields as Record<string, unknown>),
+    updatedAt: new Date(),
+  };
+  if (bankName !== undefined) updates.bankName = bankName;
+  if (accountHolderName !== undefined) updates.accountHolderName = accountHolderName;
+  if (accountNumber !== undefined) updates.accountNumber = accountNumber ?? null;
+  if (routingNumber !== undefined) updates.routingNumber = routingNumber ?? null;
+  if (iban !== undefined) updates.iban = iban ?? null;
+  if (swiftBic !== undefined) updates.swiftBic = swiftBic ?? null;
+  if (currencyId !== undefined) updates.currencyId = currencyId;
+
+  const updated = await db
+    .updateTable("PartnerBankAccount")
+    .set(updates)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ bankAccount: updated! });
+}

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

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

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

@@ -0,0 +1,162 @@
+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,
+  InvalidValueError,
+  DuplicateIdentificationError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { baseActivePartner, baseTaxIdIdentification } from "../testing/fixtures";
+import { run, type UpdatePartnerIdentificationInput } from "./updatePartnerIdentification";
+
+describe("updatePartnerIdentification", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:updatePartnerIdentification"],
+  };
+
+  it("updates identification value", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // First select: existing identification found
+    spies.select.mockReturnValueOnce(baseTaxIdIdentification);
+    // Second select: partner lookup for company scope
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // Third select: duplicate check -> no duplicate
+    spies.select.mockReturnValueOnce(undefined);
+    // Update: return updated identification
+    const updated = { ...baseTaxIdIdentification, value: "98-7654321" };
+    spies.update.mockReturnValueOnce(updated);
+
+    const input: UpdatePartnerIdentificationInput = {
+      id: baseTaxIdIdentification.id,
+      value: "98-7654321",
+    };
+
+    const result = await run(
+      db,
+      input as UpdatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.identification).toEqual(updated);
+    }
+  });
+
+  it("returns error when identification not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const input: UpdatePartnerIdentificationInput = {
+      id: "non-existent",
+      value: "new-value",
+    };
+
+    const result = await run(
+      db,
+      input as UpdatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(IdentificationNotFoundError);
+    }
+  });
+
+  it("returns error when value is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseTaxIdIdentification);
+
+    const input: UpdatePartnerIdentificationInput = {
+      id: baseTaxIdIdentification.id,
+      value: "",
+    };
+
+    const result = await run(
+      db,
+      input as UpdatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidValueError);
+    }
+  });
+
+  it("returns error when value is whitespace-only", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseTaxIdIdentification);
+
+    const input: UpdatePartnerIdentificationInput = {
+      id: baseTaxIdIdentification.id,
+      value: "   ",
+    };
+
+    const result = await run(
+      db,
+      input as UpdatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidValueError);
+    }
+  });
+
+  it("returns error when updated value creates duplicate", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Existing identification found
+    spies.select.mockReturnValueOnce(baseTaxIdIdentification);
+    // Partner lookup
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // Duplicate found
+    spies.select.mockReturnValueOnce({
+      ...baseTaxIdIdentification,
+      id: "ident-other",
+      value: "DUPLICATE",
+    });
+
+    const input: UpdatePartnerIdentificationInput = {
+      id: baseTaxIdIdentification.id,
+      value: "DUPLICATE",
+    };
+
+    const result = await run(
+      db,
+      input as UpdatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateIdentificationError);
+    }
+  });
+
+  it("returns error when validity period is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Existing identification with validFrom already set
+    const existingWithDates = {
+      ...baseTaxIdIdentification,
+      validFrom: new Date("2025-06-01"),
+      validTo: null,
+    };
+    spies.select.mockReturnValueOnce(existingWithDates);
+
+    const input: UpdatePartnerIdentificationInput = {
+      id: baseTaxIdIdentification.id,
+      validTo: new Date("2024-01-01"), // before existing validFrom
+    };
+
+    const result = await run(
+      db,
+      input as UpdatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidValidityPeriodError);
+    }
+  });
+});