@tailor-platform/erp-kit 0.3.0 → 0.4.1

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

@@ -0,0 +1,120 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  DepartmentNotFoundError,
+  InvalidNameError,
+  SelfReferenceError,
+  ParentNotFoundError,
+  CircularReferenceError,
+} from "../lib/errors.generated";
+import { run as detectCircularReference } from "../query/detectDepartmentCircularReference";
+import { ok, err } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateDepartmentInput {
+  departmentId: string;
+  name?: string;
+  parentDepartmentId?: string | null;
+}
+
+/**
+ * Function: updateDepartment
+ *
+ * Updates a department's name or parent department. Validates against
+ * self-reference and circular hierarchies when reparenting.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateDepartmentInput & CF,
+) {
+  const { departmentId, name, parentDepartmentId, ...customFields } = input;
+
+  // 1. Find department
+  const existing = await db
+    .selectFrom("Department")
+    .selectAll()
+    .where("id", "=", departmentId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new DepartmentNotFoundError(departmentId));
+  }
+
+  // 2. Validate name if provided
+  if (name !== undefined && !name?.trim()) {
+    return err(new InvalidNameError(name));
+  }
+
+  // 3. Validate parentDepartmentId if provided
+  if (parentDepartmentId !== undefined && parentDepartmentId !== null) {
+    // Self-reference check
+    if (parentDepartmentId === departmentId) {
+      return err(new SelfReferenceError(departmentId));
+    }
+
+    // Find parent department
+    const parent = await db
+      .selectFrom("Department")
+      .selectAll()
+      .where("id", "=", parentDepartmentId)
+      .executeTakeFirst();
+
+    if (!parent) {
+      return err(new ParentNotFoundError(parentDepartmentId));
+    }
+
+    // Verify parent belongs to same company
+    if (parent.companyId !== existing.companyId) {
+      return err(new ParentNotFoundError(parentDepartmentId));
+    }
+
+    // Circular reference detection via shared query
+    const circularResult = await detectCircularReference(db, {
+      departmentId,
+      newParentId: parentDepartmentId,
+    });
+    if (circularResult.ok && circularResult.value.isCircular) {
+      return err(new CircularReferenceError(departmentId));
+    }
+  }
+
+  // 4. Build update set — strip reserved model columns from customFields
+  const RESERVED_KEYS = new Set([
+    "id",
+    "code",
+    "companyId",
+    "status",
+    "name",
+    "parentDepartmentId",
+    "createdAt",
+    "updatedAt",
+  ]);
+  const safeCustomFields: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(customFields)) {
+    if (!RESERVED_KEYS.has(key)) {
+      safeCustomFields[key] = value;
+    }
+  }
+
+  const updateSet: Record<string, unknown> = {
+    ...safeCustomFields,
+    updatedAt: new Date(),
+  };
+
+  if (name !== undefined) {
+    updateSet.name = name;
+  }
+
+  if (parentDepartmentId !== undefined) {
+    updateSet.parentDepartmentId = parentDepartmentId;
+  }
+
+  // 5. Update department
+  const department = await db
+    .updateTable("Department")
+    .set(updateSet)
+    .where("id", "=", departmentId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ department: department! });
+}

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

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

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

@@ -0,0 +1,274 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  SiteNotFoundError,
+  InvalidNameError,
+  DuplicateNameError,
+  InvalidTypeError,
+  InvalidCountryError,
+  InvalidTimezoneError,
+  MissingRequiredFieldsError,
+} from "../lib/errors.generated";
+import { activeSite, inactiveSite } from "../testing/fixtures";
+import { run } from "./updateSite";
+
+describe("updateSite", () => {
+  it("updates site name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = { ...activeSite, name: "New Name", updatedAt: new Date() };
+
+    spies.select
+      .mockReturnValueOnce(activeSite) // find site
+      .mockReturnValueOnce(undefined); // no duplicate name
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, { siteId: activeSite.id, name: "New Name" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.name).toBe("New Name");
+    }
+  });
+
+  it("updates site address fields", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = {
+      ...activeSite,
+      street: "999 New St",
+      city: "Osaka",
+      postalCode: "530-0002",
+      updatedAt: new Date(),
+    };
+
+    spies.select.mockReturnValueOnce(activeSite);
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, {
+      siteId: activeSite.id,
+      street: "999 New St",
+      city: "Osaka",
+      postalCode: "530-0002",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.street).toBe("999 New St");
+      expect(result.value.site.city).toBe("Osaka");
+    }
+  });
+
+  it("updates site type", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = { ...activeSite, type: "WAREHOUSE", updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(activeSite);
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, { siteId: activeSite.id, type: "WAREHOUSE" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.type).toBe("WAREHOUSE");
+    }
+  });
+
+  it("updates site timezone", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = { ...activeSite, timezone: "America/New_York", updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(activeSite);
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, { siteId: activeSite.id, timezone: "America/New_York" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.timezone).toBe("America/New_York");
+    }
+  });
+
+  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 name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, name: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("throws when name already exists in same company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const otherSite = { ...activeSite, id: "site-other", name: "Existing Name" };
+
+    spies.select
+      .mockReturnValueOnce(activeSite) // find site
+      .mockReturnValueOnce(otherSite); // duplicate name found
+
+    const result = await run(db, { siteId: activeSite.id, name: "Existing Name" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateNameError);
+    }
+  });
+
+  it("throws when type is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, type: "INVALID" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidTypeError);
+    }
+  });
+
+  it("throws when country code is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, 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(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, timezone: "Invalid/Timezone" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidTimezoneError);
+    }
+  });
+
+  it("updates site country", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = { ...activeSite, country: "US", updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(activeSite);
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, { siteId: activeSite.id, country: "US" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.country).toBe("US");
+    }
+  });
+
+  it("throws when street is set to empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, street: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("throws when city is set to empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, city: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("throws when postalCode is set to empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, postalCode: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("throws when country is set to empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeSite);
+
+    const result = await run(db, { siteId: activeSite.id, country: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("updates state/province field", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = { ...activeSite, state: "Osaka", updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(activeSite);
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, { siteId: activeSite.id, state: "Osaka" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.state).toBe("Osaka");
+    }
+  });
+
+  it("clears state/province field", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = { ...activeSite, state: null, updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(activeSite);
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, { siteId: activeSite.id, state: null });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.state).toBeNull();
+    }
+  });
+
+  it("updates address fields on INACTIVE site", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedSite = { ...inactiveSite, street: "New Street", updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(inactiveSite);
+    spies.update.mockReturnValue(updatedSite);
+
+    const result = await run(db, { siteId: inactiveSite.id, street: "New Street" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.site.street).toBe("New Street");
+    }
+  });
+});

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

@@ -0,0 +1,176 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  SiteNotFoundError,
+  InvalidNameError,
+  DuplicateNameError,
+  InvalidTypeError,
+  MissingRequiredFieldsError,
+  InvalidCountryError,
+  InvalidTimezoneError,
+} from "../lib/errors.generated";
+import { ok, err } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateSiteInput {
+  siteId: string;
+  name?: string;
+  type?: string;
+  street?: string;
+  city?: string;
+  state?: string | null;
+  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: updateSite
+ *
+ * Modifies the details of an existing site, including its name, type, address,
+ * and timezone. Only provided fields are updated.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateSiteInput & CF,
+) {
+  const {
+    siteId,
+    name,
+    type,
+    street,
+    city,
+    state,
+    postalCode,
+    country,
+    timezone,
+    ...customFields
+  } = 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. If name provided and empty, error
+  if (name?.trim() === "") {
+    return err(new InvalidNameError(name));
+  }
+
+  // 3. If name changed, check uniqueness in company
+  if (name !== undefined && name !== existingSite.name) {
+    const duplicate = await db
+      .selectFrom("Site")
+      .selectAll()
+      .where("name", "=", name)
+      .where("companyId", "=", existingSite.companyId)
+      .forUpdate()
+      .executeTakeFirst();
+
+    if (duplicate) {
+      return err(new DuplicateNameError(name));
+    }
+  }
+
+  // 4. If type provided, validate in allowed list
+  if (type !== undefined && !VALID_SITE_TYPES.includes(type)) {
+    return err(new InvalidTypeError(type));
+  }
+
+  // 5. If address fields provided and empty, error
+  if (street?.trim() === "") {
+    return err(new MissingRequiredFieldsError("street"));
+  }
+  if (city?.trim() === "") {
+    return err(new MissingRequiredFieldsError("city"));
+  }
+  if (postalCode?.trim() === "") {
+    return err(new MissingRequiredFieldsError("postalCode"));
+  }
+  if (country?.trim() === "") {
+    return err(new MissingRequiredFieldsError("country"));
+  }
+
+  // 6. If country provided, validate
+  if (country !== undefined && !isValidCountryCode(country)) {
+    return err(new InvalidCountryError(country));
+  }
+
+  // 7. If timezone provided, validate
+  if (timezone !== undefined && !isValidTimezone(timezone)) {
+    return err(new InvalidTimezoneError(timezone));
+  }
+
+  // 8. Build update object — strip reserved model columns from customFields
+  const RESERVED_KEYS = new Set([
+    "id",
+    "companyId",
+    "status",
+    "name",
+    "type",
+    "street",
+    "city",
+    "state",
+    "postalCode",
+    "country",
+    "timezone",
+    "createdAt",
+    "updatedAt",
+  ]);
+  const safeCustomFields: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(customFields)) {
+    if (!RESERVED_KEYS.has(key)) {
+      safeCustomFields[key] = value;
+    }
+  }
+
+  const updates: Record<string, unknown> = {
+    ...safeCustomFields,
+    updatedAt: new Date(),
+  };
+
+  if (name !== undefined) updates.name = name;
+  if (type !== undefined) updates.type = type;
+  if (street !== undefined) updates.street = street;
+  if (city !== undefined) updates.city = city;
+  if (state !== undefined) updates.state = state;
+  if (postalCode !== undefined) updates.postalCode = postalCode;
+  if (country !== undefined) updates.country = country;
+  if (timezone !== undefined) updates.timezone = timezone;
+
+  // 9. Update
+  const site = await db
+    .updateTable("Site")
+    .set(updates)
+    .where("id", "=", siteId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ site: site! });
+}

package/src/modules/organization/db/company.ts

@@ -0,0 +1,44 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { currency as currencyStub } from "../lib/_db_deps";
+
+export interface CreateCompanyTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  currencyType?: TailorAnyDBType;
+}
+
+export function createCompanyType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateCompanyTypeParams<F>,
+) {
+  return db
+    .type("Company", {
+      legalName: db.string().description("Legal name of the company"),
+      taxId: db.string({ optional: true }).description("Tax identification number"),
+      registrationNumber: db.string({ optional: true }).description("Company registration number"),
+      baseCurrencyId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.currencyType ?? currencyStub },
+          backward: "companies",
+        })
+        .description("Foreign key to Currency from primitives module"),
+      street: db.string({ optional: true }).description("Registered address street"),
+      city: db.string({ optional: true }).description("Registered address city"),
+      state: db.string({ optional: true }).description("Registered address state/province"),
+      postalCode: db.string({ optional: true }).description("Registered address postal code"),
+      country: db.string({ optional: true }).description("Registered address country"),
+      status: db.string().description("Company lifecycle status: DRAFT, ACTIVE, INACTIVE"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const company = createCompanyType({});

package/src/modules/organization/db/department.ts

@@ -0,0 +1,46 @@
+import {
+  db,
+  type TailorAnyDBField,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company } from "./company";
+
+export interface CreateDepartmentTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+}
+
+export function createDepartmentType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateDepartmentTypeParams<F>,
+) {
+  const departmentType = db
+    .type("Department", {
+      code: db.string().description("Department code, unique per company"),
+      name: db.string().description("Department display name"),
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: company },
+          backward: "departments",
+        })
+        .description("Foreign key to Company"),
+      parentDepartmentId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: "self" },
+          backward: "childDepartments",
+        })
+        .description("Foreign key to parent Department for hierarchy"),
+      status: db.string().description("Department lifecycle status: ACTIVE, INACTIVE"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+
+  return departmentType;
+}
+
+export const department = createDepartmentType({});