@tailor-platform/erp-kit 0.2.2 → 0.4.0

package/src/modules/organization/command/createSite.test.ts

@@ -0,0 +1,262 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidNameError,
+  InvalidTypeError,
+  CompanyNotFoundError,
+  CompanyInactiveError,
+  DuplicateNameError,
+  MissingRequiredFieldsError,
+  InvalidCountryError,
+  InvalidTimezoneError,
+} from "../lib/errors.generated";
+import { activeCompany, activeSite, inactiveCompany } from "../testing/fixtures";
+import { run } from "./createSite";
+
+describe("createSite", () => {
+  const validInput = {
+    name: "New Site",
+    type: "OFFICE",
+    companyId: activeCompany.id,
+    street: "100 Main St",
+    city: "Tokyo",
+    postalCode: "100-0001",
+    country: "JP",
+    timezone: "Asia/Tokyo",
+  };
+
+  it("creates site in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdSite = {
+      id: "new-site-id",
+      ...validInput,
+      state: null,
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+
+    spies.select
+      .mockReturnValueOnce(activeCompany) // find company
+      .mockReturnValueOnce(undefined); // no duplicate name
+    spies.insert.mockReturnValue(createdSite);
+
+    const result = await run(db, validInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.status).toBe("ACTIVE");
+      expect(result.value.site.name).toBe("New Site");
+    }
+  });
+
+  it("throws when name is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, name: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("throws when type is invalid", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { ...validInput, type: "INVALID" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidTypeError);
+    }
+  });
+
+  it("throws when company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined); // company not found
+
+    const result = await run(db, { ...validInput, companyId: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CompanyNotFoundError);
+    }
+  });
+
+  it("throws when company is not ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(inactiveCompany);
+
+    const result = await run(db, { ...validInput, companyId: inactiveCompany.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CompanyInactiveError);
+    }
+  });
+
+  it("throws when site name already exists in same company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(activeCompany) // find company
+      .mockReturnValueOnce(activeSite); // duplicate name found
+
+    const result = await run(db, { ...validInput, name: activeSite.name });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateNameError);
+    }
+  });
+
+  it("allows same site name in different companies", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const otherCompany = { ...activeCompany, id: "company-other" };
+    const createdSite = {
+      id: "new-site-id",
+      name: activeSite.name,
+      type: "OFFICE",
+      companyId: otherCompany.id,
+      street: "100 Main St",
+      city: "Tokyo",
+      state: null,
+      postalCode: "100-0001",
+      country: "JP",
+      timezone: "Asia/Tokyo",
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+
+    spies.select
+      .mockReturnValueOnce(otherCompany) // find company
+      .mockReturnValueOnce(undefined); // no duplicate in this company
+    spies.insert.mockReturnValue(createdSite);
+
+    const result = await run(db, {
+      ...validInput,
+      name: activeSite.name,
+      companyId: otherCompany.id,
+    });
+
+    expect(result.ok).toBe(true);
+  });
+
+  it("throws when address street is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, street: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("throws when address city is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, city: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("throws when address postalCode is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, postalCode: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("throws when address country is missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, country: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("creates site without state/province", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdSite = {
+      id: "new-site-id",
+      ...validInput,
+      state: null,
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValue(createdSite);
+
+    const result = await run(db, validInput);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.state).toBeNull();
+    }
+  });
+
+  it("creates site with state/province", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdSite = {
+      id: "new-site-id",
+      ...validInput,
+      state: "Tokyo",
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValue(createdSite);
+
+    const result = await run(db, { ...validInput, state: "Tokyo" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.state).toBe("Tokyo");
+    }
+  });
+
+  it("throws when country code is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, country: "XX" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCountryError);
+    }
+  });
+
+  it("throws when timezone is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeCompany).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { ...validInput, timezone: "Invalid/Timezone" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidTimezoneError);
+    }
+  });
+});

package/src/modules/organization/command/createSite.ts

@@ -0,0 +1,155 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidNameError,
+  InvalidTypeError,
+  CompanyNotFoundError,
+  CompanyInactiveError,
+  DuplicateNameError,
+  MissingRequiredFieldsError,
+  InvalidCountryError,
+  InvalidTimezoneError,
+} from "../lib/errors.generated";
+
+export interface CreateSiteInput {
+  name: string;
+  type: string;
+  companyId: string;
+  street: string;
+  city: string;
+  state?: string;
+  postalCode: string;
+  country: string;
+  timezone: string;
+}
+
+const VALID_SITE_TYPES = ["OFFICE", "WAREHOUSE", "STORE", "FACTORY", "DISTRIBUTION_CENTER"];
+
+function isValidCountryCode(code: string): boolean {
+  try {
+    const displayNames = new Intl.DisplayNames(["en"], { type: "region" });
+    const name = displayNames.of(code);
+    return name !== undefined && name !== code;
+  } catch {
+    return false;
+  }
+}
+
+function isValidTimezone(tz: string): boolean {
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Function: createSite
+ *
+ * Creates a new operational site within a company, capturing its classification,
+ * physical address, and timezone.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateSiteInput & CF,
+) {
+  const {
+    name,
+    type,
+    companyId,
+    street,
+    city,
+    state,
+    postalCode,
+    country,
+    timezone,
+    ...customFields
+  } = input;
+
+  // 1. Validate name non-empty
+  if (!name || name.trim() === "") {
+    return err(new InvalidNameError(name ?? ""));
+  }
+
+  // 2. Validate type in allowed list
+  if (!VALID_SITE_TYPES.includes(type)) {
+    return err(new InvalidTypeError(type));
+  }
+
+  // 3. Find company by companyId
+  const company = await db
+    .selectFrom("Company")
+    .selectAll()
+    .where("id", "=", companyId)
+    .executeTakeFirst();
+
+  if (!company) {
+    return err(new CompanyNotFoundError(companyId));
+  }
+
+  // 4. Company must be ACTIVE
+  if (company.status !== "ACTIVE") {
+    return err(new CompanyInactiveError(companyId));
+  }
+
+  // 5. Check name uniqueness in company with forUpdate()
+  const existingSite = await db
+    .selectFrom("Site")
+    .selectAll()
+    .where("name", "=", name)
+    .where("companyId", "=", companyId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (existingSite) {
+    return err(new DuplicateNameError(name));
+  }
+
+  // 6. Validate address fields
+  if (!street || street.trim() === "") {
+    return err(new MissingRequiredFieldsError("street"));
+  }
+  if (!city || city.trim() === "") {
+    return err(new MissingRequiredFieldsError("city"));
+  }
+  if (!postalCode || postalCode.trim() === "") {
+    return err(new MissingRequiredFieldsError("postalCode"));
+  }
+  if (!country || country.trim() === "") {
+    return err(new MissingRequiredFieldsError("country"));
+  }
+
+  // 7. Validate country code
+  if (!isValidCountryCode(country)) {
+    return err(new InvalidCountryError(country));
+  }
+
+  // 8. Validate timezone
+  if (!isValidTimezone(timezone)) {
+    return err(new InvalidTimezoneError(timezone));
+  }
+
+  // 9. Insert with status "ACTIVE"
+  const site = await db
+    .insertInto("Site")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      name,
+      type,
+      companyId,
+      street,
+      city,
+      state: state ?? null,
+      postalCode,
+      country,
+      timezone,
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ site: site! });
+}

package/src/modules/organization/command/deactivateCompany.generated.ts

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

package/src/modules/organization/command/deactivateCompany.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CompanyNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { activeCompany, draftCompany, inactiveCompany } from "../testing/fixtures";
+import { run } from "./deactivateCompany";
+
+describe("deactivateCompany", () => {
+  it("deactivates ACTIVE company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivatedCompany = { ...activeCompany, status: "INACTIVE" };
+    spies.select.mockReturnValue(activeCompany);
+    spies.update.mockReturnValue(deactivatedCompany);
+
+    const result = await run(db, { companyId: activeCompany.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.company.status).toBe("INACTIVE");
+    }
+  });
+
+  it("throws when company does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { companyId: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CompanyNotFoundError);
+    }
+  });
+
+  it("throws when company is in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(draftCompany);
+
+    const result = await run(db, { companyId: draftCompany.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+
+  it("throws when company is already INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(inactiveCompany);
+
+    const result = await run(db, { companyId: inactiveCompany.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+});

package/src/modules/organization/command/deactivateCompany.ts

@@ -0,0 +1,47 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CompanyNotFoundError, InvalidStateError } from "../lib/errors.generated";
+
+export interface DeactivateCompanyInput {
+  companyId: string;
+}
+
+/**
+ * Function: deactivateCompany
+ *
+ * Transitions a company from ACTIVE to INACTIVE status, preventing it from
+ * being used in new transactions while preserving historical data.
+ */
+export async function run(db: Transaction, input: DeactivateCompanyInput) {
+  const { companyId } = input;
+
+  // 1. Find company with forUpdate
+  const existing = await db
+    .selectFrom("Company")
+    .selectAll()
+    .where("id", "=", companyId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new CompanyNotFoundError(companyId));
+  }
+
+  // 2. Check status is ACTIVE
+  if (existing.status !== "ACTIVE") {
+    return err(new InvalidStateError(companyId));
+  }
+
+  // 3. Set status INACTIVE
+  const company = await db
+    .updateTable("Company")
+    .set({
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", companyId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ company: company! });
+}

package/src/modules/organization/command/deactivateDepartment.generated.ts

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

package/src/modules/organization/command/deactivateDepartment.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  DepartmentNotFoundError,
+  InvalidStateError,
+  HasActiveChildrenError,
+} from "../lib/errors.generated";
+import { activeDepartment, inactiveDepartment } from "../testing/fixtures";
+import { run } from "./deactivateDepartment";
+
+describe("deactivateDepartment", () => {
+  it("deactivates ACTIVE department with no sub-departments", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivated = {
+      ...activeDepartment,
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    };
+
+    spies.select
+      .mockReturnValueOnce(activeDepartment) // find department
+      .mockReturnValueOnce(undefined); // no active children
+    spies.update.mockReturnValue(deactivated);
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.department.status).toBe("INACTIVE");
+      expect(result.value.department.updatedAt).not.toBeNull();
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("deactivates ACTIVE department with only INACTIVE sub-departments", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivated = {
+      ...activeDepartment,
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    };
+
+    spies.select
+      .mockReturnValueOnce(activeDepartment) // find department
+      .mockReturnValueOnce(undefined); // no ACTIVE children (only inactive ones)
+    spies.update.mockReturnValue(deactivated);
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.department.status).toBe("INACTIVE");
+    }
+  });
+
+  it("throws when department does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, {
+      departmentId: "nonexistent-dept",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DepartmentNotFoundError);
+    }
+  });
+
+  it("throws when department is already INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveDepartment);
+
+    const result = await run(db, {
+      departmentId: inactiveDepartment.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+
+  it("throws when department has active sub-departments", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const activeChild = {
+      id: "child-dept",
+      code: "CHILD",
+      name: "Child Dept",
+      companyId: activeDepartment.companyId,
+      parentDepartmentId: activeDepartment.id,
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+
+    spies.select
+      .mockReturnValueOnce(activeDepartment) // find department
+      .mockReturnValueOnce(activeChild); // active child found
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(HasActiveChildrenError);
+    }
+  });
+});