@tailor-platform/erp-kit 0.3.0 → 0.4.0

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

@@ -0,0 +1,193 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PartnerNotFoundError,
+  PartnerNotOrganizationError,
+  InvalidFirstNameError,
+  InvalidLastNameError,
+  MissingCommunicationChannelError,
+  InvalidEmailFormatError,
+} from "../lib/errors.generated";
+import { baseActivePartner, baseIndividualPartner } from "../testing/fixtures";
+import { run } from "./createContactPerson";
+
+describe("createContactPerson", () => {
+  it("creates contact person", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.insert.mockReturnValue({
+      id: "new-contact",
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "jane@example.com",
+      phone: null,
+      jobTitle: null,
+      department: null,
+      isPrimary: false,
+      status: "ACTIVE",
+    });
+
+    const result = await run(db, {
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "jane@example.com",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contact.status).toBe("ACTIVE");
+      expect(result.value.contact.isPrimary).toBe(false);
+    }
+  });
+
+  it("returns error when partner not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, {
+      partnerId: "nonexistent",
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "jane@example.com",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerNotFoundError);
+    }
+  });
+
+  it("returns error when partner is INDIVIDUAL", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseIndividualPartner);
+
+    const result = await run(db, {
+      partnerId: baseIndividualPartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "jane@example.com",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PartnerNotOrganizationError);
+    }
+  });
+
+  it("returns error when firstName is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      partnerId: baseActivePartner.id,
+      firstName: "",
+      lastName: "Doe",
+      email: "jane@example.com",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidFirstNameError);
+    }
+  });
+
+  it("returns error when lastName is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "",
+      email: "jane@example.com",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidLastNameError);
+    }
+  });
+
+  it("returns error when neither email nor phone provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingCommunicationChannelError);
+    }
+  });
+
+  it("returns error when whitespace-only channels provided as only communication", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "   ",
+      phone: "   ",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingCommunicationChannelError);
+    }
+  });
+
+  it("returns error for invalid email format", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+
+    const result = await run(db, {
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "invalid-email",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidEmailFormatError);
+    }
+  });
+
+  it("creates with ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActivePartner);
+    spies.insert.mockReturnValue({
+      id: "new-contact",
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "jane@example.com",
+      phone: null,
+      jobTitle: null,
+      department: null,
+      isPrimary: false,
+      status: "ACTIVE",
+    });
+
+    const result = await run(db, {
+      partnerId: baseActivePartner.id,
+      firstName: "Jane",
+      lastName: "Doe",
+      email: "jane@example.com",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contact.status).toBe("ACTIVE");
+    }
+  });
+});

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

@@ -0,0 +1,98 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PartnerNotFoundError,
+  PartnerNotOrganizationError,
+  InvalidFirstNameError,
+  InvalidLastNameError,
+  MissingCommunicationChannelError,
+  InvalidEmailFormatError,
+} from "../lib/errors.generated";
+
+export interface CreateContactPersonInput {
+  partnerId: string;
+  firstName: string;
+  lastName: string;
+  email?: string;
+  phone?: string;
+  jobTitle?: string;
+  department?: string;
+}
+
+/**
+ * Function: createContactPerson
+ *
+ * Creates a new contact person for an ORGANIZATION partner. Validates that
+ * at least one communication channel (email or phone) is provided, and that
+ * email format is valid if supplied. Created with status=ACTIVE, isPrimary=false.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateContactPersonInput & CF,
+) {
+  const { partnerId, firstName, lastName, email, phone, jobTitle, department, ...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. Check partner type is ORGANIZATION
+  if (partner.type !== "ORGANIZATION") {
+    return err(new PartnerNotOrganizationError(partnerId));
+  }
+
+  // 3. Validate firstName non-empty
+  if (!firstName?.trim()) {
+    return err(new InvalidFirstNameError(partnerId));
+  }
+
+  // 4. Validate lastName non-empty
+  if (!lastName?.trim()) {
+    return err(new InvalidLastNameError(partnerId));
+  }
+
+  // 5. At least one of email or phone required (whitespace-only values don't count)
+  const trimmedEmail = email?.trim() ?? undefined;
+  const trimmedPhone = phone?.trim() ?? undefined;
+  if (!trimmedEmail && !trimmedPhone) {
+    return err(new MissingCommunicationChannelError(partnerId));
+  }
+
+  // 6. Validate email format if provided
+  if (trimmedEmail) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(trimmedEmail)) {
+      return err(new InvalidEmailFormatError(trimmedEmail));
+    }
+  }
+
+  // 7. Create contact person
+  const contact = await db
+    .insertInto("ContactPerson")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      partnerId,
+      firstName,
+      lastName,
+      email: email ?? null,
+      phone: phone ?? null,
+      jobTitle: jobTitle ?? null,
+      department: department ?? null,
+      isPrimary: false,
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ contact: contact! });
+}

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

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

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

@@ -0,0 +1,179 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidNameError,
+  InvalidPartnerTypeError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
+import { baseDraftPartner } from "../testing/fixtures";
+import { getCompany } from "../../organization/query/getCompany.generated";
+import { getCurrency } from "../../primitives/query/getCurrency.generated";
+import { run } from "./createPartner";
+
+describe("createPartner", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["business-partner:createPartner"],
+  };
+
+  it("creates partner in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const company = { id: "company-1" };
+    const createdPartner = { ...baseDraftPartner, id: "new-partner-id" };
+
+    spies.select.mockReturnValueOnce(company); // Company lookup
+    spies.insert.mockReturnValue(createdPartner);
+
+    const result = await run(
+      db,
+      { name: "Acme Corp", type: "ORGANIZATION", companyId: "company-1" },
+      ctx,
+      { getCompany },
+      { getCurrency },
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partner.status).toBe("DRAFT");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("returns error when company not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // Company not found
+
+    const result = await run(
+      db,
+      { name: "Acme Corp", type: "ORGANIZATION", companyId: "nonexistent" },
+      ctx,
+      { getCompany },
+      { getCurrency },
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CompanyNotFoundError);
+    }
+  });
+
+  it("returns error when type is invalid", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      { name: "Acme Corp", type: "INVALID" as "ORGANIZATION", companyId: "company-1" },
+      ctx,
+      { getCompany },
+      { getCurrency },
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidPartnerTypeError);
+    }
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      { name: "", type: "ORGANIZATION", companyId: "company-1" },
+      ctx,
+      { getCompany },
+      { getCurrency },
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("creates partner without preferred currency", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const company = { id: "company-1" };
+    const createdPartner = { ...baseDraftPartner, id: "new-partner-id", preferredCurrencyId: null };
+
+    spies.select.mockReturnValueOnce(company); // Company lookup
+    spies.insert.mockReturnValue(createdPartner);
+
+    const result = await run(
+      db,
+      { name: "Acme Corp", type: "ORGANIZATION", companyId: "company-1" },
+      ctx,
+      { getCompany },
+      { getCurrency },
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partner.preferredCurrencyId).toBeNull();
+    }
+  });
+
+  it("creates partner with preferred currency", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const company = { id: "company-1" };
+    const currency = { id: "currency-usd", code: "USD" };
+    const createdPartner = {
+      ...baseDraftPartner,
+      id: "new-partner-id",
+      preferredCurrencyId: "currency-usd",
+    };
+
+    spies.select
+      .mockReturnValueOnce(company) // Company lookup
+      .mockReturnValueOnce(currency); // Currency lookup
+    spies.insert.mockReturnValue(createdPartner);
+
+    const result = await run(
+      db,
+      {
+        name: "Acme Corp",
+        type: "ORGANIZATION",
+        companyId: "company-1",
+        preferredCurrencyId: "currency-usd",
+      },
+      ctx,
+      { getCompany },
+      { getCurrency },
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partner.preferredCurrencyId).toBe("currency-usd");
+    }
+  });
+
+  it("returns error when currency not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const company = { id: "company-1" };
+
+    spies.select
+      .mockReturnValueOnce(company) // Company lookup
+      .mockReturnValueOnce(undefined); // Currency not found
+
+    const result = await run(
+      db,
+      {
+        name: "Acme Corp",
+        type: "ORGANIZATION",
+        companyId: "company-1",
+        preferredCurrencyId: "nonexistent",
+      },
+      ctx,
+      { getCompany },
+      { getCurrency },
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
+  });
+});

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

@@ -0,0 +1,83 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidNameError,
+  InvalidPartnerTypeError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
+
+import type { defineModule as defineOrganizationModule } from "../../organization";
+type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
+type OrganizationQueries = OrganizationModule["queries"];
+
+import type { defineModule as definePrimitivesModule } from "../../primitives";
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesQueries = PrimitivesModule["queries"];
+
+export interface CreatePartnerInput {
+  name: string;
+  type: "ORGANIZATION" | "INDIVIDUAL";
+  companyId: string;
+  preferredCurrencyId?: string;
+}
+
+/**
+ * Function: createPartner
+ *
+ * Creates a new business partner in DRAFT status.
+ * Validates company existence, name, type, and optional currency.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreatePartnerInput & CF,
+  ctx: CommandContext,
+  organizationQueries?: Pick<OrganizationQueries, "getCompany">,
+  primitivesQueries?: Pick<PrimitivesQueries, "getCurrency">,
+) {
+  const { name, type, companyId, preferredCurrencyId, ...customFields } = input;
+
+  // 1. Validate name is non-empty
+  if (!name || name.trim() === "") {
+    return err(new InvalidNameError(name ?? ""));
+  }
+
+  // 2. Validate type
+  if (type !== "ORGANIZATION" && type !== "INDIVIDUAL") {
+    return err(new InvalidPartnerTypeError(type));
+  }
+
+  // 3. Validate company exists
+  const { company } = (await organizationQueries!.getCompany(db, { id: companyId }, ctx)).value;
+  if (!company) {
+    return err(new CompanyNotFoundError(companyId));
+  }
+
+  // 4. Validate currency exists if provided
+  if (preferredCurrencyId) {
+    const { currency } = (
+      await primitivesQueries!.getCurrency(db, { id: preferredCurrencyId }, ctx)
+    ).value;
+    if (!currency) {
+      return err(new CurrencyNotFoundError(preferredCurrencyId));
+    }
+  }
+
+  // 5. Create partner in DRAFT status
+  const partner = await db
+    .insertInto("BusinessPartner")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      name,
+      type,
+      companyId,
+      preferredCurrencyId: preferredCurrencyId ?? null,
+      status: "DRAFT",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ partner: partner! });
+}

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

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