@tailor-platform/erp-kit 0.5.1 → 0.6.0

package/src/modules/manufacturing/lib/types.ts

@@ -0,0 +1,111 @@
+import type { DB } from "../generated/kysely-tailordb";
+import type {
+  InferSchema,
+  Selectable,
+  Insertable,
+  Updateable,
+} from "@tailor-platform/erp-kit/module";
+
+export type Schema = InferSchema<DB>;
+
+export type WorkCenter<T extends { WorkCenter: object }> = Selectable<T["WorkCenter"]>;
+export type WorkCenterCreate<T extends { WorkCenter: object }> = Insertable<T["WorkCenter"]>;
+export type WorkCenterUpdate<T extends { WorkCenter: object }> = Updateable<T["WorkCenter"]>;
+
+export type Routing<T extends { Routing: object }> = Selectable<T["Routing"]>;
+export type RoutingCreate<T extends { Routing: object }> = Insertable<T["Routing"]>;
+export type RoutingUpdate<T extends { Routing: object }> = Updateable<T["Routing"]>;
+
+export type RoutingOperation<T extends { RoutingOperation: object }> = Selectable<
+  T["RoutingOperation"]
+>;
+export type RoutingOperationCreate<T extends { RoutingOperation: object }> = Insertable<
+  T["RoutingOperation"]
+>;
+
+export type BillOfMaterial<T extends { BillOfMaterial: object }> = Selectable<T["BillOfMaterial"]>;
+export type BillOfMaterialCreate<T extends { BillOfMaterial: object }> = Insertable<
+  T["BillOfMaterial"]
+>;
+export type BillOfMaterialUpdate<T extends { BillOfMaterial: object }> = Updateable<
+  T["BillOfMaterial"]
+>;
+
+export type BillOfMaterialLine<T extends { BillOfMaterialLine: object }> = Selectable<
+  T["BillOfMaterialLine"]
+>;
+export type BillOfMaterialLineCreate<T extends { BillOfMaterialLine: object }> = Insertable<
+  T["BillOfMaterialLine"]
+>;
+
+export type ProductionOrder<T extends { ProductionOrder: object }> = Selectable<
+  T["ProductionOrder"]
+>;
+export type ProductionOrderCreate<T extends { ProductionOrder: object }> = Insertable<
+  T["ProductionOrder"]
+>;
+export type ProductionOrderUpdate<T extends { ProductionOrder: object }> = Updateable<
+  T["ProductionOrder"]
+>;
+
+export type ProductionOrderMaterialRequirement<
+  T extends { ProductionOrderMaterialRequirement: object },
+> = Selectable<T["ProductionOrderMaterialRequirement"]>;
+export type ProductionOrderMaterialRequirementCreate<
+  T extends { ProductionOrderMaterialRequirement: object },
+> = Insertable<T["ProductionOrderMaterialRequirement"]>;
+
+export type ProductionOrderBomSnapshot<T extends { ProductionOrderBomSnapshot: object }> =
+  Selectable<T["ProductionOrderBomSnapshot"]>;
+export type ProductionOrderBomSnapshotCreate<T extends { ProductionOrderBomSnapshot: object }> =
+  Insertable<T["ProductionOrderBomSnapshot"]>;
+
+export type ProductionOrderRoutingSnapshot<T extends { ProductionOrderRoutingSnapshot: object }> =
+  Selectable<T["ProductionOrderRoutingSnapshot"]>;
+export type ProductionOrderRoutingSnapshotCreate<
+  T extends { ProductionOrderRoutingSnapshot: object },
+> = Insertable<T["ProductionOrderRoutingSnapshot"]>;
+
+export type ProductionOrderCostBaseline<T extends { ProductionOrderCostBaseline: object }> =
+  Selectable<T["ProductionOrderCostBaseline"]>;
+export type ProductionOrderCostBaselineCreate<T extends { ProductionOrderCostBaseline: object }> =
+  Insertable<T["ProductionOrderCostBaseline"]>;
+
+export type WorkOrder<T extends { WorkOrder: object }> = Selectable<T["WorkOrder"]>;
+export type WorkOrderCreate<T extends { WorkOrder: object }> = Insertable<T["WorkOrder"]>;
+export type WorkOrderUpdate<T extends { WorkOrder: object }> = Updateable<T["WorkOrder"]>;
+
+export type WorkOrderExecutionEvent<T extends { WorkOrderExecutionEvent: object }> = Selectable<
+  T["WorkOrderExecutionEvent"]
+>;
+export type WorkOrderExecutionEventCreate<T extends { WorkOrderExecutionEvent: object }> =
+  Insertable<T["WorkOrderExecutionEvent"]>;
+
+export type ManufacturingCostSummary<T extends { ManufacturingCostSummary: object }> = Selectable<
+  T["ManufacturingCostSummary"]
+>;
+export type ManufacturingCostSummaryCreate<T extends { ManufacturingCostSummary: object }> =
+  Insertable<T["ManufacturingCostSummary"]>;
+export type ManufacturingCostSummaryUpdate<T extends { ManufacturingCostSummary: object }> =
+  Updateable<T["ManufacturingCostSummary"]>;
+
+export type ManufacturingCostLine<T extends { ManufacturingCostLine: object }> = Selectable<
+  T["ManufacturingCostLine"]
+>;
+export type ManufacturingCostLineCreate<T extends { ManufacturingCostLine: object }> = Insertable<
+  T["ManufacturingCostLine"]
+>;
+
+export type CostVarianceLine<T extends { CostVarianceLine: object }> = Selectable<
+  T["CostVarianceLine"]
+>;
+export type CostVarianceLineCreate<T extends { CostVarianceLine: object }> = Insertable<
+  T["CostVarianceLine"]
+>;
+
+export type ManufacturingCostSettlementRecord<
+  T extends { ManufacturingCostSettlementRecord: object },
+> = Selectable<T["ManufacturingCostSettlementRecord"]>;
+export type ManufacturingCostSettlementRecordCreate<
+  T extends { ManufacturingCostSettlementRecord: object },
+> = Insertable<T["ManufacturingCostSettlementRecord"]>;

package/src/modules/manufacturing/module.ts

@@ -0,0 +1,226 @@
+import { type TailorAnyDBField } from "@tailor-platform/sdk";
+import type { defineModule as defineOrganizationModule } from "../organization";
+import type { defineModule as defineItemManagementModule } from "../item-management";
+import { createWorkCenterType, type CreateWorkCenterTypeParams } from "./db/workCenter";
+import { createRoutingType } from "./db/routing";
+import { createRoutingOperationType } from "./db/routingOperation";
+import { createBillOfMaterialType } from "./db/billOfMaterial";
+import { createBillOfMaterialLineType } from "./db/billOfMaterialLine";
+import { createProductionOrderType } from "./db/productionOrder";
+import { createProductionOrderMaterialRequirementType } from "./db/productionOrderMaterialRequirement";
+import { createProductionOrderBomSnapshotType } from "./db/productionOrderBomSnapshot";
+import { createProductionOrderRoutingSnapshotType } from "./db/productionOrderRoutingSnapshot";
+import { createProductionOrderCostBaselineType } from "./db/productionOrderCostBaseline";
+import { createWorkOrderType } from "./db/workOrder";
+import { createWorkOrderExecutionEventType } from "./db/workOrderExecutionEvent";
+import { createManufacturingCostSummaryType } from "./db/manufacturingCostSummary";
+import { createManufacturingCostLineType } from "./db/manufacturingCostLine";
+import { createCostVarianceLineType } from "./db/costVarianceLine";
+import { createManufacturingCostSettlementRecordType } from "./db/manufacturingCostSettlementRecord";
+// Commands
+import { createWorkCenter } from "./command/createWorkCenter.generated";
+import { updateWorkCenter } from "./command/updateWorkCenter.generated";
+import { activateWorkCenter } from "./command/activateWorkCenter.generated";
+import { deactivateWorkCenter } from "./command/deactivateWorkCenter.generated";
+import { createRouting } from "./command/createRouting.generated";
+import { updateRouting } from "./command/updateRouting.generated";
+import { activateRouting } from "./command/activateRouting.generated";
+import { deactivateRouting } from "./command/deactivateRouting.generated";
+import { createBillOfMaterial } from "./command/createBillOfMaterial.generated";
+import { updateBillOfMaterial } from "./command/updateBillOfMaterial.generated";
+import { activateBillOfMaterial } from "./command/activateBillOfMaterial.generated";
+import { deactivateBillOfMaterial } from "./command/deactivateBillOfMaterial.generated";
+import { createProductionOrder } from "./command/createProductionOrder.generated";
+import { updateProductionOrder } from "./command/updateProductionOrder.generated";
+import { releaseProductionOrder } from "./command/releaseProductionOrder.generated";
+import { unreleaseProductionOrder } from "./command/unreleaseProductionOrder.generated";
+import { rescheduleProductionOrder } from "./command/rescheduleProductionOrder.generated";
+import { cancelProductionOrder } from "./command/cancelProductionOrder.generated";
+import { reopenProductionOrder } from "./command/reopenProductionOrder.generated";
+import { completeProductionOrder } from "./command/completeProductionOrder.generated";
+import { technicallyCompleteProductionOrder } from "./command/technicallyCompleteProductionOrder.generated";
+import { closeProductionOrder } from "./command/closeProductionOrder.generated";
+import { startWorkOrder } from "./command/startWorkOrder.generated";
+import { pauseWorkOrder } from "./command/pauseWorkOrder.generated";
+import { resumeWorkOrder } from "./command/resumeWorkOrder.generated";
+import { completeWorkOrder } from "./command/completeWorkOrder.generated";
+import { reportWorkOrderProgress } from "./command/reportWorkOrderProgress.generated";
+import { recordInventoryIssueOutcome } from "./command/recordInventoryIssueOutcome.generated";
+import { reviewManufacturingCostSummary } from "./command/reviewManufacturingCostSummary.generated";
+import { recordManufacturingCostSettlementAcknowledgment } from "./command/recordManufacturingCostSettlementAcknowledgment.generated";
+// Queries
+import { getWorkCenter } from "./query/getWorkCenter.generated";
+import { listWorkCentersBySite } from "./query/listWorkCentersBySite.generated";
+import { getRouting } from "./query/getRouting.generated";
+import { listRoutingsByItem } from "./query/listRoutingsByItem.generated";
+import { getBillOfMaterial } from "./query/getBillOfMaterial.generated";
+import { listBillOfMaterialsByItem } from "./query/listBillOfMaterialsByItem.generated";
+import { detectBillOfMaterialCircularReference } from "./query/detectBillOfMaterialCircularReference.generated";
+import { explodeBillOfMaterial } from "./query/explodeBillOfMaterial.generated";
+import { getProductionOrder } from "./query/getProductionOrder.generated";
+import { listProductionOrdersByStatus } from "./query/listProductionOrdersByStatus.generated";
+import { getWorkOrder } from "./query/getWorkOrder.generated";
+import { listWorkOrdersByProductionOrder } from "./query/listWorkOrdersByProductionOrder.generated";
+import { listWorkOrdersByWorkCenter } from "./query/listWorkOrdersByWorkCenter.generated";
+import { getManufacturingCostSummary } from "./query/getManufacturingCostSummary.generated";
+import { listManufacturingCostSummariesByStatus } from "./query/listManufacturingCostSummariesByStatus.generated";
+import { type EmptyFields, type FieldsToInsertable } from "@tailor-platform/erp-kit/module";
+
+type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
+type OrganizationDB = OrganizationModule["db"];
+
+type ItemManagementModule = ReturnType<typeof defineItemManagementModule>;
+type ItemManagementDB = ItemManagementModule["db"];
+
+export interface DefineModuleParams<WCF extends Record<string, TailorAnyDBField>> {
+  workCenter?: Omit<CreateWorkCenterTypeParams<WCF>, "companyType" | "siteType">;
+  organization: {
+    db: { company: OrganizationDB["company"]; site: OrganizationDB["site"] };
+  };
+  itemManagement: {
+    db: { item: ItemManagementDB["item"] };
+  };
+}
+
+export const defineModule = <const WCF extends Record<string, TailorAnyDBField> = EmptyFields>(
+  params: DefineModuleParams<WCF>,
+) => {
+  const companyType = params.organization.db.company;
+  const siteType = params.organization.db.site;
+  const itemType = params.itemManagement.db.item;
+
+  // Master data
+  const workCenter = createWorkCenterType({
+    ...params.workCenter,
+    companyType,
+    siteType,
+  });
+  const routing = createRoutingType({ companyType, siteType, itemType });
+  const routingOperation = createRoutingOperationType({
+    routingType: routing,
+    workCenterType: workCenter,
+  });
+  const billOfMaterial = createBillOfMaterialType({
+    companyType,
+    siteType,
+    itemType,
+  });
+  const billOfMaterialLine = createBillOfMaterialLineType({
+    billOfMaterialType: billOfMaterial,
+    itemType,
+  });
+
+  // Production orders
+  const productionOrder = createProductionOrderType({
+    companyType,
+    siteType,
+    itemType,
+  });
+  const productionOrderMaterialRequirement = createProductionOrderMaterialRequirementType({
+    productionOrderType: productionOrder,
+    itemType,
+  });
+  const productionOrderBomSnapshot = createProductionOrderBomSnapshotType({
+    productionOrderType: productionOrder,
+  });
+  const productionOrderRoutingSnapshot = createProductionOrderRoutingSnapshotType({
+    productionOrderType: productionOrder,
+  });
+  const productionOrderCostBaseline = createProductionOrderCostBaselineType({
+    productionOrderType: productionOrder,
+  });
+
+  // Work orders
+  const workOrder = createWorkOrderType({
+    productionOrderType: productionOrder,
+    workCenterType: workCenter,
+  });
+  const workOrderExecutionEvent = createWorkOrderExecutionEventType({
+    workOrderType: workOrder,
+  });
+
+  // Cost management
+  const manufacturingCostSummary = createManufacturingCostSummaryType({
+    productionOrderType: productionOrder,
+  });
+  const manufacturingCostLine = createManufacturingCostLineType({
+    costSummaryType: manufacturingCostSummary,
+  });
+  const costVarianceLine = createCostVarianceLineType({
+    costSummaryType: manufacturingCostSummary,
+  });
+  const manufacturingCostSettlementRecord = createManufacturingCostSettlementRecordType({
+    costSummaryType: manufacturingCostSummary,
+  });
+
+  return {
+    db: {
+      workCenter,
+      routing,
+      routingOperation,
+      billOfMaterial,
+      billOfMaterialLine,
+      productionOrder,
+      productionOrderMaterialRequirement,
+      productionOrderBomSnapshot,
+      productionOrderRoutingSnapshot,
+      productionOrderCostBaseline,
+      workOrder,
+      workOrderExecutionEvent,
+      manufacturingCostSummary,
+      manufacturingCostLine,
+      costVarianceLine,
+      manufacturingCostSettlementRecord,
+    },
+    queries: {
+      getWorkCenter,
+      listWorkCentersBySite,
+      getRouting,
+      listRoutingsByItem,
+      getBillOfMaterial,
+      listBillOfMaterialsByItem,
+      detectBillOfMaterialCircularReference,
+      explodeBillOfMaterial,
+      getProductionOrder,
+      listProductionOrdersByStatus,
+      getWorkOrder,
+      listWorkOrdersByProductionOrder,
+      listWorkOrdersByWorkCenter,
+      getManufacturingCostSummary,
+      listManufacturingCostSummariesByStatus,
+    },
+    commands: {
+      createWorkCenter: createWorkCenter<FieldsToInsertable<WCF>>(),
+      updateWorkCenter: updateWorkCenter(),
+      activateWorkCenter: activateWorkCenter(),
+      deactivateWorkCenter: deactivateWorkCenter(),
+      createRouting: createRouting(),
+      updateRouting: updateRouting(),
+      activateRouting: activateRouting(),
+      deactivateRouting: deactivateRouting(),
+      createBillOfMaterial: createBillOfMaterial(),
+      updateBillOfMaterial: updateBillOfMaterial(),
+      activateBillOfMaterial: activateBillOfMaterial(),
+      deactivateBillOfMaterial: deactivateBillOfMaterial(),
+      createProductionOrder: createProductionOrder(),
+      updateProductionOrder: updateProductionOrder(),
+      releaseProductionOrder: releaseProductionOrder(),
+      unreleaseProductionOrder: unreleaseProductionOrder(),
+      rescheduleProductionOrder: rescheduleProductionOrder(),
+      cancelProductionOrder: cancelProductionOrder(),
+      reopenProductionOrder: reopenProductionOrder(),
+      completeProductionOrder: completeProductionOrder(),
+      technicallyCompleteProductionOrder: technicallyCompleteProductionOrder(),
+      closeProductionOrder: closeProductionOrder(),
+      startWorkOrder: startWorkOrder(),
+      pauseWorkOrder: pauseWorkOrder(),
+      resumeWorkOrder: resumeWorkOrder(),
+      completeWorkOrder: completeWorkOrder(),
+      reportWorkOrderProgress: reportWorkOrderProgress(),
+      recordInventoryIssueOutcome: recordInventoryIssueOutcome(),
+      reviewManufacturingCostSummary: reviewManufacturingCostSummary(),
+      recordManufacturingCostSettlementAcknowledgment:
+        recordManufacturingCostSettlementAcknowledgment(),
+    },
+  };
+};

package/src/modules/manufacturing/permissions.ts

@@ -0,0 +1,3 @@
+import { definePermissions } from "@tailor-platform/erp-kit/module";
+
+export const { permissions, own, all } = definePermissions("manufacturing", [] as const);

package/src/modules/manufacturing/query/detectBillOfMaterialCircularReference.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./detectBillOfMaterialCircularReference";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const detectBillOfMaterialCircularReference = defineQuery(run);

package/src/modules/manufacturing/query/detectBillOfMaterialCircularReference.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { CompanyScopeRequiredError, ItemReferenceRequiredError } from "../lib/errors.generated";
+import { run } from "./detectBillOfMaterialCircularReference";
+
+describe("detectBillOfMaterialCircularReference", () => {
+  it("detects a direct BOM loop", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // B has an active BOM with a subassembly line pointing back to A
+    spies.select.mockReturnValueOnce([{ id: "bom-b" }]); // active BOMs for B
+    spies.select.mockReturnValueOnce([{ itemId: "item-1" }]); // subassembly lines -> back to A
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      childItemId: "item-2",
+    });
+    const value = expectOk<{
+      hasCircularReference: boolean;
+      path: string[];
+    }>(result as never);
+
+    expect(value.hasCircularReference).toBe(true);
+    expect(value.path).toContain("item-1");
+    expect(value.path).toContain("item-2");
+  });
+
+  it("detects an indirect BOM loop across multiple subassemblies", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // A -> B -> C -> A (circular)
+    // B has active BOM with subassembly line to C
+    spies.select.mockReturnValueOnce([{ id: "bom-b" }]); // active BOMs for B
+    spies.select.mockReturnValueOnce([{ itemId: "item-3" }]); // subassembly lines -> C
+    // C has active BOM with subassembly line back to A
+    spies.select.mockReturnValueOnce([{ id: "bom-c" }]); // active BOMs for C
+    spies.select.mockReturnValueOnce([{ itemId: "item-1" }]); // subassembly lines -> A (circular!)
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      childItemId: "item-2",
+    });
+    const value = expectOk<{
+      hasCircularReference: boolean;
+      path: string[];
+    }>(result as never);
+
+    expect(value.hasCircularReference).toBe(true);
+    expect(value.path).toContain("item-1");
+  });
+
+  it("returns no loop when the graph is acyclic", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // B has active BOM with subassembly line to C (not A)
+    spies.select.mockReturnValueOnce([{ id: "bom-b" }]); // active BOMs for B
+    spies.select.mockReturnValueOnce([{ itemId: "item-3" }]); // subassembly lines -> C
+    // C has no active BOMs (leaf node)
+    spies.select.mockReturnValueOnce([]); // active BOMs for C - none
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      childItemId: "item-2",
+    });
+    const value = expectOk<{
+      hasCircularReference: boolean;
+      path: string[] | null;
+    }>(result as never);
+
+    expect(value.hasCircularReference).toBe(false);
+    expect(value.path).toBeNull();
+  });
+
+  it("scopes detection to the requested company", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // No active BOMs found for this company scope
+    spies.select.mockReturnValueOnce([]); // no active BOMs for B in company-2
+
+    const result = await run(db, {
+      companyId: "company-2",
+      parentItemId: "item-1",
+      childItemId: "item-2",
+    });
+    const value = expectOk<{
+      hasCircularReference: boolean;
+      path: string[] | null;
+    }>(result as never);
+
+    expect(value.hasCircularReference).toBe(false);
+  });
+
+  it("returns error when parent or child reference is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "company-1",
+      parentItemId: "item-1",
+      childItemId: "",
+    });
+    expectErr(result as never, ItemReferenceRequiredError);
+  });
+
+  it("returns error when company scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {
+      companyId: "",
+      parentItemId: "item-1",
+      childItemId: "item-2",
+    });
+    expectErr(result as never, CompanyScopeRequiredError);
+  });
+});

package/src/modules/manufacturing/query/detectBillOfMaterialCircularReference.ts

@@ -0,0 +1,79 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { CompanyScopeRequiredError, ItemReferenceRequiredError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface DetectBillOfMaterialCircularReferenceInput {
+  companyId: string;
+  parentItemId: string;
+  childItemId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: DetectBillOfMaterialCircularReferenceInput) {
+  if (!input.companyId) {
+    return err(new CompanyScopeRequiredError("companyId"));
+  }
+
+  if (!input.parentItemId || !input.childItemId) {
+    return err(new ItemReferenceRequiredError("parentItemId and childItemId"));
+  }
+
+  // If child === parent, immediate circular reference
+  if (input.childItemId === input.parentItemId) {
+    return ok({
+      hasCircularReference: true,
+      path: [input.parentItemId, input.childItemId],
+    });
+  }
+
+  // BFS from childItemId through active BOMs to see if any path reaches parentItemId
+  const visited = new Set<string>();
+  const queue: { itemId: string; path: string[] }[] = [
+    { itemId: input.childItemId, path: [input.parentItemId, input.childItemId] },
+  ];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+
+    if (visited.has(current.itemId)) {
+      continue;
+    }
+    visited.add(current.itemId);
+
+    // Find active BOMs where this item is the parent
+    const activeBoms = await db
+      .selectFrom("BillOfMaterial")
+      .select("id")
+      .where("parentItemId", "=", current.itemId)
+      .where("companyId", "=", input.companyId)
+      .where("status", "=", "ACTIVE")
+      .execute();
+
+    if (activeBoms.length === 0) {
+      continue;
+    }
+
+    const bomIds = activeBoms.map((b) => b.id);
+
+    // Find subassembly lines for these BOMs
+    const subassemblyLines = await db
+      .selectFrom("BillOfMaterialLine")
+      .select("itemId")
+      .where("billOfMaterialId", "in", bomIds)
+      .where("isSubassembly", "=", true)
+      .execute();
+
+    for (const line of subassemblyLines) {
+      const newPath = [...current.path, line.itemId];
+
+      if (line.itemId === input.parentItemId) {
+        return ok({ hasCircularReference: true, path: newPath });
+      }
+
+      if (!visited.has(line.itemId)) {
+        queue.push({ itemId: line.itemId, path: newPath });
+      }
+    }
+  }
+
+  return ok({ hasCircularReference: false, path: null });
+}

package/src/modules/manufacturing/query/explodeBillOfMaterial.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./explodeBillOfMaterial";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const explodeBillOfMaterial = defineQuery(run);