@tailor-platform/erp-kit 0.5.1 → 0.6.0

package/src/modules/manufacturing/command/updateRouting.ts

@@ -0,0 +1,124 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  RoutingNotFoundError,
+  RoutingNotMutableError,
+  DuplicateOperationSequenceError,
+  InvalidStandardTimeError,
+  WorkCenterNotFoundError,
+  CrossCompanyWorkCenterError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateRoutingOperationInput {
+  sequenceNumber: number;
+  operationDescription?: string | null;
+  workCenterId: string;
+  standardSetupTime: number;
+  standardRunTime: number;
+  operatorInstructions?: string | null;
+}
+
+export interface UpdateRoutingInput {
+  id: string;
+  revisionNumber?: string | null;
+  operations: UpdateRoutingOperationInput[];
+}
+
+/**
+ * Function: updateRouting
+ *
+ * Updates a draft routing's operations. Only DRAFT routings are mutable.
+ * Replaces all existing operations with the revised set.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateRoutingInput & CF,
+  _ctx: CommandContext,
+) {
+  const { id, revisionNumber, operations, ...customFields } = input;
+
+  // 1. Fetch routing
+  const routing = await db
+    .selectFrom("Routing")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!routing) {
+    return err(new RoutingNotFoundError(id));
+  }
+
+  // 2. Verify DRAFT status
+  if (routing.status !== "DRAFT") {
+    return err(new RoutingNotMutableError(id));
+  }
+
+  // 3. Validate unique sequence numbers
+  const seqNumbers = operations.map((op) => op.sequenceNumber);
+  const uniqueSeqs = new Set(seqNumbers);
+  if (uniqueSeqs.size !== seqNumbers.length) {
+    return err(new DuplicateOperationSequenceError(id));
+  }
+
+  // 4. Validate standard times >= 0
+  for (const op of operations) {
+    if (op.standardSetupTime < 0 || op.standardRunTime < 0) {
+      return err(new InvalidStandardTimeError(id));
+    }
+  }
+
+  // 5. Validate work centers exist and belong to same company
+  for (const op of operations) {
+    const workCenter = await db
+      .selectFrom("WorkCenter")
+      .selectAll()
+      .where("id", "=", op.workCenterId)
+      .executeTakeFirst();
+
+    if (!workCenter) {
+      return err(new WorkCenterNotFoundError(op.workCenterId));
+    }
+
+    if (workCenter.companyId !== routing.companyId) {
+      return err(new CrossCompanyWorkCenterError(op.workCenterId));
+    }
+  }
+
+  // 6. Update routing header
+  const updatedRouting = await db
+    .updateTable("Routing")
+    .set({
+      ...(customFields as Record<string, unknown>),
+      ...(revisionNumber !== undefined ? { revisionNumber } : {}),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 7. Delete existing operations and replace
+  await db.deleteFrom("RoutingOperation").where("routingId", "=", id).execute();
+
+  const createdOperations = [];
+  for (const op of operations) {
+    const operation = await db
+      .insertInto("RoutingOperation")
+      .values({
+        routingId: id,
+        sequenceNumber: op.sequenceNumber,
+        operationDescription: op.operationDescription ?? null,
+        workCenterId: op.workCenterId,
+        standardSetupTime: op.standardSetupTime,
+        standardRunTime: op.standardRunTime,
+        operatorInstructions: op.operatorInstructions ?? null,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirst();
+    createdOperations.push(operation!);
+  }
+
+  return ok({ routing: updatedRouting!, operations: createdOperations });
+}

package/src/modules/manufacturing/command/updateWorkCenter.generated.ts

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

package/src/modules/manufacturing/command/updateWorkCenter.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkCenterNotFoundError,
+  InvalidCapacityError,
+  InvalidRateError,
+  InvalidOverheadMethodError,
+  OverheadCurrencyRequiredError,
+  ImmutableScopeFieldError,
+} from "../lib/errors.generated";
+import { baseActiveWorkCenter } from "../testing/fixtures";
+import { run } from "./updateWorkCenter";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateWorkCenter", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["manufacturing:updateWorkCenter"],
+  };
+
+  const validInput = {
+    id: baseActiveWorkCenter.id,
+    capacityAssumptions: 200,
+    laborRate: 30.0,
+  };
+
+  it("updates an active work center without changing scope identity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    spies.update.mockReturnValue({
+      ...baseActiveWorkCenter,
+      capacityAssumptions: 200,
+      laborRate: 30.0,
+    });
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.workCenter.capacityAssumptions).toBe(200);
+      expect(result.value.workCenter.laborRate).toBe(30.0);
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when the work center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, validInput, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WorkCenterNotFoundError);
+    }
+  });
+
+  it("returns error when immutable scope fields are changed", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      { ...validInput, companyId: "other-company" } as Parameters<typeof run>[1],
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ImmutableScopeFieldError);
+    }
+  });
+
+  it("returns error when capacity is not positive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(db, { ...validInput, capacityAssumptions: 0 }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCapacityError);
+    }
+  });
+
+  it("returns error when a rate is negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(db, { ...validInput, laborRate: -1 }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidRateError);
+    }
+  });
+
+  it("preserves released cost baselines after update", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+    spies.update.mockReturnValue({
+      ...baseActiveWorkCenter,
+      machineRate: 75.0,
+    });
+
+    const result = await run(db, { id: baseActiveWorkCenter.id, machineRate: 75.0 }, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(spies.update).toHaveBeenCalledTimes(1);
+    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ machineRate: 75.0 }));
+    expect(spies.set).toHaveBeenCalledWith(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      expect.not.objectContaining({ companyId: expect.anything() }),
+    );
+  });
+
+  it("returns error when the overhead method is not supported", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(
+      db,
+      { id: baseActiveWorkCenter.id, overheadAbsorptionMethod: "PER_ORDER" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidOverheadMethodError);
+    }
+  });
+
+  it("returns error when fixed-amount overhead omits currency", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWorkCenter);
+
+    const result = await run(
+      db,
+      {
+        id: baseActiveWorkCenter.id,
+        overheadAbsorptionMethod: "FIXED_AMOUNT_PER_GOOD_UNIT",
+        overheadAbsorptionCurrency: null,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(OverheadCurrencyRequiredError);
+    }
+  });
+});

package/src/modules/manufacturing/command/updateWorkCenter.ts

@@ -0,0 +1,137 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WorkCenterNotFoundError,
+  InvalidCapacityError,
+  InvalidRateError,
+  InvalidOverheadMethodError,
+  OverheadCurrencyRequiredError,
+  ImmutableScopeFieldError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const VALID_OVERHEAD_METHODS = [
+  "PERCENT_OF_LABOR_COST",
+  "PERCENT_OF_MACHINE_COST",
+  "FIXED_AMOUNT_PER_GOOD_UNIT",
+] as const;
+
+const IMMUTABLE_FIELDS = ["companyId", "siteId", "code"] as const;
+
+export interface UpdateWorkCenterInput {
+  id: string;
+  capacityAssumptions?: number | null;
+  laborRate?: number | null;
+  machineRate?: number | null;
+  calendarReference?: string | null;
+  overheadAbsorptionMethod?: string | null;
+  overheadAbsorptionCurrency?: string | null;
+}
+
+/**
+ * Function: updateWorkCenter
+ *
+ * Revises mutable work-center master data such as capacity, calendar,
+ * rate assumptions, and overhead policy. Only DRAFT or ACTIVE work centers
+ * may be updated.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateWorkCenterInput & CF,
+  _ctx: CommandContext,
+) {
+  const {
+    id,
+    capacityAssumptions,
+    laborRate,
+    machineRate,
+    calendarReference,
+    overheadAbsorptionMethod,
+    overheadAbsorptionCurrency,
+    ...customFields
+  } = input;
+
+  // 1. Reject immutable scope fields
+  for (const field of IMMUTABLE_FIELDS) {
+    if (field in customFields) {
+      return err(new ImmutableScopeFieldError(field));
+    }
+  }
+
+  // 2. Check work center exists
+  const workCenter = await db
+    .selectFrom("WorkCenter")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!workCenter) {
+    return err(new WorkCenterNotFoundError(id));
+  }
+
+  // 3. Only DRAFT or ACTIVE allowed
+  if (workCenter.status !== "DRAFT" && workCenter.status !== "ACTIVE") {
+    return err(new WorkCenterNotFoundError(id));
+  }
+
+  // 4. Validate capacity if provided
+  if (capacityAssumptions != null && capacityAssumptions <= 0) {
+    return err(new InvalidCapacityError(id));
+  }
+
+  // 5. Validate rates if provided
+  if (laborRate != null && laborRate < 0) {
+    return err(new InvalidRateError(id));
+  }
+  if (machineRate != null && machineRate < 0) {
+    return err(new InvalidRateError(id));
+  }
+
+  // Resolve the effective overhead method after update
+  const effectiveMethod =
+    overheadAbsorptionMethod !== undefined
+      ? overheadAbsorptionMethod
+      : workCenter.overheadAbsorptionMethod;
+  const effectiveCurrency =
+    overheadAbsorptionCurrency !== undefined
+      ? overheadAbsorptionCurrency
+      : workCenter.overheadAbsorptionCurrency;
+
+  // 6. Validate overhead method
+  if (
+    effectiveMethod != null &&
+    !VALID_OVERHEAD_METHODS.includes(effectiveMethod as (typeof VALID_OVERHEAD_METHODS)[number])
+  ) {
+    return err(new InvalidOverheadMethodError(id));
+  }
+
+  // 7. Overhead currency required for FIXED_AMOUNT_PER_GOOD_UNIT
+  if (effectiveMethod === "FIXED_AMOUNT_PER_GOOD_UNIT" && !effectiveCurrency) {
+    return err(new OverheadCurrencyRequiredError(id));
+  }
+
+  // 8. Build update set
+  const updateSet: Record<string, unknown> = {
+    ...(customFields as Record<string, unknown>),
+    updatedAt: new Date(),
+  };
+
+  if (capacityAssumptions !== undefined) updateSet.capacityAssumptions = capacityAssumptions;
+  if (laborRate !== undefined) updateSet.laborRate = laborRate;
+  if (machineRate !== undefined) updateSet.machineRate = machineRate;
+  if (calendarReference !== undefined) updateSet.calendarReference = calendarReference;
+  if (overheadAbsorptionMethod !== undefined)
+    updateSet.overheadAbsorptionMethod = overheadAbsorptionMethod;
+  if (overheadAbsorptionCurrency !== undefined)
+    updateSet.overheadAbsorptionCurrency = overheadAbsorptionCurrency;
+
+  // 9. Persist changes
+  const updated = await db
+    .updateTable("WorkCenter")
+    .set(updateSet)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ workCenter: updated });
+}

package/src/modules/manufacturing/db/billOfMaterial.ts

@@ -0,0 +1,70 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company as companyStub, site as siteStub, item as itemStub } from "../lib/_db_deps";
+
+export const BOM_TYPES = ["MANUFACTURE", "PHANTOM", "KIT"] as const;
+export const BASE_BOM_STATUSES = ["DRAFT", "ACTIVE", "INACTIVE"] as const;
+
+export interface CreateBillOfMaterialTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType: TailorAnyDBType;
+  siteType: TailorAnyDBType;
+  itemType: TailorAnyDBType;
+}
+
+export function createBillOfMaterialType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateBillOfMaterialTypeParams<F>,
+) {
+  return db
+    .type("BillOfMaterial", {
+      parentItemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType },
+          backward: "billOfMaterials",
+        })
+        .description("Foreign key to Item – the parent/finished item"),
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType },
+          backward: "billOfMaterials",
+        })
+        .description("Foreign key to Company"),
+      siteId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.siteType },
+          backward: "billOfMaterials",
+        })
+        .description("Optional foreign key to Site – site scope"),
+      bomType: db
+        .enum([...BOM_TYPES] as [string, ...string[]])
+        .description("BOM type: MANUFACTURE, PHANTOM, KIT"),
+      effectivityStartDate: db.datetime({ optional: true }).description("Effectivity start date"),
+      effectivityEndDate: db.datetime({ optional: true }).description("Effectivity end date"),
+      defaultSelection: db.bool({ optional: true }).description("Default selection flag"),
+      revisionNumber: db.string({ optional: true }).description("Revision number"),
+      status: db
+        .enum([...BASE_BOM_STATUSES] as [string, ...string[]])
+        .description("Lifecycle status: DRAFT, ACTIVE, INACTIVE"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const billOfMaterial = createBillOfMaterialType({
+  companyType: companyStub,
+  siteType: siteStub,
+  itemType: itemStub,
+});

package/src/modules/manufacturing/db/billOfMaterialLine.ts

@@ -0,0 +1,49 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { item as itemStub } from "../lib/_db_deps";
+import { billOfMaterial } from "./billOfMaterial";
+
+export interface CreateBillOfMaterialLineTypeParams {
+  billOfMaterialType: TailorAnyDBType;
+  itemType: TailorAnyDBType;
+}
+
+export function createBillOfMaterialLineType(params: CreateBillOfMaterialLineTypeParams) {
+  return db
+    .type("BillOfMaterialLine", {
+      billOfMaterialId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.billOfMaterialType },
+          backward: "billOfMaterialLines",
+        })
+        .description("Foreign key to BillOfMaterial"),
+      itemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType },
+          backward: "bomLineReferences",
+        })
+        .description("Foreign key to Item – component item"),
+      requiredQuantity: db.float().description("Required quantity, must be greater than 0"),
+      unitOfMeasure: db.string({ optional: true }).description("Compatible unit of measure"),
+      scrapAssumption: db.float({ optional: true }).description("Scrap assumption percentage"),
+      isSubassembly: db
+        .bool({ optional: true })
+        .description("Whether this component is a subassembly"),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const billOfMaterialLine = createBillOfMaterialLineType({
+  billOfMaterialType: billOfMaterial,
+  itemType: itemStub,
+});

package/src/modules/manufacturing/db/costVarianceLine.ts

@@ -0,0 +1,53 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { manufacturingCostSummary } from "./manufacturingCostSummary";
+
+export const VARIANCE_TYPES = [
+  "MATERIAL_PRICE",
+  "MATERIAL_USAGE",
+  "LABOR_RATE",
+  "LABOR_EFFICIENCY",
+  "MACHINE_RATE",
+  "MACHINE_EFFICIENCY",
+  "SCRAP",
+  "YIELD",
+] as const;
+
+export interface CreateCostVarianceLineTypeParams {
+  costSummaryType: TailorAnyDBType;
+}
+
+export function createCostVarianceLineType(params: CreateCostVarianceLineTypeParams) {
+  return db
+    .type("CostVarianceLine", {
+      costSummaryId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.costSummaryType },
+          backward: "varianceLines",
+        })
+        .description("Foreign key to ManufacturingCostSummary"),
+      varianceType: db
+        .enum([...VARIANCE_TYPES] as [string, ...string[]])
+        .description(
+          "Variance type: MATERIAL_PRICE, MATERIAL_USAGE, LABOR_RATE, LABOR_EFFICIENCY, MACHINE_RATE, MACHINE_EFFICIENCY, SCRAP, YIELD",
+        ),
+      amount: db.float().description("Variance amount"),
+      accountReference: db
+        .string({ optional: true })
+        .description("Optional account reference for settlement"),
+      variancePercentage: db.float({ optional: true }).description("Variance as a percentage"),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const costVarianceLine = createCostVarianceLineType({
+  costSummaryType: manufacturingCostSummary,
+});

package/src/modules/manufacturing/db/manufacturingCostLine.ts

@@ -0,0 +1,35 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { manufacturingCostSummary } from "./manufacturingCostSummary";
+
+export interface CreateManufacturingCostLineTypeParams {
+  costSummaryType: TailorAnyDBType;
+}
+
+export function createManufacturingCostLineType(params: CreateManufacturingCostLineTypeParams) {
+  return db
+    .type("ManufacturingCostLine", {
+      costSummaryId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.costSummaryType },
+          backward: "costLines",
+        })
+        .description("Foreign key to ManufacturingCostSummary"),
+      costType: db.string().description("Cost type: e.g. MATERIAL, LABOR, MACHINE, OVERHEAD"),
+      plannedAmount: db.float().description("Planned cost amount"),
+      actualAmount: db.float().description("Actual cost amount"),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const manufacturingCostLine = createManufacturingCostLineType({
+  costSummaryType: manufacturingCostSummary,
+});

package/src/modules/manufacturing/db/manufacturingCostSettlementRecord.ts

@@ -0,0 +1,39 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { manufacturingCostSummary } from "./manufacturingCostSummary";
+
+export interface CreateManufacturingCostSettlementRecordTypeParams {
+  costSummaryType: TailorAnyDBType;
+}
+
+export function createManufacturingCostSettlementRecordType(
+  params: CreateManufacturingCostSettlementRecordTypeParams,
+) {
+  return db
+    .type("ManufacturingCostSettlementRecord", {
+      costSummaryId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.costSummaryType },
+          backward: "settlementRecords",
+        })
+        .description("Foreign key to ManufacturingCostSummary"),
+      settlementDate: db.datetime().description("Date of settlement"),
+      settlementReference: db.string().description("Reference identifier for the settlement"),
+      acknowledgedDate: db
+        .datetime({ optional: true })
+        .description("Date when settlement was acknowledged"),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const manufacturingCostSettlementRecord = createManufacturingCostSettlementRecordType({
+  costSummaryType: manufacturingCostSummary,
+});