@tailor-platform/erp-kit 0.3.0 → 0.4.0

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

@@ -0,0 +1,63 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  DepartmentNotFoundError,
+  InvalidStateError,
+  HasActiveChildrenError,
+} from "../lib/errors.generated";
+
+export interface DeactivateDepartmentInput {
+  departmentId: string;
+}
+
+/**
+ * Function: deactivateDepartment
+ *
+ * Deactivates a department, preventing it from being used in new assignments.
+ * Fails if the department has active sub-departments.
+ */
+export async function run(db: Transaction, input: DeactivateDepartmentInput) {
+  const { departmentId } = input;
+
+  // 1. Find department
+  const existing = await db
+    .selectFrom("Department")
+    .selectAll()
+    .where("id", "=", departmentId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new DepartmentNotFoundError(departmentId));
+  }
+
+  // 2. Check status is ACTIVE
+  if (existing.status !== "ACTIVE") {
+    return err(new InvalidStateError(departmentId));
+  }
+
+  // 3. Check for active sub-departments
+  const activeChild = await db
+    .selectFrom("Department")
+    .selectAll()
+    .where("parentDepartmentId", "=", departmentId)
+    .where("status", "=", "ACTIVE")
+    .executeTakeFirst();
+
+  if (activeChild) {
+    return err(new HasActiveChildrenError(departmentId));
+  }
+
+  // 4. Set status INACTIVE
+  const department = await db
+    .updateTable("Department")
+    .set({
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", departmentId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ department: department! });
+}

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

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

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

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { SiteNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { activeSite, inactiveSite } from "../testing/fixtures";
+import { run } from "./deactivateSite";
+
+describe("deactivateSite", () => {
+  it("deactivates ACTIVE site", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deactivatedSite = {
+      ...activeSite,
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValue(activeSite);
+    spies.update.mockReturnValue(deactivatedSite);
+
+    const result = await run(db, { siteId: activeSite.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.status).toBe("INACTIVE");
+      expect(result.value.site.updatedAt).not.toBeNull();
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("throws when site does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { siteId: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SiteNotFoundError);
+    }
+  });
+
+  it("throws when site is already INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(inactiveSite);
+
+    const result = await run(db, { siteId: inactiveSite.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+});

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

@@ -0,0 +1,47 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { SiteNotFoundError, InvalidStateError } from "../lib/errors.generated";
+
+export interface DeactivateSiteInput {
+  siteId: string;
+}
+
+/**
+ * Function: deactivateSite
+ *
+ * Transitions a site from an active state to inactive, preventing it from
+ * being used in new operational assignments.
+ */
+export async function run(db: Transaction, input: DeactivateSiteInput) {
+  const { siteId } = input;
+
+  // 1. Find site with forUpdate()
+  const existingSite = await db
+    .selectFrom("Site")
+    .selectAll()
+    .where("id", "=", siteId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existingSite) {
+    return err(new SiteNotFoundError(siteId));
+  }
+
+  // 2. Check status is ACTIVE
+  if (existingSite.status !== "ACTIVE") {
+    return err(new InvalidStateError(siteId));
+  }
+
+  // 3. Set status INACTIVE, updatedAt
+  const site = await db
+    .updateTable("Site")
+    .set({
+      status: "INACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", siteId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ site: site! });
+}

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

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

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

@@ -0,0 +1,99 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidStateError,
+  HasDepartmentsError,
+  HasSitesError,
+} from "../lib/errors.generated";
+import {
+  draftCompany,
+  activeCompany,
+  inactiveCompany,
+  activeDepartment,
+  activeSite,
+} from "../testing/fixtures";
+import { run } from "./deleteCompany";
+
+describe("deleteCompany", () => {
+  it("deletes DRAFT company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(draftCompany) // company lookup
+      .mockReturnValueOnce(undefined) // no departments
+      .mockReturnValueOnce(undefined); // no sites
+
+    const result = await run(db, { companyId: draftCompany.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.companyId).toBe(draftCompany.id);
+    }
+  });
+
+  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 ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(activeCompany);
+
+    const result = await run(db, { companyId: activeCompany.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+
+  it("throws when company is 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);
+    }
+  });
+
+  it("throws when company has existing departments", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(draftCompany) // company lookup
+      .mockReturnValueOnce(activeDepartment); // has departments
+
+    const result = await run(db, { companyId: draftCompany.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(HasDepartmentsError);
+    }
+  });
+
+  it("throws when company has existing sites", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(draftCompany) // company lookup
+      .mockReturnValueOnce(undefined) // no departments
+      .mockReturnValueOnce(activeSite); // has sites
+
+    const result = await run(db, { companyId: draftCompany.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(HasSitesError);
+    }
+  });
+});

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

@@ -0,0 +1,66 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CompanyNotFoundError,
+  InvalidStateError,
+  HasDepartmentsError,
+  HasSitesError,
+} from "../lib/errors.generated";
+
+export interface DeleteCompanyInput {
+  companyId: string;
+}
+
+/**
+ * Function: deleteCompany
+ *
+ * Permanently removes a DRAFT company from the system. Companies with existing
+ * departments or sites cannot be deleted.
+ */
+export async function run(db: Transaction, input: DeleteCompanyInput) {
+  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. Must be DRAFT
+  if (existing.status !== "DRAFT") {
+    return err(new InvalidStateError(companyId));
+  }
+
+  // 3. Check for departments
+  const department = await db
+    .selectFrom("Department")
+    .selectAll()
+    .where("companyId", "=", companyId)
+    .executeTakeFirst();
+
+  if (department) {
+    return err(new HasDepartmentsError(companyId));
+  }
+
+  // 4. Check for sites
+  const site = await db
+    .selectFrom("Site")
+    .selectAll()
+    .where("companyId", "=", companyId)
+    .executeTakeFirst();
+
+  if (site) {
+    return err(new HasSitesError(companyId));
+  }
+
+  // 5. Delete company
+  await db.deleteFrom("Company").where("id", "=", companyId).execute();
+
+  return ok({ companyId });
+}

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

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

package/src/modules/organization/command/reactivateCompany.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 "./reactivateCompany";
+
+describe("reactivateCompany", () => {
+  it("reactivates INACTIVE company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivatedCompany = { ...inactiveCompany, status: "ACTIVE" };
+    spies.select.mockReturnValue(inactiveCompany);
+    spies.update.mockReturnValue(reactivatedCompany);
+
+    const result = await run(db, { companyId: inactiveCompany.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.company.status).toBe("ACTIVE");
+    }
+  });
+
+  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 ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(activeCompany);
+
+    const result = await run(db, { companyId: activeCompany.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+});

package/src/modules/organization/command/reactivateCompany.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 ReactivateCompanyInput {
+  companyId: string;
+}
+
+/**
+ * Function: reactivateCompany
+ *
+ * Transitions a company from INACTIVE back to ACTIVE status, re-enabling it
+ * for use in new transactions.
+ */
+export async function run(db: Transaction, input: ReactivateCompanyInput) {
+  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 INACTIVE
+  if (existing.status !== "INACTIVE") {
+    return err(new InvalidStateError(companyId));
+  }
+
+  // 3. Set status ACTIVE
+  const company = await db
+    .updateTable("Company")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", companyId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ company: company! });
+}

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

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

package/src/modules/organization/command/reactivateDepartment.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 { DepartmentNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { activeDepartment, inactiveDepartment } from "../testing/fixtures";
+import { run } from "./reactivateDepartment";
+
+describe("reactivateDepartment", () => {
+  it("reactivates INACTIVE department", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivated = {
+      ...inactiveDepartment,
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValueOnce(inactiveDepartment); // find department
+    spies.update.mockReturnValue(reactivated);
+
+    const result = await run(db, {
+      departmentId: inactiveDepartment.id,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.department.status).toBe("ACTIVE");
+      expect(result.value.department.updatedAt).not.toBeNull();
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  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 ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeDepartment);
+
+    const result = await run(db, {
+      departmentId: activeDepartment.id,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+});

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

@@ -0,0 +1,47 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { DepartmentNotFoundError, InvalidStateError } from "../lib/errors.generated";
+
+export interface ReactivateDepartmentInput {
+  departmentId: string;
+}
+
+/**
+ * Function: reactivateDepartment
+ *
+ * Re-enables a previously deactivated department, making it available
+ * for new assignments.
+ */
+export async function run(db: Transaction, input: ReactivateDepartmentInput) {
+  const { departmentId } = input;
+
+  // 1. Find department
+  const existing = await db
+    .selectFrom("Department")
+    .selectAll()
+    .where("id", "=", departmentId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new DepartmentNotFoundError(departmentId));
+  }
+
+  // 2. Check status is INACTIVE
+  if (existing.status !== "INACTIVE") {
+    return err(new InvalidStateError(departmentId));
+  }
+
+  // 3. Set status ACTIVE
+  const department = await db
+    .updateTable("Department")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", departmentId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ department: department! });
+}

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

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

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

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { SiteNotFoundError, InvalidStateError } from "../lib/errors.generated";
+import { activeSite, inactiveSite } from "../testing/fixtures";
+import { run } from "./reactivateSite";
+
+describe("reactivateSite", () => {
+  it("reactivates INACTIVE site", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const reactivatedSite = {
+      ...inactiveSite,
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValue(inactiveSite);
+    spies.update.mockReturnValue(reactivatedSite);
+
+    const result = await run(db, { siteId: inactiveSite.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.status).toBe("ACTIVE");
+      expect(result.value.site.updatedAt).not.toBeNull();
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("throws when site does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { siteId: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SiteNotFoundError);
+    }
+  });
+
+  it("throws when site is already ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+});

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

@@ -0,0 +1,47 @@
+import { ok, err } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { SiteNotFoundError, InvalidStateError } from "../lib/errors.generated";
+
+export interface ReactivateSiteInput {
+  siteId: string;
+}
+
+/**
+ * Function: reactivateSite
+ *
+ * Transitions a site from an inactive state back to active, making it
+ * available for operational assignments again.
+ */
+export async function run(db: Transaction, input: ReactivateSiteInput) {
+  const { siteId } = input;
+
+  // 1. Find site with forUpdate()
+  const existingSite = await db
+    .selectFrom("Site")
+    .selectAll()
+    .where("id", "=", siteId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existingSite) {
+    return err(new SiteNotFoundError(siteId));
+  }
+
+  // 2. Check status is INACTIVE
+  if (existingSite.status !== "INACTIVE") {
+    return err(new InvalidStateError(siteId));
+  }
+
+  // 3. Set status ACTIVE, updatedAt
+  const site = await db
+    .updateTable("Site")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", siteId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ site: site! });
+}