@tailor-platform/erp-kit 0.3.0 → 0.4.1

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

@@ -0,0 +1,32 @@
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "createdAt";
+
+export interface ListPartnerBankAccountsByPartnerInput extends PaginationInput<OrderByField> {
+  partnerId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListPartnerBankAccountsByPartnerInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "createdAt";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  const items = await db
+    .selectFrom("PartnerBankAccount")
+    .selectAll()
+    .where("partnerId", "=", input.partnerId)
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

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

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

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

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseTaxIdIdentification, baseVatIdentification } from "../testing/fixtures";
+import { run } from "./listPartnerIdentificationsByPartner";
+
+describe("listPartnerIdentificationsByPartner", () => {
+  it("returns all identification records for a partner with multiple identifications", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseTaxIdIdentification, baseVatIdentification]);
+
+    const result = await run(db, { partnerId: "partner-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseTaxIdIdentification, baseVatIdentification]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns only TAX_ID records when type filter is provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseTaxIdIdentification]);
+
+    const result = await run(db, { partnerId: "partner-2", type: "TAX_ID" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseTaxIdIdentification]);
+    }
+  });
+
+  it("returns empty array when partner has no identification records", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { partnerId: "partner-99" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns empty array when partner has no identifications of the requested type", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { partnerId: "partner-2", type: "DUNS" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+    }
+  });
+
+  it("includes identifications regardless of validity period", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseTaxIdIdentification, baseVatIdentification]);
+
+    const result = await run(db, { partnerId: "partner-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      const hasNoExpiry = result.value.items.some((i) => i.validTo === null);
+      const hasExpiry = result.value.items.some((i) => i.validTo !== null);
+      expect(hasNoExpiry).toBe(true);
+      expect(hasExpiry).toBe(true);
+    }
+  });
+});

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

@@ -0,0 +1,40 @@
+import type { DB } from "../generated/kysely-tailordb";
+import type { PartnerIdentificationType } from "../generated/enums";
+import {
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "createdAt";
+
+export interface ListPartnerIdentificationsByPartnerInput extends PaginationInput<OrderByField> {
+  partnerId: string;
+  type?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListPartnerIdentificationsByPartnerInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "createdAt";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db
+    .selectFrom("PartnerIdentification")
+    .selectAll()
+    .where("partnerId", "=", input.partnerId);
+
+  if (input.type !== undefined) {
+    query = query.where("type", "=", input.type as PartnerIdentificationType);
+  }
+
+  const items = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

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

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

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

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { InvalidRoleError } from "../lib/errors.generated";
+import { baseActivePartner, baseDraftPartner, baseInactivePartner } from "../testing/fixtures";
+import { run } from "./listPartnersByRole";
+
+describe("listPartnersByRole", () => {
+  it("returns all partners with CUSTOMER role", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseActivePartner, baseDraftPartner]);
+
+    const result = await run(db, { role: "CUSTOMER" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseActivePartner, baseDraftPartner]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns all partners with SUPPLIER role", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseActivePartner]);
+
+    const result = await run(db, { role: "SUPPLIER" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseActivePartner]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns only ACTIVE partners when status filter is ACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseActivePartner]);
+
+    const result = await run(db, { role: "CUSTOMER", status: "ACTIVE" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseActivePartner]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns partners of all statuses when status filter is omitted", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseActivePartner, baseDraftPartner, baseInactivePartner]);
+
+    const result = await run(db, { role: "CUSTOMER" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([
+        baseActivePartner,
+        baseDraftPartner,
+        baseInactivePartner,
+      ]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns partner in both queries when partner holds both roles", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseActivePartner]);
+
+    const customerResult = await run(db, { role: "CUSTOMER" });
+    const supplierResult = await run(db, { role: "SUPPLIER" });
+
+    expect(customerResult.ok).toBe(true);
+    expect(supplierResult.ok).toBe(true);
+    if (customerResult.ok && supplierResult.ok) {
+      expect(customerResult.value.items).toEqual([baseActivePartner]);
+      expect(supplierResult.value.items).toEqual([baseActivePartner]);
+    }
+  });
+
+  it("returns empty array when no partners match the criteria", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { role: "SUPPLIER" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns error for invalid role value", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { role: "INVALID_ROLE" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidRoleError);
+    }
+  });
+});

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

@@ -0,0 +1,47 @@
+import type { DB } from "../generated/kysely-tailordb";
+import type { BusinessPartnerStatus, PartnerRoleRole } from "../generated/enums";
+import { InvalidRoleError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "name";
+
+export interface ListPartnersByRoleInput extends PaginationInput<OrderByField> {
+  role: string;
+  status?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListPartnersByRoleInput) {
+  if (input.role !== "CUSTOMER" && input.role !== "SUPPLIER") {
+    return err(new InvalidRoleError(input.role));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "name";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db
+    .selectFrom("PartnerRole")
+    .innerJoin("BusinessPartner", "BusinessPartner.id", "PartnerRole.partnerId")
+    .selectAll("BusinessPartner")
+    .where("PartnerRole.role", "=", input.role as PartnerRoleRole);
+
+  if (input.status !== undefined) {
+    query = query.where("BusinessPartner.status", "=", input.status as BusinessPartnerStatus);
+  }
+
+  const items = await query
+    .orderBy(`BusinessPartner.${orderBy}`, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(items, limit));
+}

package/src/modules/business-partner/tailor.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig, definePlugins } from "@tailor-platform/sdk";
+import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";
+import { enumConstantsPlugin } from "@tailor-platform/sdk/plugin/enum-constants";
+
+export default defineConfig({
+  name: "business-partner",
+  db: { "main-db": { files: [`./db/*.ts`, `./lib/_db_deps.ts`] } },
+});
+
+export const plugins = definePlugins(
+  kyselyTypePlugin({ distPath: `./generated/kysely-tailordb.ts` }),
+  enumConstantsPlugin({ distPath: "./generated/enums.ts" }),
+);

package/src/modules/business-partner/tailor.d.ts

@@ -0,0 +1,13 @@
+// This file is auto-generated by @tailor-platform/sdk
+// Do not edit this file manually
+// Regenerated automatically when running 'tailor-sdk apply' or 'tailor-sdk generate'
+
+declare module "@tailor-platform/sdk" {
+  interface AttributeMap {}
+  interface AttributeList {
+    __tuple?: [];
+  }
+  interface Env {}
+}
+
+export {};

package/src/modules/business-partner/testing/fixtures.ts

@@ -0,0 +1,204 @@
+import type {
+  BusinessPartner,
+  ContactPerson,
+  PartnerAddress,
+  PartnerBankAccount,
+  PartnerIdentification,
+  PartnerRole,
+  Schema,
+} from "../lib/types";
+
+// BusinessPartner fixtures
+export const baseDraftPartner = {
+  id: "partner-1",
+  name: "Acme Corp",
+  type: "ORGANIZATION",
+  companyId: "company-1",
+  preferredCurrencyId: null,
+  status: "DRAFT",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies BusinessPartner<Schema>;
+
+export const baseActivePartner = {
+  id: "partner-2",
+  name: "Global Supplies Inc",
+  type: "ORGANIZATION",
+  companyId: "company-1",
+  preferredCurrencyId: "currency-usd",
+  status: "ACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies BusinessPartner<Schema>;
+
+export const baseInactivePartner = {
+  id: "partner-3",
+  name: "Old Vendor Ltd",
+  type: "ORGANIZATION",
+  companyId: "company-1",
+  preferredCurrencyId: null,
+  status: "INACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies BusinessPartner<Schema>;
+
+export const baseIndividualPartner = {
+  id: "partner-4",
+  name: "John Doe",
+  type: "INDIVIDUAL",
+  companyId: "company-1",
+  preferredCurrencyId: null,
+  status: "ACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies BusinessPartner<Schema>;
+
+// PartnerRole fixtures
+export const baseCustomerRole = {
+  id: "role-1",
+  partnerId: "partner-2",
+  role: "CUSTOMER",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerRole<Schema>;
+
+export const baseSupplierRole = {
+  id: "role-2",
+  partnerId: "partner-2",
+  role: "SUPPLIER",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerRole<Schema>;
+
+// PartnerAddress fixtures
+export const baseBillingAddress = {
+  id: "address-1",
+  partnerId: "partner-2",
+  addressType: "BILLING",
+  line1: "123 Main St",
+  line2: null,
+  city: "New York",
+  state: "NY",
+  postalCode: "10001",
+  country: "US",
+  isDefault: true,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerAddress<Schema>;
+
+export const baseShippingAddress = {
+  id: "address-2",
+  partnerId: "partner-2",
+  addressType: "SHIPPING",
+  line1: "456 Oak Ave",
+  line2: "Suite 100",
+  city: "Los Angeles",
+  state: "CA",
+  postalCode: "90001",
+  country: "US",
+  isDefault: false,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerAddress<Schema>;
+
+// ContactPerson fixtures
+export const baseActiveContact = {
+  id: "contact-1",
+  partnerId: "partner-2",
+  firstName: "Jane",
+  lastName: "Smith",
+  email: "jane@example.com",
+  phone: "+1-555-0100",
+  jobTitle: "Procurement Manager",
+  department: "Purchasing",
+  isPrimary: true,
+  status: "ACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies ContactPerson<Schema>;
+
+export const baseInactiveContact = {
+  id: "contact-2",
+  partnerId: "partner-2",
+  firstName: "Bob",
+  lastName: "Jones",
+  email: "bob@example.com",
+  phone: null,
+  jobTitle: null,
+  department: null,
+  isPrimary: false,
+  status: "INACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies ContactPerson<Schema>;
+
+export const baseNonPrimaryContact = {
+  id: "contact-3",
+  partnerId: "partner-2",
+  firstName: "Alice",
+  lastName: "Williams",
+  email: null,
+  phone: "+1-555-0200",
+  jobTitle: null,
+  department: null,
+  isPrimary: false,
+  status: "ACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies ContactPerson<Schema>;
+
+// PartnerBankAccount fixtures
+export const baseDefaultBankAccount = {
+  id: "bank-1",
+  partnerId: "partner-2",
+  bankName: "First National Bank",
+  accountHolderName: "Global Supplies Inc",
+  accountNumber: "1234567890",
+  routingNumber: "021000021",
+  iban: null,
+  swiftBic: null,
+  currencyId: "currency-usd",
+  isDefault: true,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerBankAccount<Schema>;
+
+export const baseSecondBankAccount = {
+  id: "bank-2",
+  partnerId: "partner-2",
+  bankName: "Deutsche Bank",
+  accountHolderName: "Global Supplies GmbH",
+  accountNumber: null,
+  routingNumber: null,
+  iban: "DE89370400440532013000",
+  swiftBic: "DEUTDEDB",
+  currencyId: "currency-eur",
+  isDefault: false,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerBankAccount<Schema>;
+
+// PartnerIdentification fixtures
+export const baseTaxIdIdentification = {
+  id: "ident-1",
+  partnerId: "partner-2",
+  type: "TAX_ID",
+  value: "12-3456789",
+  issuingCountry: "US",
+  validFrom: null,
+  validTo: null,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerIdentification<Schema>;
+
+export const baseVatIdentification = {
+  id: "ident-2",
+  partnerId: "partner-2",
+  type: "VAT",
+  value: "DE123456789",
+  issuingCountry: "DE",
+  validFrom: new Date("2024-01-01"),
+  validTo: new Date("2025-12-31"),
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies PartnerIdentification<Schema>;

package/src/modules/coa-management/README.md

@@ -0,0 +1,61 @@
+# README
+
+## Overview
+
+The Chart of Accounts (CoA) Management module manages the master data for an organization's financial account structure. It provides a CoA container entity scoped per company (legal entity), GL accounts classified by standard accounting types (ASSET, LIABILITY, EQUITY, REVENUE, EXPENSE) with operational classifications (REGULAR, RECEIVABLE, PAYABLE, BANK_CASH, FIXED_ASSET, RETAINED_EARNINGS, NON_POSTING), hierarchical account groups as structural metadata, and a lifecycle state machine (DRAFT → ACTIVE → ARCHIVED for the CoA container; DRAFT → ACTIVE ↔ INACTIVE for individual GL accounts) that controls when accounts can receive postings.
+
+The CoA is the foundational accounting master data that all downstream financial modules reference. Journal entries in the general ledger post to accounts defined here; accounts payable and receivable reference GL control accounts identified by their operational classification; downstream modules consume the account group hierarchy for balance aggregation and reporting. The module owns the account definitions and structural hierarchy but does not own transactional posting, balance computation, or reporting aggregation — those responsibilities belong to separate general-ledger and reporting modules.
+
+## Key Features
+
+- **[Chart of Accounts Setup](docs/features/chart-of-accounts-setup.md)**: Creation and management of CoA containers scoped per company. Each CoA has a name, description, and lifecycle status (DRAFT → ACTIVE → ARCHIVED). The CoA inherits its base currency from the parent company (owned by the organization module). A company has one active CoA at a time, serving as the single authoritative account structure
+- **[Account Management](docs/features/account-management.md)**: CRUD operations for GL accounts within a CoA. Each account carries a structured code, name, account type (ASSET, LIABILITY, EQUITY, REVENUE, EXPENSE), operational classification (REGULAR, RECEIVABLE, PAYABLE, BANK_CASH, FIXED_ASSET, RETAINED_EARNINGS, NON_POSTING), optional currency restriction, reconciliation flag, default tax code, and tags for cross-cutting categorization
+- **[Account Group & Hierarchy](docs/features/account-group-hierarchy.md)**: Organization of accounts into named groups with hierarchical nesting. Groups define logical categories (e.g., "Current Assets", "Operating Expenses") and can control account numbering ranges. A single operational tree structure per CoA provides structural metadata that downstream modules consume for balance aggregation and reporting
+- **[Account Lifecycle](docs/features/account-lifecycle.md)**: Status management for GL accounts through a state machine (DRAFT → ACTIVE ↔ INACTIVE). Controls when accounts can receive postings, includes successor account mapping for deprecated accounts, and exposes a pre-deactivation hook for balance verification by the general-ledger module
+
+## Module Scope
+
+### In Scope
+
+- Chart of Accounts container management (create, update, archive) scoped per company
+- GL account master data management (create, update, deactivate) with structured account codes
+- Account type classification (ASSET, LIABILITY, EQUITY, REVENUE, EXPENSE) with operational classifications (REGULAR, RECEIVABLE, PAYABLE, BANK_CASH, FIXED_ASSET, RETAINED_EARNINGS, NON_POSTING)
+- Account group management with hierarchical nesting as structural metadata for downstream consumption
+- Account lifecycle state machine (DRAFT → ACTIVE ↔ INACTIVE) with pre-deactivation hook for external balance checks
+- Successor account mapping for deprecated accounts
+- Account currency restriction (optional per-account currency assignment, referencing primitives module)
+- Reconciliation flag for bank, receivable, and payable accounts
+- Tag-based categorization for cross-cutting account filtering
+
+### Out of Scope
+
+- Journal entries and posting rules (general-ledger module)
+- Trial balance and balance aggregation (general-ledger module)
+- Fiscal calendar — fiscal years, periods, cutoff dates (accounting module)
+- Cost centers and profit centers (management-accounting module)
+- Business units and divisions for financial reporting (management-accounting module)
+- Multi-segment account structures — Oracle-style Key Accounting Flexfield (future enhancement)
+- Cross-validation rules for segment combinations (future enhancement)
+- Fiscal localization packages — country-specific CoA templates (application layer)
+- Multi-book accounting — parallel books under different GAAP (general-ledger module)
+- Consolidation mapping — subsidiary to group CoA mapping (consolidation module)
+- Financial statement version management (reporting module)
+- Bulk import/export of accounts (application-layer tooling)
+
+### Scope Decision Rationale
+
+CoA Management is scoped to **accounting master data** — the "what accounts exist and how they are structured" foundation. It owns the account definitions, type classification, grouping hierarchy, and lifecycle but does not own transactional concerns like journal entries, balance computation, or period-end close. This separation follows the standard ERP pattern where the Chart of Accounts is a reference data module consumed by transactional modules (general-ledger, AP, AR, fixed-assets).
+
+Fiscal calendar is excluded because it is a shared accounting concern needed by multiple modules (general-ledger, AP, AR, budgeting) and should not be owned by the account structure module. Fiscal calendar ownership belongs to the accounting module, consistent with the organization module's deferral. Similarly, cost centers and profit centers are management-accounting dimensions that cross-cut many modules — the organization module explicitly defers these to a future accounting module, and they are better served by a dedicated management-accounting module.
+
+Multi-segment account structures (Oracle's Key Accounting Flexfield pattern) are deferred as a future enhancement. The initial design uses a single structured account code, which covers the majority of use cases. Segment-based design can be layered on later without breaking the core account model.
+
+Country-specific CoA templates (fiscal localizations) are excluded because they are data packages rather than domain logic. They belong in the application layer where they can be installed as configuration, not in the core module.
+
+## Module Dependencies
+
+- [organization](../organization/README.md) — Company reference for CoA and account scoping (each CoA belongs to a company); base currency is inherited from the company
+- [primitives](../primitives/README.md) — Currency definitions for per-account currency restriction
+- [audit](../audit/README.md) — Audit trail for account master data changes (account creation, modification, status transitions)
+- **general-ledger** (future integration) — Reads successor account mappings to redirect postings; provides balance-check hook to block account deactivation when open balances exist; determines whether an account has posted transactions
+- **tax-configuration** (future integration) — Will own the tax code catalog and validate default tax code references stored on accounts. Migration contract: when `tax-configuration` is implemented, this module will add a dependency and enforce referential integrity on the `defaultTaxCode` field. Until then, tax codes are stored as free-text identifiers with no external validation

package/src/modules/coa-management/command/activateAccount.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateAccount";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const activateAccount = defineCommand(permissions.activateAccount, run);