@tailor-platform/erp-kit 0.3.0 → 0.4.1

package/src/modules/business-partner/lib/errors.generated.ts

@@ -0,0 +1,172 @@
+// @generated — do not edit
+import { createDomainError } from "@tailor-platform/erp-kit/module";
+
+export const PartnerNotFoundError = createDomainError(
+  "PartnerNotFoundError", "BUSINESS_PARTNER_PARTNER_NOT_FOUND",
+  (identifier: string) => `Specified partner ID does not exist: ${identifier}`,
+);
+
+export const InvalidStateTransitionError = createDomainError(
+  "InvalidStateTransitionError", "BUSINESS_PARTNER_INVALID_STATE_TRANSITION",
+  (identifier: string) => `The required state transition is not valid for the current status: ${identifier}`,
+);
+
+export const PartnerNotActiveError = createDomainError(
+  "PartnerNotActiveError", "BUSINESS_PARTNER_PARTNER_NOT_ACTIVE",
+  (identifier: string) => `Partner is not in ACTIVE status: ${identifier}`,
+);
+
+export const InvalidRoleError = createDomainError(
+  "InvalidRoleError", "BUSINESS_PARTNER_INVALID_ROLE",
+  (identifier: string) => `Role is not CUSTOMER or SUPPLIER: ${identifier}`,
+);
+
+export const PartnerNotOrganizationError = createDomainError(
+  "PartnerNotOrganizationError", "BUSINESS_PARTNER_PARTNER_NOT_ORGANIZATION",
+  (identifier: string) => `Partner is of type INDIVIDUAL, not ORGANIZATION: ${identifier}`,
+);
+
+export const InvalidFirstNameError = createDomainError(
+  "InvalidFirstNameError", "BUSINESS_PARTNER_INVALID_FIRST_NAME",
+  (identifier: string) => `First name is empty or not provided: ${identifier}`,
+);
+
+export const InvalidLastNameError = createDomainError(
+  "InvalidLastNameError", "BUSINESS_PARTNER_INVALID_LAST_NAME",
+  (identifier: string) => `Last name is empty or not provided: ${identifier}`,
+);
+
+export const MissingCommunicationChannelError = createDomainError(
+  "MissingCommunicationChannelError", "BUSINESS_PARTNER_MISSING_COMMUNICATION_CHANNEL",
+  (identifier: string) => `Neither email nor phone was provided: ${identifier}`,
+);
+
+export const InvalidEmailFormatError = createDomainError(
+  "InvalidEmailFormatError", "BUSINESS_PARTNER_INVALID_EMAIL_FORMAT",
+  (identifier: string) => `Provided email is not in a valid format: ${identifier}`,
+);
+
+export const CompanyNotFoundError = createDomainError(
+  "CompanyNotFoundError", "BUSINESS_PARTNER_COMPANY_NOT_FOUND",
+  (identifier: string) => `Specified company ID does not exist: ${identifier}`,
+);
+
+export const InvalidNameError = createDomainError(
+  "InvalidNameError", "BUSINESS_PARTNER_INVALID_NAME",
+  (identifier: string) => `Name is empty or not provided: ${identifier}`,
+);
+
+export const InvalidPartnerTypeError = createDomainError(
+  "InvalidPartnerTypeError", "BUSINESS_PARTNER_INVALID_PARTNER_TYPE",
+  (identifier: string) => `Type is not ORGANIZATION or INDIVIDUAL: ${identifier}`,
+);
+
+export const CurrencyNotFoundError = createDomainError(
+  "CurrencyNotFoundError", "BUSINESS_PARTNER_CURRENCY_NOT_FOUND",
+  (identifier: string) => `Referenced preferred currency does not exist: ${identifier}`,
+);
+
+export const PartnerInactiveError = createDomainError(
+  "PartnerInactiveError", "BUSINESS_PARTNER_PARTNER_INACTIVE",
+  (identifier: string) => `Partner is in INACTIVE status: ${identifier}`,
+);
+
+export const InvalidAddressTypeError = createDomainError(
+  "InvalidAddressTypeError", "BUSINESS_PARTNER_INVALID_ADDRESS_TYPE",
+  (identifier: string) => `Address type is not a valid enum value: ${identifier}`,
+);
+
+export const MissingRequiredAddressFieldError = createDomainError(
+  "MissingRequiredAddressFieldError", "BUSINESS_PARTNER_MISSING_REQUIRED_ADDRESS_FIELD",
+  (identifier: string) => `One or more required fields (line1, city, postalCode) are empty or not provided: ${identifier}`,
+);
+
+export const InvalidCountryCodeError = createDomainError(
+  "InvalidCountryCodeError", "BUSINESS_PARTNER_INVALID_COUNTRY_CODE",
+  (identifier: string) => `Country is not a valid ISO 3166-1 alpha-2 code: ${identifier}`,
+);
+
+export const MissingAccountIdentifierError = createDomainError(
+  "MissingAccountIdentifierError", "BUSINESS_PARTNER_MISSING_ACCOUNT_IDENTIFIER",
+  (identifier: string) => `Neither accountNumber nor iban was provided: ${identifier}`,
+);
+
+export const InvalidBankNameError = createDomainError(
+  "InvalidBankNameError", "BUSINESS_PARTNER_INVALID_BANK_NAME",
+  (identifier: string) => `Bank name is empty: ${identifier}`,
+);
+
+export const InvalidAccountHolderNameError = createDomainError(
+  "InvalidAccountHolderNameError", "BUSINESS_PARTNER_INVALID_ACCOUNT_HOLDER_NAME",
+  (identifier: string) => `Account holder name is empty: ${identifier}`,
+);
+
+export const InvalidIdentificationTypeError = createDomainError(
+  "InvalidIdentificationTypeError", "BUSINESS_PARTNER_INVALID_IDENTIFICATION_TYPE",
+  (identifier: string) => `Type is not a valid identification type enum value: ${identifier}`,
+);
+
+export const InvalidValueError = createDomainError(
+  "InvalidValueError", "BUSINESS_PARTNER_INVALID_VALUE",
+  (identifier: string) => `Value is empty or not provided: ${identifier}`,
+);
+
+export const DuplicateIdentificationError = createDomainError(
+  "DuplicateIdentificationError", "BUSINESS_PARTNER_DUPLICATE_IDENTIFICATION",
+  (identifier: string) => `An identification with the same type and value already exists within the company: ${identifier}`,
+);
+
+export const InvalidValidityPeriodError = createDomainError(
+  "InvalidValidityPeriodError", "BUSINESS_PARTNER_INVALID_VALIDITY_PERIOD",
+  (identifier: string) => `validTo is earlier than validFrom: ${identifier}`,
+);
+
+export const ContactPersonNotFoundError = createDomainError(
+  "ContactPersonNotFoundError", "BUSINESS_PARTNER_CONTACT_PERSON_NOT_FOUND",
+  (identifier: string) => `Specified contact person ID does not exist: ${identifier}`,
+);
+
+export const ContactNotActiveError = createDomainError(
+  "ContactNotActiveError", "BUSINESS_PARTNER_CONTACT_NOT_ACTIVE",
+  (identifier: string) => `Contact person is not in ACTIVE status and cannot be deleted: ${identifier}`,
+);
+
+export const ContactIsPrimaryError = createDomainError(
+  "ContactIsPrimaryError", "BUSINESS_PARTNER_CONTACT_IS_PRIMARY",
+  (identifier: string) => `Contact person is currently the primary contact and cannot be deleted: ${identifier}`,
+);
+
+export const AddressNotFoundError = createDomainError(
+  "AddressNotFoundError", "BUSINESS_PARTNER_ADDRESS_NOT_FOUND",
+  (identifier: string) => `Specified address ID does not exist: ${identifier}`,
+);
+
+export const AddressInUseError = createDomainError(
+  "AddressInUseError", "BUSINESS_PARTNER_ADDRESS_IN_USE",
+  (identifier: string) => `Address is referenced on existing transactions and cannot be deleted: ${identifier}`,
+);
+
+export const BankAccountNotFoundError = createDomainError(
+  "BankAccountNotFoundError", "BUSINESS_PARTNER_BANK_ACCOUNT_NOT_FOUND",
+  (identifier: string) => `Specified bank account ID does not exist: ${identifier}`,
+);
+
+export const IdentificationNotFoundError = createDomainError(
+  "IdentificationNotFoundError", "BUSINESS_PARTNER_IDENTIFICATION_NOT_FOUND",
+  (identifier: string) => `Specified identification ID does not exist: ${identifier}`,
+);
+
+export const NoDefaultAddressError = createDomainError(
+  "NoDefaultAddressError", "BUSINESS_PARTNER_NO_DEFAULT_ADDRESS",
+  (identifier: string) => `Addresses of the requested type exist for the partner, but none is marked as default — the caller must set a default or select an address explicitly: ${identifier}`,
+);
+
+export const NoAddressOfTypeError = createDomainError(
+  "NoAddressOfTypeError", "BUSINESS_PARTNER_NO_ADDRESS_OF_TYPE",
+  (identifier: string) => `The partner has no addresses of the requested address type: ${identifier}`,
+);
+
+export const RoleNotFoundError = createDomainError(
+  "RoleNotFoundError", "BUSINESS_PARTNER_ROLE_NOT_FOUND",
+  (identifier: string) => `No role assignment matches the given partnerId and role — caller receives null: ${identifier}`,
+);

package/src/modules/business-partner/lib/permissions.generated.ts

@@ -0,0 +1,30 @@
+// @generated — do not edit
+import { definePermissions } from "@tailor-platform/erp-kit/module";
+
+export const { permissions, own, all } = definePermissions("business-partner", [
+  "activatePartner",
+  "assignRoleToPartner",
+  "createContactPerson",
+  "createPartner",
+  "createPartnerAddress",
+  "createPartnerBankAccount",
+  "createPartnerIdentification",
+  "deactivateContactPerson",
+  "deactivatePartner",
+  "deleteContactPerson",
+  "deletePartner",
+  "deletePartnerAddress",
+  "deletePartnerBankAccount",
+  "deletePartnerIdentification",
+  "reactivateContactPerson",
+  "reactivatePartner",
+  "removeRoleFromPartner",
+  "setDefaultPartnerAddress",
+  "setDefaultPartnerBankAccount",
+  "setPrimaryContactPerson",
+  "updateContactPerson",
+  "updatePartner",
+  "updatePartnerAddress",
+  "updatePartnerBankAccount",
+  "updatePartnerIdentification",
+] as const);

package/src/modules/business-partner/lib/types.ts

@@ -0,0 +1,58 @@
+import type { DB } from "../generated/kysely-tailordb";
+import type {
+  InferSchema,
+  Selectable,
+  Insertable,
+  Updateable,
+} from "@tailor-platform/erp-kit/module";
+
+export type Schema = InferSchema<DB>;
+
+export type BusinessPartner<T extends { BusinessPartner: object }> = Selectable<
+  T["BusinessPartner"]
+>;
+export type BusinessPartnerCreate<T extends { BusinessPartner: object }> = Insertable<
+  T["BusinessPartner"]
+>;
+export type BusinessPartnerUpdate<T extends { BusinessPartner: object }> = Updateable<
+  T["BusinessPartner"]
+>;
+
+export type PartnerRole<T extends { PartnerRole: object }> = Selectable<T["PartnerRole"]>;
+export type PartnerRoleCreate<T extends { PartnerRole: object }> = Insertable<T["PartnerRole"]>;
+
+export type PartnerAddress<T extends { PartnerAddress: object }> = Selectable<T["PartnerAddress"]>;
+export type PartnerAddressCreate<T extends { PartnerAddress: object }> = Insertable<
+  T["PartnerAddress"]
+>;
+export type PartnerAddressUpdate<T extends { PartnerAddress: object }> = Updateable<
+  T["PartnerAddress"]
+>;
+
+export type ContactPerson<T extends { ContactPerson: object }> = Selectable<T["ContactPerson"]>;
+export type ContactPersonCreate<T extends { ContactPerson: object }> = Insertable<
+  T["ContactPerson"]
+>;
+export type ContactPersonUpdate<T extends { ContactPerson: object }> = Updateable<
+  T["ContactPerson"]
+>;
+
+export type PartnerBankAccount<T extends { PartnerBankAccount: object }> = Selectable<
+  T["PartnerBankAccount"]
+>;
+export type PartnerBankAccountCreate<T extends { PartnerBankAccount: object }> = Insertable<
+  T["PartnerBankAccount"]
+>;
+export type PartnerBankAccountUpdate<T extends { PartnerBankAccount: object }> = Updateable<
+  T["PartnerBankAccount"]
+>;
+
+export type PartnerIdentification<T extends { PartnerIdentification: object }> = Selectable<
+  T["PartnerIdentification"]
+>;
+export type PartnerIdentificationCreate<T extends { PartnerIdentification: object }> = Insertable<
+  T["PartnerIdentification"]
+>;
+export type PartnerIdentificationUpdate<T extends { PartnerIdentification: object }> = Updateable<
+  T["PartnerIdentification"]
+>;

package/src/modules/business-partner/module.ts

@@ -0,0 +1,181 @@
+import { type TailorAnyDBField } from "@tailor-platform/sdk";
+import type { defineModule as defineOrganizationModule } from "../organization";
+import type { defineModule as definePrimitivesModule } from "../primitives";
+// Commands
+import { createPartner } from "./command/createPartner.generated";
+import { updatePartner } from "./command/updatePartner.generated";
+import { activatePartner } from "./command/activatePartner.generated";
+import { deactivatePartner } from "./command/deactivatePartner.generated";
+import { reactivatePartner } from "./command/reactivatePartner.generated";
+import { deletePartner } from "./command/deletePartner.generated";
+import { assignRoleToPartner } from "./command/assignRoleToPartner.generated";
+import { removeRoleFromPartner } from "./command/removeRoleFromPartner.generated";
+import { createPartnerAddress } from "./command/createPartnerAddress.generated";
+import { updatePartnerAddress } from "./command/updatePartnerAddress.generated";
+import { deletePartnerAddress } from "./command/deletePartnerAddress.generated";
+import { setDefaultPartnerAddress } from "./command/setDefaultPartnerAddress.generated";
+import { createContactPerson } from "./command/createContactPerson.generated";
+import { updateContactPerson } from "./command/updateContactPerson.generated";
+import { deactivateContactPerson } from "./command/deactivateContactPerson.generated";
+import { reactivateContactPerson } from "./command/reactivateContactPerson.generated";
+import { setPrimaryContactPerson } from "./command/setPrimaryContactPerson.generated";
+import { deleteContactPerson } from "./command/deleteContactPerson.generated";
+import { createPartnerBankAccount } from "./command/createPartnerBankAccount.generated";
+import { updatePartnerBankAccount } from "./command/updatePartnerBankAccount.generated";
+import { deletePartnerBankAccount } from "./command/deletePartnerBankAccount.generated";
+import { setDefaultPartnerBankAccount } from "./command/setDefaultPartnerBankAccount.generated";
+import { createPartnerIdentification } from "./command/createPartnerIdentification.generated";
+import { updatePartnerIdentification } from "./command/updatePartnerIdentification.generated";
+import { deletePartnerIdentification } from "./command/deletePartnerIdentification.generated";
+// Queries
+import { getPartner } from "./query/getPartner.generated";
+import { getPartnerRole } from "./query/getPartnerRole.generated";
+import { getPartnerAddress } from "./query/getPartnerAddress.generated";
+import { getDefaultPartnerAddress } from "./query/getDefaultPartnerAddress.generated";
+import { listPartnerAddressesByPartner } from "./query/listPartnerAddressesByPartner.generated";
+import { getContactPerson } from "./query/getContactPerson.generated";
+import { getPrimaryContactPerson } from "./query/getPrimaryContactPerson.generated";
+import { listContactPersonsByPartner } from "./query/listContactPersonsByPartner.generated";
+import { getPartnerBankAccount } from "./query/getPartnerBankAccount.generated";
+import { getDefaultPartnerBankAccount } from "./query/getDefaultPartnerBankAccount.generated";
+import { listPartnerBankAccountsByPartner } from "./query/listPartnerBankAccountsByPartner.generated";
+import { getPartnerIdentification } from "./query/getPartnerIdentification.generated";
+import { listPartnerIdentificationsByPartner } from "./query/listPartnerIdentificationsByPartner.generated";
+import { listPartnersByRole } from "./query/listPartnersByRole.generated";
+// DB types
+import {
+  createBusinessPartnerType,
+  type CreateBusinessPartnerTypeParams,
+} from "./db/businessPartner";
+import { createPartnerRoleType, type CreatePartnerRoleTypeParams } from "./db/partnerRole";
+import { createPartnerAddressType, type CreatePartnerAddressTypeParams } from "./db/partnerAddress";
+import { createContactPersonType, type CreateContactPersonTypeParams } from "./db/contactPerson";
+import {
+  createPartnerBankAccountType,
+  type CreatePartnerBankAccountTypeParams,
+} from "./db/partnerBankAccount";
+import {
+  createPartnerIdentificationType,
+  type CreatePartnerIdentificationTypeParams,
+} from "./db/partnerIdentification";
+import { type EmptyFields, type FieldsToInsertable } from "@tailor-platform/erp-kit/module";
+
+type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
+type OrganizationDB = OrganizationModule["db"];
+export type OrganizationQueries = OrganizationModule["queries"];
+
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesDB = PrimitivesModule["db"];
+export type PrimitivesQueries = PrimitivesModule["queries"];
+
+export interface DefineModuleParams<
+  BPF extends Record<string, TailorAnyDBField>,
+  PRF extends Record<string, TailorAnyDBField>,
+  PAF extends Record<string, TailorAnyDBField>,
+  CPF extends Record<string, TailorAnyDBField>,
+  BAF extends Record<string, TailorAnyDBField>,
+  PIF extends Record<string, TailorAnyDBField>,
+> {
+  businessPartner?: CreateBusinessPartnerTypeParams<BPF>;
+  partnerRole?: CreatePartnerRoleTypeParams<PRF>;
+  partnerAddress?: CreatePartnerAddressTypeParams<PAF>;
+  contactPerson?: CreateContactPersonTypeParams<CPF>;
+  partnerBankAccount?: CreatePartnerBankAccountTypeParams<BAF>;
+  partnerIdentification?: CreatePartnerIdentificationTypeParams<PIF>;
+  organization: {
+    db: { company: OrganizationDB["company"] };
+    queries: Pick<OrganizationQueries, "getCompany">;
+  };
+  primitives: {
+    db: { currency: PrimitivesDB["currency"] };
+    queries: Pick<PrimitivesQueries, "getCurrency">;
+  };
+}
+
+export const defineModule = <
+  const BPF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PRF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PAF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const CPF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const BAF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PIF extends Record<string, TailorAnyDBField> = EmptyFields,
+>(
+  params: DefineModuleParams<BPF, PRF, PAF, CPF, BAF, PIF>,
+) => {
+  const businessPartnerDb = createBusinessPartnerType({
+    ...params.businessPartner,
+    companyType: params.organization.db.company,
+    currencyType: params.primitives.db.currency,
+  });
+  const partnerRoleDb = createPartnerRoleType(params.partnerRole ?? {});
+  const partnerAddressDb = createPartnerAddressType(params.partnerAddress ?? {});
+  const contactPersonDb = createContactPersonType(params.contactPerson ?? {});
+  const partnerBankAccountDb = createPartnerBankAccountType({
+    ...params.partnerBankAccount,
+    currencyType: params.primitives.db.currency,
+  });
+  const partnerIdentificationDb = createPartnerIdentificationType(
+    params.partnerIdentification ?? {},
+  );
+
+  return {
+    db: {
+      businessPartner: businessPartnerDb,
+      partnerRole: partnerRoleDb,
+      partnerAddress: partnerAddressDb,
+      contactPerson: contactPersonDb,
+      partnerBankAccount: partnerBankAccountDb,
+      partnerIdentification: partnerIdentificationDb,
+    },
+    commands: {
+      createPartner: createPartner<FieldsToInsertable<BPF>>(
+        params.organization.queries,
+        params.primitives.queries,
+      ),
+      updatePartner: updatePartner<FieldsToInsertable<BPF>>(params.primitives.queries),
+      activatePartner: activatePartner(),
+      deactivatePartner: deactivatePartner(),
+      reactivatePartner: reactivatePartner(),
+      deletePartner: deletePartner(),
+      assignRoleToPartner: assignRoleToPartner(),
+      removeRoleFromPartner: removeRoleFromPartner(),
+      createPartnerAddress: createPartnerAddress<FieldsToInsertable<PAF>>(),
+      updatePartnerAddress: updatePartnerAddress<FieldsToInsertable<PAF>>(),
+      deletePartnerAddress: deletePartnerAddress(),
+      setDefaultPartnerAddress: setDefaultPartnerAddress(),
+      createContactPerson: createContactPerson<FieldsToInsertable<CPF>>(),
+      updateContactPerson: updateContactPerson<FieldsToInsertable<CPF>>(),
+      deactivateContactPerson: deactivateContactPerson(),
+      reactivateContactPerson: reactivateContactPerson(),
+      setPrimaryContactPerson: setPrimaryContactPerson(),
+      deleteContactPerson: deleteContactPerson(),
+      createPartnerBankAccount: createPartnerBankAccount<FieldsToInsertable<BAF>>(
+        params.primitives.queries,
+      ),
+      updatePartnerBankAccount: updatePartnerBankAccount<FieldsToInsertable<BAF>>(
+        params.primitives.queries,
+      ),
+      deletePartnerBankAccount: deletePartnerBankAccount(),
+      setDefaultPartnerBankAccount: setDefaultPartnerBankAccount(),
+      createPartnerIdentification: createPartnerIdentification<FieldsToInsertable<PIF>>(),
+      updatePartnerIdentification: updatePartnerIdentification<FieldsToInsertable<PIF>>(),
+      deletePartnerIdentification: deletePartnerIdentification(),
+    },
+    queries: {
+      getPartner,
+      getPartnerRole,
+      getPartnerAddress,
+      getDefaultPartnerAddress,
+      listPartnerAddressesByPartner,
+      getContactPerson,
+      getPrimaryContactPerson,
+      listContactPersonsByPartner,
+      getPartnerBankAccount,
+      getDefaultPartnerBankAccount,
+      listPartnerBankAccountsByPartner,
+      getPartnerIdentification,
+      listPartnerIdentificationsByPartner,
+      listPartnersByRole,
+    },
+  };
+};

package/src/modules/business-partner/permissions.ts

@@ -0,0 +1,3 @@
+import { definePermissions } from "@tailor-platform/erp-kit/module";
+
+export const { permissions, own, all } = definePermissions("business-partner", [] as const);

package/src/modules/business-partner/query/getContactPerson.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getContactPerson";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getContactPerson = defineQuery(run);

package/src/modules/business-partner/query/getContactPerson.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveContact } from "../testing/fixtures";
+import { run } from "./getContactPerson";
+
+describe("getContactPerson", () => {
+  it("returns contact person when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseActiveContact);
+
+    const result = await run(db, { id: "contact-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contactPerson).toEqual(baseActiveContact);
+    }
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.contactPerson).toBeNull();
+    }
+  });
+});

package/src/modules/business-partner/query/getContactPerson.ts

@@ -0,0 +1,16 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetContactPersonInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetContactPersonInput) {
+  const contactPerson = await db
+    .selectFrom("ContactPerson")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  return ok({ contactPerson: contactPerson ?? null });
+}

package/src/modules/business-partner/query/getDefaultPartnerAddress.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getDefaultPartnerAddress";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getDefaultPartnerAddress = defineQuery(run);

package/src/modules/business-partner/query/getDefaultPartnerAddress.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { NoAddressOfTypeError, NoDefaultAddressError } from "../lib/errors.generated";
+import { baseBillingAddress, baseShippingAddress } from "../testing/fixtures";
+import { run } from "./getDefaultPartnerAddress";
+
+describe("getDefaultPartnerAddress", () => {
+  it("returns default address when one exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseBillingAddress]);
+
+    const result = await run(db, { partnerId: "partner-2", addressType: "BILLING" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partnerAddress).toEqual(baseBillingAddress);
+    }
+  });
+
+  it("returns error when addresses of the type exist but no default is set", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const nonDefaultAddress = { ...baseShippingAddress, isDefault: false };
+    spies.select.mockReturnValue([nonDefaultAddress]);
+
+    const result = await run(db, { partnerId: "partner-2", addressType: "SHIPPING" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NoDefaultAddressError);
+    }
+  });
+
+  it("returns error when partner has no addresses of the given type", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { partnerId: "partner-2", addressType: "REGISTERED" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NoAddressOfTypeError);
+    }
+  });
+});

package/src/modules/business-partner/query/getDefaultPartnerAddress.ts

@@ -0,0 +1,30 @@
+import type { DB } from "../generated/kysely-tailordb";
+import type { PartnerAddressAddressType } from "../generated/enums";
+import { NoAddressOfTypeError, NoDefaultAddressError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetDefaultPartnerAddressInput {
+  partnerId: string;
+  addressType: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetDefaultPartnerAddressInput) {
+  const addresses = await db
+    .selectFrom("PartnerAddress")
+    .selectAll()
+    .where("partnerId", "=", input.partnerId)
+    .where("addressType", "=", input.addressType as PartnerAddressAddressType)
+    .execute();
+
+  if (addresses.length === 0) {
+    return err(new NoAddressOfTypeError(input.partnerId));
+  }
+
+  const defaultAddress = addresses.find((a) => a.isDefault);
+
+  if (!defaultAddress) {
+    return err(new NoDefaultAddressError(input.partnerId));
+  }
+
+  return ok({ partnerAddress: defaultAddress });
+}

package/src/modules/business-partner/query/getDefaultPartnerBankAccount.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getDefaultPartnerBankAccount";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getDefaultPartnerBankAccount = defineQuery(run);

package/src/modules/business-partner/query/getDefaultPartnerBankAccount.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseDefaultBankAccount } from "../testing/fixtures";
+import { run } from "./getDefaultPartnerBankAccount";
+
+describe("getDefaultPartnerBankAccount", () => {
+  it("returns default bank account when one exists", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseDefaultBankAccount);
+
+    const result = await run(db, { partnerId: "partner-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partnerBankAccount).toEqual(baseDefaultBankAccount);
+    }
+  });
+
+  it("returns null when no default is set", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { partnerId: "partner-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partnerBankAccount).toBeNull();
+    }
+  });
+
+  it("returns null when partner has no bank accounts", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { partnerId: "partner-99" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.partnerBankAccount).toBeNull();
+    }
+  });
+});

package/src/modules/business-partner/query/getDefaultPartnerBankAccount.ts

@@ -0,0 +1,17 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetDefaultPartnerBankAccountInput {
+  partnerId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetDefaultPartnerBankAccountInput) {
+  const partnerBankAccount = await db
+    .selectFrom("PartnerBankAccount")
+    .selectAll()
+    .where("partnerId", "=", input.partnerId)
+    .where("isDefault", "=", true)
+    .executeTakeFirst();
+
+  return ok({ partnerBankAccount: partnerBankAccount ?? null });
+}

package/src/modules/business-partner/query/getPartner.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getPartner";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getPartner = defineQuery(run);