@unifiedcommerce/plugin-production 0.0.1

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBxB,CAAC;AAEJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe5B,CAAC;AAEJ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB1B,CAAC;AAEJ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe/B,CAAC"}

package/dist/schema.js

@@ -0,0 +1,71 @@
+import { pgTable, uuid, text, integer, boolean, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+export const productionBoms = pgTable("production_boms", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    entityId: uuid("entity_id").notNull(),
+    name: text("name").notNull(),
+    version: integer("version").default(1),
+    yieldQuantity: integer("yield_quantity").default(1),
+    yieldUomId: uuid("yield_uom_id"),
+    isActive: boolean("is_active").default(true),
+    level: integer("level").default(0),
+    totalCost: integer("total_cost").default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_production_boms_org").on(table.organizationId),
+    entityIdx: index("idx_production_boms_entity").on(table.entityId),
+}));
+export const productionBomItems = pgTable("production_bom_items", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    bomId: uuid("bom_id").references(() => productionBoms.id, { onDelete: "cascade" }).notNull(),
+    entityId: uuid("entity_id").notNull(),
+    itemName: text("item_name").notNull(),
+    quantity: integer("quantity").notNull(),
+    unitCost: integer("unit_cost").default(0),
+    totalCost: integer("total_cost").default(0),
+    uomId: uuid("uom_id"),
+    isSubAssembly: boolean("is_sub_assembly").default(false),
+    subBomId: uuid("sub_bom_id").references(() => productionBoms.id),
+    sortOrder: integer("sort_order").default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    bomIdx: index("idx_production_bom_items_bom").on(table.bomId),
+}));
+export const productionOrders = pgTable("production_orders", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    orderNumber: text("order_number").notNull(),
+    bomId: uuid("bom_id").references(() => productionBoms.id).notNull(),
+    entityId: uuid("entity_id").notNull(),
+    quantity: integer("quantity").notNull(),
+    warehouseId: uuid("warehouse_id").notNull(),
+    status: text("status", { enum: ["planned", "in_progress", "completed", "cancelled"] }).default("planned").notNull(),
+    plannedDate: timestamp("planned_date", { withTimezone: true }).notNull(),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    producedBy: text("produced_by"),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_production_orders_org").on(table.organizationId),
+    statusIdx: index("idx_production_orders_status").on(table.status),
+    orderNumUnique: uniqueIndex("production_orders_org_number_unique").on(table.organizationId, table.orderNumber),
+}));
+export const productionConsumption = pgTable("production_consumption", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    productionOrderId: uuid("production_order_id").references(() => productionOrders.id, { onDelete: "cascade" }).notNull(),
+    entityId: uuid("entity_id").notNull(),
+    variantId: uuid("variant_id"),
+    plannedQuantity: integer("planned_quantity").notNull(),
+    actualQuantity: integer("actual_quantity").notNull(),
+    uomId: uuid("uom_id"),
+    unitCost: integer("unit_cost").default(0),
+    totalCost: integer("total_cost").default(0),
+    batchNumber: text("batch_number"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orderIdx: index("idx_production_consumption_order").on(table.productionOrderId),
+    entityIdx: index("idx_production_consumption_entity").on(table.entityId),
+}));

package/dist/services/production-order-service.d.ts

@@ -0,0 +1,34 @@
+import type { PluginResult } from "@unifiedcommerce/core";
+import type { Db, ProductionOrder, Consumption } from "../types";
+export declare class ProductionOrderService {
+    private db;
+    constructor(db: Db);
+    create(orgId: string, input: {
+        bomId: string;
+        entityId: string;
+        quantity: number;
+        warehouseId: string;
+        plannedDate: Date;
+        notes?: string;
+    }): Promise<PluginResult<ProductionOrder>>;
+    list(orgId: string, status?: string): Promise<PluginResult<ProductionOrder[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<ProductionOrder & {
+        consumption: Consumption[];
+    }>>;
+    start(orgId: string, id: string, producedBy: string): Promise<PluginResult<ProductionOrder>>;
+    recordConsumption(orgId: string, orderId: string, items: Array<{
+        entityId: string;
+        variantId?: string;
+        plannedQuantity: number;
+        actualQuantity: number;
+        uomId?: string;
+        unitCost: number;
+        batchNumber?: string;
+    }>): Promise<PluginResult<Consumption[]>>;
+    complete(orgId: string, id: string): Promise<PluginResult<ProductionOrder & {
+        consumption: Consumption[];
+    }>>;
+    cancel(orgId: string, id: string): Promise<PluginResult<ProductionOrder>>;
+    private generateOrderNumber;
+}
+//# sourceMappingURL=production-order-service.d.ts.map

package/dist/services/production-order-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"production-order-service.d.ts","sourceRoot":"","sources":["../../src/services/production-order-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,EAAE,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEjE,qBAAa,sBAAsB;IACrB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,IAAI,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;IAqBpC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC,CAAC;IAS9E,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,GAAG;QAAE,WAAW,EAAE,WAAW,EAAE,CAAA;KAAE,CAAC,CAAC;IAY3G,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;IAiB5F,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC;QACnE,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;IA4BnC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,GAAG;QAAE,WAAW,EAAE,WAAW,EAAE,CAAA;KAAE,CAAC,CAAC;IAgD5G,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;YAgBjE,mBAAmB;CAMlC"}

package/dist/services/production-order-service.js

@@ -0,0 +1,154 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import { productionBoms, productionBomItems, productionOrders, productionConsumption } from "../schema";
+export class ProductionOrderService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        // Verify BOM exists
+        const boms = await this.db.select().from(productionBoms)
+            .where(and(eq(productionBoms.id, input.bomId), eq(productionBoms.organizationId, orgId)));
+        if (boms.length === 0)
+            return Err("BOM not found");
+        const orderNumber = await this.generateOrderNumber(orgId);
+        const rows = await this.db.insert(productionOrders).values({
+            organizationId: orgId,
+            orderNumber,
+            bomId: input.bomId,
+            entityId: input.entityId,
+            quantity: input.quantity,
+            warehouseId: input.warehouseId,
+            plannedDate: input.plannedDate,
+            notes: input.notes,
+        }).returning();
+        return Ok(rows[0]);
+    }
+    async list(orgId, status) {
+        const conditions = [eq(productionOrders.organizationId, orgId)];
+        if (status) {
+            conditions.push(eq(productionOrders.status, status));
+        }
+        const rows = await this.db.select().from(productionOrders).where(and(...conditions));
+        return Ok(rows);
+    }
+    async getById(orgId, id) {
+        const orders = await this.db.select().from(productionOrders)
+            .where(and(eq(productionOrders.id, id), eq(productionOrders.organizationId, orgId)));
+        if (orders.length === 0)
+            return Err("Order not found");
+        const order = orders[0];
+        const consumption = await this.db.select().from(productionConsumption)
+            .where(eq(productionConsumption.productionOrderId, id));
+        return Ok({ ...order, consumption });
+    }
+    async start(orgId, id, producedBy) {
+        const orders = await this.db.select().from(productionOrders)
+            .where(and(eq(productionOrders.id, id), eq(productionOrders.organizationId, orgId)));
+        if (orders.length === 0)
+            return Err("Order not found");
+        const order = orders[0];
+        if (order.status !== "planned")
+            return Err(`Cannot start order in '${order.status}' status`);
+        const rows = await this.db.update(productionOrders).set({
+            status: "in_progress",
+            producedBy,
+            startedAt: new Date(),
+            updatedAt: new Date(),
+        }).where(eq(productionOrders.id, id)).returning();
+        return Ok(rows[0]);
+    }
+    async recordConsumption(orgId, orderId, items) {
+        // Verify order exists and is in_progress
+        const orders = await this.db.select().from(productionOrders)
+            .where(and(eq(productionOrders.id, orderId), eq(productionOrders.organizationId, orgId)));
+        if (orders.length === 0)
+            return Err("Order not found");
+        const order = orders[0];
+        if (order.status !== "in_progress")
+            return Err(`Cannot record consumption for order in '${order.status}' status`);
+        const insertedItems = [];
+        for (const item of items) {
+            const totalCost = item.actualQuantity * item.unitCost;
+            const rows = await this.db.insert(productionConsumption).values({
+                productionOrderId: orderId,
+                entityId: item.entityId,
+                variantId: item.variantId,
+                plannedQuantity: item.plannedQuantity,
+                actualQuantity: item.actualQuantity,
+                uomId: item.uomId,
+                unitCost: item.unitCost,
+                totalCost,
+                batchNumber: item.batchNumber,
+            }).returning();
+            insertedItems.push(rows[0]);
+        }
+        return Ok(insertedItems);
+    }
+    async complete(orgId, id) {
+        const orders = await this.db.select().from(productionOrders)
+            .where(and(eq(productionOrders.id, id), eq(productionOrders.organizationId, orgId)));
+        if (orders.length === 0)
+            return Err("Order not found");
+        const order = orders[0];
+        if (order.status !== "in_progress")
+            return Err(`Cannot complete order in '${order.status}' status`);
+        // If no consumption records yet, auto-generate from BOM explosion
+        const existingConsumption = await this.db.select().from(productionConsumption)
+            .where(eq(productionConsumption.productionOrderId, id));
+        if (existingConsumption.length === 0) {
+            // Auto-consume based on BOM items
+            const bomItems = await this.db.select().from(productionBomItems)
+                .where(eq(productionBomItems.bomId, order.bomId));
+            const boms = await this.db.select().from(productionBoms)
+                .where(eq(productionBoms.id, order.bomId));
+            const yieldQty = boms.length > 0 ? (boms[0].yieldQuantity ?? 1) : 1;
+            const multiplier = order.quantity / yieldQty;
+            for (const bomItem of bomItems) {
+                if (bomItem.isSubAssembly)
+                    continue; // Skip sub-assemblies for auto-consumption
+                const plannedQty = Math.round((bomItem.quantity ?? 0) * multiplier);
+                const unitCost = bomItem.unitCost ?? 0;
+                await this.db.insert(productionConsumption).values({
+                    productionOrderId: id,
+                    entityId: bomItem.entityId,
+                    plannedQuantity: plannedQty,
+                    actualQuantity: plannedQty,
+                    unitCost,
+                    totalCost: plannedQty * unitCost,
+                });
+            }
+        }
+        const rows = await this.db.update(productionOrders).set({
+            status: "completed",
+            completedAt: new Date(),
+            updatedAt: new Date(),
+        }).where(eq(productionOrders.id, id)).returning();
+        const consumption = await this.db.select().from(productionConsumption)
+            .where(eq(productionConsumption.productionOrderId, id));
+        return Ok({ ...rows[0], consumption });
+    }
+    async cancel(orgId, id) {
+        const orders = await this.db.select().from(productionOrders)
+            .where(and(eq(productionOrders.id, id), eq(productionOrders.organizationId, orgId)));
+        if (orders.length === 0)
+            return Err("Order not found");
+        const order = orders[0];
+        if (order.status === "completed")
+            return Err("Cannot cancel a completed order");
+        if (order.status === "cancelled")
+            return Err("Order is already cancelled");
+        const rows = await this.db.update(productionOrders).set({
+            status: "cancelled",
+            updatedAt: new Date(),
+        }).where(eq(productionOrders.id, id)).returning();
+        return Ok(rows[0]);
+    }
+    async generateOrderNumber(orgId) {
+        const countRows = await this.db.select({ count: sql `COUNT(*)`.as("count") })
+            .from(productionOrders).where(eq(productionOrders.organizationId, orgId));
+        const seq = Number(countRows[0]?.count ?? 0) + 1;
+        return `PRD-${String(seq).padStart(4, "0")}`;
+    }
+}

package/dist/services/production-service.d.ts

@@ -0,0 +1,48 @@
+import type { PluginResult } from "@unifiedcommerce/core";
+import type { Db, BOM, BOMItem } from "../types";
+export interface ExplodedItem {
+    entityId: string;
+    itemName: string;
+    totalQuantity: number;
+    unitCost: number;
+    totalCost: number;
+}
+export declare class ProductionService {
+    private db;
+    constructor(db: Db);
+    createBOM(orgId: string, input: {
+        entityId: string;
+        name: string;
+        yieldQuantity?: number;
+        yieldUomId?: string;
+        level?: number;
+        items: Array<{
+            entityId: string;
+            itemName: string;
+            quantity: number;
+            unitCost: number;
+            uomId?: string;
+            isSubAssembly?: boolean;
+            subBomId?: string;
+        }>;
+    }): Promise<PluginResult<BOM & {
+        items: BOMItem[];
+    }>>;
+    getBOM(orgId: string, id: string): Promise<PluginResult<BOM & {
+        items: BOMItem[];
+    }>>;
+    listBOMs(orgId: string): Promise<PluginResult<BOM[]>>;
+    addBOMItem(orgId: string, bomId: string, input: {
+        entityId: string;
+        itemName: string;
+        quantity: number;
+        unitCost: number;
+        uomId?: string;
+        isSubAssembly?: boolean;
+        subBomId?: string;
+    }): Promise<PluginResult<BOMItem>>;
+    costRollup(orgId: string, id: string): Promise<PluginResult<BOM>>;
+    explode(orgId: string, bomId: string, quantity: number): Promise<PluginResult<ExplodedItem[]>>;
+    private explodeRecursive;
+}
+//# sourceMappingURL=production-service.d.ts.map

package/dist/services/production-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"production-service.d.ts","sourceRoot":"","sources":["../../src/services/production-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEjD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,iBAAiB;IAChB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACpC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,KAAK,CAAC;YACX,QAAQ,EAAE,MAAM,CAAC;YACjB,QAAQ,EAAE,MAAM,CAAC;YACjB,QAAQ,EAAE,MAAM,CAAC;YACjB,QAAQ,EAAE,MAAM,CAAC;YACjB,KAAK,CAAC,EAAE,MAAM,CAAC;YACf,aAAa,CAAC,EAAE,OAAO,CAAC;YACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;SACnB,CAAC,CAAC;KACJ,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,GAAG;QAAE,KAAK,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,CAAC;IA6E/C,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,GAAG;QAAE,KAAK,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,CAAC;IAapF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC;IAMrD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACpD,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAgD5B,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;IAuCjE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,CAAC;YAYtF,gBAAgB;CA0C/B"}

package/dist/services/production-service.js

@@ -0,0 +1,202 @@
+import { eq, and } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import { productionBoms, productionBomItems } from "../schema";
+export class ProductionService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async createBOM(orgId, input) {
+        const yieldQty = input.yieldQuantity ?? 1;
+        // Calculate total cost, resolving sub-assembly costs
+        let totalCost = 0;
+        const itemsWithCosts = [];
+        for (let i = 0; i < input.items.length; i++) {
+            const item = input.items[i];
+            let unitCost = item.unitCost;
+            if (item.isSubAssembly && item.subBomId) {
+                const subBom = await this.db.select().from(productionBoms)
+                    .where(and(eq(productionBoms.id, item.subBomId), eq(productionBoms.organizationId, orgId)));
+                if (subBom.length > 0) {
+                    const sub = subBom[0];
+                    unitCost = Math.round((sub.totalCost ?? 0) / (sub.yieldQuantity ?? 1));
+                }
+            }
+            const itemTotal = item.quantity * unitCost;
+            totalCost += itemTotal;
+            itemsWithCosts.push({
+                entityId: item.entityId,
+                itemName: item.itemName,
+                quantity: item.quantity,
+                unitCost,
+                totalCost: itemTotal,
+                uomId: item.uomId,
+                isSubAssembly: item.isSubAssembly ?? false,
+                subBomId: item.subBomId,
+                sortOrder: i,
+            });
+        }
+        const bomRows = await this.db.insert(productionBoms).values({
+            organizationId: orgId,
+            entityId: input.entityId,
+            name: input.name,
+            yieldQuantity: yieldQty,
+            yieldUomId: input.yieldUomId,
+            level: input.level ?? 0,
+            totalCost,
+        }).returning();
+        const bom = bomRows[0];
+        const insertedItems = [];
+        for (const item of itemsWithCosts) {
+            const rows = await this.db.insert(productionBomItems).values({
+                bomId: bom.id,
+                entityId: item.entityId,
+                itemName: item.itemName,
+                quantity: item.quantity,
+                unitCost: item.unitCost,
+                totalCost: item.totalCost,
+                uomId: item.uomId,
+                isSubAssembly: item.isSubAssembly,
+                subBomId: item.subBomId,
+                sortOrder: item.sortOrder,
+            }).returning();
+            insertedItems.push(rows[0]);
+        }
+        return Ok({ ...bom, items: insertedItems });
+    }
+    async getBOM(orgId, id) {
+        const boms = await this.db.select().from(productionBoms)
+            .where(and(eq(productionBoms.id, id), eq(productionBoms.organizationId, orgId)));
+        if (boms.length === 0)
+            return Err("BOM not found");
+        const bom = boms[0];
+        const items = await this.db.select().from(productionBomItems)
+            .where(eq(productionBomItems.bomId, id))
+            .orderBy(productionBomItems.sortOrder);
+        return Ok({ ...bom, items });
+    }
+    async listBOMs(orgId) {
+        const rows = await this.db.select().from(productionBoms)
+            .where(eq(productionBoms.organizationId, orgId));
+        return Ok(rows);
+    }
+    async addBOMItem(orgId, bomId, input) {
+        // Verify BOM exists and belongs to org
+        const boms = await this.db.select().from(productionBoms)
+            .where(and(eq(productionBoms.id, bomId), eq(productionBoms.organizationId, orgId)));
+        if (boms.length === 0)
+            return Err("BOM not found");
+        let unitCost = input.unitCost;
+        if (input.isSubAssembly && input.subBomId) {
+            const subBom = await this.db.select().from(productionBoms)
+                .where(and(eq(productionBoms.id, input.subBomId), eq(productionBoms.organizationId, orgId)));
+            if (subBom.length > 0) {
+                const sub = subBom[0];
+                unitCost = Math.round((sub.totalCost ?? 0) / (sub.yieldQuantity ?? 1));
+            }
+        }
+        const itemTotal = input.quantity * unitCost;
+        // Get current max sort order
+        const existingItems = await this.db.select().from(productionBomItems)
+            .where(eq(productionBomItems.bomId, bomId));
+        const maxSort = existingItems.reduce((max, i) => Math.max(max, i.sortOrder ?? 0), -1);
+        const rows = await this.db.insert(productionBomItems).values({
+            bomId,
+            entityId: input.entityId,
+            itemName: input.itemName,
+            quantity: input.quantity,
+            unitCost,
+            totalCost: itemTotal,
+            uomId: input.uomId,
+            isSubAssembly: input.isSubAssembly ?? false,
+            subBomId: input.subBomId,
+            sortOrder: maxSort + 1,
+        }).returning();
+        // Recalculate BOM total cost
+        const allItems = await this.db.select().from(productionBomItems)
+            .where(eq(productionBomItems.bomId, bomId));
+        const newTotal = allItems.reduce((sum, i) => sum + (i.totalCost ?? 0), 0);
+        await this.db.update(productionBoms).set({
+            totalCost: newTotal,
+            updatedAt: new Date(),
+        }).where(eq(productionBoms.id, bomId));
+        return Ok(rows[0]);
+    }
+    async costRollup(orgId, id) {
+        const boms = await this.db.select().from(productionBoms)
+            .where(and(eq(productionBoms.id, id), eq(productionBoms.organizationId, orgId)));
+        if (boms.length === 0)
+            return Err("BOM not found");
+        const items = await this.db.select().from(productionBomItems)
+            .where(eq(productionBomItems.bomId, id));
+        let totalCost = 0;
+        for (const item of items) {
+            let unitCost = item.unitCost ?? 0;
+            if (item.isSubAssembly && item.subBomId) {
+                // Recursively roll up sub-assembly first
+                const subRollup = await this.costRollup(orgId, item.subBomId);
+                if (subRollup.ok) {
+                    unitCost = Math.round((subRollup.value.totalCost ?? 0) / (subRollup.value.yieldQuantity ?? 1));
+                }
+            }
+            const itemTotal = (item.quantity ?? 0) * unitCost;
+            totalCost += itemTotal;
+            // Update item costs
+            await this.db.update(productionBomItems).set({
+                unitCost,
+                totalCost: itemTotal,
+            }).where(eq(productionBomItems.id, item.id));
+        }
+        // Update BOM total
+        const updated = await this.db.update(productionBoms).set({
+            totalCost,
+            updatedAt: new Date(),
+        }).where(eq(productionBoms.id, id)).returning();
+        return Ok(updated[0]);
+    }
+    async explode(orgId, bomId, quantity) {
+        const boms = await this.db.select().from(productionBoms)
+            .where(and(eq(productionBoms.id, bomId), eq(productionBoms.organizationId, orgId)));
+        if (boms.length === 0)
+            return Err("BOM not found");
+        const bom = boms[0];
+        const materialMap = new Map();
+        await this.explodeRecursive(orgId, bomId, quantity, bom.yieldQuantity ?? 1, materialMap);
+        return Ok(Array.from(materialMap.values()));
+    }
+    async explodeRecursive(orgId, bomId, quantity, yieldQuantity, materialMap) {
+        const items = await this.db.select().from(productionBomItems)
+            .where(eq(productionBomItems.bomId, bomId))
+            .orderBy(productionBomItems.sortOrder);
+        const multiplier = quantity / yieldQuantity;
+        for (const item of items) {
+            const requiredQty = Math.round((item.quantity ?? 0) * multiplier);
+            if (item.isSubAssembly && item.subBomId) {
+                // Recurse into sub-assembly
+                const subBoms = await this.db.select().from(productionBoms)
+                    .where(and(eq(productionBoms.id, item.subBomId), eq(productionBoms.organizationId, orgId)));
+                if (subBoms.length > 0) {
+                    const subBom = subBoms[0];
+                    await this.explodeRecursive(orgId, item.subBomId, requiredQty, subBom.yieldQuantity ?? 1, materialMap);
+                }
+            }
+            else {
+                // Raw material — accumulate
+                const existing = materialMap.get(item.entityId);
+                if (existing) {
+                    existing.totalQuantity += requiredQty;
+                    existing.totalCost += requiredQty * (item.unitCost ?? 0);
+                }
+                else {
+                    materialMap.set(item.entityId, {
+                        entityId: item.entityId,
+                        itemName: item.itemName,
+                        totalQuantity: requiredQty,
+                        unitCost: item.unitCost ?? 0,
+                        totalCost: requiredQty * (item.unitCost ?? 0),
+                    });
+                }
+            }
+        }
+    }
+}