@tailor-platform/erp-kit 0.2.2 → 0.4.0

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

@@ -0,0 +1,195 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PartnerNotFoundError,
+  PartnerInactiveError,
+  InvalidAddressTypeError,
+  MissingRequiredAddressFieldError,
+  InvalidCountryCodeError,
+} from "../lib/errors.generated";
+import {
+  baseActivePartner,
+  baseDraftPartner,
+  baseInactivePartner,
+  baseBillingAddress,
+} from "../testing/fixtures";
+import { run } from "./createPartnerAddress";
+
+describe("createPartnerAddress", () => {
+  const validInput = {
+    partnerId: "partner-2",
+    addressType: "BILLING" as const,
+    line1: "123 Main St",
+    city: "New York",
+    postalCode: "10001",
+    country: "US",
+  };
+
+  it("creates address for active partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdAddress = {
+      ...baseBillingAddress,
+      id: "new-address-id",
+    };
+
+    spies.select.mockReturnValueOnce(baseActivePartner); // Partner lookup
+    spies.insert.mockReturnValue(createdAddress);
+
+    const result = await run(db, validInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.address.id).toBe("new-address-id");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates address for draft partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdAddress = {
+      ...baseBillingAddress,
+      id: "new-address-id",
+      partnerId: "partner-1",
+    };
+
+    spies.select.mockReturnValueOnce(baseDraftPartner); // Partner lookup
+    spies.insert.mockReturnValue(createdAddress);
+
+    const result = await run(db, { ...validInput, partnerId: "partner-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.address).toBeDefined();
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  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, { ...validInput, partnerId: "nonexistent" });
+
+    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); // Inactive partner
+
+    const result = await run(db, { ...validInput, partnerId: "partner-3" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerInactiveError);
+    }
+  });
+
+  it("returns error when address type is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      ...validInput,
+      addressType: "INVALID" as never,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAddressTypeError);
+    }
+  });
+
+  it("returns error when required fields missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      ...validInput,
+      line1: "",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredAddressFieldError);
+    }
+  });
+
+  it("returns error when country code is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      ...validInput,
+      country: "USA",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCountryCodeError);
+    }
+  });
+
+  it("returns error when country code is lowercase", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      ...validInput,
+      country: "us",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCountryCodeError);
+    }
+  });
+
+  it("creates non-default address", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdAddress = {
+      ...baseBillingAddress,
+      id: "new-address-id",
+      isDefault: false,
+    };
+
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.insert.mockReturnValue(createdAddress);
+
+    const result = await run(db, {
+      ...validInput,
+      isDefault: false,
+    });
+
+    expect(result.ok).toBe(true);
+    // No update call to unset previous defaults
+    expect(spies.update).not.toHaveBeenCalled();
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("unsets previous default when creating with isDefault true", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdAddress = {
+      ...baseBillingAddress,
+      id: "new-address-id",
+      isDefault: true,
+    };
+
+    spies.select.mockReturnValueOnce(baseActivePartner); // Partner lookup
+    spies.insert.mockReturnValue(createdAddress);
+
+    const result = await run(db, {
+      ...validInput,
+      isDefault: true,
+    });
+
+    expect(result.ok).toBe(true);
+    // The update call unsets previous defaults
+    expect(spies.update).toHaveBeenCalled();
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,119 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PartnerNotFoundError,
+  PartnerInactiveError,
+  InvalidAddressTypeError,
+  MissingRequiredAddressFieldError,
+  InvalidCountryCodeError,
+} from "../lib/errors.generated";
+
+const VALID_ADDRESS_TYPES = ["BILLING", "SHIPPING", "REGISTERED", "OTHER"] as const;
+type AddressType = (typeof VALID_ADDRESS_TYPES)[number];
+
+export interface CreatePartnerAddressInput {
+  partnerId: string;
+  addressType: AddressType;
+  line1: string;
+  line2?: string;
+  city: string;
+  state?: string;
+  postalCode: string;
+  country: string;
+  isDefault?: boolean;
+}
+
+/**
+ * Function: createPartnerAddress
+ *
+ * Creates a new address for a business partner. If isDefault is true,
+ * unsets the previous default address of the same type for the same partner.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreatePartnerAddressInput & CF,
+) {
+  const {
+    partnerId,
+    addressType,
+    line1,
+    line2,
+    city,
+    state,
+    postalCode,
+    country,
+    isDefault = false,
+    ...customFields
+  } = input;
+
+  // 1. Check partner exists
+  const partner = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", partnerId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!partner) {
+    return err(new PartnerNotFoundError(partnerId));
+  }
+
+  // 2. Check partner is not INACTIVE
+  if (partner.status === "INACTIVE") {
+    return err(new PartnerInactiveError(partnerId));
+  }
+
+  // 3. Validate addressType
+  if (!VALID_ADDRESS_TYPES.includes(addressType)) {
+    return err(new InvalidAddressTypeError(addressType));
+  }
+
+  // 4. Validate required fields
+  if (!line1?.trim()) {
+    return err(new MissingRequiredAddressFieldError("line1"));
+  }
+  if (!city?.trim()) {
+    return err(new MissingRequiredAddressFieldError("city"));
+  }
+  if (!postalCode?.trim()) {
+    return err(new MissingRequiredAddressFieldError("postalCode"));
+  }
+
+  // 5. Validate country code (ISO 3166-1 alpha-2: two uppercase letters)
+  if (!/^[A-Z]{2}$/.test(country)) {
+    return err(new InvalidCountryCodeError(country));
+  }
+
+  // 6. If isDefault, unset previous default of same type for same partner
+  if (isDefault) {
+    await db
+      .updateTable("PartnerAddress")
+      .set({ isDefault: false, updatedAt: new Date() })
+      .where("partnerId", "=", partnerId)
+      .where("addressType", "=", addressType)
+      .where("isDefault", "=", true)
+      .execute();
+  }
+
+  // 7. Create address
+  const address = await db
+    .insertInto("PartnerAddress")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      partnerId,
+      addressType,
+      line1,
+      line2: line2 ?? null,
+      city,
+      state: state ?? null,
+      postalCode,
+      country,
+      isDefault,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ address: address! });
+}

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

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

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

@@ -0,0 +1,297 @@
+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 {
+  PartnerNotFoundError,
+  InvalidBankNameError,
+  InvalidAccountHolderNameError,
+  MissingAccountIdentifierError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
+import {
+  baseActivePartner,
+  baseDraftPartner,
+  baseInactivePartner,
+  baseDefaultBankAccount,
+  baseSecondBankAccount,
+} from "../testing/fixtures";
+import { run } from "./createPartnerBankAccount";
+
+describe("createPartnerBankAccount", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:createPartnerBankAccount"],
+  };
+
+  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 };
+
+  const baseInput = {
+    partnerId: "partner-2",
+    bankName: "First National Bank",
+    accountHolderName: "Global Supplies Inc",
+    accountNumber: "1234567890",
+    currencyId: "currency-usd",
+  };
+
+  it("creates bank account for partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // partner exists
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // no existing accounts
+    spies.select.mockReturnValueOnce([]);
+    // insert returns new account
+    spies.insert.mockReturnValueOnce({ ...baseDefaultBankAccount });
+
+    const result = await run(db, baseInput, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount).toEqual(baseDefaultBankAccount);
+    }
+  });
+
+  it("auto-sets first account as default", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // no existing accounts — empty array
+    spies.select.mockReturnValueOnce([]);
+    spies.insert.mockReturnValueOnce({ ...baseDefaultBankAccount, isDefault: true });
+
+    await run(db, baseInput, ctx, primitivesQueries);
+
+    expect(spies.values).toHaveBeenCalledWith(expect.objectContaining({ isDefault: true }));
+  });
+
+  it("does not set default when partner already has accounts", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // existing accounts
+    spies.select.mockReturnValueOnce([{ id: "bank-1" }]);
+    spies.insert.mockReturnValueOnce({ ...baseDefaultBankAccount, isDefault: false });
+
+    await run(db, baseInput, ctx, primitivesQueries);
+
+    expect(spies.values).toHaveBeenCalledWith(expect.objectContaining({ isDefault: false }));
+  });
+
+  it("creates bank account with iban", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.select.mockReturnValueOnce([]);
+    spies.insert.mockReturnValueOnce({
+      ...baseSecondBankAccount,
+      partnerId: "partner-2",
+      isDefault: true,
+    });
+
+    const result = await run(
+      db,
+      {
+        partnerId: "partner-2",
+        bankName: "Deutsche Bank",
+        accountHolderName: "Global Supplies GmbH",
+        iban: "DE89370400440532013000",
+        currencyId: "currency-usd",
+      },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(true);
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({ iban: "DE89370400440532013000" }),
+    );
+  });
+
+  it("creates bank account with both accountNumber and iban", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.select.mockReturnValueOnce([]);
+    spies.insert.mockReturnValueOnce({ ...baseDefaultBankAccount, iban: "DE89370400440532013000" });
+
+    const result = await run(
+      db,
+      {
+        ...baseInput,
+        iban: "DE89370400440532013000",
+      },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(true);
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountNumber: "1234567890",
+        iban: "DE89370400440532013000",
+      }),
+    );
+  });
+
+  it("creates bank account with routingNumber", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.select.mockReturnValueOnce([]);
+    spies.insert.mockReturnValueOnce({ ...baseDefaultBankAccount, routingNumber: "021000021" });
+
+    const result = await run(
+      db,
+      {
+        ...baseInput,
+        routingNumber: "021000021",
+      },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(true);
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({ routingNumber: "021000021" }),
+    );
+  });
+
+  it("creates bank account with swiftBic", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.select.mockReturnValueOnce([]);
+    spies.insert.mockReturnValueOnce({ ...baseDefaultBankAccount, swiftBic: "DEUTDEDB" });
+
+    const result = await run(
+      db,
+      {
+        ...baseInput,
+        swiftBic: "DEUTDEDB",
+      },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(true);
+    expect(spies.values).toHaveBeenCalledWith(expect.objectContaining({ swiftBic: "DEUTDEDB" }));
+  });
+
+  it("creates bank account for DRAFT partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftPartner);
+    spies.select.mockReturnValueOnce([]);
+    spies.insert.mockReturnValueOnce({
+      ...baseDefaultBankAccount,
+      partnerId: "partner-1",
+    });
+
+    const result = await run(db, { ...baseInput, partnerId: "partner-1" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.partnerId).toBe("partner-1");
+    }
+  });
+
+  it("creates bank account for INACTIVE partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInactivePartner);
+    spies.select.mockReturnValueOnce([]);
+    spies.insert.mockReturnValueOnce({
+      ...baseDefaultBankAccount,
+      partnerId: "partner-3",
+    });
+
+    const result = await run(db, { ...baseInput, partnerId: "partner-3" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.bankAccount.partnerId).toBe("partner-3");
+    }
+  });
+
+  it("returns error when partner not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, baseInput, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerNotFoundError);
+    }
+  });
+
+  it("returns error when bank name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, { ...baseInput, 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(baseActivePartner);
+
+    const result = await run(db, { ...baseInput, accountHolderName: "" }, ctx, primitivesQueries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAccountHolderNameError);
+    }
+  });
+
+  it("returns error when neither account number nor iban provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(
+      db,
+      { ...baseInput, accountNumber: undefined, iban: undefined },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingAccountIdentifierError);
+    }
+  });
+
+  it("returns error when currency not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(
+      db,
+      { ...baseInput, currencyId: "currency-nonexistent" },
+      ctx,
+      primitivesQueries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
+  });
+});