@tailor-platform/erp-kit 0.5.1 → 0.7.0

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,
+});

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

@@ -0,0 +1,59 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+
+export const BASE_COST_SUMMARY_STATUSES = [
+  "COLLECTING",
+  "PENDING_VARIANCE_REVIEW",
+  "VARIANCE_REVIEWED",
+  "SETTLED",
+] as const;
+
+export interface CreateManufacturingCostSummaryTypeParams {
+  productionOrderType: TailorAnyDBType;
+}
+
+export function createManufacturingCostSummaryType(
+  params: CreateManufacturingCostSummaryTypeParams,
+) {
+  return db
+    .type("ManufacturingCostSummary", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "1-1",
+          toward: { type: params.productionOrderType },
+          backward: "manufacturingCostSummary",
+        })
+        .description("Foreign key to ProductionOrder"),
+      plannedMaterialCost: db.float().description("Planned material cost"),
+      plannedLaborCost: db.float().description("Planned labor cost"),
+      plannedMachineCost: db.float().description("Planned machine cost"),
+      plannedOverheadCost: db.float().description("Planned overhead cost"),
+      actualMaterialCost: db.float().description("Actual material cost"),
+      actualLaborCost: db.float().description("Actual labor cost"),
+      actualMachineCost: db.float().description("Actual machine cost"),
+      actualOverheadCost: db.float().description("Actual overhead cost"),
+      currencyCode: db.string().description("Currency code (e.g. USD, EUR)"),
+      reviewedDate: db
+        .datetime({ optional: true })
+        .description("Date when cost summary was reviewed"),
+      reviewerNotes: db.string({ optional: true }).description("Notes from the reviewer"),
+      status: db
+        .enum([...BASE_COST_SUMMARY_STATUSES] as [string, ...string[]])
+        .description(
+          "Lifecycle status: COLLECTING, PENDING_VARIANCE_REVIEW, VARIANCE_REVIEWED, SETTLED",
+        ),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const manufacturingCostSummary = createManufacturingCostSummaryType({
+  productionOrderType: productionOrder,
+});

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

@@ -0,0 +1,83 @@
+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 BASE_PRODUCTION_ORDER_STATUSES = [
+  "DRAFT",
+  "RELEASED",
+  "IN_PROGRESS",
+  "COMPLETED",
+  "TECHNICALLY_COMPLETE",
+  "CLOSED",
+  "CANCELLED",
+] as const;
+
+export interface CreateProductionOrderTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType: TailorAnyDBType;
+  siteType: TailorAnyDBType;
+  itemType: TailorAnyDBType;
+}
+
+export function createProductionOrderType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateProductionOrderTypeParams<F>,
+) {
+  return db
+    .type("ProductionOrder", {
+      orderedItemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType },
+          backward: "productionOrders",
+        })
+        .description("Foreign key to Item – the item to be manufactured"),
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType },
+          backward: "productionOrders",
+        })
+        .description("Foreign key to Company"),
+      siteId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.siteType },
+          backward: "productionOrders",
+        })
+        .description("Foreign key to Site"),
+      plannedQuantity: db
+        .float()
+        .description("Planned production quantity, must be greater than 0"),
+      plannedStartDate: db.datetime().description("Planned start date for the production order"),
+      plannedEndDate: db.datetime().description("Planned end date for the production order"),
+      selectedBomVersionId: db
+        .uuid({ optional: true })
+        .description("Optional reference to BillOfMaterial – resolved at release"),
+      selectedRoutingRevisionId: db
+        .uuid({ optional: true })
+        .description("Optional reference to Routing – resolved at release"),
+      status: db
+        .enum([...BASE_PRODUCTION_ORDER_STATUSES] as [string, ...string[]])
+        .description(
+          "Lifecycle status: DRAFT, RELEASED, IN_PROGRESS, COMPLETED, TECHNICALLY_COMPLETE, CLOSED, CANCELLED",
+        ),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrder = createProductionOrderType({
+  companyType: companyStub,
+  siteType: siteStub,
+  itemType: itemStub,
+});

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

@@ -0,0 +1,44 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+
+export interface CreateProductionOrderBomSnapshotTypeParams<
+  F extends Record<string, TailorAnyDBField>,
+> {
+  fields?: F;
+  productionOrderType: TailorAnyDBType;
+}
+
+export function createProductionOrderBomSnapshotType<
+  const F extends Record<string, TailorAnyDBField>,
+>(params: CreateProductionOrderBomSnapshotTypeParams<F>) {
+  return db
+    .type("ProductionOrderBomSnapshot", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "1-1",
+          toward: { type: params.productionOrderType },
+          backward: "bomSnapshot",
+        })
+        .description("Foreign key to ProductionOrder (one snapshot per order)"),
+      parentItemId: db.uuid().description("Item ID of the parent item in the BOM snapshot"),
+      bomType: db.string().description("BOM type (e.g., STANDARD, PHANTOM)"),
+      snapshotData: db
+        .string({ optional: true })
+        .description("JSON blob containing the full BOM snapshot"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrderBomSnapshot = createProductionOrderBomSnapshotType({
+  productionOrderType: productionOrder,
+});

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

@@ -0,0 +1,44 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+
+export interface CreateProductionOrderCostBaselineTypeParams<
+  F extends Record<string, TailorAnyDBField>,
+> {
+  fields?: F;
+  productionOrderType: TailorAnyDBType;
+}
+
+export function createProductionOrderCostBaselineType<
+  const F extends Record<string, TailorAnyDBField>,
+>(params: CreateProductionOrderCostBaselineTypeParams<F>) {
+  return db
+    .type("ProductionOrderCostBaseline", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "1-1",
+          toward: { type: params.productionOrderType },
+          backward: "costBaseline",
+        })
+        .description("Foreign key to ProductionOrder (one baseline per order)"),
+      plannedMaterialCost: db.float().description("Planned total material cost"),
+      plannedLaborCost: db.float().description("Planned total labor cost"),
+      plannedMachineCost: db.float().description("Planned total machine cost"),
+      plannedOverheadCost: db.float().description("Planned total overhead cost"),
+      currencyCode: db.string().description("ISO 4217 currency code (e.g., USD)"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrderCostBaseline = createProductionOrderCostBaselineType({
+  productionOrderType: productionOrder,
+});

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

@@ -0,0 +1,57 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { item as itemStub } from "../lib/_db_deps";
+import { productionOrder } from "./productionOrder";
+
+export interface CreateProductionOrderMaterialRequirementTypeParams<
+  F extends Record<string, TailorAnyDBField>,
+> {
+  fields?: F;
+  productionOrderType: TailorAnyDBType;
+  itemType: TailorAnyDBType;
+}
+
+export function createProductionOrderMaterialRequirementType<
+  const F extends Record<string, TailorAnyDBField>,
+>(params: CreateProductionOrderMaterialRequirementTypeParams<F>) {
+  return db
+    .type("ProductionOrderMaterialRequirement", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.productionOrderType },
+          backward: "materialRequirements",
+        })
+        .description("Foreign key to ProductionOrder"),
+      itemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType },
+          backward: "productionOrderMaterialRequirements",
+        })
+        .description("Foreign key to Item – the required material"),
+      requiredQuantity: db.float().description("Required quantity of the material"),
+      unitOfMeasure: db
+        .string({ optional: true })
+        .description("Unit of measure for the required quantity"),
+      plannedUnitCost: db
+        .float({ optional: true })
+        .description("Planned cost per unit of the material"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrderMaterialRequirement = createProductionOrderMaterialRequirementType({
+  productionOrderType: productionOrder,
+  itemType: itemStub,
+});