@tailor-platform/erp-kit 0.2.2 → 0.4.0

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

@@ -0,0 +1,114 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PartnerNotFoundError,
+  InvalidBankNameError,
+  InvalidAccountHolderNameError,
+  MissingAccountIdentifierError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
+import type { defineModule as definePrimitivesModule } from "../../primitives";
+
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesQueries = PrimitivesModule["queries"];
+
+export interface CreatePartnerBankAccountInput {
+  partnerId: string;
+  bankName: string;
+  accountHolderName: string;
+  accountNumber?: string;
+  routingNumber?: string;
+  iban?: string;
+  swiftBic?: string;
+  currencyId: string;
+}
+
+/**
+ * Function: createPartnerBankAccount
+ *
+ * Adds a bank account to a business partner. The first account is
+ * automatically set as default. At least one of accountNumber or iban
+ * is required.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreatePartnerBankAccountInput & CF,
+  ctx: CommandContext,
+  primitivesQueries?: Pick<PrimitivesQueries, "getCurrency">,
+) {
+  const {
+    partnerId,
+    bankName,
+    accountHolderName,
+    accountNumber,
+    routingNumber,
+    iban,
+    swiftBic,
+    currencyId,
+    ...customFields
+  } = input;
+
+  // 1. Check partner exists
+  const partner = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", partnerId)
+    .executeTakeFirst();
+
+  if (!partner) {
+    return err(new PartnerNotFoundError(partnerId));
+  }
+
+  // 2. Validate bankName non-empty
+  if (!bankName?.trim()) {
+    return err(new InvalidBankNameError(bankName ?? ""));
+  }
+
+  // 3. Validate accountHolderName non-empty
+  if (!accountHolderName?.trim()) {
+    return err(new InvalidAccountHolderNameError(accountHolderName ?? ""));
+  }
+
+  // 4. At least one of accountNumber or iban required
+  if (!accountNumber?.trim() && !iban?.trim()) {
+    return err(new MissingAccountIdentifierError(partnerId));
+  }
+
+  // 5. Validate currency exists
+  if (primitivesQueries?.getCurrency) {
+    const currencyResult = await primitivesQueries.getCurrency(db, { id: currencyId }, ctx);
+    if (!currencyResult.ok || !currencyResult.value.currency) {
+      return err(new CurrencyNotFoundError(currencyId));
+    }
+  }
+
+  // 6. Check if partner has existing accounts to determine isDefault
+  const existingAccounts = await db
+    .selectFrom("PartnerBankAccount")
+    .select("id")
+    .where("partnerId", "=", partnerId)
+    .execute();
+
+  const isDefault = existingAccounts.length === 0;
+
+  // 7. Create bank account
+  const bankAccount = await db
+    .insertInto("PartnerBankAccount")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      partnerId,
+      bankName,
+      accountHolderName,
+      accountNumber: accountNumber ?? null,
+      routingNumber: routingNumber ?? null,
+      iban: iban ?? null,
+      swiftBic: swiftBic ?? null,
+      currencyId,
+      isDefault,
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ bankAccount });
+}

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

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

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

@@ -0,0 +1,255 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PartnerNotFoundError,
+  InvalidIdentificationTypeError,
+  InvalidValueError,
+  DuplicateIdentificationError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import {
+  baseActivePartner,
+  baseDraftPartner,
+  baseInactivePartner,
+  baseTaxIdIdentification,
+} from "../testing/fixtures";
+import { run, type CreatePartnerIdentificationInput } from "./createPartnerIdentification";
+
+describe("createPartnerIdentification", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:createPartnerIdentification"],
+  };
+
+  it("creates identification for DRAFT partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // First select: partner lookup -> found (DRAFT)
+    spies.select.mockReturnValueOnce(baseDraftPartner);
+    // Second select: duplicate check -> no duplicate
+    spies.select.mockReturnValueOnce(undefined);
+    // Insert: return created identification
+    const created = { ...baseTaxIdIdentification, partnerId: baseDraftPartner.id };
+    spies.insert.mockReturnValueOnce(created);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: baseDraftPartner.id,
+      type: "TAX_ID",
+      value: "12-3456789",
+      issuingCountry: "US",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.identification).toEqual(created);
+    }
+  });
+
+  it("creates identification for partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // First select: partner lookup -> found
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // Second select: duplicate check -> no duplicate
+    spies.select.mockReturnValueOnce(undefined);
+    // Insert: return created identification
+    const created = { ...baseTaxIdIdentification, partnerId: baseActivePartner.id };
+    spies.insert.mockReturnValueOnce(created);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: baseActivePartner.id,
+      type: "TAX_ID",
+      value: "12-3456789",
+      issuingCountry: "US",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.identification).toEqual(created);
+    }
+  });
+
+  it("returns error when partner not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: "non-existent",
+      type: "TAX_ID",
+      value: "12-3456789",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerNotFoundError);
+    }
+  });
+
+  it("returns error when type is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const input = {
+      partnerId: baseActivePartner.id,
+      type: "INVALID_TYPE" as "TAX_ID",
+      value: "12-3456789",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidIdentificationTypeError);
+    }
+  });
+
+  it("returns error when value is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: baseActivePartner.id,
+      type: "TAX_ID",
+      value: "",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidValueError);
+    }
+  });
+
+  it("returns error when duplicate (type, value) in company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Partner found
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // Duplicate found
+    spies.select.mockReturnValueOnce(baseTaxIdIdentification);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: baseActivePartner.id,
+      type: "TAX_ID",
+      value: "12-3456789",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateIdentificationError);
+    }
+  });
+
+  it("returns error when validTo is before validFrom", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Partner found
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // No duplicate
+    spies.select.mockReturnValueOnce(undefined);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: baseActivePartner.id,
+      type: "VAT",
+      value: "DE999999999",
+      validFrom: new Date("2025-12-31"),
+      validTo: new Date("2024-01-01"),
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidValidityPeriodError);
+    }
+  });
+
+  it("creates identification for INACTIVE partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // First select: partner lookup -> found (INACTIVE)
+    spies.select.mockReturnValueOnce(baseInactivePartner);
+    // Second select: duplicate check -> no duplicate
+    spies.select.mockReturnValueOnce(undefined);
+    // Insert: return created identification
+    const created = { ...baseTaxIdIdentification, partnerId: baseInactivePartner.id };
+    spies.insert.mockReturnValueOnce(created);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: baseInactivePartner.id,
+      type: "TAX_ID",
+      value: "12-3456789",
+      issuingCountry: "US",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.identification).toEqual(created);
+    }
+  });
+
+  it("creates with optional fields omitted", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // First select: partner lookup -> found
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    // Second select: duplicate check -> no duplicate
+    spies.select.mockReturnValueOnce(undefined);
+    // Insert: return created identification with nulls for optional fields
+    const created = {
+      ...baseTaxIdIdentification,
+      partnerId: baseActivePartner.id,
+      issuingCountry: null,
+      validFrom: null,
+      validTo: null,
+    };
+    spies.insert.mockReturnValueOnce(created);
+
+    const input: CreatePartnerIdentificationInput = {
+      partnerId: baseActivePartner.id,
+      type: "TAX_ID",
+      value: "12-3456789",
+    };
+
+    const result = await run(
+      db,
+      input as CreatePartnerIdentificationInput & Record<string, unknown>,
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.identification).toEqual(created);
+    }
+  });
+});

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

@@ -0,0 +1,97 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PartnerNotFoundError,
+  InvalidIdentificationTypeError,
+  InvalidValueError,
+  DuplicateIdentificationError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+
+const VALID_TYPES = ["TAX_ID", "VAT", "DUNS", "COMPANY_REGISTRY", "NATIONAL_ID", "OTHER"] as const;
+type IdentificationType = (typeof VALID_TYPES)[number];
+
+export interface CreatePartnerIdentificationInput {
+  partnerId: string;
+  type: IdentificationType;
+  value: string;
+  issuingCountry?: string;
+  validFrom?: Date;
+  validTo?: Date;
+}
+
+/**
+ * Function: createPartnerIdentification
+ *
+ * Creates a new identification record for a business partner.
+ * Validates partner existence, type enum, non-empty value,
+ * (type, value) uniqueness within company scope, and validity period.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreatePartnerIdentificationInput & CF,
+  _ctx: CommandContext,
+) {
+  const { partnerId, type, value, issuingCountry, validFrom, validTo, ...customFields } = input;
+
+  // 1. Check partner exists
+  const partner = await db
+    .selectFrom("BusinessPartner")
+    .selectAll()
+    .where("id", "=", partnerId)
+    .executeTakeFirst();
+
+  if (!partner) {
+    return err(new PartnerNotFoundError(partnerId));
+  }
+
+  // 2. Validate type is valid enum value
+  if (!VALID_TYPES.includes(type)) {
+    return err(new InvalidIdentificationTypeError(type));
+  }
+
+  // 3. Validate value is non-empty
+  if (!value || value.trim() === "") {
+    return err(new InvalidValueError(value ?? ""));
+  }
+
+  // 4. Check (type, value) uniqueness within company scope
+  const duplicate = await db
+    .selectFrom("PartnerIdentification")
+    .innerJoin("BusinessPartner", "BusinessPartner.id", "PartnerIdentification.partnerId")
+    .selectAll("PartnerIdentification")
+    .where("BusinessPartner.companyId", "=", partner.companyId)
+    .where("PartnerIdentification.type", "=", type)
+    .where("PartnerIdentification.value", "=", value)
+    .executeTakeFirst();
+
+  if (duplicate) {
+    return err(new DuplicateIdentificationError(`${type}:${value}`));
+  }
+
+  // 5. Validate validity period
+  if (validFrom && validTo && validTo < validFrom) {
+    return err(
+      new InvalidValidityPeriodError(`${validFrom.toISOString()} - ${validTo.toISOString()}`),
+    );
+  }
+
+  // 6. Create identification record
+  const identification = await db
+    .insertInto("PartnerIdentification")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      partnerId,
+      type,
+      value,
+      issuingCountry: issuingCountry ?? null,
+      validFrom: validFrom ?? null,
+      validTo: validTo ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ identification: identification! });
+}

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

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

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

@@ -0,0 +1,70 @@
+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 "./deactivateContactPerson";
+
+describe("deactivateContactPerson", () => {
+  it("deactivates an active contact person", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseActiveContact, isPrimary: false });
+    spies.update.mockReturnValue({
+      ...baseActiveContact,
+      isPrimary: false,
+      status: "INACTIVE",
+    });
+
+    const result = await run(db, { id: baseActiveContact.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contact.status).toBe("INACTIVE");
+    }
+  });
+
+  it("removes primary designation when deactivating primary contact", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveContact); // isPrimary: true
+    spies.update.mockReturnValue({
+      ...baseActiveContact,
+      isPrimary: false,
+      status: "INACTIVE",
+    });
+
+    const result = await run(db, { id: baseActiveContact.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contact.isPrimary).toBe(false);
+      expect(result.value.contact.status).toBe("INACTIVE");
+    }
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({ isPrimary: false, status: "INACTIVE" }),
+    );
+  });
+
+  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 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);
+    }
+  });
+});

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

@@ -0,0 +1,54 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { ContactPersonNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
+
+export interface DeactivateContactPersonInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: deactivateContactPerson
+ *
+ * Deactivates a contact person by setting status to INACTIVE. If the contact
+ * is primary, removes the primary designation (sets isPrimary=false).
+ */
+export async function run(db: Transaction, input: DeactivateContactPersonInput) {
+  const { id, from = ["ACTIVE"] } = 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. Build update: set INACTIVE, remove primary if needed
+  const updateValues: Record<string, unknown> = {
+    status: "INACTIVE",
+    updatedAt: new Date(),
+  };
+
+  if (existing.isPrimary) {
+    updateValues.isPrimary = false;
+  }
+
+  const contact = await db
+    .updateTable("ContactPerson")
+    .set(updateValues)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ contact: contact! });
+}

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

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

package/src/modules/business-partner/command/deactivatePartner.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 "./deactivatePartner";
+
+describe("deactivatePartner", () => {
+  it("deactivates an ACTIVE partner", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivatedPartner = { ...baseActivePartner, status: "INACTIVE" };
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.update.mockReturnValue(deactivatedPartner);
+
+    const result = await run(db, { id: baseActivePartner.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partner.status).toBe("INACTIVE");
+    }
+    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 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);
+    }
+  });
+});